@vzeta/camunda-api-zod-schemas/dist/8.8/job.js

Zod schemas and TypeScript types for Camunda 8 unified API

import { z } from "zod";
import { getEnumFilterSchema, getQueryRequestBodySchema, advancedStringFilterSchema, basicStringFilterSchema, getQueryResponseBodySchema, API_VERSION } from "../common.js";
const jobStateSchema = z.enum([
  "CREATED",
  "COMPLETED",
  "FAILED",
  "RETRIES_UPDATED",
  "TIMED_OUT",
  "CANCELED",
  "ERROR_THROWN",
  "MIGRATED"
]);
const jobKindSchema = z.enum(["BPMN_ELEMENT", "EXECUTION_LISTENER", "TASK_LISTENER"]);
const listenerEventTypeSchema = z.enum([
  "UNSPECIFIED",
  "START",
  "END",
  "CREATING",
  "ASSIGNING",
  "UPDATING",
  "COMPLETING",
  "CANCELING"
]);
const jobStateFilterSchema = getEnumFilterSchema(jobStateSchema);
const jobKindFilterSchema = getEnumFilterSchema(jobKindSchema);
const listenerEventTypeFilterSchema = getEnumFilterSchema(listenerEventTypeSchema);
const jobSchema = z.object({
  jobKey: z.string(),
  type: z.string(),
  worker: z.string(),
  state: jobStateSchema,
  kind: jobKindSchema,
  listenerEventType: listenerEventTypeSchema,
  retries: z.number(),
  isDenied: z.boolean(),
  deniedReason: z.string(),
  hasFailedWithRetriesLeft: z.boolean(),
  errorCode: z.string(),
  errorMessage: z.string(),
  customHeaders: z.record(z.string(), z.unknown()).optional(),
  deadline: z.string(),
  endTime: z.string(),
  processDefinitionId: z.string(),
  processDefinitionKey: z.string(),
  processInstanceKey: z.string(),
  elementId: z.string(),
  elementInstanceKey: z.string(),
  tenantId: z.string()
});
const queryJobsRequestBodySchema = getQueryRequestBodySchema({
  sortFields: [
    "jobKey",
    "type",
    "worker",
    "state",
    "kind",
    "listenerEventType",
    "retries",
    "isDenied",
    "deniedReason",
    "hasFailedWithRetriesLeft",
    "errorCode",
    "errorMessage",
    "customHeaders",
    "deadline",
    "endTime",
    "processDefinitionId",
    "processDefinitionKey",
    "processInstanceKey",
    "elementId",
    "elementInstanceKey",
    "tenantId"
  ],
  filter: z.object({
    jobKey: basicStringFilterSchema.optional(),
    type: advancedStringFilterSchema.optional(),
    worker: advancedStringFilterSchema.optional(),
    state: jobStateFilterSchema.optional(),
    kind: jobKindFilterSchema.optional(),
    listenerEventType: listenerEventTypeFilterSchema.optional(),
    processDefinitionId: advancedStringFilterSchema.optional(),
    processDefinitionKey: basicStringFilterSchema.optional(),
    processInstanceKey: basicStringFilterSchema.optional(),
    elementId: advancedStringFilterSchema.optional(),
    elementInstanceKey: basicStringFilterSchema.optional(),
    tenantId: advancedStringFilterSchema.optional()
  })
});
const queryJobs = {
  method: "POST",
  getUrl() {
    return `/${API_VERSION}/jobs/search`;
  }
};
const queryJobsResponseBodySchema = getQueryResponseBodySchema(jobSchema);
const activateJobsRequestBodySchema = z.object({
  type: z.string(),
  worker: z.string().optional(),
  timeout: z.number(),
  maxJobsToActivate: z.number(),
  fetchVariable: z.array(z.string()).optional(),
  requestTimeout: z.number().optional(),
  tenantIds: z.array(z.string()).optional()
});
const activatedJobSchema = z.object({
  type: z.string(),
  processDefinitionId: z.string(),
  processDefinitionVersion: z.number(),
  elementId: z.string(),
  customHeaders: z.record(z.string(), z.unknown()).optional(),
  worker: z.string(),
  retries: z.number(),
  deadline: z.number(),
  variables: z.record(z.string(), z.unknown()).optional(),
  tenantId: z.string(),
  jobKey: z.string(),
  processInstanceKey: z.string(),
  processDefinitionKey: z.string(),
  elementInstanceKey: z.string()
});
const activateJobsResponseBodySchema = z.object({
  jobs: z.array(activatedJobSchema)
});
const activateJobs = {
  method: "POST",
  getUrl() {
    return `/${API_VERSION}/jobs/activation`;
  }
};
const failJobRequestBodySchema = z.object({
  retries: z.number().optional(),
  errorMessage: z.string().optional(),
  retryBackOff: z.number().optional(),
  variables: z.record(z.string(), z.unknown()).optional()
});
const failJob = {
  method: "POST",
  getUrl(params) {
    const { jobKey } = params;
    return `/${API_VERSION}/jobs/${jobKey}/failure`;
  }
};
const throwJobErrorRequestBodySchema = z.object({
  errorCode: z.string(),
  errorMessage: z.string().optional(),
  variables: z.record(z.string(), z.unknown()).optional()
});
const throwJobError = {
  method: "POST",
  getUrl(params) {
    const { jobKey } = params;
    return `/${API_VERSION}/jobs/${jobKey}/error`;
  }
};
const jobResultCorrectionsSchema = z.object({}).passthrough();
const jobResultSchema = z.object({
  denied: z.boolean().optional(),
  deniedReason: z.string().optional(),
  corrections: jobResultCorrectionsSchema.optional()
});
const completeJobRequestBodySchema = z.object({
  variables: z.record(z.string(), z.unknown()).optional(),
  result: jobResultSchema.optional()
});
const completeJob = {
  method: "POST",
  getUrl(params) {
    const { jobKey } = params;
    return `/${API_VERSION}/jobs/${jobKey}/completion`;
  }
};
const jobChangesetSchema = z.object({
  retries: z.number().optional(),
  timeout: z.number().optional()
});
const updateJobRequestBodySchema = z.object({
  changeset: jobChangesetSchema
});
const updateJob = {
  method: "PATCH",
  getUrl(params) {
    const { jobKey } = params;
    return `/${API_VERSION}/jobs/${jobKey}`;
  }
};
export {
  activateJobs,
  activateJobsRequestBodySchema,
  activateJobsResponseBodySchema,
  activatedJobSchema,
  completeJob,
  completeJobRequestBodySchema,
  failJob,
  failJobRequestBodySchema,
  jobChangesetSchema,
  jobKindFilterSchema,
  jobKindSchema,
  jobResultSchema,
  jobSchema,
  jobStateFilterSchema,
  jobStateSchema,
  listenerEventTypeFilterSchema,
  listenerEventTypeSchema,
  queryJobs,
  queryJobsRequestBodySchema,
  queryJobsResponseBodySchema,
  throwJobError,
  throwJobErrorRequestBodySchema,
  updateJob,
  updateJobRequestBodySchema
};