@temporal-contract/worker 0.0.4 → 0.0.5

package/README.md

@@ -36,6 +36,55 @@ export const processOrder = declareWorkflow({
 });
 ```
 
+### Child Workflows
+
+Execute child workflows with type-safe Future/Result pattern. Supports both same-contract and cross-contract child workflows:
+
+```typescript
+// workflows.ts
+import { declareWorkflow } from '@temporal-contract/worker/workflow';
+
+export const parentWorkflow = declareWorkflow({
+  workflowName: 'parentWorkflow',
+  contract: myContract,
+  implementation: async (context, input) => {
+    // Execute child workflow from same contract and wait for result
+    const childResult = await context.executeChildWorkflow(myContract, 'processPayment', {
+      workflowId: `payment-${input.orderId}`,
+      args: { amount: input.totalAmount }
+    });
+
+    childResult.match({
+      Ok: (output) => console.log('Payment processed:', output),
+      Error: (error) => console.error('Payment failed:', error),
+    });
+
+    // Execute child workflow from another contract (another worker)
+    const notificationResult = await context.executeChildWorkflow(notificationContract, 'sendNotification', {
+      workflowId: `notification-${input.orderId}`,
+      args: { message: 'Order received' }
+    });
+
+    // Or start child workflow without waiting
+    const handleResult = await context.startChildWorkflow(myContract, 'sendEmail', {
+      workflowId: `email-${input.orderId}`,
+      args: { to: 'user@example.com', body: 'Order received' }
+    });
+
+    handleResult.match({
+      Ok: async (handle) => {
+        // Can wait for result later
+        const result = await handle.result();
+        // ...
+      },
+      Error: (error) => console.error('Failed to start:', error),
+    });
+
+    return { success: true };
+  }
+});
+```
+
 ## Documentation
 
 📖 **[Read the full documentation →](https://btravers.github.io/temporal-contract)**

package/dist/activity.cjs

@@ -1,33 +1,8 @@
-const require_handler = require('./handler-D9BllGor.cjs');
-let __swan_io_boxed = require("@swan-io/boxed");
+const require_handler = require('./handler-BAzNuAZz.cjs');
 
 exports.ActivityDefinitionNotFoundError = require_handler.ActivityDefinitionNotFoundError;
 exports.ActivityError = require_handler.ActivityError;
 exports.ActivityInputValidationError = require_handler.ActivityInputValidationError;
 exports.ActivityOutputValidationError = require_handler.ActivityOutputValidationError;
-Object.defineProperty(exports, 'AsyncData', {
-  enumerable: true,
-  get: function () {
-    return __swan_io_boxed.AsyncData;
-  }
-});
-Object.defineProperty(exports, 'Future', {
-  enumerable: true,
-  get: function () {
-    return __swan_io_boxed.Future;
-  }
-});
-Object.defineProperty(exports, 'Option', {
-  enumerable: true,
-  get: function () {
-    return __swan_io_boxed.Option;
-  }
-});
-Object.defineProperty(exports, 'Result', {
-  enumerable: true,
-  get: function () {
-    return __swan_io_boxed.Result;
-  }
-});
 exports.WorkerError = require_handler.WorkerError;
 exports.declareActivitiesHandler = require_handler.declareActivitiesHandler;

package/dist/activity.d.cts

@@ -1,3 +1,2 @@
-import { S as WorkerError, d as declareActivitiesHandler, g as ActivityOutputValidationError, h as ActivityInputValidationError, i as DeclareActivitiesHandlerOptions, m as ActivityError, n as ActivityImplementations, p as ActivityDefinitionNotFoundError, r as BoxedActivityImplementation, t as ActivitiesHandler } from "./handler-Czi-kgwZ.cjs";
-import { AsyncData, Future, Option, Result } from "@swan-io/boxed";
-export { type ActivitiesHandler, ActivityDefinitionNotFoundError, ActivityError, type ActivityImplementations, ActivityInputValidationError, ActivityOutputValidationError, AsyncData, type BoxedActivityImplementation, type DeclareActivitiesHandlerOptions, Future, Option, Result, WorkerError, declareActivitiesHandler };
+import { A as WorkerInferActivities, E as WorkerError, M as WorkerInferInput, N as WorkerInferOutput, R as WorkerInferWorkflowActivities, W as WorkflowActivityHandler, _ as ActivityInputValidationError, g as ActivityError, h as ActivityDefinitionNotFoundError, i as DeclareActivitiesHandlerOptions, j as WorkerInferActivity, k as ActivityHandler, n as ActivityImplementations, p as declareActivitiesHandler, r as BoxedActivityImplementation, t as ActivitiesHandler, v as ActivityOutputValidationError, z as WorkerInferWorkflowContextActivities } from "./handler-Cp9h_XCy.cjs";
+export { type ActivitiesHandler, ActivityDefinitionNotFoundError, ActivityError, type ActivityHandler, type ActivityImplementations, ActivityInputValidationError, ActivityOutputValidationError, type BoxedActivityImplementation, type DeclareActivitiesHandlerOptions, WorkerError, type WorkerInferActivities, type WorkerInferActivity, type WorkerInferInput, type WorkerInferOutput, type WorkerInferWorkflowActivities, type WorkerInferWorkflowContextActivities, type WorkflowActivityHandler, declareActivitiesHandler };

package/dist/activity.d.mts

@@ -1,3 +1,2 @@
-import { S as WorkerError, d as declareActivitiesHandler, g as ActivityOutputValidationError, h as ActivityInputValidationError, i as DeclareActivitiesHandlerOptions, m as ActivityError, n as ActivityImplementations, p as ActivityDefinitionNotFoundError, r as BoxedActivityImplementation, t as ActivitiesHandler } from "./handler-DThqdaaS.mjs";
-import { AsyncData, Future, Option, Result } from "@swan-io/boxed";
-export { type ActivitiesHandler, ActivityDefinitionNotFoundError, ActivityError, type ActivityImplementations, ActivityInputValidationError, ActivityOutputValidationError, AsyncData, type BoxedActivityImplementation, type DeclareActivitiesHandlerOptions, Future, Option, Result, WorkerError, declareActivitiesHandler };
+import { A as WorkerInferActivities, E as WorkerError, M as WorkerInferInput, N as WorkerInferOutput, R as WorkerInferWorkflowActivities, W as WorkflowActivityHandler, _ as ActivityInputValidationError, g as ActivityError, h as ActivityDefinitionNotFoundError, i as DeclareActivitiesHandlerOptions, j as WorkerInferActivity, k as ActivityHandler, n as ActivityImplementations, p as declareActivitiesHandler, r as BoxedActivityImplementation, t as ActivitiesHandler, v as ActivityOutputValidationError, z as WorkerInferWorkflowContextActivities } from "./handler-uAeIi9f0.mjs";
+export { type ActivitiesHandler, ActivityDefinitionNotFoundError, ActivityError, type ActivityHandler, type ActivityImplementations, ActivityInputValidationError, ActivityOutputValidationError, type BoxedActivityImplementation, type DeclareActivitiesHandlerOptions, WorkerError, type WorkerInferActivities, type WorkerInferActivity, type WorkerInferInput, type WorkerInferOutput, type WorkerInferWorkflowActivities, type WorkerInferWorkflowContextActivities, type WorkflowActivityHandler, declareActivitiesHandler };

package/dist/activity.mjs

@@ -1,4 +1,3 @@
-import { a as ActivityInputValidationError, f as WorkerError, i as ActivityError, o as ActivityOutputValidationError, r as ActivityDefinitionNotFoundError, t as declareActivitiesHandler } from "./handler-B7B5QHez.mjs";
-import { AsyncData, Future, Option, Result } from "@swan-io/boxed";
+import { a as ActivityInputValidationError, i as ActivityError, m as WorkerError, o as ActivityOutputValidationError, r as ActivityDefinitionNotFoundError, t as declareActivitiesHandler } from "./handler-DFFpSaGN.mjs";
 
-export { ActivityDefinitionNotFoundError, ActivityError, ActivityInputValidationError, ActivityOutputValidationError, AsyncData, Future, Option, Result, WorkerError, declareActivitiesHandler };
+export { ActivityDefinitionNotFoundError, ActivityError, ActivityInputValidationError, ActivityOutputValidationError, WorkerError, declareActivitiesHandler };

package/dist/{handler-D9BllGor.cjs → handler-BAzNuAZz.cjs}

@@ -1,3 +1,4 @@
+let __temporal_contract_boxed = require("@temporal-contract/boxed");
 let __temporalio_workflow = require("@temporalio/workflow");
 
 //#region src/errors.ts
@@ -146,6 +147,27 @@ var UpdateOutputValidationError = class extends WorkerError {
 		this.name = "UpdateOutputValidationError";
 	}
 };
+/**
+* Error thrown when a child workflow is not found in the contract
+*/
+var ChildWorkflowNotFoundError = class extends WorkerError {
+	constructor(workflowName, availableWorkflows = []) {
+		const available = availableWorkflows.length > 0 ? availableWorkflows.join(", ") : "none";
+		super(`Child workflow not found: "${workflowName}". Available workflows: ${available}`);
+		this.workflowName = workflowName;
+		this.availableWorkflows = availableWorkflows;
+		this.name = "ChildWorkflowNotFoundError";
+	}
+};
+/**
+* Generic error for child workflow operations
+*/
+var ChildWorkflowError = class extends WorkerError {
+	constructor(message, cause) {
+		super(message, cause);
+		this.name = "ChildWorkflowError";
+	}
+};
 
 //#endregion
 //#region src/handler.ts
@@ -191,7 +213,7 @@ function createValidatedActivities(rawActivities, workflowActivitiesDefinition,
 * @example
 * ```ts
 * import { declareActivitiesHandler, ActivityError } from '@temporal-contract/worker/activity';
