@temporal-contract/worker 0.0.1 → 0.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@temporal-contract/worker",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "type": "module",
   "description": "Worker utilities for implementing temporal-contract workflows and activities",
   "homepage": "https://github.com/btravers/temporal-contract#readme",
@@ -47,20 +47,21 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@temporal-contract/contract": "0.0.1"
+    "@standard-schema/spec": "1.0.0",
+    "@temporal-contract/contract": "0.0.2"
   },
   "devDependencies": {
     "@temporalio/workflow": "1.13.2",
     "@types/node": "24.10.2",
+    "@vitest/coverage-v8": "4.0.15",
     "tsdown": "0.17.2",
     "typescript": "5.9.3",
     "vitest": "4.0.15",
     "zod": "4.1.13",
-    "@temporal-contract/tsconfig": "0.0.1"
+    "@temporal-contract/tsconfig": "0.0.2"
   },
   "peerDependencies": {
-    "@temporalio/workflow": ">=1.13.0 <2.0.0",
-    "zod": "^4.0.0"
+    "@temporalio/workflow": ">=1.13.0 <2.0.0"
   },
   "scripts": {
     "dev": "tsdown src/activity.ts src/workflow.ts --format cjs,esm --dts --watch",

package/src/errors.ts

@@ -1,4 +1,4 @@
-import type { z } from "zod";
+import type { StandardSchemaV1 } from "@standard-schema/spec";
 
 /**
  * Base error class for worker errors
@@ -52,9 +52,10 @@ export class ActivityDefinitionNotFoundError extends WorkerError {
 export class ActivityInputValidationError extends WorkerError {
   constructor(
     public readonly activityName: string,
-    public readonly zodError: z.ZodError,
+    public readonly issues: ReadonlyArray<StandardSchemaV1.Issue>,
   ) {
-    super(`Activity "${activityName}" input validation failed: ${zodError.message}`);
+    const message = issues.map((issue) => issue.message).join("; ");
+    super(`Activity "${activityName}" input validation failed: ${message}`);
     this.name = "ActivityInputValidationError";
   }
 }
@@ -65,9 +66,10 @@ export class ActivityInputValidationError extends WorkerError {
 export class ActivityOutputValidationError extends WorkerError {
   constructor(
     public readonly activityName: string,
-    public readonly zodError: z.ZodError,
+    public readonly issues: ReadonlyArray<StandardSchemaV1.Issue>,
   ) {
-    super(`Activity "${activityName}" output validation failed: ${zodError.message}`);
+    const message = issues.map((issue) => issue.message).join("; ");
+    super(`Activity "${activityName}" output validation failed: ${message}`);
     this.name = "ActivityOutputValidationError";
   }
 }
@@ -78,9 +80,10 @@ export class ActivityOutputValidationError extends WorkerError {
 export class WorkflowInputValidationError extends WorkerError {
   constructor(
     public readonly workflowName: string,
-    public readonly zodError: z.ZodError,
+    public readonly issues: ReadonlyArray<StandardSchemaV1.Issue>,
   ) {
-    super(`Workflow "${workflowName}" input validation failed: ${zodError.message}`);
+    const message = issues.map((issue) => issue.message).join("; ");
+    super(`Workflow "${workflowName}" input validation failed: ${message}`);
     this.name = "WorkflowInputValidationError";
   }
 }
@@ -91,9 +94,10 @@ export class WorkflowInputValidationError extends WorkerError {
 export class WorkflowOutputValidationError extends WorkerError {
   constructor(
     public readonly workflowName: string,
-    public readonly zodError: z.ZodError,
+    public readonly issues: ReadonlyArray<StandardSchemaV1.Issue>,
   ) {
-    super(`Workflow "${workflowName}" output validation failed: ${zodError.message}`);
+    const message = issues.map((issue) => issue.message).join("; ");
+    super(`Workflow "${workflowName}" output validation failed: ${message}`);
     this.name = "WorkflowOutputValidationError";
   }
 }
@@ -104,9 +108,10 @@ export class WorkflowOutputValidationError extends WorkerError {
 export class SignalInputValidationError extends WorkerError {
   constructor(
     public readonly signalName: string,
-    public readonly zodError: z.ZodError,
+    public readonly issues: ReadonlyArray<StandardSchemaV1.Issue>,
   ) {
-    super(`Signal "${signalName}" input validation failed: ${zodError.message}`);
+    const message = issues.map((issue) => issue.message).join("; ");
+    super(`Signal "${signalName}" input validation failed: ${message}`);
     this.name = "SignalInputValidationError";
   }
 }
@@ -117,9 +122,10 @@ export class SignalInputValidationError extends WorkerError {
 export class QueryInputValidationError extends WorkerError {
   constructor(
     public readonly queryName: string,
-    public readonly zodError: z.ZodError,
+    public readonly issues: ReadonlyArray<StandardSchemaV1.Issue>,
   ) {
-    super(`Query "${queryName}" input validation failed: ${zodError.message}`);
+    const message = issues.map((issue) => issue.message).join("; ");
+    super(`Query "${queryName}" input validation failed: ${message}`);
     this.name = "QueryInputValidationError";
   }
 }
@@ -130,9 +136,10 @@ export class QueryInputValidationError extends WorkerError {
 export class QueryOutputValidationError extends WorkerError {
   constructor(
     public readonly queryName: string,
-    public readonly zodError: z.ZodError,
+    public readonly issues: ReadonlyArray<StandardSchemaV1.Issue>,
   ) {
-    super(`Query "${queryName}" output validation failed: ${zodError.message}`);
+    const message = issues.map((issue) => issue.message).join("; ");
+    super(`Query "${queryName}" output validation failed: ${message}`);
     this.name = "QueryOutputValidationError";
   }
 }
@@ -143,9 +150,10 @@ export class QueryOutputValidationError extends WorkerError {
 export class UpdateInputValidationError extends WorkerError {
   constructor(
     public readonly updateName: string,
-    public readonly zodError: z.ZodError,
+    public readonly issues: ReadonlyArray<StandardSchemaV1.Issue>,
   ) {
-    super(`Update "${updateName}" input validation failed: ${zodError.message}`);
+    const message = issues.map((issue) => issue.message).join("; ");
+    super(`Update "${updateName}" input validation failed: ${message}`);
     this.name = "UpdateInputValidationError";
   }
 }
@@ -156,9 +164,10 @@ export class UpdateInputValidationError extends WorkerError {
 export class UpdateOutputValidationError extends WorkerError {
   constructor(
     public readonly updateName: string,
-    public readonly zodError: z.ZodError,
+    public readonly issues: ReadonlyArray<StandardSchemaV1.Issue>,
   ) {
-    super(`Update "${updateName}" output validation failed: ${zodError.message}`);
+    const message = issues.map((issue) => issue.message).join("; ");
+    super(`Update "${updateName}" output validation failed: ${message}`);
     this.name = "UpdateOutputValidationError";
   }
 }

package/src/handler.spec.ts

@@ -1,15 +1,7 @@
 import { describe, expect, it, vi } from "vitest";
 import { z } from "zod";
 import { declareActivitiesHandler, declareWorkflow } from "./handler.js";
-import type { ActivityImplementations } from "./handler.js";
 import type { ContractDefinition, WorkflowDefinition } from "@temporal-contract/contract";
-import {
-  ActivityDefinitionNotFoundError,
-  ActivityInputValidationError,
-  ActivityOutputValidationError,
-  WorkflowInputValidationError,
-  WorkflowOutputValidationError,
-} from "./errors.js";
 
 // Mock Temporal workflow functions
 vi.mock("@temporalio/workflow", () => ({
@@ -363,23 +355,16 @@ describe("Worker Package", () => {
       expect(() => {
         declareActivitiesHandler({
           contract,
-          activities: testActivities as unknown as ActivityImplementations<typeof contract>,
+          // @ts-expect-error Testing unknown activity
+          activities: testActivities,
         });
-      }).toThrow(ActivityDefinitionNotFoundError);
-
-      try {
-        declareActivitiesHandler({
-          contract,
-          activities: testActivities as unknown as ActivityImplementations<typeof contract>,
-        });
-      } catch (error) {
-        if (error instanceof ActivityDefinitionNotFoundError) {
-          expect(error.activityName).toBe("unknownActivity");
-          expect(error.availableDefinitions).toEqual(["sendEmail", "processPayment"]);
-          expect(error.message).toContain("unknownActivity");
-          expect(error.message).toContain("sendEmail");
-        }
-      }
+      }).toThrowError(
+        expect.objectContaining({
+          name: "ActivityDefinitionNotFoundError",
+          activityName: "unknownActivity",
+          availableDefinitions: ["sendEmail", "processPayment"],
+        }),
+      );
     });
 
     it("should throw ActivityInputValidationError with Zod details", async () => {
@@ -403,19 +388,16 @@ describe("Worker Package", () => {
         },
       });
 
-      try {
-        await handler.activities["processPayment"]!({
+      await expect(
+        handler.activities["processPayment"]!({
           amount: -100,
           currency: "USD",
-        });
-      } catch (error) {
-        if (error instanceof ActivityInputValidationError) {
-          expect(error.activityName).toBe("processPayment");
-          expect(error.zodError).toBeDefined();
-          expect(error.message).toContain("processPayment");
-          expect(error.message).toContain("input validation failed");
-        }
-      }
+        }),
+      ).rejects.toMatchObject({
+        name: "ActivityInputValidationError",
+        activityName: "processPayment",
+        message: expect.stringContaining("processPayment"),
+      });
     });
 
     it("should throw ActivityOutputValidationError with Zod details", async () => {
@@ -439,16 +421,11 @@ describe("Worker Package", () => {
         },
       });
 
-      try {
-        await handler.activities["fetchData"]!({ id: "123" });
-      } catch (error) {
-        if (error instanceof ActivityOutputValidationError) {
-          expect(error.activityName).toBe("fetchData");
-          expect(error.zodError).toBeDefined();
-          expect(error.message).toContain("fetchData");
-          expect(error.message).toContain("output validation failed");
-        }
-      }
+      await expect(handler.activities["fetchData"]!({ id: "123" })).rejects.toMatchObject({
+        name: "ActivityOutputValidationError",
+        activityName: "fetchData",
+        message: expect.stringContaining("fetchData"),
+      });
     });
 
     it("should throw WorkflowInputValidationError", async () => {
@@ -472,18 +449,16 @@ describe("Worker Package", () => {
         },
       });
 
-      try {
-        await workflow([{ orderId: "not-a-uuid", amount: 100 }] as unknown as {
+      await expect(
+        workflow([{ orderId: "not-a-uuid", amount: 100 }] as unknown as {
           orderId: string;
           amount: number;
-        });
-      } catch (error) {
-        if (error instanceof WorkflowInputValidationError) {
-          expect(error.workflowName).toBe("processOrder");
-          expect(error.zodError).toBeDefined();
-          expect(error.message).toContain("input validation failed");
-        }
-      }
+        }),
+      ).rejects.toMatchObject({
+        name: "WorkflowInputValidationError",
+        workflowName: "processOrder",
+        message: expect.stringContaining("input validation failed"),
+      });
     });
 
     it("should throw WorkflowOutputValidationError", async () => {
@@ -511,15 +486,14 @@ describe("Worker Package", () => {
         },
       });
 
-      try {
-        await workflow([{ orderId: "123" }] as unknown as { orderId: string });
-      } catch (error) {
-        if (error instanceof WorkflowOutputValidationError) {
-          expect(error.workflowName).toBe("processOrder");
-          expect(error.zodError).toBeDefined();
-          expect(error.message).toContain("output validation failed");
-        }
-      }
+      await expect(
+        // @ts-expect-error Testing invalid output
+        workflow([{ orderId: "123" }]),
+      ).rejects.toMatchObject({
+        name: "WorkflowOutputValidationError",
+        workflowName: "processOrder",
+        message: expect.stringContaining("output validation failed"),
+      });
     });
   });
 });

package/src/handler.ts

@@ -8,7 +8,6 @@ import {
   setHandler,
   workflowInfo,
 } from "@temporalio/workflow";
-import { ZodError } from "zod";
 import type {
   ActivityDefinition,
   ContractDefinition,
@@ -236,32 +235,29 @@ function createValidatedActivities<
       throw new ActivityImplementationNotFoundError(activityName, Object.keys(rawActivities));
     }
 
-    // @ts-expect-error fixme later
-    validatedActivities[activityName] = async (input: unknown) => {
+    // Create the wrapped activity with validation
+    // Type assertion to unknown is safe as we're building the object step by step
+    const wrappedActivity = async (input: unknown) => {
       // Validate input before sending over network
-      let validatedInput: unknown;
-      try {
-        validatedInput = activityDef.input.parse(input);
-      } catch (error) {
-        if (error instanceof ZodError) {
-          throw new ActivityInputValidationError(activityName, error);
-        }
-        throw error;
+      const inputResult = await activityDef.input["~standard"].validate(input);
+      if (inputResult.issues) {
+        throw new ActivityInputValidationError(activityName, inputResult.issues);
       }
 
       // Call the actual activity (pass the single parameter directly)
-      const result = await rawActivity(validatedInput);
+      const result = await rawActivity(inputResult.value);
 
       // Validate output after receiving from network
-      try {
-        return activityDef.output.parse(result);
-      } catch (error) {
-        if (error instanceof ZodError) {
-          throw new ActivityOutputValidationError(activityName, error);
-        }
-        throw error;
+      const outputResult = await activityDef.output["~standard"].validate(result);
+      if (outputResult.issues) {
+        throw new ActivityOutputValidationError(activityName, outputResult.issues);
       }
+
+      return outputResult.value;
     };
+
+    // Assign to validatedActivities with proper type handling
+    (validatedActivities as Record<string, unknown>)[activityName] = wrappedActivity;
   }
 
   return validatedActivities;
@@ -348,28 +344,21 @@ export function declareActivitiesHandler<T extends ContractDefinition>(
 
     wrappedActivities[activityName] = async (input: unknown) => {
       // Validate input
-      let validatedInput: unknown;
-      try {
-        validatedInput = activityDef.input.parse(input);
-      } catch (error) {
-        if (error instanceof ZodError) {
-          throw new ActivityInputValidationError(activityName, error);
-        }
-        throw error;
+      const inputResult = await activityDef.input["~standard"].validate(input);
+      if (inputResult.issues) {
+        throw new ActivityInputValidationError(activityName, inputResult.issues);
       }
 
       // Execute activity
-      const result = await activityImpl(validatedInput);
+      const result = await activityImpl(inputResult.value);
 
       // Validate output
-      try {
-        return activityDef.output.parse(result);
-      } catch (error) {
-        if (error instanceof ZodError) {
-          throw new ActivityOutputValidationError(activityName, error);
-        }
-        throw error;
+      const outputResult = await activityDef.output["~standard"].validate(result);
+      if (outputResult.issues) {
+        throw new ActivityOutputValidationError(activityName, outputResult.issues);
       }
+
+      return outputResult.value;
     };
   }
 
@@ -464,17 +453,13 @@ export function declareWorkflow<
     const singleArg = Array.isArray(args) ? args[0] : args;
 
     // Validate workflow input
-    let validatedInput: WorkerInferInput<TContract["workflows"][TWorkflowName]>;
-    try {
-      validatedInput = definition.input.parse(singleArg) as WorkerInferInput<
-        TContract["workflows"][TWorkflowName]
-      >;
-    } catch (error) {
-      if (error instanceof ZodError) {
-        throw new WorkflowInputValidationError(String(workflowName), error);
-      }
-      throw error;
+    const inputResult = await definition.input["~standard"].validate(singleArg);
+    if (inputResult.issues) {
+      throw new WorkflowInputValidationError(String(workflowName), inputResult.issues);
     }
+    const validatedInput = inputResult.value as WorkerInferInput<
+      TContract["workflows"][TWorkflowName]
+    >;
 
     // Register signal handlers
     if (definition.signals && signals) {
@@ -488,16 +473,11 @@ export function declareWorkflow<
           setHandler(signal, async (...args: unknown[]) => {
             // Extract single parameter (Temporal passes as args array)
             const input = args.length === 1 ? args[0] : args;
-            let validatedInput: unknown;
-            try {
-              validatedInput = signalDef.input.parse(input);
-            } catch (error) {
-              if (error instanceof ZodError) {
-                throw new SignalInputValidationError(signalName, error);
-              }
-              throw error;
+            const inputResult = await signalDef.input["~standard"].validate(input);
+            if (inputResult.issues) {
+              throw new SignalInputValidationError(signalName, inputResult.issues);
             }
-            await (handler as SignalHandlerImplementation<SignalDefinition>)(validatedInput);
+            await (handler as SignalHandlerImplementation<SignalDefinition>)(inputResult.value);
           });
         }
       }
@@ -515,24 +495,37 @@ export function declareWorkflow<
           setHandler(query, (...args: unknown[]) => {
             // Extract single parameter (Temporal passes as args array)
             const input = args.length === 1 ? args[0] : args;
-            let validatedInput: unknown;
-            try {
-              validatedInput = queryDef.input.parse(input);
-            } catch (error) {
-              if (error instanceof ZodError) {
-                throw new QueryInputValidationError(queryName, error);
-              }
-              throw error;
+            // Note: Query handlers must be synchronous, so we need to handle validation synchronously
+            // Standard Schema validate can return sync or async results
+            const inputResult = queryDef.input["~standard"].validate(input);
+
+            // Handle both sync and async validation results
+            if (inputResult instanceof Promise) {
+              throw new Error(
+                `Query "${queryName}" validation must be synchronous. Use a schema library that supports synchronous validation for queries.`,
+              );
+            }
+
+            if (inputResult.issues) {
+              throw new QueryInputValidationError(queryName, inputResult.issues);
             }
-            const result = (handler as QueryHandlerImplementation<QueryDefinition>)(validatedInput);
-            try {
-              return queryDef.output.parse(result);
-            } catch (error) {
-              if (error instanceof ZodError) {
-                throw new QueryOutputValidationError(queryName, error);
-              }
-              throw error;
+
+            const result = (handler as QueryHandlerImplementation<QueryDefinition>)(
+              inputResult.value,
+            );
+
+            const outputResult = queryDef.output["~standard"].validate(result);
+            if (outputResult instanceof Promise) {
+              throw new Error(
+                `Query "${queryName}" output validation must be synchronous. Use a schema library that supports synchronous validation for queries.`,
+              );
             }
+
+            if (outputResult.issues) {
+              throw new QueryOutputValidationError(queryName, outputResult.issues);
+            }
+
+            return outputResult.value;
           });
         }
       }
@@ -550,26 +543,21 @@ export function declareWorkflow<
           setHandler(update, async (...args: unknown[]) => {
             // Extract single parameter (Temporal passes as args array)
             const input = args.length === 1 ? args[0] : args;
-            let validatedInput: unknown;
-            try {
-              validatedInput = updateDef.input.parse(input);
-            } catch (error) {
-              if (error instanceof ZodError) {
-                throw new UpdateInputValidationError(updateName, error);
-              }
-              throw error;
+            const inputResult = await updateDef.input["~standard"].validate(input);
+            if (inputResult.issues) {
+              throw new UpdateInputValidationError(updateName, inputResult.issues);
             }
+
             const result = await (handler as UpdateHandlerImplementation<UpdateDefinition>)(
-              validatedInput,
+              inputResult.value,
             );
-            try {
-              return updateDef.output.parse(result);
-            } catch (error) {
-              if (error instanceof ZodError) {
-                throw new UpdateOutputValidationError(updateName, error);
-              }
-              throw error;
+
+            const outputResult = await updateDef.output["~standard"].validate(result);
+            if (outputResult.issues) {
+              throw new UpdateOutputValidationError(updateName, outputResult.issues);
             }
+
+            return outputResult.value;
           });
         }
       }
@@ -607,15 +595,11 @@ export function declareWorkflow<
     const result = await implementation(context, validatedInput);
 
     // Validate workflow output
-    try {
-      return definition.output.parse(result) as WorkerInferOutput<
-        TContract["workflows"][TWorkflowName]
-      >;
-    } catch (error) {
-      if (error instanceof ZodError) {
-        throw new WorkflowOutputValidationError(String(workflowName), error);
-      }
-      throw error;
+    const outputResult = await definition.output["~standard"].validate(result);
+    if (outputResult.issues) {
+      throw new WorkflowOutputValidationError(String(workflowName), outputResult.issues);
     }
+
+    return outputResult.value as WorkerInferOutput<TContract["workflows"][TWorkflowName]>;
   };
 }

package/vitest.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    reporters: ["default"],
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "json", "json-summary", "html"],
+      include: ["src/**"],
+    },
+  },
+});