@aikirun/workflow 0.15.0 → 0.17.0

package/README.md

@@ -52,7 +52,6 @@ Run workflows on a schedule using cron expressions or intervals:
 import { schedule } from "@aikirun/workflow";
 
 const dailyReport = schedule({
-	name: "daily-report",
 	type: "cron",
 	expression: "0 9 * * *", // Every day at 9 AM
 });

package/dist/index.d.ts

@@ -5,12 +5,12 @@ import { WorkflowRun, TerminalWorkflowRunStatus, WorkflowRunState, WorkflowRunId
 import { StandardSchemaV1 } from '@standard-schema/spec';
 import { DurationObject, Duration } from '@aikirun/types/duration';
 import { SleepResult } from '@aikirun/types/sleep';
-import { EventSendOptions, EventWaitOptions, EventWaitState } from '@aikirun/types/event';
+import { EventSendOptions, EventWaitOptions, EventWaitResult } from '@aikirun/types/event';
 import { Serializable } from '@aikirun/types/serializable';
 import { DistributiveOmit, RequireAtLeastOneProp } from '@aikirun/types/utils';
 import { TaskId } from '@aikirun/types/task';
 import { WorkflowRunStateRequest, WorkflowRunTransitionTaskStateRequestV1 } from '@aikirun/types/workflow-run-api';
-import { OverlapPolicy, ScheduleName, ScheduleId } from '@aikirun/types/schedule';
+import { ScheduleOverlapPolicy, ScheduleActivateOptions, ScheduleId } from '@aikirun/types/schedule';
 
 type NonEmptyArray<T> = [T, ...T[]];
 
@@ -151,8 +151,8 @@ type EventWaiters<TEvents extends EventsDefinition> = {
     [K in keyof TEvents]: EventWaiter<EventData<TEvents[K]>>;
 };
 interface EventWaiter<Data> {
-    wait(options?: EventWaitOptions<false>): Promise<EventWaitState<Data, false>>;
-    wait(options: EventWaitOptions<true>): Promise<EventWaitState<Data, true>>;
+    wait(options?: EventWaitOptions<false>): Promise<EventWaitResult<Data, false>>;
+    wait(options: EventWaitOptions<true>): Promise<EventWaitResult<Data, true>>;
 }
 type EventSenders<TEvents extends EventsDefinition> = {
     [K in keyof TEvents]: EventSender<EventData<TEvents[K]>>;
@@ -309,28 +309,29 @@ interface CronScheduleParams {
     type: "cron";
     expression: string;
     timezone?: string;
-    overlapPolicy?: OverlapPolicy;
+    overlapPolicy?: ScheduleOverlapPolicy;
 }
 interface IntervalScheduleParams {
     type: "interval";
     every: DurationObject;
-    overlapPolicy?: OverlapPolicy;
+    overlapPolicy?: ScheduleOverlapPolicy;
 }
 type ScheduleParams = CronScheduleParams | IntervalScheduleParams;
 interface ScheduleHandle {
     id: ScheduleId;
-    name: ScheduleName;
     pause(): Promise<void>;
     resume(): Promise<void>;
     delete(): Promise<void>;
 }
+interface ScheduleBuilder {
+    opt<Path extends PathFromObject<ScheduleActivateOptions>>(path: Path, value: TypeOfValueAtPath<ScheduleActivateOptions, Path>): ScheduleBuilder;
+    activate<Input, Output, AppContext, TEvents extends EventsDefinition>(client: Client<AppContext>, workflow: WorkflowVersion<Input, Output, AppContext, TEvents>, ...args: Input extends void ? [] : [Input]): Promise<ScheduleHandle>;
+}
 type ScheduleDefinition = ScheduleParams & {
-    name: ScheduleName;
+    with(): ScheduleBuilder;
     activate<Input, Output, AppContext, TEvents extends EventsDefinition>(client: Client<AppContext>, workflow: WorkflowVersion<Input, Output, AppContext, TEvents>, ...args: Input extends void ? [] : [Input]): Promise<ScheduleHandle>;
 };
-declare function schedule(params: {
-    name: string;
-} & ScheduleParams): ScheduleDefinition;
+declare function schedule(params: ScheduleParams): ScheduleDefinition;
 
 /**
  * Defines a durable workflow with versioning and multiple task execution.

package/dist/index.js

@@ -77,6 +77,9 @@ function delay(ms, options) {
   });
 }
 
+// ../../lib/crypto/hash.ts
+import { createHash } from "crypto";
+
 // ../../lib/json/stable-stringify.ts
 function stableStringify(value) {
   return stringifyValue(value);
@@ -292,8 +295,8 @@ function getRetryParams(attempts, strategy) {
 import { INTERNAL } from "@aikirun/types/symbols";
 import { SchemaValidationError } from "@aikirun/types/validator";
 import {
-  WorkflowRunConflictError,
   WorkflowRunFailedError,
+  WorkflowRunRevisionConflictError,
   WorkflowRunSuspendedError
 } from "@aikirun/types/workflow-run";
 function event(params) {
@@ -320,17 +323,17 @@ function createEventWaiter(handle, eventName, schema, logger) {
   let nextEventIndex = 0;
   async function wait(options) {
     await handle.refresh();
-    const events = handle.run.eventsQueue[eventName]?.events ?? [];
-    const event2 = events[nextEventIndex];
-    if (event2) {
+    const eventWaits = handle.run.eventWaitQueues[eventName]?.eventWaits ?? [];
+    const eventWait = eventWaits[nextEventIndex];
+    if (eventWait) {
       nextEventIndex++;
-      if (event2.status === "timeout") {
+      if (eventWait.status === "timeout") {
         logger.debug("Timed out waiting for event");
         return { timeout: true };
       }
-      let data = event2.data;
+      let data = eventWait.data;
       if (schema) {
-        const schemaValidation = schema["~standard"].validate(event2.data);
+        const schemaValidation = schema["~standard"].validate(eventWait.data);
         const schemaValidationResult = schemaValidation instanceof Promise ? await schemaValidation : schemaValidation;
         if (!schemaValidationResult.issues) {
           data = schemaValidationResult.value;
@@ -361,7 +364,7 @@ function createEventWaiter(handle, eventName, schema, logger) {
         ...timeoutInMs !== void 0 ? { "aiki.timeoutInMs": timeoutInMs } : {}
       });
     } catch (error) {
-      if (error instanceof WorkflowRunConflictError) {
+      if (error instanceof WorkflowRunRevisionConflictError) {
         throw new WorkflowRunSuspendedError(handle.run.id);
       }
       throw error;
@@ -485,8 +488,8 @@ function createEventMulticaster(workflowName, workflowVersionId, eventName, sche
 import { INTERNAL as INTERNAL2 } from "@aikirun/types/symbols";
 import {
   isTerminalWorkflowRunStatus,
-  WorkflowRunConflictError as WorkflowRunConflictError2,
-  WorkflowRunNotExecutableError
+  WorkflowRunNotExecutableError,
+  WorkflowRunRevisionConflictError as WorkflowRunRevisionConflictError2
 } from "@aikirun/types/workflow-run";
 async function workflowRunHandle(client, runOrId, eventsDefinition, logger) {
   const run = typeof runOrId !== "string" ? runOrId : (await client.api.workflowRun.getByIdV1({ id: runOrId })).run;
@@ -622,7 +625,7 @@ var WorkflowRunHandleImpl = class {
       this._run = run;
     } catch (error) {
       if (isConflictError(error)) {
-        throw new WorkflowRunConflictError2(this.run.id);
+        throw new WorkflowRunRevisionConflictError2(this.run.id);
       }
       throw error;
     }
@@ -638,7 +641,7 @@ var WorkflowRunHandleImpl = class {
       return { taskId };
     } catch (error) {
       if (isConflictError(error)) {
-        throw new WorkflowRunConflictError2(this.run.id);
+        throw new WorkflowRunRevisionConflictError2(this.run.id);
       }
       throw error;
     }
@@ -656,7 +659,10 @@ function isConflictError(error) {
 
 // run/sleeper.ts
 import { INTERNAL as INTERNAL3 } from "@aikirun/types/symbols";
-import { WorkflowRunConflictError as WorkflowRunConflictError3, WorkflowRunSuspendedError as WorkflowRunSuspendedError2 } from "@aikirun/types/workflow-run";
+import {
+  WorkflowRunRevisionConflictError as WorkflowRunRevisionConflictError3,
+  WorkflowRunSuspendedError as WorkflowRunSuspendedError2
+} from "@aikirun/types/workflow-run";
 var MAX_SLEEP_YEARS = 10;
 var MAX_SLEEP_MS = MAX_SLEEP_YEARS * 365 * 24 * 60 * 60 * 1e3;
 function createSleeper(handle, logger) {
@@ -678,7 +684,7 @@ function createSleeper(handle, logger) {
           "aiki.durationMs": durationMs
         });
       } catch (error) {
-        if (error instanceof WorkflowRunConflictError3) {
+        if (error instanceof WorkflowRunRevisionConflictError3) {
           throw new WorkflowRunSuspendedError2(handle.run.id);
         }
         throw error;
@@ -726,7 +732,7 @@ function createSleeper(handle, logger) {
         "aiki.durationMs": durationMs
       });
     } catch (error) {
-      if (error instanceof WorkflowRunConflictError3) {
+      if (error instanceof WorkflowRunRevisionConflictError3) {
         throw new WorkflowRunSuspendedError2(handle.run.id);
       }
       throw error;
@@ -737,48 +743,61 @@ function createSleeper(handle, logger) {
 
 // schedule.ts
 function schedule(params) {
-  const { name, ...scheduleParams } = params;
+  async function activateWithOpts(client, workflow2, options, ...args) {
+    const input = args[0];
+    let scheduleSpec;
+    if (params.type === "interval") {
+      const { every, ...rest } = params;
+      scheduleSpec = {
+        ...rest,
+        everyMs: toMilliseconds(every)
+      };
+    } else {
+      scheduleSpec = params;
+    }
+    const { schedule: schedule2 } = await client.api.schedule.activateV1({
+      workflowName: workflow2.name,
+      workflowVersionId: workflow2.versionId,
+      spec: scheduleSpec,
+      input,
+      options
+    });
+    client.logger.info("Schedule activated", {
+      scheduleSpec,
+      workflowName: workflow2.name,
+      workflowVersionId: workflow2.versionId,
+      referenceId: options?.reference?.id
+    });
+    const scheduleId = schedule2.id;
+    return {
+      id: scheduleId,
+      pause: async () => {
+        await client.api.schedule.pauseV1({ id: scheduleId });
+      },
+      resume: async () => {
+        await client.api.schedule.resumeV1({ id: scheduleId });
+      },
+      delete: async () => {
+        await client.api.schedule.deleteV1({ id: scheduleId });
+      }
+    };
+  }
+  function createBuilder(optsBuilder) {
+    return {
+      opt: (path, value) => createBuilder(optsBuilder.with(path, value)),
+      async activate(client, workflow2, ...args) {
+        return activateWithOpts(client, workflow2, optsBuilder.build(), ...args);
+      }
+    };
+  }
   return {
-    name,
-    ...scheduleParams,
+    ...params,
+    with() {
+      const optsOverrider = objectOverrider({});
+      return createBuilder(optsOverrider());
+    },
     async activate(client, workflow2, ...args) {
-      const input = args[0];
-      let scheduleSpec;
-      if (scheduleParams.type === "interval") {
-        const { every, ...rest } = scheduleParams;
-        scheduleSpec = {
-          ...rest,
-          everyMs: toMilliseconds(every)
-        };
-      } else {
-        scheduleSpec = scheduleParams;
-      }
-      const { schedule: schedule2 } = await client.api.schedule.activateV1({
-        name,
-        workflowName: workflow2.name,
-        workflowVersionId: workflow2.versionId,
-        spec: scheduleSpec,
-        input
-      });
-      client.logger.info("Schedule activated", {
-        scheduleSpec,
-        workflowName: workflow2.name,
-        workflowVersionId: workflow2.versionId
-      });
-      const scheduleId = schedule2.id;
-      return {
-        id: scheduleId,
-        name,
-        pause: async () => {
-          await client.api.schedule.pauseV1({ id: scheduleId });
-        },
-        resume: async () => {
-          await client.api.schedule.resumeV1({ id: scheduleId });
-        },
-        delete: async () => {
-          await client.api.schedule.deleteV1({ id: scheduleId });
-        }
-      };
+      return activateWithOpts(client, workflow2, {}, ...args);
     }
   };
 }
@@ -788,7 +807,7 @@ import { INTERNAL as INTERNAL6 } from "@aikirun/types/symbols";
 
 // ../../lib/address/index.ts
 function getWorkflowRunAddress(name, versionId, referenceId) {
-  return `${name}/${versionId}/${referenceId}`;
+  return `${name}:${versionId}:${referenceId}`;
 }
 
 // workflow-version.ts
@@ -796,8 +815,8 @@ import { INTERNAL as INTERNAL5 } from "@aikirun/types/symbols";
 import { TaskFailedError } from "@aikirun/types/task";
 import { SchemaValidationError as SchemaValidationError2 } from "@aikirun/types/validator";
 import {
-  WorkflowRunConflictError as WorkflowRunConflictError5,
   WorkflowRunFailedError as WorkflowRunFailedError2,
+  WorkflowRunRevisionConflictError as WorkflowRunRevisionConflictError5,
   WorkflowRunSuspendedError as WorkflowRunSuspendedError4
 } from "@aikirun/types/workflow-run";
 
@@ -805,7 +824,7 @@ import {
 import { INTERNAL as INTERNAL4 } from "@aikirun/types/symbols";
 import {
   isTerminalWorkflowRunStatus as isTerminalWorkflowRunStatus2,
-  WorkflowRunConflictError as WorkflowRunConflictError4,
+  WorkflowRunRevisionConflictError as WorkflowRunRevisionConflictError4,
   WorkflowRunSuspendedError as WorkflowRunSuspendedError3
 } from "@aikirun/types/workflow-run";
 async function childWorkflowRunHandle(client, run, parentRun, logger, eventsDefinition) {
@@ -884,7 +903,7 @@ function createStatusWaiter(handle, parentRun, logger) {
         ...timeoutInMs !== void 0 ? { "aiki.timeoutInMs": timeoutInMs } : {}
       });
     } catch (error) {
-      if (error instanceof WorkflowRunConflictError4) {
+      if (error instanceof WorkflowRunRevisionConflictError4) {
         throw new WorkflowRunSuspendedError3(parentRun.id);
       }
       throw error;
@@ -1065,7 +1084,7 @@ var WorkflowVersionImpl = class {
         const output = await this.parse(handle, this.params.schema?.output, outputRaw, run.logger);
         return output;
       } catch (error) {
-        if (error instanceof WorkflowRunSuspendedError4 || error instanceof WorkflowRunFailedError2 || error instanceof WorkflowRunConflictError5) {
+        if (error instanceof WorkflowRunSuspendedError4 || error instanceof WorkflowRunFailedError2 || error instanceof WorkflowRunRevisionConflictError5) {
           throw error;
         }
         const attempts = handle.run.attempts;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@aikirun/workflow",
-	"version": "0.15.0",
+	"version": "0.17.0",
 	"description": "Workflow SDK for Aiki - define durable workflows with tasks, sleeps, waits, and event handling",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -18,7 +18,7 @@
 		"build": "tsup"
 	},
 	"dependencies": {
-		"@aikirun/types": "0.15.0",
+		"@aikirun/types": "0.17.0",
 		"@standard-schema/spec": "^1.1.0"
 	},
 	"publishConfig": {