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

package/dist/{fp → 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"
       })
@@ -9219,19 +9219,30 @@ default, with local set to \`false\`, scope '1' will be { "foo": 5 } and scope '
   }
 });
 
-// src/fp/index.ts
-var fp_exports = {};
-__export(fp_exports, {
-  classifyDomainError: () => classifyDomainError,
-  createCamundaFpClient: () => createCamundaFpClient,
-  eventuallyTE: () => eventuallyTE,
-  foldDomainError: () => foldDomainError,
-  isLeft: () => isLeft,
-  isRight: () => isRight,
-  retryTE: () => retryTE,
-  withTimeoutTE: () => withTimeoutTE
+// src/effect/index.ts
+var effect_exports = {};
+__export(effect_exports, {
+  CamundaEffect: () => CamundaEffect,
+  CamundaGenericError: () => CamundaGenericError,
+  CamundaValidationError: () => CamundaValidationError2,
+  EventualConsistencyTimeout: () => EventualConsistencyTimeout,
+  HttpError: () => HttpError,
+  RetryableJobError: () => RetryableJobError,
+  TerminalJobError: () => TerminalJobError,
+  activateJobsStream: () => activateJobsStream,
+  createCamundaEffectClient: () => createCamundaEffectClient,
+  createCamundaEffectWorker: () => createCamundaEffectWorker,
+  eventually: () => eventually,
+  layer: () => layer,
+  retryWithBackoff: () => retryWithBackoff,
+  runWorkerLoop: () => runWorkerLoop,
+  withTimeout: () => withTimeout,
+  workerLayer: () => workerLayer
 });
-module.exports = __toCommonJS(fp_exports);
+module.exports = __toCommonJS(effect_exports);
+
+// src/effect.ts
+var import_effect = require("effect");
 
 // src/gen/core/serverSentEvents.gen.ts
 var __STANDARD_REQUEST_INIT_KEYS = [
@@ -13783,7 +13794,7 @@ function createLogger(opts = {}) {
 }
 
 // src/runtime/version.ts
-var packageVersion = "10.0.0-alpha.30";
+var packageVersion = "10.0.0-alpha.32";
 
 // src/runtime/supportLogger.ts
 var NoopSupportLogger = class {
@@ -14239,18 +14250,18 @@ function unwrapForInspection(s) {
       continue;
     }
     if (t === "ZodIntersection") {
-      const left2 = cur._def.left;
-      const right2 = cur._def.right;
-      if (left2?._def?.typeName === "ZodObject" && right2?._def?.typeName === "ZodObject") {
+      const left = cur._def.left;
+      const right = cur._def.right;
+      if (left?._def?.typeName === "ZodObject" && right?._def?.typeName === "ZodObject") {
         try {
-          const leftShapeFn = left2._def.shape;
-          const rightShapeFn = right2._def.shape;
+          const leftShapeFn = left._def.shape;
+          const rightShapeFn = right._def.shape;
           const merged = { ...leftShapeFn(), ...rightShapeFn() };
           return import_zod.ZodObject.create(merged);
         } catch {
         }
       }
-      cur = left2;
+      cur = left;
       continue;
     }
     break;
@@ -29957,54 +29968,73 @@ var CamundaClient = class {
   }
 };
 
-// src/fp-ts.ts
-var left = (e) => ({ _tag: "Left", left: e });
-var right = (a) => ({ _tag: "Right", right: a });
-var isLeft = (e) => e._tag === "Left";
-var isRight = (e) => e._tag === "Right";
+// src/effect.ts
+var CamundaValidationError2 = class extends import_effect.Data.TaggedError("CamundaValidationError") {
+};
+var EventualConsistencyTimeout = class extends import_effect.Data.TaggedError("EventualConsistencyTimeout") {
+};
+var HttpError = class extends import_effect.Data.TaggedError("HttpError") {
+};
+var CamundaGenericError = class extends import_effect.Data.TaggedError("CamundaGenericError") {
+};
 function toDomainError(err) {
-  if (err instanceof CamundaValidationError) return err;
-  if (err instanceof EventualConsistencyTimeoutError) return err;
-  if (err instanceof Error) return err;
-  if (typeof err === "object") return err;
-  return { message: String(err) };
-}
-function classifyDomainError(err) {
-  if (err instanceof CamundaValidationError) return "validation";
-  if (err instanceof EventualConsistencyTimeoutError) return "timeout";
-  if (!(err instanceof Error) || err.status !== void 0) return "http";
-  return "generic";
-}
-function foldDomainError(handlers) {
-  return (err) => {
-    switch (classifyDomainError(err)) {
-      case "validation":
-        return handlers.validation(err);
-      case "timeout":
-        return handlers.timeout(err);
-      case "http":
-        return handlers.http(err);
-      case "generic":
-        return handlers.generic(err);
-    }
-  };
+  if (err instanceof CamundaValidationError) {
+    return new CamundaValidationError2({
+      side: err.side,
+      operationId: err.operationId,
+      summary: err.summary,
+      issues: err.issues,
+      message: err.message,
+      cause: err
+    });
+  }
+  if (err instanceof EventualConsistencyTimeoutError) {
+    return new EventualConsistencyTimeout({
+      attempts: err.attempts,
+      elapsedMs: err.elapsedMs,
+      message: err.message,
+      cause: err
+    });
+  }
+  const anyErr = err;
+  if (anyErr && typeof anyErr === "object" && typeof anyErr.status === "number") {
+    return new HttpError({
+      status: anyErr.status,
+      body: anyErr.body,
+      message: typeof anyErr.message === "string" ? anyErr.message : `HTTP ${anyErr.status}`,
+      cause: err
+    });
+  }
+  if (err instanceof Error) {
+    return new CamundaGenericError({ message: err.message, cause: err });
+  }
+  return new CamundaGenericError({ message: String(err), cause: err });
 }
 function isPromiseLike(v) {
-  return v && typeof v.then === "function";
+  return !!v && typeof v.then === "function";
 }
-function createCamundaFpClient(options) {
+function createCamundaEffectClient(options) {
   const base = createCamundaClient(options);
   const cache = /* @__PURE__ */ new Map();
   function wrap(fn) {
-    return (...args) => async () => {
+    return (...args) => import_effect.Effect.suspend(() => {
+      let r;
       try {
-        const r = fn.apply(base, args);
-        const val = isPromiseLike(r) ? await r : r;
-        return right(val);
+        r = fn.apply(base, args);
       } catch (e) {
-        return left(toDomainError(e));
-      }
-    };
+        return import_effect.Effect.fail(toDomainError(e));
+      }
+      if (!isPromiseLike(r)) return import_effect.Effect.succeed(r);
+      const promise = r;
+      return import_effect.Effect.callback((resume) => {
+        promise.then(
+          (a) => resume(import_effect.Effect.succeed(a)),
+          (e) => resume(import_effect.Effect.fail(toDomainError(e)))
+        );
+        const cancel = r.cancel;
+        return typeof cancel === "function" ? import_effect.Effect.sync(() => cancel.call(r)) : void 0;
+      });
+    });
   }
   const handler = {
     get(_t, prop) {
@@ -30022,71 +30052,233 @@ function createCamundaFpClient(options) {
   };
   return new Proxy({}, handler);
 }
-function retryTE(task, opts) {
-  const { max, baseDelayMs = 100, shouldRetry } = opts;
-  return async () => {
-    let attempt = 0;
-    let lastLeft;
-    while (attempt < max) {
-      const res = await task();
-      if (isRight(res)) return res;
-      lastLeft = res;
-      attempt++;
-      const retry = attempt < max && (shouldRetry ? await shouldRetry(res.left, attempt) : true);
-      if (!retry) return res;
-      const delay = Math.min(2e3, baseDelayMs * 2 ** (attempt - 1));
-      await new Promise((r) => setTimeout(r, delay));
-    }
-    return lastLeft;
+function formatDuration(d) {
+  try {
+    return import_effect.Duration.format(import_effect.Duration.fromInputUnsafe(d));
+  } catch {
+    return String(d);
+  }
+}
+function retryWithBackoff(effect, opts) {
+  const backoff = import_effect.Schedule.exponential(opts.baseDelay ?? "100 millis").pipe(import_effect.Schedule.jittered);
+  return import_effect.Effect.retry(effect, {
+    schedule: backoff,
+    times: Math.max(0, opts.max - 1),
+    while: opts.while
+  });
+}
+function withTimeout(effect, duration, onTimeout) {
+  return import_effect.Effect.timeoutOrElse(effect, {
+    duration,
+    orElse: () => import_effect.Effect.fail(
+      onTimeout ? onTimeout() : new EventualConsistencyTimeout({
+        message: `Timed out after ${formatDuration(duration)}`
+      })
+    )
+  });
+}
+function eventually(effect, predicate, opts) {
+  const interval = opts.interval ?? "500 millis";
+  const poll = import_effect.Effect.suspend(
+    () => effect.pipe(
+      import_effect.Effect.flatMap(
+        (a) => predicate(a) ? import_effect.Effect.succeed(a) : import_effect.Effect.sleep(interval).pipe(import_effect.Effect.andThen(poll))
+      )
+    )
+  );
+  return withTimeout(
+    poll,
+    opts.waitUpTo,
+    () => new EventualConsistencyTimeout({
+      message: `Eventual consistency timeout after ${formatDuration(opts.waitUpTo)}`
+    })
+  );
+}
+var CamundaEffect = class extends import_effect.Context.Service()(
+  "CamundaEffect"
+) {
+};
+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 withTimeoutTE(task, ms, onTimeout) {
-  return async () => {
-    let settled = false;
-    const t = task().then((r) => {
-      settled = true;
-      return r;
+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 } : {}
     });
-    const timeout = new Promise(
-      (res) => setTimeout(() => {
-        if (!settled)
-          res(left(onTimeout ? onTimeout() : new Error(`Timeout after ${ms}ms`)));
-      }, ms)
+  });
+}
+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
     );
-    return Promise.race([t, timeout]);
-  };
+    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 eventuallyTE(thunk, predicate, opts) {
-  const { intervalMs = 500, waitUpToMs } = opts;
-  return async () => {
-    const start = Date.now();
-    let attempt = 0;
-    while (true) {
-      attempt++;
-      try {
-        const val = await thunk();
-        if (await predicate(val)) return right(val);
-      } catch (e) {
-        return left(e);
-      }
-      const elapsed = Date.now() - start;
-      if (elapsed >= waitUpToMs)
-        return left(
-          new EventualConsistencyTimeoutError({ attempts: attempt, elapsedMs: elapsed })
-        );
-      await new Promise((r) => setTimeout(r, intervalMs));
-    }
-  };
+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 = {
-  classifyDomainError,
-  createCamundaFpClient,
-  eventuallyTE,
-  foldDomainError,
-  isLeft,
-  isRight,
-  retryTE,
-  withTimeoutTE
+  CamundaEffect,
+  CamundaGenericError,
+  CamundaValidationError,
+  EventualConsistencyTimeout,
+  HttpError,
+  RetryableJobError,
+  TerminalJobError,
+  activateJobsStream,
+  createCamundaEffectClient,
+  createCamundaEffectWorker,
+  eventually,
+  layer,
+  retryWithBackoff,
+  runWorkerLoop,
+  withTimeout,
+  workerLayer
 });
 //# sourceMappingURL=index.cjs.map