awaitly 2.0.0 → 3.0.0

package/dist/webhook.js

@@ -0,0 +1,422 @@
+// src/slugs.ts
+var AWAITLY_SLUGS = {
+  // --- step-* ---
+  "step-require-id": "step-require-id",
+  "step-no-immediate-execution": "step-no-immediate-execution",
+  "step-require-thunk-for-key": "step-require-thunk-for-key",
+  "step-no-bare-await": "step-no-bare-await",
+  "step-no-try-catch-wrap": "step-no-try-catch-wrap",
+  "step-stable-cache-keys": "step-stable-cache-keys",
+  // --- workflow-* ---
+  "workflow-no-floating": "workflow-no-floating",
+  "workflow-options-position": "workflow-options-position",
+  "workflow-callback-shape": "workflow-callback-shape",
+  "workflow-no-callable-form": "workflow-no-callable-form",
+  "workflow-no-dynamic-import": "workflow-no-dynamic-import",
+  "workflow-prefer-step-if": "workflow-prefer-step-if",
+  "workflow-prefer-step-foreach": "workflow-prefer-step-foreach",
+  // --- result-* ---
+  "result-no-floating": "result-no-floating",
+  "result-require-handling": "result-require-handling",
+  "result-no-double-wrap": "result-no-double-wrap",
+  "result-no-manual-propagation": "result-no-manual-propagation",
+  "result-no-direct-ok-err": "result-no-direct-ok-err",
+  // --- error-* ---
+  "error-check-unexpected-first": "error-check-unexpected-first",
+  "error-access-cause": "error-access-cause",
+  "error-normalize": "error-normalize",
+  "error-no-throw-in-deps": "error-no-throw-in-deps",
+  // --- concurrency-* ---
+  "concurrency-no-promise-all": "concurrency-no-promise-all",
+  "concurrency-no-promise-race": "concurrency-no-promise-race",
+  "concurrency-no-promise-allsettled": "concurrency-no-promise-allsettled",
+  // --- runtime-* ---
+  "runtime-step-timeout": "runtime-step-timeout",
+  "runtime-step-aborted": "runtime-step-aborted",
+  "runtime-retry-exhausted": "runtime-retry-exhausted",
+  "runtime-rate-limit": "runtime-rate-limit",
+  "runtime-circuit-open": "runtime-circuit-open",
+  "runtime-unexpected": "runtime-unexpected",
+  "runtime-resolver-not-found": "runtime-resolver-not-found",
+  "runtime-saga-compensation": "runtime-saga-compensation"
+};
+function slugDocsUrl(slug) {
+  return `https://jagreehal.github.io/awaitly/rules/#${slug}`;
+}
+var ALL_SLUGS = Object.keys(
+  AWAITLY_SLUGS
+);
+
+// src/tagged-error.ts
+var InternalTaggedErrorBase = class extends Error {
+  type;
+  /** @deprecated Use `type`. */
+  _tag;
+};
+function TaggedError(tag, options) {
+  return class extends InternalTaggedErrorBase {
+    type = tag;
+    /** @deprecated Use `type`. */
+    _tag = tag;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    constructor(props, errorOptions) {
+      const message = options?.message ? options.message(props ?? {}) : tag;
+      super(message);
+      this.name = tag;
+      if (options?.slug !== void 0) {
+        if (!options.hint) {
+          throw new TypeError(
+            `TaggedError: 'hint' is required when 'slug' is set (slug: "${options.slug}")`
+          );
+        }
+        Object.defineProperty(this, "code", {
+          value: options.slug,
+          enumerable: true,
+          writable: false,
+          configurable: false
+        });
+        Object.defineProperty(this, "hint", {
+          value: options.hint,
+          enumerable: true,
+          writable: false,
+          configurable: false
+        });
+        Object.defineProperty(this, "docsUrl", {
+          value: slugDocsUrl(options.slug),
+          enumerable: true,
+          writable: false,
+          configurable: false
+        });
+      }
+      Object.setPrototypeOf(this, new.target.prototype);
+      if (props && typeof props === "object") {
+        let safeProps;
+        if (options?.slug !== void 0) {
+          const {
+            _tag: _,
+            type: _t,
+            name: _n,
+            message: _m,
+            stack: _s,
+            code: _c,
+            hint: _h,
+            docsUrl: _d,
+            ...rest
+          } = props;
+          safeProps = rest;
+        } else {
+          const {
+            _tag: _,
+            type: _t,
+            name: _n,
+            message: _m,
+            stack: _s,
+            ...rest
+          } = props;
+          safeProps = rest;
+        }
+        const hasUserCause = Object.prototype.hasOwnProperty.call(
+          safeProps,
+          "cause"
+        );
+        const userCause = hasUserCause ? safeProps.cause : void 0;
+        if (hasUserCause) {
+          delete safeProps.cause;
+        }
+        const hasOptionsCause = errorOptions?.cause !== void 0;
+        if (hasUserCause && hasOptionsCause) {
+          throw new TypeError(
+            "TaggedError: cannot provide 'cause' in props when also setting ErrorOptions.cause"
+          );
+        }
+        Object.assign(this, safeProps);
+        if (hasUserCause) {
+          this.cause = userCause;
+        }
+        if (hasOptionsCause) {
+          this.cause = errorOptions?.cause;
+        }
+      } else if (errorOptions?.cause !== void 0) {
+        this.cause = errorOptions.cause;
+      }
+    }
+  };
+}
+Object.defineProperty(TaggedError, Symbol.hasInstance, {
+  value: (instance) => instance instanceof InternalTaggedErrorBase
+});
+((TaggedError2) => {
+  function isError(value) {
+    return value instanceof Error;
+  }
+  TaggedError2.isError = isError;
+  function isTaggedError(value) {
+    return value instanceof InternalTaggedErrorBase;
+  }
+  TaggedError2.isTaggedError = isTaggedError;
+  function match(error, handlers) {
+    const tag = error._tag;
+    const handler = handlers[tag];
+    return handler(
+      error
+    );
+  }
+  TaggedError2.match = match;
+  function matchPartial(error, handlers, otherwise) {
+    const tag = error._tag;
+    const handler = handlers[tag];
+    if (handler) {
+      return handler(
+        error
+      );
+    }
+    return otherwise(error);
+  }
+  TaggedError2.matchPartial = matchPartial;
+})(TaggedError || (TaggedError = {}));
+
+// src/errors.ts
+var UnexpectedError = class extends (/* @__PURE__ */ TaggedError("UnexpectedError", {
+  slug: "runtime-unexpected",
+  hint: "An unexpected exception escaped a step. Inspect cause; consider returning a typed Result instead of throwing.",
+  message: (p) => `UnexpectedError: ${p.cause instanceof Error ? p.cause.message : String(p.cause ?? "unknown")}`
+})) {
+};
+
+// src/core/index.ts
+function ok(value) {
+  return { ok: true, value };
+}
+function err(error, options) {
+  const cause = options?.cause;
+  return { ok: false, error, ...cause !== void 0 ? { cause } : {} };
+}
+var isOk = (r) => r.ok;
+var isUnexpectedError = (e) => e instanceof UnexpectedError || typeof e === "object" && e !== null && "_tag" in e && e._tag === "UnexpectedError";
+
+// src/webhook/index.ts
+function isValidationError(e) {
+  return typeof e === "object" && e !== null && e.type === "VALIDATION_ERROR";
+}
+function defaultValidationErrorMapper(error) {
+  return {
+    status: 400,
+    body: {
+      error: {
+        type: error.type,
+        message: error.message,
+        details: error.field ? { field: error.field } : error.details
+      }
+    }
+  };
+}
+function defaultUnexpectedErrorMapper(error) {
+  return {
+    status: 500,
+    body: {
+      error: {
+        type: "INTERNAL_ERROR",
+        message: error instanceof Error ? error.message : "An unexpected error occurred"
+      }
+    }
+  };
+}
+function createWebhookHandler(workflow, workflowFn, config) {
+  const {
+    validateInput,
+    mapResult,
+    mapValidationError = defaultValidationErrorMapper,
+    mapUnexpectedError = defaultUnexpectedErrorMapper,
+    beforeValidation,
+    afterResponse
+  } = config;
+  return async (req) => {
+    try {
+      const processedReq = beforeValidation ? await beforeValidation(req) : req;
+      const validationResult = await validateInput(processedReq);
+      if (!isOk(validationResult)) {
+        const response2 = mapValidationError(validationResult.error, processedReq);
+        return afterResponse ? await afterResponse(response2, processedReq) : response2;
+      }
+      const args = validationResult.value;
+      const workflowResult = await workflow.run(
+        async ({ step, deps }) => workflowFn({ step, deps, args })
+      );
+      const response = mapResult(workflowResult, processedReq);
+      return afterResponse ? await afterResponse(response, processedReq) : response;
+    } catch (error) {
+      const response = mapUnexpectedError(error, req);
+      return afterResponse ? await afterResponse(response, req) : response;
+    }
+  };
+}
+function createSimpleHandler(config) {
+  const {
+    validateInput,
+    handler,
+    mapResult,
+    mapValidationError = defaultValidationErrorMapper,
+    mapUnexpectedError = defaultUnexpectedErrorMapper
+  } = config;
+  return async (req) => {
+    try {
+      const validationResult = await validateInput(req);
+      if (!isOk(validationResult)) {
+        return mapValidationError(validationResult.error, req);
+      }
+      const result = await handler(validationResult.value, req);
+      return mapResult(result, req);
+    } catch (error) {
+      return mapUnexpectedError(error, req);
+    }
+  };
+}
+function createResultMapper(mappings, options = {}) {
+  const { defaultStatus = 500, successStatus = 200 } = options;
+  const errorMap = /* @__PURE__ */ new Map();
+  for (const mapping of mappings) {
+    errorMap.set(mapping.error, mapping);
+  }
+  return (result) => {
+    if (result.ok) {
+      return {
+        status: successStatus,
+        body: result.value
+      };
+    }
+    if (isUnexpectedError(result.error)) {
+      return {
+        status: 500,
+        body: {
+          error: {
+            type: "INTERNAL_ERROR",
+            message: result.error instanceof Error ? result.error.message : "An unexpected error occurred"
+          }
+        }
+      };
+    }
+    const mapping = errorMap.get(result.error);
+    if (mapping) {
+      return {
+        status: mapping.status,
+        body: {
+          error: {
+            type: String(mapping.error),
+            message: mapping.message
+          }
+        }
+      };
+    }
+    return {
+      status: defaultStatus,
+      body: {
+        error: {
+          type: String(result.error)
+        }
+      }
+    };
+  };
+}
+function toWebhookRequest(req) {
+  return {
+    method: req.method,
+    path: req.path,
+    headers: req.headers,
+    body: req.body,
+    query: req.query,
+    params: req.params,
+    raw: req
+  };
+}
+function sendWebhookResponse(res, response) {
+  if (response.headers) {
+    res.set(response.headers);
+  }
+  res.status(response.status).json(response.body);
+}
+function createExpressHandler(handler) {
+  return async (req, res) => {
+    const webhookReq = toWebhookRequest(req);
+    const response = await handler(webhookReq);
+    sendWebhookResponse(res, response);
+  };
+}
+function validationError(message, field, details) {
+  return {
+    type: "VALIDATION_ERROR",
+    message,
+    field,
+    details
+  };
+}
+function requireFields(fields) {
+  return (body) => {
+    for (const field of fields) {
+      if (body[field] === void 0 || body[field] === null || body[field] === "") {
+        return err(validationError(`Missing required field: ${field}`, field));
+      }
+    }
+    return ok(void 0);
+  };
+}
+function composeValidators(...validators) {
+  return (input) => {
+    for (const validator of validators) {
+      const result = validator(input);
+      if (!result.ok) return result;
+    }
+    return ok(void 0);
+  };
+}
+function createEventHandler(workflow, workflowFn, config) {
+  const { validatePayload, mapResult } = config;
+  return async (event) => {
+    try {
+      const validationResult = validatePayload(event);
+      if (!isOk(validationResult)) {
+        return {
+          success: false,
+          ack: true,
+          // Don't retry validation errors
+          error: {
+            type: validationResult.error.type,
+            message: validationResult.error.message,
+            retryable: false
+          }
+        };
+      }
+      const args = validationResult.value;
+      const workflowResult = await workflow.run(
+        async ({ step, deps }) => workflowFn({ step, deps, args })
+      );
+      return mapResult(workflowResult, event);
+    } catch (error) {
+      return {
+        success: false,
+        ack: false,
+        // Retry unexpected errors
+        error: {
+          type: "UnexpectedError",
+          message: error instanceof Error ? error.message : String(error),
+          retryable: true
+        }
+      };
+    }
+  };
+}
+export {
+  composeValidators,
+  createEventHandler,
+  createExpressHandler,
+  createResultMapper,
+  createSimpleHandler,
+  createWebhookHandler,
+  defaultUnexpectedErrorMapper,
+  defaultValidationErrorMapper,
+  isValidationError,
+  requireFields,
+  sendWebhookResponse,
+  toWebhookRequest,
+  validationError
+};
+//# sourceMappingURL=webhook.js.map