@camunda8/orchestration-cluster-api 10.0.0-alpha.31 → 10.0.0-alpha.32

package/dist/effect/index.cjs

@@ -6473,7 +6473,7 @@ var init_zod_gen = __esm({
     }));
     zSecretResolveRequest = z.object({
       references: z.array(z.string().max(256).register(z.globalRegistry, {
-        description: "A secret reference of the form `camunda.secrets.<name>`."
+        description: "A secret reference of the form `camunda.secrets.<name>`, where `<name>` is a\nnon-empty token of letters, digits, `_` and `-`. A reference outside that form is\nreported in `errors` with `INVALID_REFERENCE` rather than failing the request.\n"
       })).max(20).register(z.globalRegistry, {
         description: "The secret references to resolve, each of the form `camunda.secrets.<name>`.\nDuplicate references are deduplicated by the server and resolved once.\nAt most 20 references may be requested in a single batch.\n"
       })
@@ -9227,11 +9227,17 @@ __export(effect_exports, {
   CamundaValidationError: () => CamundaValidationError2,
   EventualConsistencyTimeout: () => EventualConsistencyTimeout,
   HttpError: () => HttpError,
+  RetryableJobError: () => RetryableJobError,
+  TerminalJobError: () => TerminalJobError,
+  activateJobsStream: () => activateJobsStream,
   createCamundaEffectClient: () => createCamundaEffectClient,
+  createCamundaEffectWorker: () => createCamundaEffectWorker,
   eventually: () => eventually,
   layer: () => layer,
   retryWithBackoff: () => retryWithBackoff,
-  withTimeout: () => withTimeout
+  runWorkerLoop: () => runWorkerLoop,
+  withTimeout: () => withTimeout,
+  workerLayer: () => workerLayer
 });
 module.exports = __toCommonJS(effect_exports);
 
@@ -13788,7 +13794,7 @@ function createLogger(opts = {}) {
 }
 
 // src/runtime/version.ts
-var packageVersion = "10.0.0-alpha.31";
+var packageVersion = "10.0.0-alpha.32";
 
 // src/runtime/supportLogger.ts
 var NoopSupportLogger = class {
@@ -30095,6 +30101,167 @@ var CamundaEffect = class extends import_effect.Context.Service()(
 function layer(options) {
   return import_effect.Layer.sync(CamundaEffect, () => createCamundaEffectClient(options));
 }
+
+// src/effect-worker.ts
+var import_effect2 = require("effect");
+var RetryableJobError = class extends import_effect2.Data.TaggedError("RetryableJobError") {
+};
+var TerminalJobError = class extends import_effect2.Data.TaggedError("TerminalJobError") {
+};
+var DEFAULT_MAX_JOBS = 10;
+var DEFAULT_POLL_INTERVAL = "1 second";
+var DEFAULT_JOB_TIMEOUT = "60 seconds";
+var DEFAULT_LONGPOLL_TIMEOUT3 = 0;
+var _workerCounter3 = 0;
+function toMillis(d) {
+  return import_effect2.Duration.toMillis(import_effect2.Duration.fromInputUnsafe(d));
+}
+function activateJobsStream(type, options = {}) {
+  const worker = options.workerName ?? `effect-worker-${type}-${++_workerCounter3}`;
+  const batch = options.maxJobsToActivate ?? DEFAULT_MAX_JOBS;
+  const pollInterval = options.pollInterval ?? DEFAULT_POLL_INTERVAL;
+  const jobTimeout = options.jobTimeout ?? DEFAULT_JOB_TIMEOUT;
+  const requestTimeout = typeof options.requestTimeout === "number" ? options.requestTimeout : options.requestTimeout !== void 0 ? toMillis(options.requestTimeout) : DEFAULT_LONGPOLL_TIMEOUT3;
+  const body = {
+    type,
+    worker,
+    maxJobsToActivate: batch,
+    requestTimeout,
+    timeout: toMillis(jobTimeout),
+    ...options.fetchVariables && options.fetchVariables.length > 0 ? { fetchVariable: [...options.fetchVariables] } : {}
+  };
+  const pollOnce = import_effect2.Effect.gen(function* () {
+    const camunda = yield* CamundaEffect;
+    const result = yield* camunda.activateJobs(body);
+    const jobs = result?.jobs ?? [];
+    if (jobs.length === 0) yield* import_effect2.Effect.sleep(pollInterval);
+    return jobs;
+  });
+  const activation = options.activationRetrySchedule ? import_effect2.Effect.retry(pollOnce, { schedule: options.activationRetrySchedule }) : pollOnce;
+  return import_effect2.Stream.fromIterableEffectRepeat(activation);
+}
+function completeJob2(job, vars) {
+  return import_effect2.Effect.gen(function* () {
+    const camunda = yield* CamundaEffect;
+    yield* camunda.completeJob({
+      jobKey: job.jobKey,
+      variables: vars ?? {},
+      ...job.leaseToken != null ? { leaseToken: job.leaseToken } : {}
+    });
+  });
+}
+function failJobRetryable(job, error) {
+  return import_effect2.Effect.gen(function* () {
+    const camunda = yield* CamundaEffect;
+    yield* camunda.failJob({
+      jobKey: job.jobKey,
+      errorMessage: error.message,
+      retries: Math.max(0, (job.retries ?? 1) - 1),
+      ...error.retryBackoff !== void 0 ? { retryBackOff: toMillis(error.retryBackoff) } : {},
+      ...error.variables ? { variables: { ...error.variables } } : {},
+      ...job.leaseToken != null ? { leaseToken: job.leaseToken } : {}
+    });
+  });
+}
+function raiseIncident(job, error) {
+  return import_effect2.Effect.gen(function* () {
+    const camunda = yield* CamundaEffect;
+    yield* camunda.throwJobError({
+      jobKey: job.jobKey,
+      errorCode: error.code,
+      errorMessage: error.message,
+      ...error.variables ? { variables: { ...error.variables } } : {},
+      ...job.leaseToken != null ? { leaseToken: job.leaseToken } : {}
+    });
+  });
+}
+function releaseLease(job) {
+  return import_effect2.Effect.gen(function* () {
+    const camunda = yield* CamundaEffect;
+    yield* camunda.failJob({
+      jobKey: job.jobKey,
+      errorMessage: "worker interrupted; releasing lease for re-activation",
+      retries: job.retries ?? 1,
+      ...job.leaseToken != null ? { leaseToken: job.leaseToken } : {}
+    });
+  }).pipe(import_effect2.Effect.ignore);
+}
+function failJobOnDefect(job, defect) {
+  return import_effect2.Effect.gen(function* () {
+    const camunda = yield* CamundaEffect;
+    yield* import_effect2.Effect.logError(
+      `effect-worker: handler for job ${job.jobKey} threw an unexpected defect; failing job with retries - 1`,
+      defect
+    );
+    yield* camunda.failJob({
+      jobKey: job.jobKey,
+      errorMessage: defect instanceof Error ? defect.message : "Handler error",
+      retries: Math.max(0, (job.retries ?? 1) - 1),
+      ...job.leaseToken != null ? { leaseToken: job.leaseToken } : {}
+    });
+  });
+}
+function processJob(config, job) {
+  const handled = config.handlerRetrySchedule ? import_effect2.Effect.retry(config.handler(job), {
+    schedule: config.handlerRetrySchedule,
+    while: (e) => e._tag === "RetryableJobError"
+  }) : config.handler(job);
+  return handled.pipe(
+    import_effect2.Effect.flatMap((vars) => completeJob2(job, vars)),
+    import_effect2.Effect.catchTag("RetryableJobError", (e) => failJobRetryable(job, e)),
+    import_effect2.Effect.catchTag("TerminalJobError", (e) => raiseIncident(job, e)),
+    // Interruption is re-raised (not a defect) by `onInterrupt` below; only genuine
+    // handler defects reach here and are converted to a best-effort failJob.
+    import_effect2.Effect.catchDefect((defect) => failJobOnDefect(job, defect)),
+    import_effect2.Effect.onInterrupt(() => releaseLease(job))
+  );
+}
+function runWorkerLoop(config) {
+  const concurrency = config.concurrency ?? config.maxJobsToActivate ?? DEFAULT_MAX_JOBS;
+  const maxJobsToActivate = typeof concurrency === "number" ? Math.min(config.maxJobsToActivate ?? DEFAULT_MAX_JOBS, concurrency) : config.maxJobsToActivate;
+  return activateJobsStream(config.type, { ...config, maxJobsToActivate }).pipe(
+    import_effect2.Stream.mapEffect(
+      (job) => (
+        // A per-job acknowledgement failure (completeJob/failJob/throwJobError raising a
+        // `DomainError`) must not tear down the worker: a transient ack outage on one job
+        // would otherwise fail `Stream.runDrain` and stop all processing. Log it and keep
+        // going so `join` ends only on a fatal activation error (its documented contract),
+        // matching the Promise worker which swallows per-job ack failures. Two causes are
+        // re-raised instead of swallowed: a pure interruption (scope close / `interrupt`),
+        // so shutdown and the best-effort lease release in `processJob` still propagate;
+        // and a genuine defect (`die`), so an unexpected bug surfaces rather than hiding —
+        // note handler defects are already converted to a best-effort failJob inside
+        // `processJob`, so only truly unexpected defects reach here.
+        // NOTE: `Effect.catchAll` is avoided deliberately — under the effect 4.0.0-rc it
+        // suppresses `Stream.mapEffect` emission even on the success path; `catchCause`
+        // does not.
+        processJob(config, job).pipe(
+          import_effect2.Effect.catchCause(
+            (cause) => import_effect2.Cause.hasInterruptsOnly(cause) || import_effect2.Cause.hasDies(cause) ? import_effect2.Effect.failCause(cause) : import_effect2.Effect.logError(
+              `effect-worker[${config.type}]: acknowledging job ${job.jobKey} failed; continuing`,
+              cause
+            )
+          )
+        )
+      ),
+      { concurrency }
+    ),
+    import_effect2.Stream.runDrain
+  );
+}
+function createCamundaEffectWorker(config) {
+  return import_effect2.Effect.gen(function* () {
+    const fiber = yield* import_effect2.Effect.forkScoped(runWorkerLoop(config));
+    return {
+      type: config.type,
+      join: import_effect2.Fiber.join(fiber),
+      interrupt: import_effect2.Fiber.interrupt(fiber).pipe(import_effect2.Effect.asVoid)
+    };
+  });
+}
+function workerLayer(config) {
+  return import_effect2.Layer.effectDiscard(createCamundaEffectWorker(config));
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CamundaEffect,
@@ -30102,10 +30269,16 @@ function layer(options) {
   CamundaValidationError,
   EventualConsistencyTimeout,
   HttpError,
+  RetryableJobError,
+  TerminalJobError,
+  activateJobsStream,
   createCamundaEffectClient,
+  createCamundaEffectWorker,
   eventually,
   layer,
   retryWithBackoff,
-  withTimeout
+  runWorkerLoop,
+  withTimeout,
+  workerLayer
 });
 //# sourceMappingURL=index.cjs.map