@temporal-contract/worker 0.0.4 → 0.0.6

package/dist/workflow.mjs

@@ -1,3 +1,245 @@
-import { c as QueryOutputValidationError, d as UpdateOutputValidationError, f as WorkerError, l as SignalInputValidationError, m as WorkflowOutputValidationError, n as declareWorkflow, p as WorkflowInputValidationError, s as QueryInputValidationError, u as UpdateInputValidationError } from "./handler-B7B5QHez.mjs";
+import { a as ChildWorkflowNotFoundError, c as SignalInputValidationError, d as WorkflowInputValidationError, f as WorkflowOutputValidationError, i as ChildWorkflowError, l as UpdateInputValidationError, n as ActivityInputValidationError, o as QueryInputValidationError, r as ActivityOutputValidationError, s as QueryOutputValidationError, u as UpdateOutputValidationError } from "./errors-BqVTpfcf.mjs";
+import { Future, Result } from "@temporal-contract/boxed";
+import { defineQuery, defineSignal, defineUpdate, executeChild, proxyActivities, setHandler, startChild, workflowInfo } from "@temporalio/workflow";
 
-export { QueryInputValidationError, QueryOutputValidationError, SignalInputValidationError, UpdateInputValidationError, UpdateOutputValidationError, WorkerError, WorkflowInputValidationError, WorkflowOutputValidationError, declareWorkflow };
+//#region src/workflow.ts
+/**
+* Create a typed workflow implementation with automatic validation
+*
+* This wraps a workflow implementation with:
+* - Input/output validation
+* - Typed workflow context with activities
+* - Workflow info access
+*
+* Workflows must be defined in separate files and imported by the Temporal Worker
+* via workflowsPath.
+*
+* @example
+* ```ts
+* // workflows/processOrder.ts
+* import { declareWorkflow } from '@temporal-contract/worker';
+* import myContract from '../contract';
+*
+* export const processOrder = declareWorkflow({
+*   workflowName: 'processOrder',
+*   contract: myContract,
+*   implementation: async (context, orderId, customerId) => {
+*     // context.activities: typed activities (workflow + global)
+*     // context.info: WorkflowInfo
+*
+*     const inventory = await context.activities.validateInventory(orderId);
+*
+*     if (!inventory.available) {
+*       throw new Error('Out of stock');
+*     }
+*
+*     const payment = await context.activities.chargePayment(customerId, 100);
+*
+*     // Global activity
+*     await context.activities.sendEmail(
+*       customerId,
+*       'Order processed',
+*       'Your order has been processed'
+*     );
+*
+*     return {
+*       orderId,
+*       status: payment.success ? 'success' : 'failed',
+*       transactionId: payment.transactionId,
+*     };
+*   },
+*   activityOptions: {
+*     startToCloseTimeout: '1 minute',
+*   },
+* });
+* ```
+*
+* Then in your worker setup:
+* ```ts
+* // worker.ts
+* import { Worker } from '@temporalio/worker';
+* import { activitiesHandler } from './activities';
+*
+* const worker = await Worker.create({
+*   workflowsPath: require.resolve('./workflows'), // Imports processOrder
+*   activities: activitiesHandler.activities,
+*   taskQueue: activitiesHandler.contract.taskQueue,
+* });
+* ```
+*/
+function declareWorkflow({ workflowName, contract, implementation, activityOptions }) {
+	const definition = contract.workflows[workflowName];
+	return async (...args) => {
+		const input = args.length === 1 ? args[0] : args;
+		const inputResult = await definition.input["~standard"].validate(input);
+		if (inputResult.issues) throw new WorkflowInputValidationError(String(workflowName), inputResult.issues);
+		const validatedInput = inputResult.value;
+		let contextActivities = {};
+		if (definition.activities || contract.activities) contextActivities = createValidatedActivities(proxyActivities(activityOptions), definition.activities, contract.activities);
+		async function validateChildWorkflowOutput(childDefinition, result$1, childWorkflowName) {
+			const outputResult$1 = await childDefinition.output["~standard"].validate(result$1);
+			if (outputResult$1.issues) return Result.Error(new ChildWorkflowError(`Child workflow "${childWorkflowName}" output validation failed: ${outputResult$1.issues.map((i) => i.message).join("; ")}`));
+			return Result.Ok(outputResult$1.value);
+		}
+		async function getAndValidateChildWorkflow(childContract, childWorkflowName, args$1) {
+			const childDefinition = childContract.workflows[childWorkflowName];
+			if (!childDefinition) return Result.Error(new ChildWorkflowNotFoundError(String(childWorkflowName), Object.keys(childContract.workflows)));
+			const inputResult$1 = await childDefinition.input["~standard"].validate(args$1);
+			if (inputResult$1.issues) return Result.Error(new ChildWorkflowError(`Child workflow "${String(childWorkflowName)}" input validation failed: ${inputResult$1.issues.map((i) => i.message).join("; ")}`));
+			const validatedInput$1 = inputResult$1.value;
+			return Result.Ok({
+				definition: childDefinition,
+				validatedInput: validatedInput$1,
+				taskQueue: childContract.taskQueue
+			});
+		}
+		function createTypedChildHandle(handle, childDefinition, childWorkflowName) {
+			return {
+				workflowId: handle.workflowId,
+				result: () => {
+					return Future.make((resolve) => {
+						(async () => {
+							try {
+								resolve(await validateChildWorkflowOutput(childDefinition, await handle.result(), childWorkflowName));
+							} catch (error) {
+								resolve(Result.Error(new ChildWorkflowError(`Child workflow execution failed: ${error instanceof Error ? error.message : String(error)}`, error)));
+							}
+						})();
+					});
+				}
+			};
+		}
+		function createStartChildWorkflow(childContract, childWorkflowName, options) {
+			return Future.make((resolve) => {
+				(async () => {
+					const validationResult = await getAndValidateChildWorkflow(childContract, childWorkflowName, options.args);
+					if (validationResult.isError()) {
+						resolve(Result.Error(validationResult.error));
+						return;
+					}
+					const { definition: childDefinition, validatedInput: validatedInput$1, taskQueue } = validationResult.value;
+					try {
+						const { args: _args, ...temporalOptions } = options;
+						const typedHandle = createTypedChildHandle(await startChild(childWorkflowName, {
+							...temporalOptions,
+							taskQueue,
+							args: [validatedInput$1]
+						}), childDefinition, String(childWorkflowName));
+						resolve(Result.Ok(typedHandle));
+					} catch (error) {
+						resolve(Result.Error(new ChildWorkflowError(`Failed to start child workflow: ${error instanceof Error ? error.message : String(error)}`, error)));
+					}
+				})();
+			});
+		}
+		function createExecuteChildWorkflow(childContract, childWorkflowName, options) {
+			return Future.make((resolve) => {
+				(async () => {
+					const validationResult = await getAndValidateChildWorkflow(childContract, childWorkflowName, options.args);
+					if (validationResult.isError()) {
+						resolve(Result.Error(validationResult.error));
+						return;
+					}
+					const { definition: childDefinition, validatedInput: validatedInput$1, taskQueue } = validationResult.value;
+					try {
+						const { args: _args, ...temporalOptions } = options;
+						const outputValidationResult = await validateChildWorkflowOutput(childDefinition, await executeChild(childWorkflowName, {
+							...temporalOptions,
+							taskQueue,
+							args: [validatedInput$1]
+						}), String(childWorkflowName));
+						if (outputValidationResult.isError()) {
+							resolve(Result.Error(outputValidationResult.error));
+							return;
+						}
+						resolve(Result.Ok(outputValidationResult.value));
+					} catch (error) {
+						resolve(Result.Error(new ChildWorkflowError(`Failed to execute child workflow: ${error instanceof Error ? error.message : String(error)}`, error)));
+					}
+				})();
+			});
+		}
+		function createDefineSignal(signalName, handler) {
+			if (!definition.signals) throw new Error(`Signal "${String(signalName)}" cannot be defined: workflow "${String(workflowName)}" has no signals in its contract`);
+			const signalDef = definition.signals[signalName];
+			if (!signalDef) throw new Error(`Signal "${String(signalName)}" not found in workflow "${String(workflowName)}" contract`);
+			setHandler(defineSignal(signalName), async (...args$1) => {
+				const input$1 = args$1.length === 1 ? args$1[0] : args$1;
+				const inputResult$1 = await signalDef.input["~standard"].validate(input$1);
+				if (inputResult$1.issues) throw new SignalInputValidationError(signalName, inputResult$1.issues);
+				await handler(inputResult$1.value);
+			});
+		}
+		function createDefineQuery(queryName, handler) {
+			if (!definition.queries) throw new Error(`Query "${String(queryName)}" cannot be defined: workflow "${String(workflowName)}" has no queries in its contract`);
+			const queryDef = definition.queries[queryName];
+			if (!queryDef) throw new Error(`Query "${String(queryName)}" not found in workflow "${String(workflowName)}" contract`);
+			setHandler(defineQuery(queryName), (...args$1) => {
+				const input$1 = args$1.length === 1 ? args$1[0] : args$1;
+				const inputResult$1 = queryDef.input["~standard"].validate(input$1);
+				if (inputResult$1 instanceof Promise) throw new Error(`Query "${String(queryName)}" validation must be synchronous. Use a schema library that supports synchronous validation for queries.`);
+				if (inputResult$1.issues) throw new QueryInputValidationError(queryName, inputResult$1.issues);
+				const result$1 = handler(inputResult$1.value);
+				const outputResult$1 = queryDef.output["~standard"].validate(result$1);
+				if (outputResult$1 instanceof Promise) throw new Error(`Query "${String(queryName)}" output validation must be synchronous. Use a schema library that supports synchronous validation for queries.`);
+				if (outputResult$1.issues) throw new QueryOutputValidationError(queryName, outputResult$1.issues);
+				return outputResult$1.value;
+			});
+		}
+		function createDefineUpdate(updateName, handler) {
+			if (!definition.updates) throw new Error(`Update "${String(updateName)}" cannot be defined: workflow "${String(workflowName)}" has no updates in its contract`);
+			const updateDef = definition.updates[updateName];
+			if (!updateDef) throw new Error(`Update "${String(updateName)}" not found in workflow "${String(workflowName)}" contract`);
+			setHandler(defineUpdate(updateName), async (...args$1) => {
+				const input$1 = args$1.length === 1 ? args$1[0] : args$1;
+				const inputResult$1 = await updateDef.input["~standard"].validate(input$1);
+				if (inputResult$1.issues) throw new UpdateInputValidationError(updateName, inputResult$1.issues);
+				const result$1 = await handler(inputResult$1.value);
+				const outputResult$1 = await updateDef.output["~standard"].validate(result$1);
+				if (outputResult$1.issues) throw new UpdateOutputValidationError(updateName, outputResult$1.issues);
+				return outputResult$1.value;
+			});
+		}
+		const result = await implementation({
+			activities: contextActivities,
+			info: workflowInfo(),
+			startChildWorkflow: createStartChildWorkflow,
+			executeChildWorkflow: createExecuteChildWorkflow,
+			defineSignal: createDefineSignal,
+			defineQuery: createDefineQuery,
+			defineUpdate: createDefineUpdate
+		}, validatedInput);
+		const outputResult = await definition.output["~standard"].validate(result);
+		if (outputResult.issues) throw new WorkflowOutputValidationError(String(workflowName), outputResult.issues);
+		return outputResult.value;
+	};
+}
+/**
+* Create a validated activities proxy that parses inputs and outputs
+*
+* This wrapper ensures data integrity across the network boundary between
+* workflow and activity execution.
+*/
+function createValidatedActivities(rawActivities, workflowActivitiesDefinition, contractActivitiesDefinition) {
+	const validatedActivities = {};
+	const allActivitiesDefinition = {
+		...contractActivitiesDefinition,
+		...workflowActivitiesDefinition
+	};
+	for (const [activityName, activityDef] of Object.entries(allActivitiesDefinition)) {
+		const rawActivity = rawActivities[activityName];
+		if (!rawActivity) throw new Error(`Activity implementation not found for: "${activityName}". Available activities: ${Object.keys(rawActivities).length > 0 ? Object.keys(rawActivities).join(", ") : "none"}`);
+		validatedActivities[activityName] = async (input) => {
+			const inputResult = await activityDef.input["~standard"].validate(input);
+			if (inputResult.issues) throw new ActivityInputValidationError(activityName, inputResult.issues);
+			const result = await rawActivity(inputResult.value);
+			const outputResult = await activityDef.output["~standard"].validate(result);
+			if (outputResult.issues) throw new ActivityOutputValidationError(activityName, outputResult.issues);
+			return outputResult.value;
+		};
+	}
+	return validatedActivities;
+}
+
+//#endregion
+export { ActivityInputValidationError, ActivityOutputValidationError, ChildWorkflowError, ChildWorkflowNotFoundError, QueryInputValidationError, QueryOutputValidationError, SignalInputValidationError, UpdateInputValidationError, UpdateOutputValidationError, WorkflowInputValidationError, WorkflowOutputValidationError, declareWorkflow };

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@temporal-contract/worker",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "Worker utilities with Result/Future pattern for implementing temporal-contract workflows and activities",
   "keywords": [
-    "temporal",
-    "typescript",
     "contract",
-    "worker",
+    "future",
     "result",
-    "future"
+    "temporal",
+    "typescript",
+    "worker"
   ],
   "homepage": "https://github.com/btravers/temporal-contract#readme",
   "bugs": {
@@ -20,7 +20,7 @@
     "directory": "packages/worker"
   },
   "license": "MIT",
-  "author": "Benoit TRAVERS <benoit.travers.frgmail.com>",
+  "author": "Benoit TRAVERS <benoit.travers.fr@gmail.com>",
   "type": "module",
   "exports": {
     "./activity": {
@@ -33,6 +33,17 @@
         "default": "./dist/activity.cjs"
       }
     },
+    "./package.json": "./package.json",
+    "./worker": {
+      "import": {
+        "types": "./dist/worker.d.mts",
+        "default": "./dist/worker.mjs"
+      },
+      "require": {
+        "types": "./dist/worker.d.cts",
+        "default": "./dist/worker.cjs"
+      }
+    },
     "./workflow": {
       "import": {
         "types": "./dist/workflow.d.mts",
@@ -42,8 +53,7 @@
         "types": "./dist/workflow.d.cts",
         "default": "./dist/workflow.cjs"
       }
-    },
-    "./package.json": "./package.json"
+    }
   },
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
@@ -52,28 +62,34 @@
     "dist"
   ],
   "dependencies": {
-    "@standard-schema/spec": "1.0.0",
-    "@swan-io/boxed": "3.2.1",
-    "@temporal-contract/contract": "0.0.4"
+    "@standard-schema/spec": "1.1.0",
+    "@temporal-contract/boxed": "0.0.6",
+    "@temporal-contract/contract": "0.0.6"
   },
   "devDependencies": {
-    "@temporalio/workflow": "1.13.2",
-    "@types/node": "25.0.1",
-    "@vitest/coverage-v8": "4.0.15",
-    "tsdown": "0.17.3",
+    "@temporalio/client": "1.14.0",
+    "@temporalio/worker": "1.14.0",
+    "@temporalio/workflow": "1.14.0",
+    "@types/node": "25.0.3",
+    "@vitest/coverage-v8": "4.0.16",
+    "tsdown": "0.18.1",
     "typescript": "5.9.3",
-    "vitest": "4.0.15",
-    "zod": "4.1.13",
-    "@temporal-contract/tsconfig": "0.0.4"
+    "vitest": "4.0.16",
+    "zod": "4.2.1",
+    "@temporal-contract/client": "0.0.6",
+    "@temporal-contract/testing": "0.0.6",
+    "@temporal-contract/tsconfig": "0.0.6"
   },
   "peerDependencies": {
-    "@temporalio/workflow": ">=1.13.0 <2.0.0"
+    "@temporalio/worker": "^1",
+    "@temporalio/workflow": "^1"
   },
   "scripts": {
-    "build": "tsdown src/activity.ts src/workflow.ts --format cjs,esm --dts --clean",
-    "dev": "tsdown src/activity.ts src/workflow.ts --format cjs,esm --dts --watch",
-    "test": "vitest run",
-    "test:watch": "vitest",
+    "build": "tsdown src/activity.ts src/worker.ts src/workflow.ts --format cjs,esm --dts --clean",
+    "dev": "tsdown src/activity.ts src/worker.ts src/workflow.ts --format cjs,esm --dts --watch",
+    "test": "vitest run --project unit",
+    "test:integration": "vitest run --project integration",
+    "test:watch": "vitest --project unit",
     "typecheck": "tsc --noEmit"
   }
 }