@cometloop/safe 0.0.1

package/dist/index.cjs

@@ -0,0 +1,692 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  TimeoutError: () => TimeoutError,
+  createSafe: () => createSafe,
+  err: () => err,
+  errObj: () => errObj,
+  ok: () => ok,
+  okObj: () => okObj,
+  safe: () => safe,
+  withObjects: () => withObjects
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/safe/types.ts
+function ok(value) {
+  const tuple = [value, null];
+  Object.defineProperties(tuple, {
+    ok: { value: true, enumerable: false },
+    value: { value, enumerable: false },
+    error: { value: null, enumerable: false }
+  });
+  return tuple;
+}
+function err(error) {
+  const tuple = [null, error];
+  Object.defineProperties(tuple, {
+    ok: { value: false, enumerable: false },
+    value: { value: null, enumerable: false },
+    error: { value: error, enumerable: false }
+  });
+  return tuple;
+}
+function okObj(data) {
+  return { ok: true, data, error: null };
+}
+function errObj(error) {
+  return { ok: false, data: null, error };
+}
+var TimeoutError = class extends Error {
+  constructor(ms) {
+    super(`Operation timed out after ${ms}ms`);
+    this.name = "TimeoutError";
+  }
+};
+
+// src/safe/safe.ts
+var HOOK_KEY_MAP = {
+  parseResult: true,
+  onSuccess: true,
+  onError: true,
+  onSettled: true,
+  onHookError: true,
+  defaultError: true,
+  onRetry: true,
+  retry: true,
+  abortAfter: true
+};
+var HOOK_KEYS = new Set(Object.keys(HOOK_KEY_MAP));
+var FUNCTION_HOOK_KEYS = /* @__PURE__ */ new Set([
+  "parseResult",
+  "onSuccess",
+  "onError",
+  "onSettled",
+  "onHookError",
+  "onRetry"
+]);
+var isHooks = (arg) => {
+  if (typeof arg !== "object" || arg === null || Array.isArray(arg))
+    return false;
+  const keys = Object.keys(arg);
+  if (keys.length === 0) return false;
+  const obj = arg;
+  for (const key of keys) {
+    if (!HOOK_KEYS.has(key)) return false;
+    const val = obj[key];
+    if (val === void 0) continue;
+    if (FUNCTION_HOOK_KEYS.has(key)) {
+      if (typeof val !== "function") return false;
+    } else if (key === "retry") {
+      if (typeof val !== "object" || val === null) return false;
+    } else if (key === "abortAfter") {
+      if (typeof val !== "number") return false;
+    }
+  }
+  return true;
+};
+var callHook = (fn, onHookError, hookName) => {
+  try {
+    fn?.();
+  } catch (e) {
+    try {
+      onHookError?.(e, hookName ?? "unknown");
+    } catch {
+    }
+  }
+};
+var toError = (e) => {
+  if (e instanceof Error) return e;
+  const error = new Error(String(e));
+  error.cause = e;
+  return error;
+};
+var callParseError = (e, parseError, onHookError, defaultError) => {
+  if (!parseError) return toError(e);
+  try {
+    return parseError(e);
+  } catch (parseErrorException) {
+    try {
+      onHookError?.(parseErrorException, "parseError");
+    } catch {
+    }
+    return defaultError ?? toError(e);
+  }
+};
+var callParseResult = (parseResult, rawResult) => {
+  if (!parseResult) return rawResult;
+  return parseResult(rawResult);
+};
+var sanitiseRetryTimes = (times) => {
+  if (times === void 0) return 0;
+  const n = Math.floor(times);
+  if (!Number.isFinite(n) || n < 0) return 0;
+  return n;
+};
+var validateAbortAfter = (ms) => {
+  if (ms === void 0) return void 0;
+  if (!Number.isFinite(ms) || ms < 0) {
+    throw new RangeError(
+      `abortAfter must be a non-negative finite number, got ${ms}`
+    );
+  }
+  return ms;
+};
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var withTimeout = (promise, ms, controller) => {
+  let timeoutId;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => {
+      controller.abort();
+      reject(new TimeoutError(ms));
+    }, ms);
+  });
+  return Promise.race([promise, timeoutPromise]).finally(() => {
+    clearTimeout(timeoutId);
+  });
+};
+function safeSync(fn, parseErrorOrHooks, hooks) {
+  const context = [];
+  let parseError;
+  let resolvedHooks;
+  if (isHooks(parseErrorOrHooks)) {
+    resolvedHooks = parseErrorOrHooks;
+  } else {
+    parseError = parseErrorOrHooks;
+    resolvedHooks = hooks;
+  }
+  const onHookError = resolvedHooks?.onHookError;
+  try {
+    const rawResult = fn();
+    const result = callParseResult(resolvedHooks?.parseResult, rawResult);
+    callHook(
+      () => resolvedHooks?.onSuccess?.(result, context),
+      onHookError,
+      "onSuccess"
+    );
+    callHook(
+      () => resolvedHooks?.onSettled?.(result, null, context),
+      onHookError,
+      "onSettled"
+    );
+    return ok(result);
+  } catch (e) {
+    const error = callParseError(
+      e,
+      parseError,
+      onHookError,
+      resolvedHooks?.defaultError
+    );
+    callHook(
+      () => resolvedHooks?.onError?.(error, context),
+      onHookError,
+      "onError"
+    );
+    callHook(
+      () => resolvedHooks?.onSettled?.(null, error, context),
+      onHookError,
+      "onSettled"
+    );
+    return err(error);
+  }
+}
+async function safeAsync(fn, parseErrorOrHooks, hooks) {
+  const context = [];
+  let parseError;
+  let resolvedHooks;
+  if (isHooks(parseErrorOrHooks)) {
+    resolvedHooks = parseErrorOrHooks;
+  } else {
+    parseError = parseErrorOrHooks;
+    resolvedHooks = hooks;
+  }
+  const maxAttempts = sanitiseRetryTimes(resolvedHooks?.retry?.times) + 1;
+  const abortAfter = validateAbortAfter(resolvedHooks?.abortAfter);
+  const onHookError = resolvedHooks?.onHookError;
+  let lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    const controller = abortAfter !== void 0 ? new AbortController() : void 0;
+    try {
+      let promise = fn(controller?.signal);
+      if (abortAfter !== void 0 && controller) {
+        promise = withTimeout(promise, abortAfter, controller);
+      }
+      const rawResult = await promise;
+      const result = callParseResult(resolvedHooks?.parseResult, rawResult);
+      callHook(
+        () => resolvedHooks?.onSuccess?.(result, context),
+        onHookError,
+        "onSuccess"
+      );
+      callHook(
+        () => resolvedHooks?.onSettled?.(result, null, context),
+        onHookError,
+        "onSettled"
+      );
+      return ok(result);
+    } catch (e) {
+      lastError = callParseError(
+        e,
+        parseError,
+        onHookError,
+        resolvedHooks?.defaultError
+      );
+      if (attempt < maxAttempts) {
+        callHook(
+          () => resolvedHooks?.onRetry?.(lastError, attempt, context),
+          onHookError,
+          "onRetry"
+        );
+        const waitMs = resolvedHooks?.retry?.waitBefore?.(attempt) ?? 0;
+        if (waitMs > 0 && Number.isFinite(waitMs)) {
+          await sleep(waitMs);
+        }
+      }
+    }
+  }
+  callHook(
+    () => resolvedHooks?.onError?.(lastError, context),
+    onHookError,
+    "onError"
+  );
+  callHook(
+    () => resolvedHooks?.onSettled?.(null, lastError, context),
+    onHookError,
+    "onSettled"
+  );
+  return err(lastError);
+}
+function wrap(fn, parseErrorOrHooks, hooks) {
+  let parseError;
+  let resolvedHooks;
+  if (isHooks(parseErrorOrHooks)) {
+    resolvedHooks = parseErrorOrHooks;
+  } else {
+    parseError = parseErrorOrHooks;
+    resolvedHooks = hooks;
+  }
+  const onHookError = resolvedHooks?.onHookError;
+  return function(...args) {
+    try {
+      const rawResult = fn.call(this, ...args);
+      const result = callParseResult(resolvedHooks?.parseResult, rawResult);
+      callHook(
+        () => resolvedHooks?.onSuccess?.(result, args),
+        onHookError,
+        "onSuccess"
+      );
+      callHook(
+        () => resolvedHooks?.onSettled?.(result, null, args),
+        onHookError,
+        "onSettled"
+      );
+      return ok(result);
+    } catch (e) {
+      const error = callParseError(
+        e,
+        parseError,
+        onHookError,
+        resolvedHooks?.defaultError
+      );
+      callHook(
+        () => resolvedHooks?.onError?.(error, args),
+        onHookError,
+        "onError"
+      );
+      callHook(
+        () => resolvedHooks?.onSettled?.(null, error, args),
+        onHookError,
+        "onSettled"
+      );
+      return err(error);
+    }
+  };
+}
+function wrapAsync(fn, parseErrorOrHooks, hooks) {
+  let parseError;
+  let resolvedHooks;
+  if (isHooks(parseErrorOrHooks)) {
+    resolvedHooks = parseErrorOrHooks;
+  } else {
+    parseError = parseErrorOrHooks;
+    resolvedHooks = hooks;
+  }
+  const maxAttempts = sanitiseRetryTimes(resolvedHooks?.retry?.times) + 1;
+  const abortAfter = validateAbortAfter(resolvedHooks?.abortAfter);
+  const onHookError = resolvedHooks?.onHookError;
+  return async function(...args) {
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      const controller = abortAfter !== void 0 ? new AbortController() : void 0;
+      try {
+        let promise = fn.call(this, ...args);
+        if (abortAfter !== void 0 && controller) {
+          promise = withTimeout(promise, abortAfter, controller);
+        }
+        const rawResult = await promise;
+        const result = callParseResult(resolvedHooks?.parseResult, rawResult);
+        callHook(
+          () => resolvedHooks?.onSuccess?.(result, args),
+          onHookError,
+          "onSuccess"
+        );
+        callHook(
+          () => resolvedHooks?.onSettled?.(result, null, args),
+          onHookError,
+          "onSettled"
+        );
+        return ok(result);
+      } catch (e) {
+        lastError = callParseError(
+          e,
+          parseError,
+          onHookError,
+          resolvedHooks?.defaultError
+        );
+        if (attempt < maxAttempts) {
+          callHook(
+            () => resolvedHooks?.onRetry?.(lastError, attempt, args),
+            onHookError,
+            "onRetry"
+          );
+          const waitMs = resolvedHooks?.retry?.waitBefore?.(attempt) ?? 0;
+          if (waitMs > 0 && Number.isFinite(waitMs)) {
+            await sleep(waitMs);
+          }
+        }
+      }
+    }
+    callHook(
+      () => resolvedHooks?.onError?.(lastError, args),
+      onHookError,
+      "onError"
+    );
+    callHook(
+      () => resolvedHooks?.onSettled?.(null, lastError, args),
+      onHookError,
+      "onSettled"
+    );
+    return err(lastError);
+  };
+}
+function safeAll(promises) {
+  const keys = Object.keys(promises);
+  const values = Object.values(promises);
+  if (values.length === 0) {
+    return Promise.resolve(ok({}));
+  }
+  return new Promise((resolve) => {
+    const results = new Array(values.length);
+    let remaining = values.length;
+    let done = false;
+    for (let i = 0; i < values.length; i++) {
+      values[i].then(
+        (result) => {
+          if (done) return;
+          if (!result.ok) {
+            done = true;
+            resolve(err(result.error));
+            return;
+          }
+          results[i] = result;
+          remaining--;
+          if (remaining === 0) {
+            done = true;
+            const obj = {};
+            for (let j = 0; j < keys.length; j++) {
+              obj[keys[j]] = results[j].value;
+            }
+            resolve(ok(obj));
+          }
+        },
+        // Safety net: safe-wrapped promises should never reject.
+        // No parseError is available in the standalone API, so toError is
+        // the best fallback. Use createSafe.all() if custom error mapping is needed.
+        (rejection) => {
+          if (done) return;
+          done = true;
+          resolve(err(toError(rejection)));
+        }
+      );
+    }
+  });
+}
+async function safeAllSettled(promises) {
+  const keys = Object.keys(promises);
+  const values = Object.values(promises);
+  const results = await Promise.all(
+    values.map(
+      (p) => p.catch(
+        (rejection) => err(toError(rejection))
+      )
+    )
+  );
+  const obj = {};
+  for (let i = 0; i < keys.length; i++) {
+    obj[keys[i]] = results[i];
+  }
+  return obj;
+}
+var safe = {
+  sync: safeSync,
+  async: safeAsync,
+  wrap,
+  wrapAsync,
+  all: safeAll,
+  allSettled: safeAllSettled
+};
+
+// src/safe/createSafe.ts
+function createSafe(config) {
+  const {
+    parseError,
+    defaultError,
+    parseResult: defaultParseResult,
+    onSuccess: defaultOnSuccess,
+    onError: defaultOnError,
+    onSettled: defaultOnSettled,
+    onRetry: defaultOnRetry,
+    retry: defaultRetry,
+    abortAfter: defaultAbortAfter,
+    onHookError: defaultOnHookError
+  } = config;
+  const mergeHooks = (hooks) => {
+    const onHookError = hooks?.onHookError ?? defaultOnHookError;
+    return {
+      parseResult: hooks?.parseResult ?? defaultParseResult,
+      onSuccess: (result, context) => {
+        callHook(() => defaultOnSuccess?.(result), onHookError, "onSuccess");
+        hooks?.onSuccess?.(result, context);
+      },
+      onError: (error, context) => {
+        callHook(() => defaultOnError?.(error), onHookError, "onError");
+        hooks?.onError?.(error, context);
+      },
+      onSettled: (result, error, context) => {
+        callHook(
+          () => defaultOnSettled?.(result, error),
+          onHookError,
+          "onSettled"
+        );
+        hooks?.onSettled?.(result, error, context);
+      },
+      onHookError,
+      defaultError: hooks?.defaultError ?? defaultError
+    };
+  };
+  const mergeAsyncHooks = (hooks) => {
+    const onHookError = hooks?.onHookError ?? defaultOnHookError;
+    return {
+      parseResult: hooks?.parseResult ?? defaultParseResult,
+      onSuccess: (result, context) => {
+        callHook(() => defaultOnSuccess?.(result), onHookError, "onSuccess");
+        hooks?.onSuccess?.(result, context);
+      },
+      onError: (error, context) => {
+        callHook(() => defaultOnError?.(error), onHookError, "onError");
+        hooks?.onError?.(error, context);
+      },
+      onSettled: (result, error, context) => {
+        callHook(
+          () => defaultOnSettled?.(result, error),
+          onHookError,
+          "onSettled"
+        );
+        hooks?.onSettled?.(result, error, context);
+      },
+      onRetry: (error, attempt, context) => {
+        callHook(() => defaultOnRetry?.(error, attempt), onHookError, "onRetry");
+        hooks?.onRetry?.(error, attempt, context);
+      },
+      // Per-call retry completely overrides default retry
+      retry: hooks?.retry ?? defaultRetry,
+      // Per-call abortAfter overrides default abortAfter
+      abortAfter: hooks?.abortAfter ?? defaultAbortAfter,
+      onHookError,
+      defaultError: hooks?.defaultError ?? defaultError
+    };
+  };
+  return {
+    sync: (fn, hooks) => {
+      return safeSync(
+        fn,
+        parseError,
+        mergeHooks(hooks)
+      );
+    },
+    async: (fn, hooks) => {
+      return safeAsync(
+        fn,
+        parseError,
+        mergeAsyncHooks(hooks)
+      );
+    },
+    wrap: (fn, hooks) => {
+      return wrap(
+        fn,
+        parseError,
+        mergeHooks(hooks)
+      );
+    },
+    wrapAsync: (fn, hooks) => {
+      return wrapAsync(
+        fn,
+        parseError,
+        mergeAsyncHooks(hooks)
+      );
+    },
+    all: (fns) => {
+      const keys = Object.keys(fns);
+      const promises = keys.map(
+        (key) => safeAsync(
+          fns[key],
+          parseError,
+          mergeAsyncHooks()
+        )
+      );
+      if (promises.length === 0) {
+        return Promise.resolve(ok({}));
+      }
+      return new Promise((resolve) => {
+        const results = new Array(promises.length);
+        let remaining = promises.length;
+        let done = false;
+        for (let i = 0; i < promises.length; i++) {
+          promises[i].then(
+            (result) => {
+              if (done) return;
+              if (!result.ok) {
+                done = true;
+                resolve(err(result.error));
+                return;
+              }
+              results[i] = result;
+              remaining--;
+              if (remaining === 0) {
+                done = true;
+                const obj = {};
+                for (let j = 0; j < keys.length; j++) {
+                  obj[keys[j]] = results[j].value;
+                }
+                resolve(ok(obj));
+              }
+            },
+            (rejection) => {
+              if (done) return;
+              done = true;
+              resolve(
+                err(
+                  callParseError(
+                    rejection,
+                    parseError,
+                    defaultOnHookError,
+                    defaultError
+                  )
+                )
+              );
+            }
+          );
+        }
+      });
+    },
+    allSettled: async (fns) => {
+      const keys = Object.keys(fns);
+      const promises = keys.map(
+        (key) => safeAsync(
+          fns[key],
+          parseError,
+          mergeAsyncHooks()
+        )
+      );
+      const results = await Promise.all(promises);
+      const obj = {};
+      for (let i = 0; i < keys.length; i++) {
+        obj[keys[i]] = results[i];
+      }
+      return obj;
+    }
+  };
+}
+
+// src/safe/withObjects.ts
+function toObjectResult(result) {
+  if (result.ok) return okObj(result.value);
+  return errObj(result.error);
+}
+function withObjects(input) {
+  if (Array.isArray(input)) {
+    return toObjectResult(input);
+  }
+  if (input instanceof Promise) {
+    return input.then(
+      (result) => toObjectResult(result)
+    );
+  }
+  if (typeof input === "function") {
+    return (...args) => {
+      const result = input(...args);
+      if (result instanceof Promise) {
+        return result.then(
+          (r) => toObjectResult(r)
+        );
+      }
+      return toObjectResult(result);
+    };
+  }
+  if (typeof input === "object" && input !== null && "sync" in input && "async" in input) {
+    const instance = input;
+    return {
+      sync: (fn, hooks) => toObjectResult(instance.sync(fn, hooks)),
+      async: (fn, hooks) => instance.async(fn, hooks).then(toObjectResult),
+      wrap: (fn, hooks) => {
+        const wrapped = instance.wrap(fn, hooks);
+        return (...args) => toObjectResult(wrapped(...args));
+      },
+      wrapAsync: (fn, hooks) => {
+        const wrapped = instance.wrapAsync(fn, hooks);
+        return (...args) => wrapped(...args).then(toObjectResult);
+      },
+      all: (fns) => instance.all(fns).then(toObjectResult),
+      allSettled: async (fns) => {
+        const results = await instance.allSettled(fns);
+        const obj = {};
+        for (const key of Object.keys(results)) {
+          obj[key] = toObjectResult(results[key]);
+        }
+        return obj;
+      }
+    };
+  }
+  throw new TypeError("withObjects: unsupported input type");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TimeoutError,
+  createSafe,
+  err,
+  errObj,
+  ok,
+  okObj,
+  safe,
+  withObjects
+});
+//# sourceMappingURL=index.cjs.map