-* import { Result, Future } from '@swan-io/boxed';
+* import { Result, Future } from '@temporal-contract/boxed';
 * import myContract from './contract';
 *
 * export const activitiesHandler = declareActivitiesHandler({
@@ -247,7 +269,7 @@ function declareActivitiesHandler(options) {
 			const input = args.length === 1 ? args[0] : args;
 			const inputResult = await activityDef.input["~standard"].validate(input);
 			if (inputResult.issues) throw new ActivityInputValidationError(activityName, inputResult.issues);
-			const result = await activityImpl(inputResult.value).toPromise();
+			const result = await activityImpl(inputResult.value);
 			if (result.isOk()) {
 				const outputResult = await activityDef.output["~standard"].validate(result.value);
 				if (outputResult.issues) throw new ActivityOutputValidationError(activityName, outputResult.issues);
@@ -325,68 +347,150 @@ function declareActivitiesHandler(options) {
 * ```
 */
 function declareWorkflow(options) {
-	const { workflowName, contract, implementation, activityOptions, signals, queries, updates } = options;
+	const { workflowName, contract, implementation, activityOptions } = options;
 	const definition = contract.workflows[workflowName];
 	return async (args) => {
 		const singleArg = Array.isArray(args) ? args[0] : args;
 		const inputResult = await definition.input["~standard"].validate(singleArg);
 		if (inputResult.issues) throw new WorkflowInputValidationError(String(workflowName), inputResult.issues);
 		const validatedInput = inputResult.value;
-		if (definition.signals && signals) {
-			const signalDefs = definition.signals;
-			const signalHandlers = signals;
-			for (const [signalName, signalDef] of Object.entries(signalDefs)) {
-				const handler = signalHandlers[signalName];
-				if (handler) (0, __temporalio_workflow.setHandler)((0, __temporalio_workflow.defineSignal)(signalName), async (...args$1) => {
-					const input = args$1.length === 1 ? args$1[0] : args$1;
-					const inputResult$1 = await signalDef.input["~standard"].validate(input);
-					if (inputResult$1.issues) throw new SignalInputValidationError(signalName, inputResult$1.issues);
-					await handler(inputResult$1.value);
-				});
-			}
-		}
-		if (definition.queries && queries) {
-			const queryDefs = definition.queries;
-			const queryHandlers = queries;
-			for (const [queryName, queryDef] of Object.entries(queryDefs)) {
-				const handler = queryHandlers[queryName];
-				if (handler) (0, __temporalio_workflow.setHandler)((0, __temporalio_workflow.defineQuery)(queryName), (...args$1) => {
-					const input = args$1.length === 1 ? args$1[0] : args$1;
-					const inputResult$1 = queryDef.input["~standard"].validate(input);
-					if (inputResult$1 instanceof Promise) throw new Error(`Query "${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 "${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;
-				});
-			}
-		}
-		if (definition.updates && updates) {
-			const updateDefs = definition.updates;
-			const updateHandlers = updates;
-			for (const [updateName, updateDef] of Object.entries(updateDefs)) {
-				const handler = updateHandlers[updateName];
-				if (handler) (0, __temporalio_workflow.setHandler)((0, __temporalio_workflow.defineUpdate)(updateName), async (...args$1) => {
-					const input = args$1.length === 1 ? args$1[0] : args$1;
-					const inputResult$1 = await updateDef.input["~standard"].validate(input);
-					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;
-				});
-			}
-		}
 		let contextActivities = {};
 		if (definition.activities || contract.activities) contextActivities = createValidatedActivities((0, __temporalio_workflow.proxyActivities)({
 			startToCloseTimeout: activityOptions?.startToCloseTimeout ?? 6e4,
 			...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 __temporal_contract_boxed.Result.Error(new ChildWorkflowError(`Child workflow "${childWorkflowName}" output validation failed: ${outputResult$1.issues.map((i) => i.message).join("; ")}`));
+			return __temporal_contract_boxed.Result.Ok(outputResult$1.value);
+		}
+		async function getAndValidateChildWorkflow(childContract, childWorkflowName, args$1) {
+			const childDefinition = childContract.workflows[childWorkflowName];
+			if (!childDefinition) return __temporal_contract_boxed.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 __temporal_contract_boxed.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 __temporal_contract_boxed.Result.Ok({
+				definition: childDefinition,
+				validatedInput: validatedInput$1,
+				taskQueue: childContract.taskQueue
+			});
+		}
+		function createTypedChildHandle(handle, childDefinition, childWorkflowName) {
+			return {
+				workflowId: handle.workflowId,
+				result: () => {
+					return __temporal_contract_boxed.Future.make((resolve) => {
+						(async () => {
+							try {
+								resolve(await validateChildWorkflowOutput(childDefinition, await handle.result(), childWorkflowName));
+							} catch (error) {
+								resolve(__temporal_contract_boxed.Result.Error(new ChildWorkflowError(`Child workflow execution failed: ${error instanceof Error ? error.message : String(error)}`, error)));
+							}
+						})();
+					});
+				}
+			};
+		}
+		function createStartChildWorkflow(childContract, childWorkflowName, options$1) {
+			return __temporal_contract_boxed.Future.make((resolve) => {
+				(async () => {
+					const validationResult = await getAndValidateChildWorkflow(childContract, childWorkflowName, options$1.args);
+					if (validationResult.isError()) {
+						resolve(__temporal_contract_boxed.Result.Error(validationResult.error));
+						return;
+					}
+					const { definition: childDefinition, validatedInput: validatedInput$1, taskQueue } = validationResult.value;
+					try {
+						const { args: _args, ...temporalOptions } = options$1;
+						const typedHandle = createTypedChildHandle(await (0, __temporalio_workflow.startChild)(childWorkflowName, {
+							...temporalOptions,
+							taskQueue,
+							args: [validatedInput$1]
+						}), childDefinition, String(childWorkflowName));
+						resolve(__temporal_contract_boxed.Result.Ok(typedHandle));
+					} catch (error) {
+						resolve(__temporal_contract_boxed.Result.Error(new ChildWorkflowError(`Failed to start child workflow: ${error instanceof Error ? error.message : String(error)}`, error)));
+					}
+				})();
+			});
+		}
+		function createExecuteChildWorkflow(childContract, childWorkflowName, options$1) {
+			return __temporal_contract_boxed.Future.make((resolve) => {
+				(async () => {
+					const validationResult = await getAndValidateChildWorkflow(childContract, childWorkflowName, options$1.args);
+					if (validationResult.isError()) {
+						resolve(__temporal_contract_boxed.Result.Error(validationResult.error));
+						return;
+					}
+					const { definition: childDefinition, validatedInput: validatedInput$1, taskQueue } = validationResult.value;
+					try {
+						const { args: _args, ...temporalOptions } = options$1;
+						const outputValidationResult = await validateChildWorkflowOutput(childDefinition, await (0, __temporalio_workflow.executeChild)(childWorkflowName, {
+							...temporalOptions,
+							taskQueue,
+							args: [validatedInput$1]
+						}), String(childWorkflowName));
+						if (outputValidationResult.isError()) {
+							resolve(__temporal_contract_boxed.Result.Error(outputValidationResult.error));
+							return;
+						}
+						resolve(__temporal_contract_boxed.Result.Ok(outputValidationResult.value));
+					} catch (error) {
+						resolve(__temporal_contract_boxed.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`);
+			(0, __temporalio_workflow.setHandler)((0, __temporalio_workflow.defineSignal)(signalName), async (...args$1) => {
+				const input = args$1.length === 1 ? args$1[0] : args$1;
+				const inputResult$1 = await signalDef.input["~standard"].validate(input);
+				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`);
+			(0, __temporalio_workflow.setHandler)((0, __temporalio_workflow.defineQuery)(queryName), (...args$1) => {
+				const input = args$1.length === 1 ? args$1[0] : args$1;
+				const inputResult$1 = queryDef.input["~standard"].validate(input);
+				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`);
+			(0, __temporalio_workflow.setHandler)((0, __temporalio_workflow.defineUpdate)(updateName), async (...args$1) => {
+				const input = args$1.length === 1 ? args$1[0] : args$1;
+				const inputResult$1 = await updateDef.input["~standard"].validate(input);
+				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: (0, __temporalio_workflow.workflowInfo)()
+			info: (0, __temporalio_workflow.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);
@@ -419,6 +523,18 @@ Object.defineProperty(exports, 'ActivityOutputValidationError', {
     return ActivityOutputValidationError;
   }
 });
+Object.defineProperty(exports, 'ChildWorkflowError', {
+  enumerable: true,
+  get: function () {
+    return ChildWorkflowError;
+  }
+});
+Object.defineProperty(exports, 'ChildWorkflowNotFoundError', {
+  enumerable: true,
+  get: function () {
+    return ChildWorkflowNotFoundError;
+  }
+});
 Object.defineProperty(exports, 'QueryInputValidationError', {
   enumerable: true,
   get: function () {