@usehelical/workflows 0.0.1-alpha.13 → 0.0.1-alpha.15

package/dist/{chunk-SQ7WUJCB.js → chunk-TZSPUZQ3.js}

@@ -28,95 +28,29 @@ var QueueNotFoundError = class extends Error {
   }
 };
 
-// core/internal/errors.ts
-var RunCancelledError = class extends Error {
-  constructor() {
-    super("This workflow run has been cancelled");
-    this.name = "RUN_CANCELLED" /* RUN_CANCELLED */;
-  }
-};
-var RunNotFoundError = class extends Error {
-  constructor(runId) {
-    super(`Workflow run "${runId}" not found`);
-    this.name = "RUN_NOT_FOUND" /* RUN_NOT_FOUND */;
-  }
-};
-var RunOutsideOfWorkflowError = class extends Error {
-  constructor() {
-    super("This function must be called within a workflow");
-    this.name = "RUN_OUTSIDE_OF_WORKFLOW" /* RUN_OUTSIDE_OF_WORKFLOW */;
-  }
-};
-var FatalError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "FATAL_ERROR" /* FATAL_ERROR */;
-  }
-};
-var MaxRetriesExceededError = class extends Error {
-  attemptErrors;
-  stepName;
-  maxAttempts;
-  constructor(stepName, maxAttempts, errors) {
-    const formattedErrors = errors.map((error, index) => `Attempt ${index + 1}: ${error.message}`).join(". ");
-    super(`Step "${stepName}" failed after ${maxAttempts + 1} attempts. ${formattedErrors}`);
-    this.name = "MAX_RETRIES_EXCEEDED" /* MAX_RETRIES_EXCEEDED */;
-    this.attemptErrors = errors;
-    this.stepName = stepName;
-    this.maxAttempts = maxAttempts;
-  }
-};
-var ErrorThatShouldNeverHappen = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "ERROR_THAT_SHOULD_NEVER_HAPPEN" /* ERROR_THAT_SHOULD_NEVER_HAPPEN */;
-  }
-};
-var SerializationError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "SERIALIZATION_ERROR" /* SERIALIZATION_ERROR */;
-  }
-};
-var TimeoutError2 = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "TIMEOUT" /* TIMEOUT */;
-  }
-};
-var DeadlineError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "DEADLINE" /* DEADLINE */;
-  }
-};
-function serialize(value) {
-  try {
-    return JSON.stringify(value);
-  } catch (error) {
-    throw new SerializationError(error.message);
-  }
-}
-function deserialize(value) {
-  try {
-    return JSON.parse(value);
-  } catch (error) {
-    throw new SerializationError(error.message);
-  }
-}
-function serializeError(error) {
-  try {
-    return JSON.stringify(serializeError$1(error));
-  } catch (error2) {
-    throw new SerializationError(error2.message);
-  }
+// core/workflow.ts
+var TERMINAL_STATES = [
+  "success",
+  "error",
+  "cancelled",
+  "max_recovery_attempts_exceeded"
+];
+function defineWorkflow(fn, options = {}) {
+  return () => {
+    return {
+      fn,
+      maxRecoveryAttempts: options.maxRecoveryAttempts
+    };
+  };
 }
-function deserializeError(serialized) {
-  try {
-    return deserializeError$1(JSON.parse(serialized));
-  } catch (error) {
-    throw new SerializationError(error.message);
+
+// core/internal/repository/get-state.ts
+async function getState(db, runId, key) {
+  const result = await db.selectFrom("state").select(["key", "value", "change_id"]).where("run_id", "=", runId).where("key", "=", key).executeTakeFirst();
+  if (!result) {
+    return void 0;
   }
+  return result.value;
 }
 
 // core/internal/utils/sleep.ts
@@ -234,6 +168,116 @@ async function withDbRetry(fn, options = {}) {
     }
   }
 }
+
+// core/internal/errors.ts
+var BaseError = class extends Error {
+  reason;
+  constructor(message, reason) {
+    super(message);
+    this.reason = reason;
+  }
+};
+var RunTimedOutError = class extends BaseError {
+  constructor() {
+    super("This workflow run has timed out", "timeout");
+  }
+};
+var UnknownError = class extends BaseError {
+  constructor(message) {
+    super(message || "An unknown error occurred", "unknown");
+  }
+};
+var RunDeadlineExceededError = class extends BaseError {
+  constructor() {
+    super("This workflow run has exceeded its deadline", "deadline");
+  }
+};
+var RunCancelledError = class extends BaseError {
+  constructor(message) {
+    super(message || "This workflow run has been cancelled", "cancel");
+  }
+};
+var MaxRecoveryAttemptsExceededError2 = class extends BaseError {
+  constructor(message) {
+    super(message || "Max recovery attempts exceeded", "max_recovery_attempts_exceeded");
+  }
+};
+var OperationTimedOutError = class extends BaseError {
+  constructor(operationName) {
+    super(`This operation "${operationName}" has timed out`, "timeout");
+  }
+};
+var RunNotFoundError = class extends Error {
+  constructor(runId) {
+    super(`Workflow run "${runId}" not found`);
+    this.name = "RUN_NOT_FOUND" /* RUN_NOT_FOUND */;
+  }
+};
+var RunOutsideOfWorkflowError = class extends Error {
+  constructor() {
+    super("This function must be called within a workflow");
+    this.name = "RUN_OUTSIDE_OF_WORKFLOW" /* RUN_OUTSIDE_OF_WORKFLOW */;
+  }
+};
+var FatalError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "FATAL_ERROR" /* FATAL_ERROR */;
+  }
+};
+var MaxRetriesExceededError = class extends Error {
+  attemptErrors;
+  stepName;
+  maxAttempts;
+  constructor(stepName, maxAttempts, errors) {
+    const formattedErrors = errors.map((error, index) => `Attempt ${index + 1}: ${error.message}`).join(". ");
+    super(`Step "${stepName}" failed after ${maxAttempts + 1} attempts. ${formattedErrors}`);
+    this.name = "MAX_RETRIES_EXCEEDED" /* MAX_RETRIES_EXCEEDED */;
+    this.attemptErrors = errors;
+    this.stepName = stepName;
+    this.maxAttempts = maxAttempts;
+  }
+};
+var ErrorThatShouldNeverHappen = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ERROR_THAT_SHOULD_NEVER_HAPPEN" /* ERROR_THAT_SHOULD_NEVER_HAPPEN */;
+  }
+};
+var SerializationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SERIALIZATION_ERROR" /* SERIALIZATION_ERROR */;
+  }
+};
+function serialize(value) {
+  try {
+    return JSON.stringify(value);
+  } catch (error) {
+    throw new SerializationError(error.message);
+  }
+}
+function deserialize(value) {
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    throw new SerializationError(error.message);
+  }
+}
+function serializeError(error) {
+  try {
+    return JSON.stringify(serializeError$1(error));
+  } catch (error2) {
+    throw new SerializationError(error2.message);
+  }
+}
+function deserializeError(serialized) {
+  try {
+    return deserializeError$1(JSON.parse(serialized));
+  } catch (error) {
+    throw new SerializationError(error.message);
+  }
+}
 function getExecutionContext() {
   const store = asyncLocalStorage.getStore();
   if (!store) {
@@ -273,7 +317,7 @@ async function insertOperation(tx, runId, operationName, sequenceId, result, err
   }).execute();
 }
 
