@coji/durably 0.6.0 → 0.6.1

package/dist/index.js

@@ -1,3 +1,7 @@
+import {
+  withLogPersistence
+} from "./chunk-UCUP6NMJ.js";
+
 // src/durably.ts
 import { Kysely } from "kysely";
 
@@ -48,6 +52,15 @@ function createEventEmitter() {
 }
 
 // src/job.ts
+import { prettifyError } from "zod";
+function validateJobInputOrThrow(schema, input, context) {
+  const result = schema.safeParse(input);
+  if (!result.success) {
+    const prefix = context ? `${context}: ` : "";
+    throw new Error(`${prefix}Invalid input: ${prettifyError(result.error)}`);
+  }
+  return result.data;
+}
 function createJobRegistry() {
   const jobs = /* @__PURE__ */ new Map();
   return {
@@ -77,13 +90,10 @@ function createJobHandle(jobDef, storage, eventEmitter, registry) {
   const handle = {
     name: jobDef.name,
     async trigger(input, options) {
-      const parseResult = inputSchema.safeParse(input);
-      if (!parseResult.success) {
-        throw new Error(`Invalid input: ${parseResult.error.message}`);
-      }
+      const validatedInput = validateJobInputOrThrow(inputSchema, input);
       const run = await storage.createRun({
         jobName: jobDef.name,
-        payload: parseResult.data,
+        payload: validatedInput,
         idempotencyKey: options?.idempotencyKey,
         concurrencyKey: options?.concurrencyKey
       });
@@ -91,7 +101,7 @@ function createJobHandle(jobDef, storage, eventEmitter, registry) {
         type: "run:trigger",
         runId: run.id,
         jobName: jobDef.name,
-        payload: parseResult.data
+        payload: validatedInput
       });
       return run;
     },
@@ -161,14 +171,13 @@ function createJobHandle(jobDef, storage, eventEmitter, registry) {
       });
       const validated = [];
       for (let i = 0; i < normalized.length; i++) {
-        const parseResult = inputSchema.safeParse(normalized[i].input);
-        if (!parseResult.success) {
-          throw new Error(
-            `Invalid input at index ${i}: ${parseResult.error.message}`
-          );
-        }
+        const validatedInput = validateJobInputOrThrow(
+          inputSchema,
+          normalized[i].input,
+          `at index ${i}`
+        );
         validated.push({
-          payload: parseResult.data,
+          payload: validatedInput,
           options: normalized[i].options
         });
       }
@@ -424,7 +433,7 @@ function createKyselyStorage(db) {
     async getNextPendingRun(excludeConcurrencyKeys) {
       let query = db.selectFrom("durably_runs").leftJoin("durably_steps", "durably_runs.id", "durably_steps.run_id").selectAll("durably_runs").select(
         (eb) => eb.fn.count("durably_steps.id").as("step_count")
-      ).where("durably_runs.status", "=", "pending").groupBy("durably_runs.id").orderBy("durably_runs.created_at", "asc").limit(1);
+      ).where("durably_runs.status", "=", "pending").groupBy("durably_runs.id").orderBy("durably_runs.created_at", "asc").orderBy("durably_runs.id", "asc").limit(1);
       if (excludeConcurrencyKeys.length > 0) {
         query = query.where(
           (eb) => eb.or([
@@ -487,6 +496,9 @@ function createKyselyStorage(db) {
   };
 }
 
+// src/worker.ts
+import { prettifyError as prettifyError2 } from "zod";
+
 // src/errors.ts
 var CancelledError = class extends Error {
   constructor(runId) {
@@ -494,6 +506,9 @@ var CancelledError = class extends Error {
     this.name = "CancelledError";
   }
 };
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
 
 // src/context.ts
 function createStepContext(run, jobName, storage, eventEmitter) {
@@ -641,9 +656,6 @@ function createWorker(config, storage, eventEmitter, jobRegistry) {
       });
     }
   }
-  function getErrorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-  }
   async function handleRunSuccess(runId, jobName, output, startTime) {
     const currentRun = await storage.getRun(runId);
     if (currentRun?.status === "cancelled") {
@@ -690,7 +702,7 @@ function createWorker(config, storage, eventEmitter, jobRegistry) {
       updateHeartbeat().catch((error) => {
         eventEmitter.emit({
           type: "worker:error",
-          error: error instanceof Error ? error.message : String(error),
+          error: getErrorMessage(error),
           context: "heartbeat",
           runId: run.id
         });
@@ -709,7 +721,7 @@ function createWorker(config, storage, eventEmitter, jobRegistry) {
       if (job.outputSchema) {
         const parseResult = job.outputSchema.safeParse(output);
         if (!parseResult.success) {
-          throw new Error(`Invalid output: ${parseResult.error.message}`);
+          throw new Error(`Invalid output: ${prettifyError2(parseResult.error)}`);
         }
       }
       await handleRunSuccess(run.id, run.jobName, output, startTime);
@@ -1051,22 +1063,104 @@ function defineJob(config) {
   };
 }
 
-// src/plugins/log-persistence.ts
-function withLogPersistence() {
-  return {
-    name: "log-persistence",
-    install(durably) {
-      durably.on("log:write", async (event) => {
-        await durably.storage.createLog({
-          runId: event.runId,
-          stepName: event.stepName,
-          level: event.level,
-          message: event.message,
-          data: event.data
-        });
-      });
+// src/http.ts
+var JSON_HEADERS = {
+  "Content-Type": "application/json"
+};
+function jsonResponse(data, status = 200) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: JSON_HEADERS
+  });
+}
+function errorResponse(message, status = 500) {
+  return jsonResponse({ error: message }, status);
+}
+function successResponse() {
+  return jsonResponse({ success: true });
+}
+function getRequiredQueryParam(url, paramName) {
+  const value = url.searchParams.get(paramName);
+  if (!value) {
+    return errorResponse(`${paramName} query parameter is required`, 400);
+  }
+  return value;
+}
+
+// src/sse.ts
+var SSE_HEADERS = {
+  "Content-Type": "text/event-stream",
+  "Cache-Control": "no-cache",
+  Connection: "keep-alive"
+};
+function formatSSE(data) {
+  return `data: ${JSON.stringify(data)}
+
+`;
+}
+function createSSEEncoder() {
+  return new TextEncoder();
+}
+function encodeSSE(encoder, data) {
+  return encoder.encode(formatSSE(data));
+}
+function createSSEResponse(stream) {
+  return new Response(stream, {
+    status: 200,
+    headers: SSE_HEADERS
+  });
+}
+function createSSEStreamFromReader(reader) {
+  const encoder = createSSEEncoder();
+  return new ReadableStream({
+    async start(controller) {
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) {
+            controller.close();
+            break;
+          }
+          controller.enqueue(encodeSSE(encoder, value));
+        }
+      } catch (error) {
+        controller.error(error);
+      }
+    },
+    cancel() {
+      reader.releaseLock();
     }
-  };
+  });
+}
+function createSSEStreamFromSubscriptions(setup) {
+  const encoder = createSSEEncoder();
+  let closed = false;
+  let unsubscribes = [];
+  return new ReadableStream({
+    start(controller) {
+      const sseController = {
+        enqueue: (data) => {
+          if (closed) return;
+          controller.enqueue(encodeSSE(encoder, data));
+        },
+        close: () => {
+          if (closed) return;
+          closed = true;
+          controller.close();
+        },
+        get closed() {
+          return closed;
+        }
+      };
+      unsubscribes = setup(sseController);
+    },
+    cancel() {
+      closed = true;
+      for (const unsubscribe of unsubscribes) {
+        unsubscribe();
+      }
+    }
+  });
 }
 
 // src/server.ts
@@ -1100,75 +1194,31 @@ function createDurablyHandler(durably, options) {
       try {
         const body = await request.json();
         if (!body.jobName) {
-          return new Response(
-            JSON.stringify({ error: "jobName is required" }),
-            { status: 400, headers: { "Content-Type": "application/json" } }
-          );
+          return errorResponse("jobName is required", 400);
         }
         const job = durably.getJob(body.jobName);
         if (!job) {
-          return new Response(
-            JSON.stringify({ error: `Job not found: ${body.jobName}` }),
-            { status: 404, headers: { "Content-Type": "application/json" } }
-          );
+          return errorResponse(`Job not found: ${body.jobName}`, 404);
         }
         const run = await job.trigger(body.input ?? {}, {
           idempotencyKey: body.idempotencyKey,
           concurrencyKey: body.concurrencyKey
         });
         const response = { runId: run.id };
-        return new Response(JSON.stringify(response), {
-          status: 200,
-          headers: { "Content-Type": "application/json" }
-        });
+        return jsonResponse(response);
       } catch (error) {
-        const message = error instanceof Error ? error.message : "Unknown error";
-        return new Response(JSON.stringify({ error: message }), {
-          status: 500,
-          headers: { "Content-Type": "application/json" }
-        });
+        return errorResponse(getErrorMessage(error), 500);
       }
     },
     subscribe(request) {
       const url = new URL(request.url);
-      const runId = url.searchParams.get("runId");
-      if (!runId) {
-        return new Response(
-          JSON.stringify({ error: "runId query parameter is required" }),
-          { status: 400, headers: { "Content-Type": "application/json" } }
-        );
-      }
+      const runId = getRequiredQueryParam(url, "runId");
+      if (runId instanceof Response) return runId;
       const stream = durably.subscribe(runId);
-      const encoder = new TextEncoder();
-      const sseStream = new ReadableStream({
-        async start(controller) {
-          const reader = stream.getReader();
-          try {
-            while (true) {
-              const { done, value } = await reader.read();
-              if (done) {
-                controller.close();
-                break;
-              }
-              const event = value;
-              const data = `data: ${JSON.stringify(event)}
-
-`;
-              controller.enqueue(encoder.encode(data));
-            }
-          } catch (error) {
-            controller.error(error);
-          }
-        }
-      });
-      return new Response(sseStream, {
-        status: 200,
-        headers: {
-          "Content-Type": "text/event-stream",
-          "Cache-Control": "no-cache",
-          Connection: "keep-alive"
-        }
-      });
+      const sseStream = createSSEStreamFromReader(
+        stream.getReader()
+      );
+      return createSSEResponse(sseStream);
     },
     async runs(request) {
       try {
@@ -1183,320 +1233,188 @@ function createDurablyHandler(durably, options) {
           limit: limit ? Number.parseInt(limit, 10) : void 0,
           offset: offset ? Number.parseInt(offset, 10) : void 0
         });
-        return new Response(JSON.stringify(runs), {
-          status: 200,
-          headers: { "Content-Type": "application/json" }
-        });
+        return jsonResponse(runs);
       } catch (error) {
-        const message = error instanceof Error ? error.message : "Unknown error";
-        return new Response(JSON.stringify({ error: message }), {
-          status: 500,
-          headers: { "Content-Type": "application/json" }
-        });
+        return errorResponse(getErrorMessage(error), 500);
       }
     },
     async run(request) {
       try {
         const url = new URL(request.url);
-        const runId = url.searchParams.get("runId");
-        if (!runId) {
-          return new Response(
-            JSON.stringify({ error: "runId query parameter is required" }),
-            { status: 400, headers: { "Content-Type": "application/json" } }
-          );
-        }
+        const runId = getRequiredQueryParam(url, "runId");
+        if (runId instanceof Response) return runId;
         const run = await durably.getRun(runId);
         if (!run) {
-          return new Response(JSON.stringify({ error: "Run not found" }), {
-            status: 404,
-            headers: { "Content-Type": "application/json" }
-          });
+          return errorResponse("Run not found", 404);
         }
-        return new Response(JSON.stringify(run), {
-          status: 200,
-          headers: { "Content-Type": "application/json" }
-        });
+        return jsonResponse(run);
       } catch (error) {
-        const message = error instanceof Error ? error.message : "Unknown error";
-        return new Response(JSON.stringify({ error: message }), {
-          status: 500,
-          headers: { "Content-Type": "application/json" }
-        });
+        return errorResponse(getErrorMessage(error), 500);
       }
     },
     async retry(request) {
       try {
         const url = new URL(request.url);
-        const runId = url.searchParams.get("runId");
-        if (!runId) {
-          return new Response(
-            JSON.stringify({ error: "runId query parameter is required" }),
-            { status: 400, headers: { "Content-Type": "application/json" } }
-          );
-        }
+        const runId = getRequiredQueryParam(url, "runId");
+        if (runId instanceof Response) return runId;
         await durably.retry(runId);
-        return new Response(JSON.stringify({ success: true }), {
-          status: 200,
-          headers: { "Content-Type": "application/json" }
-        });
+        return successResponse();
       } catch (error) {
-        const message = error instanceof Error ? error.message : "Unknown error";
-        return new Response(JSON.stringify({ error: message }), {
-          status: 500,
-          headers: { "Content-Type": "application/json" }
-        });
+        return errorResponse(getErrorMessage(error), 500);
       }
     },
     async cancel(request) {
       try {
         const url = new URL(request.url);
-        const runId = url.searchParams.get("runId");
-        if (!runId) {
-          return new Response(
-            JSON.stringify({ error: "runId query parameter is required" }),
-            { status: 400, headers: { "Content-Type": "application/json" } }
-          );
-        }
+        const runId = getRequiredQueryParam(url, "runId");
+        if (runId instanceof Response) return runId;
         await durably.cancel(runId);
-        return new Response(JSON.stringify({ success: true }), {
-          status: 200,
-          headers: { "Content-Type": "application/json" }
-        });
+        return successResponse();
       } catch (error) {
-        const message = error instanceof Error ? error.message : "Unknown error";
-        return new Response(JSON.stringify({ error: message }), {
-          status: 500,
-          headers: { "Content-Type": "application/json" }
-        });
+        return errorResponse(getErrorMessage(error), 500);
       }
     },
     async delete(request) {
       try {
         const url = new URL(request.url);
-        const runId = url.searchParams.get("runId");
-        if (!runId) {
-          return new Response(
-            JSON.stringify({ error: "runId query parameter is required" }),
-            { status: 400, headers: { "Content-Type": "application/json" } }
-          );
-        }
+        const runId = getRequiredQueryParam(url, "runId");
+        if (runId instanceof Response) return runId;
         await durably.deleteRun(runId);
-        return new Response(JSON.stringify({ success: true }), {
-          status: 200,
-          headers: { "Content-Type": "application/json" }
-        });
+        return successResponse();
       } catch (error) {
-        const message = error instanceof Error ? error.message : "Unknown error";
-        return new Response(JSON.stringify({ error: message }), {
-          status: 500,
-          headers: { "Content-Type": "application/json" }
-        });
+        return errorResponse(getErrorMessage(error), 500);
       }
     },
     async steps(request) {
       try {
         const url = new URL(request.url);
-        const runId = url.searchParams.get("runId");
-        if (!runId) {
-          return new Response(
-            JSON.stringify({ error: "runId query parameter is required" }),
-            { status: 400, headers: { "Content-Type": "application/json" } }
-          );
-        }
+        const runId = getRequiredQueryParam(url, "runId");
+        if (runId instanceof Response) return runId;
         const steps = await durably.storage.getSteps(runId);
-        return new Response(JSON.stringify(steps), {
-          status: 200,
-          headers: { "Content-Type": "application/json" }
-        });
+        return jsonResponse(steps);
       } catch (error) {
-        const message = error instanceof Error ? error.message : "Unknown error";
-        return new Response(JSON.stringify({ error: message }), {
-          status: 500,
-          headers: { "Content-Type": "application/json" }
-        });
+        return errorResponse(getErrorMessage(error), 500);
       }
     },
     runsSubscribe(request) {
       const url = new URL(request.url);
       const jobNameFilter = url.searchParams.get("jobName");
-      const encoder = new TextEncoder();
-      let closed = false;
-      const sseStream = new ReadableStream({
-        start(controller) {
-          const unsubscribeTrigger = durably.on("run:trigger", (event) => {
-            if (closed) return;
-            if (jobNameFilter && event.jobName !== jobNameFilter) return;
-            const data = `data: ${JSON.stringify({
-              type: "run:trigger",
-              runId: event.runId,
-              jobName: event.jobName
-            })}
-
-`;
-            controller.enqueue(encoder.encode(data));
-          });
-          const unsubscribeStart = durably.on("run:start", (event) => {
-            if (closed) return;
-            if (jobNameFilter && event.jobName !== jobNameFilter) return;
-            const data = `data: ${JSON.stringify({
-              type: "run:start",
-              runId: event.runId,
-              jobName: event.jobName
-            })}
-
-`;
-            controller.enqueue(encoder.encode(data));
-          });
-          const unsubscribeComplete = durably.on("run:complete", (event) => {
-            if (closed) return;
-            if (jobNameFilter && event.jobName !== jobNameFilter) return;
-            const data = `data: ${JSON.stringify({
-              type: "run:complete",
-              runId: event.runId,
-              jobName: event.jobName
-            })}
-
-`;
-            controller.enqueue(encoder.encode(data));
-          });
-          const unsubscribeFail = durably.on("run:fail", (event) => {
-            if (closed) return;
-            if (jobNameFilter && event.jobName !== jobNameFilter) return;
-            const data = `data: ${JSON.stringify({
-              type: "run:fail",
-              runId: event.runId,
-              jobName: event.jobName
-            })}
-
-`;
-            controller.enqueue(encoder.encode(data));
-          });
-          const unsubscribeCancel = durably.on("run:cancel", (event) => {
-            if (closed) return;
-            if (jobNameFilter && event.jobName !== jobNameFilter) return;
-            const data = `data: ${JSON.stringify({
-              type: "run:cancel",
-              runId: event.runId,
-              jobName: event.jobName
-            })}
-
-`;
-            controller.enqueue(encoder.encode(data));
-          });
-          const unsubscribeRetry = durably.on("run:retry", (event) => {
-            if (closed) return;
-            if (jobNameFilter && event.jobName !== jobNameFilter) return;
-            const data = `data: ${JSON.stringify({
-              type: "run:retry",
-              runId: event.runId,
-              jobName: event.jobName
-            })}
-
-`;
-            controller.enqueue(encoder.encode(data));
-          });
-          const unsubscribeProgress = durably.on("run:progress", (event) => {
-            if (closed) return;
-            if (jobNameFilter && event.jobName !== jobNameFilter) return;
-            const data = `data: ${JSON.stringify({
-              type: "run:progress",
-              runId: event.runId,
-              jobName: event.jobName,
-              progress: event.progress
-            })}
-
-`;
-            controller.enqueue(encoder.encode(data));
-          });
-          const unsubscribeStepStart = durably.on("step:start", (event) => {
-            if (closed) return;
-            if (jobNameFilter && event.jobName !== jobNameFilter) return;
-            const data = `data: ${JSON.stringify({
-              type: "step:start",
-              runId: event.runId,
-              jobName: event.jobName,
-              stepName: event.stepName,
-              stepIndex: event.stepIndex
-            })}
-
-`;
-            controller.enqueue(encoder.encode(data));
-          });
-          const unsubscribeStepComplete = durably.on(
-            "step:complete",
-            (event) => {
-              if (closed) return;
-              if (jobNameFilter && event.jobName !== jobNameFilter) return;
-              const data = `data: ${JSON.stringify({
+      const matchesFilter = (jobName) => !jobNameFilter || jobName === jobNameFilter;
+      const sseStream = createSSEStreamFromSubscriptions(
+        (ctrl) => [
+          durably.on("run:trigger", (event) => {
+            if (matchesFilter(event.jobName)) {
+              ctrl.enqueue({
+                type: "run:trigger",
+                runId: event.runId,
+                jobName: event.jobName
+              });
+            }
+          }),
+          durably.on("run:start", (event) => {
+            if (matchesFilter(event.jobName)) {
+              ctrl.enqueue({
+                type: "run:start",
+                runId: event.runId,
+                jobName: event.jobName
+              });
+            }
+          }),
+          durably.on("run:complete", (event) => {
+            if (matchesFilter(event.jobName)) {
+              ctrl.enqueue({
+                type: "run:complete",
+                runId: event.runId,
+                jobName: event.jobName
+              });
+            }
+          }),
+          durably.on("run:fail", (event) => {
+            if (matchesFilter(event.jobName)) {
+              ctrl.enqueue({
+                type: "run:fail",
+                runId: event.runId,
+                jobName: event.jobName
+              });
+            }
+          }),
+          durably.on("run:cancel", (event) => {
+            if (matchesFilter(event.jobName)) {
+              ctrl.enqueue({
+                type: "run:cancel",
+                runId: event.runId,
+                jobName: event.jobName
+              });
+            }
+          }),
+          durably.on("run:retry", (event) => {
+            if (matchesFilter(event.jobName)) {
+              ctrl.enqueue({
+                type: "run:retry",
+                runId: event.runId,
+                jobName: event.jobName
+              });
+            }
+          }),
+          durably.on("run:progress", (event) => {
+            if (matchesFilter(event.jobName)) {
+              ctrl.enqueue({
+                type: "run:progress",
+                runId: event.runId,
+                jobName: event.jobName,
+                progress: event.progress
+              });
+            }
+          }),
+          durably.on("step:start", (event) => {
+            if (matchesFilter(event.jobName)) {
+              ctrl.enqueue({
+                type: "step:start",
+                runId: event.runId,
+                jobName: event.jobName,
+                stepName: event.stepName,
+                stepIndex: event.stepIndex
+              });
+            }
+          }),
+          durably.on("step:complete", (event) => {
+            if (matchesFilter(event.jobName)) {
+              ctrl.enqueue({
                 type: "step:complete",
                 runId: event.runId,
                 jobName: event.jobName,
                 stepName: event.stepName,
                 stepIndex: event.stepIndex
-              })}
-
-`;
-              controller.enqueue(encoder.encode(data));
+              });
             }
-          );
-          const unsubscribeStepFail = durably.on("step:fail", (event) => {
-            if (closed) return;
-            if (jobNameFilter && event.jobName !== jobNameFilter) return;
-            const data = `data: ${JSON.stringify({
-              type: "step:fail",
-              runId: event.runId,
-              jobName: event.jobName,
-              stepName: event.stepName,
-              stepIndex: event.stepIndex,
-              error: event.error
-            })}
-
-`;
-            controller.enqueue(encoder.encode(data));
-          });
-          const unsubscribeLogWrite = durably.on("log:write", (event) => {
-            if (closed) return;
-            if (jobNameFilter) return;
-            const data = `data: ${JSON.stringify({
-              type: "log:write",
-              runId: event.runId,
-              stepName: event.stepName,
-              level: event.level,
-              message: event.message,
-              data: event.data
-            })}
-
-`;
-            controller.enqueue(encoder.encode(data));
-          });
-          controller.cleanup = () => {
-            closed = true;
-            unsubscribeTrigger();
-            unsubscribeStart();
-            unsubscribeComplete();
-            unsubscribeFail();
-            unsubscribeCancel();
-            unsubscribeRetry();
-            unsubscribeProgress();
-            unsubscribeStepStart();
-            unsubscribeStepComplete();
-            unsubscribeStepFail();
-            unsubscribeLogWrite();
-          };
-        },
-        cancel(controller) {
-          const cleanup = controller.cleanup;
-          if (cleanup) cleanup();
-        }
-      });
-      return new Response(sseStream, {
-        status: 200,
-        headers: {
-          "Content-Type": "text/event-stream",
-          "Cache-Control": "no-cache",
-          Connection: "keep-alive"
-        }
-      });
+          }),
+          durably.on("step:fail", (event) => {
+            if (matchesFilter(event.jobName)) {
+              ctrl.enqueue({
+                type: "step:fail",
+                runId: event.runId,
+                jobName: event.jobName,
+                stepName: event.stepName,
+                stepIndex: event.stepIndex,
+                error: event.error
+              });
+            }
+          }),
+          durably.on("log:write", (event) => {
+            if (!jobNameFilter) {
+              ctrl.enqueue({
+                type: "log:write",
+                runId: event.runId,
+                stepName: event.stepName,
+                level: event.level,
+                message: event.message,
+                data: event.data
+              });
+            }
+          })
+        ]
+      );
+      return createSSEResponse(sseStream);
     }
   };
   return handler;