@aikirun/workflow 0.10.0 → 0.10.1

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 import { WorkflowName, WorkflowVersionId } from '@aikirun/types/workflow';
 import { Client, Logger, ApiClient } from '@aikirun/types/client';
 import { INTERNAL } from '@aikirun/types/symbols';
-import { Schema } from '@aikirun/types/validator';
 import { WorkflowRun, TerminalWorkflowRunStatus, WorkflowRunState, WorkflowRunId, WorkflowOptions } from '@aikirun/types/workflow-run';
+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';
@@ -138,11 +138,11 @@ type WorkflowRunWaitResult<Status extends TerminalWorkflowRunStatus, Output, Tim
 declare function event(): EventDefinition<void>;
 declare function event<Data extends Serializable>(params?: EventParams<Data>): EventDefinition<Data>;
 interface EventParams<Data> {
-    schema?: Schema<Data>;
+    schema?: StandardSchemaV1<Data>;
 }
 interface EventDefinition<Data> {
     _type: Data;
-    schema?: Schema<Data>;
+    schema?: StandardSchemaV1<Data>;
 }
 type EventsDefinition = Record<string, EventDefinition<unknown>>;
 type EventData<TEventDefinition> = TEventDefinition extends EventDefinition<infer Data> ? Data : never;
@@ -244,8 +244,8 @@ interface WorkflowVersionParams<Input, Output, AppContext, TEventsDefinition ext
     events?: TEventsDefinition;
     opts?: WorkflowOptions;
     schema?: RequireAtLeastOneProp<{
-        input?: Schema<Input>;
-        output?: Schema<Output>;
+        input?: StandardSchemaV1<Input>;
+        output?: StandardSchemaV1<Output>;
     }>;
 }
 interface WorkflowVersion<Input, Output, AppContext, TEventsDefinition extends EventsDefinition = EventsDefinition> {

package/dist/index.js

@@ -289,6 +289,7 @@ function getRetryParams(attempts, strategy) {
 
 // run/event.ts
 import { INTERNAL } from "@aikirun/types/symbols";
+import { SchemaValidationError } from "@aikirun/types/validator";
 import {
   WorkflowRunConflictError,
   WorkflowRunFailedError,
@@ -325,17 +326,24 @@ function createEventWaiter(handle, eventName, schema, logger) {
         logger.debug("Timed out waiting for event");
         return { timeout: true };
       }
-      let data;
-      try {
-        data = schema ? schema.parse(event2.data) : event2.data;
-      } catch (error) {
-        logger.error("Invalid event data", { data: event2.data, error });
-        await handle[INTERNAL].transitionState({
-          status: "failed",
-          cause: "self",
-          error: createSerializableError(error)
-        });
-        throw new WorkflowRunFailedError(handle.run.id, handle.run.attempts);
+      let data = event2.data;
+      if (schema) {
+        const schemaValidation = schema["~standard"].validate(event2.data);
+        const schemaValidationResult = schemaValidation instanceof Promise ? await schemaValidation : schemaValidation;
+        if (!schemaValidationResult.issues) {
+          data = schemaValidationResult.value;
+        } else {
+          logger.error("Invalid event data", { "aiki.issues": schemaValidationResult.issues });
+          await handle[INTERNAL].transitionState({
+            status: "failed",
+            cause: "self",
+            error: {
+              name: "SchemaValidationError",
+              message: JSON.stringify(schemaValidationResult.issues)
+            }
+          });
+          throw new WorkflowRunFailedError(handle.run.id, handle.run.attempts);
+        }
       }
       logger.debug("Event received");
       return { timeout: false, data };
@@ -382,9 +390,16 @@ function createEventSender(api, workflowRunId, eventName, schema, logger, onSend
     send: (...args) => createEventSender(api, workflowRunId, eventName, schema, logger, onSend, optsBuilder.build()).send(...args)
   });
   async function send(...args) {
-    const data = isNonEmptyArray(args) ? args[0] : void 0;
+    const dataRaw = isNonEmptyArray(args) ? args[0] : void 0;
+    let data = dataRaw;
     if (schema) {
-      schema.parse(data);
+      const schemaValidation = schema["~standard"].validate(dataRaw);
+      const schemaValidationResult = schemaValidation instanceof Promise ? await schemaValidation : schemaValidation;
+      if (schemaValidationResult.issues) {
+        logger.error("Invalid event data", { "aiki.issues": schemaValidationResult.issues });
+        throw new SchemaValidationError("Invalid event data", schemaValidationResult.issues);
+      }
+      data = schemaValidationResult.value;
     }
     const { run } = await api.workflowRun.sendEventV1({
       id: workflowRunId,
@@ -426,26 +441,33 @@ function createEventMulticaster(workflowName, workflowVersionId, eventName, sche
     )
   });
   async function send(client, runId, ...args) {
-    const data = isNonEmptyArray(args) ? args[0] : void 0;
+    const dataRaw = isNonEmptyArray(args) ? args[0] : void 0;
+    let data = dataRaw;
     if (schema) {
-      schema.parse(data);
+      const schemaValidation = schema["~standard"].validate(dataRaw);
+      const schemaValidationResult = schemaValidation instanceof Promise ? await schemaValidation : schemaValidation;
+      if (schemaValidationResult.issues) {
+        client.logger.error("Invalid event data", {
+          "aiki.workflowName": workflowName,
+          "aiki.workflowVersionId": workflowVersionId,
+          "aiki.eventName": eventName,
+          "aiki.issues": schemaValidationResult.issues
+        });
+        throw new SchemaValidationError("Invalid event data", schemaValidationResult.issues);
+      }
+      data = schemaValidationResult.value;
     }
     const runIds = Array.isArray(runId) ? runId : [runId];
     if (!isNonEmptyArray(runIds)) {
       return;
     }
-    const logger = client.logger.child({
-      "aiki.workflowName": workflowName,
-      "aiki.workflowVersionId": workflowVersionId,
-      "aiki.eventName": eventName
-    });
     await client.api.workflowRun.multicastEventV1({
       ids: runIds,
       eventName,
       data,
       options
     });
-    logger.info("Multicasted event to workflows", {
+    client.logger.info("Multicasted event to workflows", {
       "aiki.workflowName": workflowName,
       "aiki.workflowVersionId": workflowVersionId,
       "aiki.workflowRunIds": runIds,
@@ -721,6 +743,7 @@ function getWorkflowRunPath(name, versionId, referenceId) {
 // workflow-version.ts
 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,
@@ -854,7 +877,17 @@ var WorkflowVersionImpl = class _WorkflowVersionImpl {
   }
   async start(client, ...args) {
     const inputRaw = isNonEmptyArray(args) ? args[0] : void 0;
-    const input = this.params.schema?.input ? this.params.schema.input.parse(inputRaw) : inputRaw;
+    let input = inputRaw;
+    const schema = this.params.schema?.input;
+    if (schema) {
+      const schemaValidation = schema["~standard"].validate(inputRaw);
+      const schemaValidationResult = schemaValidation instanceof Promise ? await schemaValidation : schemaValidation;
+      if (schemaValidationResult.issues) {
+        client.logger.error("Invalid workflow data", { "aiki.issues": schemaValidationResult.issues });
+        throw new SchemaValidationError2("Invalid workflow data", schemaValidationResult.issues);
+      }
+      input = schemaValidationResult.value;
+    }
     const { run } = await client.api.workflowRun.createV1({
       name: this.name,
       versionId: this.versionId,
@@ -873,7 +906,7 @@ var WorkflowVersionImpl = class _WorkflowVersionImpl {
     parentRunHandle[INTERNAL5].assertExecutionAllowed();
     const { client } = parentRunHandle[INTERNAL5];
     const inputRaw = isNonEmptyArray(args) ? args[0] : void 0;
-    const input = await this.parse(parentRunHandle, this.params.schema?.input, inputRaw);
+    const input = await this.parse(parentRunHandle, this.params.schema?.input, inputRaw, parentRun.logger);
     const inputHash = await hashInput(input);
     const reference = this.params.opts?.reference;
     const path = getWorkflowRunPath(this.name, this.versionId, reference?.id ?? inputHash);
@@ -888,7 +921,7 @@ var WorkflowVersionImpl = class _WorkflowVersionImpl {
       );
       const { run: existingRun } = await client.api.workflowRun.getByIdV1({ id: existingRunInfo.id });
       if (existingRun.state.status === "completed") {
-        await this.parse(parentRunHandle, this.params.schema?.output, existingRun.state.output);
+        await this.parse(parentRunHandle, this.params.schema?.output, existingRun.state.output, parentRun.logger);
       }
       const logger2 = parentRun.logger.child({
         "aiki.childWorkflowName": existingRun.name,
@@ -975,7 +1008,7 @@ var WorkflowVersionImpl = class _WorkflowVersionImpl {
     while (true) {
       try {
         const outputRaw = await this.params.handler(run, input, context);
-        const output = await this.parse(handle, this.params.schema?.output, outputRaw);
+        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) {
@@ -1024,20 +1057,25 @@ var WorkflowVersionImpl = class _WorkflowVersionImpl {
       throw error;
     }
   }
-  async parse(handle, schema, data) {
+  async parse(handle, schema, data, logger) {
     if (!schema) {
       return data;
     }
-    try {
-      return schema.parse(data);
-    } catch (error) {
-      await handle[INTERNAL5].transitionState({
-        status: "failed",
-        cause: "self",
-        error: createSerializableError(error)
-      });
-      throw new WorkflowRunFailedError2(handle.run.id, handle.run.attempts);
+    const schemaValidation = schema["~standard"].validate(data);
+    const schemaValidationResult = schemaValidation instanceof Promise ? await schemaValidation : schemaValidation;
+    if (!schemaValidationResult.issues) {
+      return schemaValidationResult.value;
     }
+    logger.error("Invalid workflow data", { "aiki.issues": schemaValidationResult.issues });
+    await handle[INTERNAL5].transitionState({
+      status: "failed",
+      cause: "self",
+      error: {
+        name: "SchemaValidationError",
+        message: JSON.stringify(schemaValidationResult.issues)
+      }
+    });
+    throw new WorkflowRunFailedError2(handle.run.id, handle.run.attempts);
   }
   createFailedState(error) {
     if (error instanceof TaskFailedError) {

package/package.json

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