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

package/dist/{fp → effect}/index.cjs

@@ -9219,19 +9219,24 @@ 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,
+  createCamundaEffectClient: () => createCamundaEffectClient,
+  eventually: () => eventually,
+  layer: () => layer,
+  retryWithBackoff: () => retryWithBackoff,
+  withTimeout: () => withTimeout
 });
-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 +13788,7 @@ function createLogger(opts = {}) {
 }
 
 // src/runtime/version.ts
-var packageVersion = "10.0.0-alpha.30";
+var packageVersion = "10.0.0-alpha.31";
 
 // src/runtime/supportLogger.ts
 var NoopSupportLogger = class {
@@ -14239,18 +14244,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 +29962,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 +30046,66 @@ 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 withTimeoutTE(task, ms, onTimeout) {
-  return async () => {
-    let settled = false;
-    const t = task().then((r) => {
-      settled = true;
-      return r;
-    });
-    const timeout = new Promise(
-      (res) => setTimeout(() => {
-        if (!settled)
-          res(left(onTimeout ? onTimeout() : new Error(`Timeout after ${ms}ms`)));
-      }, ms)
-    );
-    return Promise.race([t, timeout]);
-  };
+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 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 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));
 }
 // 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,
+  createCamundaEffectClient,
+  eventually,
+  layer,
+  retryWithBackoff,
+  withTimeout
 });
 //# sourceMappingURL=index.cjs.map