-// core/internal/operation-manager.ts
+// core/internal/context/operation-manager.ts
 var OperationManager = class {
   constructor(db, runId, operations = []) {
     this.db = db;
@@ -399,53 +443,22 @@ function createExecutionContext({
     db: ctx.db
   };
 }
-async function recordRunResult(db, runId, result) {
+async function recordRunResult(db, runId, result, cancelled) {
   const [{ change_id }] = await db.updateTable("runs").set({
     output: result.result,
     error: result.error,
-    status: result.error ? "error" : "success",
+    status: cancelled ? "cancelled" : result.error ? "error" : "success",
     updated_at: sql`(extract(epoch from now()) * 1000)::bigint`
   }).where("id", "=", runId).returning(["change_id"]).execute();
   return change_id;
 }
-async function cancelRun(runId, db) {
-  return withDbRetry(async () => {
-    return db.transaction().execute(async (tx) => {
-      const result = await tx.updateTable("runs").set({
-        status: "cancelled",
-        updated_at: sql`(extract(epoch from now()) * 1000)::bigint`
-      }).where(
-        (eb) => eb.and([eb("id", "=", runId), eb("status", "not in", ["cancelled", "success", "error"])])
-      ).returning(["change_id", "path"]).executeTakeFirst();
-      if (!result) {
-        const exists = await tx.selectFrom("runs").select([]).where("id", "=", runId).executeTakeFirst();
-        if (exists) {
-          return void 0;
-        }
-        throw new RunNotFoundError(runId);
-      }
-      await sql`
-                UPDATE runs
-                SET 
-                    status = ${"cancelled"},
-                    updated_at = (extract(epoch from now()) * 1000)::bigint
-                WHERE path @> ARRAY[${runId}]::text[]
-                AND id != ${runId}
-                AND status NOT IN (${"cancelled"}, ${"success"}, ${"error"})
-            `.execute(tx);
-      return {
-        path: result.path
-      };
-    });
-  });
-}
 
 // core/internal/execute-workflow.ts
 async function executeWorkflow(ctx, params) {
   const { db, runRegistry } = ctx;
   const { options, runId, runPath, fn, args, operations } = params;
   const abortController = new AbortController();
-  const [deadline] = getDeadlineAndReason({
+  const [deadline, deadlineReason] = getDeadlineAndReason({
     timeout: options?.timeout,
     deadline: options?.deadline
   });
@@ -463,12 +476,16 @@ async function executeWorkflow(ctx, params) {
       const result = await runWithExecutionContext(runStore, async () => {
         return await runWithTimeout(async () => {
           return await fn(...args);
-        });
+        }, deadlineReason);
       });
       await recordRunResult(db, runId, { result: result ? serialize(result) : void 0 });
       return result;
     } catch (error) {
-      await recordRunResult(db, runId, { error: serializeError(error) });
+      if (error instanceof RunCancelledError) {
+        await recordRunResult(db, runId, { error: serializeError(error) }, true);
+      } else {
+        await recordRunResult(db, runId, { error: serializeError(error) });
+      }
       throw error;
     } finally {
       runRegistry.unregisterRun(runId);
@@ -498,15 +515,15 @@ function getDeadlineAndReason({
   }
   return [void 0, void 0];
 }
-async function runWithTimeout(fn) {
-  const { runId, db, abortSignal } = getExecutionContext();
+async function runWithTimeout(fn, deadlineReason) {
+  const { abortSignal } = getExecutionContext();
   const abortPromise = new Promise((_, reject) => {
     abortSignal.throwIfAborted();
     abortSignal.addEventListener(
       "abort",
       () => {
         if (abortSignal.reason?.name === "TimeoutError") {
-          reject(new TimeoutError(`Workflow timed out`));
+          reject(new RunTimedOutError());
           return;
         }
         reject(new RunCancelledError());
@@ -518,8 +535,13 @@ async function runWithTimeout(fn) {
   try {
     return await Promise.race([callPromise, abortPromise]);
   } catch (error) {
-    if (error instanceof TimeoutError || error instanceof DeadlineError) {
-      await cancelRun(runId, db);
+    if (error instanceof RunTimedOutError) {
+      if (deadlineReason === "timeout") {
+        throw new RunTimedOutError();
+      } else if (deadlineReason === "deadline") {
+        throw new RunDeadlineExceededError();
+      }
+      throw error;
     }
     await callPromise.catch(() => {
     });
@@ -527,7 +549,7 @@ async function runWithTimeout(fn) {
   }
 }
 
-// core/internal/repository/get-run-status.ts
+// core/internal/db/queries/get-run-status.ts
 async function getRunStatus(db, runId) {
   const run = await db.selectFrom("runs").select("status").where("id", "=", runId).executeTakeFirst();
   if (!run) {
@@ -536,16 +558,16 @@ async function getRunStatus(db, runId) {
   return run.status;
 }
 
-// client/get-run-status.ts
+// core/internal/get-run-status.ts
 async function getRunStatus2(ctx, runId) {
   const { db, runRegistry } = ctx;
   const run = runRegistry.getRun(runId);
   if (run) {
-    return getRunStatusFromRegistry(run);
+    return deriveRunStatus(run);
   }
   return getRunStatus(db, runId);
 }
-async function getRunStatusFromRegistry(runEntry) {
+async function deriveRunStatus(runEntry) {
   if (runEntry.store.abortSignal.aborted) {
     return "cancelled";
   }
@@ -559,7 +581,7 @@ async function getRunStatusFromRegistry(runEntry) {
   return "error";
 }
 
-// client/wait-for-run-result.ts
+// core/internal/wait-for-run-result.ts
 async function waitForRunResult(ctx, runId) {
   const { db, runEventBus } = ctx;
   const run = await getRun(db, runId);
@@ -569,48 +591,69 @@ async function waitForRunResult(ctx, runId) {
       success: false
     };
   }
-  if (run.status === "cancelled") {
-    return {
-      error: new RunCancelledError(),
-      success: false
-    };
-  }
-  if (run.status === "error") {
-    return {
-      error: run.error ? deserializeError(run.error) : new Error("Unexptected error"),
-      success: false
-    };
+  switch (run.status) {
+    case "success":
+      return {
+        data: run.output ? deserialize(run.output) : void 0,
+        success: true
+      };
+    case "error":
+      return {
+        error: run.error ? deserializeError(run.error) : new UnknownError(),
+        success: false
+      };
+    case "cancelled":
+      return {
+        error: new RunCancelledError(),
+        success: false
+      };
+    case "max_recovery_attempts_exceeded":
+      return {
+        error: run.error ? deserializeError(run.error) : new MaxRecoveryAttemptsExceededError2(),
+        success: false
+      };
   }
   return new Promise((resolve, reject) => {
     const unsubscribe = runEventBus.subscribe(runId, "*", async (e) => {
-      if (e.status === "cancelled") {
-        unsubscribe();
-        resolve({
-          error: new RunCancelledError(),
-          success: false
-        });
-        return;
-      }
-      if (e.status === "success" || e.status === "error") {
+      if (TERMINAL_STATES.includes(e.status)) {
         unsubscribe();
         try {
-          const completedRun = await getRun(db, runId);
-          if (!completedRun) {
+          const run2 = await getRun(db, runId);
+          if (!run2) {
             reject(new RunNotFoundError(runId));
             return;
           }
-          if (completedRun.status === "error") {
-            resolve({
-              error: completedRun.error ? deserializeError(completedRun.error) : new Error("error"),
-              success: false
-            });
-            return;
+          switch (run2.status) {
+            case "success":
+              resolve({
+                data: run2.output ? deserialize(run2.output) : void 0,
+                success: true
+              });
+              return;
+            case "error":
+              resolve({
+                error: run2.error ? deserializeError(run2.error) : new UnknownError(),
+                success: false
+              });
+              return;
+            case "cancelled":
+              resolve({
+                error: new RunCancelledError(),
+                success: false
+              });
+              return;
+            case "max_recovery_attempts_exceeded":
+              resolve({
+                error: run2.error ? deserializeError(run2.error) : new MaxRecoveryAttemptsExceededError2(),
+                success: false
+              });
+              return;
           }
-          resolve({
-            data: completedRun.output ? deserialize(completedRun.output) : void 0,
-            success: true
-          });
         } catch (error) {
+          if (error instanceof RunNotFoundError) {
+            reject(error);
+            return;
+          }
           resolve({
             error,
             success: false
@@ -647,7 +690,70 @@ async function insertPendingRun(db, options) {
     changeId: result.change_id
   };
 }
+async function enqueueRun(db, options) {
+  const result = await db.insertInto("runs").values({
+    id: options.runId,
+    path: options.path,
+    inputs: options.inputs,
+    queue_name: options.queueName,
+    queue_partition_key: options.queuePartitionKey,
+    queue_deduplication_id: options.deduplicationId,
+    executor_id: options.executorId,
+    workflow_name: options.workflowName,
+    status: "queued",
+    recovery_attempts: options.recoveryAttempts,
+    created_at: sql`(extract(epoch from now()) * 1000)::bigint`,
+    updated_at: sql`(extract(epoch from now()) * 1000)::bigint`
+  }).onConflict((oc) => oc.columns(["queue_name", "queue_deduplication_id"]).doNothing()).returning(["id", "change_id"]).executeTakeFirst();
+  return {
+    runId: result?.id,
+    changeId: result?.change_id
+  };
+}
+
+// core/internal/repository/insert-message.ts
+async function insertMessage(db, options) {
+  return await db.insertInto("messages").values({
+    destination_run_id: options.destinationWorkflowId,
+    type: options.messageType,
+    payload: options.data
+  }).execute();
+}
+
+// core/internal/get-state.ts
+var StateNotAvailableError = class extends Error {
+};
+async function getState2(ctx, target, key) {
+  const { db, stateEventBus } = ctx;
+  const destinationWorkflowId = typeof target === "string" ? target : target.id;
+  const stateKey = typeof key === "string" ? key : key.name;
+  while (true) {
+    try {
+      return await withDbRetry(async () => {
+        const state = await getState(db, destinationWorkflowId, stateKey);
+        if (!state) {
+          throw new StateNotAvailableError();
+        }
+        return deserialize(state);
+      });
+    } catch (error) {
+      if (error instanceof StateNotAvailableError) {
+        await waitForStateNotification(stateEventBus, destinationWorkflowId, stateKey);
+        continue;
+      }
+      throw error;
+    }
+  }
+}
+async function waitForStateNotification(stateEventBus, runId, key) {
+  return new Promise((resolve) => {
+    const unsubscribe = stateEventBus.subscribe(runId, key, (state) => {
+      unsubscribe();
+      resolve(state);
+    });
+  });
+}
 
-export { ErrorThatShouldNeverHappen, FatalError, MaxRecoveryAttemptsExceededError, MaxRetriesExceededError, QueueNotFoundError, RunCancelledError, RunNotFoundError, TimeoutError2 as TimeoutError, TimeoutError as TimeoutError2, WorkflowNotFoundError, cancelRun, createRunHandle, deserialize, deserializeError, executeAndRecordOperation, executeWorkflow, getExecutionContext, getRun, getRunStatus2 as getRunStatus, insertPendingRun, returnOrThrowOperationResult, serialize, serializeError, sleep, waitForRunResult, withDbRetry };
-//# sourceMappingURL=chunk-SQ7WUJCB.js.map
-//# sourceMappingURL=chunk-SQ7WUJCB.js.map
+export { ErrorThatShouldNeverHappen, FatalError, MaxRecoveryAttemptsExceededError, MaxRetriesExceededError, OperationTimedOutError, QueueNotFoundError, RunCancelledError, RunNotFoundError, StateNotAvailableError, TERMINAL_STATES, TimeoutError, WorkflowNotFoundError, createRunHandle, defineWorkflow, deserialize, deserializeError, enqueueRun, executeAndRecordOperation, executeWorkflow, getExecutionContext, getRun, getRunStatus2 as getRunStatus, getState, getState2, insertMessage, insertPendingRun, returnOrThrowOperationResult, serialize, serializeError, sleep, waitForRunResult, waitForStateNotification, withDbRetry };
+//# sourceMappingURL=chunk-TZSPUZQ3.js.map
+//# sourceMappingURL=chunk-TZSPUZQ3.js.map