@hasna/workflows 0.1.0 → 0.1.1

package/dist/handlers.js

@@ -1,5 +1,23 @@
 // @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
 // src/handlers.ts
+import { createHash, timingSafeEqual } from "crypto";
 function jsonResponse(body, status = 200) {
   return new Response(JSON.stringify(body), {
     status,
@@ -13,10 +31,85 @@ function openApiDoc(service) {
     paths: {
       "/health": { get: { summary: "Service health", responses: { "200": { description: "ok" } } } },
       "/ready": { get: { summary: "Service readiness", responses: { "200": { description: "ok" } } } },
-      "/version": { get: { summary: "Service version", responses: { "200": { description: "ok" } } } }
+      "/version": { get: { summary: "Service version", responses: { "200": { description: "ok" } } } },
+      "/trigger": {
+        post: {
+          summary: "Authenticated trigger: run a workflow graph to a terminal state",
+          security: [{ bearerAuth: [] }],
+          requestBody: {
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  required: ["graph"],
+                  properties: {
+                    graph: { type: "object", description: "the workflow graph" },
+                    context: { type: "object", description: "optional run context" },
+                    idempotencyKey: { type: "string", description: "re-run with the same key returns the same run" },
+                    maxCycles: { type: "number", description: "bound on reap cycles (default 500, max 2000)" }
+                  }
+                }
+              }
+            }
+          },
+          responses: {
+            "200": { description: "run summary" },
+            "401": { description: "missing or invalid Bearer token" },
+            "503": { description: "trigger not configured (WORKFLOWS_API_KEY unset)" }
+          }
+        }
+      }
+    },
+    components: {
+      securitySchemes: {
+        bearerAuth: { type: "http", scheme: "bearer" }
+      }
     }
   };
 }
+function bearerMatches(authHeader, expected) {
+  if (!authHeader.startsWith("Bearer "))
+    return false;
+  const supplied = authHeader.slice("Bearer ".length);
+  if (supplied.length === 0)
+    return false;
+  const a = createHash("sha256").update(supplied).digest();
+  const b = createHash("sha256").update(expected).digest();
+  return timingSafeEqual(a, b);
+}
+async function handleTrigger(service, req) {
+  const expected = service.config.apiKey;
+  if (!expected) {
+    return jsonResponse({ error: "trigger_not_configured", message: "WORKFLOWS_API_KEY is not configured \u2014 set it to enable the authenticated trigger" }, 503);
+  }
+  const auth = req.headers.get("authorization") ?? "";
+  if (!bearerMatches(auth, expected)) {
+    return jsonResponse({ error: "unauthorized", message: "a valid Bearer token is required" }, 401);
+  }
+  let body;
+  try {
+    body = await req.json();
+  } catch {
+    return jsonResponse({ error: "invalid_json", message: "request body must be JSON" }, 400);
+  }
+  const record = body;
+  if (record.graph === null || typeof record.graph !== "object" || Array.isArray(record.graph)) {
+    return jsonResponse({ error: "graph_required", message: "body.graph must be a workflow graph object" }, 400);
+  }
+  const context = record.context ?? {};
+  if (typeof context !== "object" || Array.isArray(context)) {
+    return jsonResponse({ error: "invalid_context", message: "body.context must be an object" }, 400);
+  }
+  const maxCycles = typeof record.maxCycles === "number" ? record.maxCycles : undefined;
+  const idempotencyKey = typeof record.idempotencyKey === "string" ? record.idempotencyKey : undefined;
+  try {
+    const summary = await service.triggerRun(record.graph, context, { maxCycles, idempotencyKey });
+    return jsonResponse(summary);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return jsonResponse({ error: "trigger_failed", message }, 400);
+  }
+}
 function createRequestHandler(service) {
   return (req) => {
     const url = new URL(req.url);
@@ -27,6 +120,8 @@ function createRequestHandler(service) {
         return jsonResponse(service.ready());
       case "/version":
         return jsonResponse({ service: service.name, version: service.version });
+      case "/trigger":
+        return handleTrigger(service, req);
       case "/openapi.json":
         return jsonResponse(openApiDoc(service));
       default: