@temporal-contract/worker 0.0.4 → 0.0.5

package/dist/{handler-B7B5QHez.mjs → handler-DFFpSaGN.mjs}

@@ -1,4 +1,5 @@
-import { defineQuery, defineSignal, defineUpdate, proxyActivities, setHandler, workflowInfo } from "@temporalio/workflow";
+import { Future, Result } from "@temporal-contract/boxed";
+import { defineQuery, defineSignal, defineUpdate, executeChild, proxyActivities, setHandler, startChild, workflowInfo } from "@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) setHandler(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) setHandler(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) setHandler(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(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 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$1) {
+			return Future.make((resolve) => {
+				(async () => {
+					const validationResult = await getAndValidateChildWorkflow(childContract, childWorkflowName, options$1.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$1;
+						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$1) {
+			return Future.make((resolve) => {
+				(async () => {
+					const validationResult = await getAndValidateChildWorkflow(childContract, childWorkflowName, options$1.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$1;
+						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 = 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`);
+			setHandler(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`);
+			setHandler(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: workflowInfo()
+			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);
@@ -395,4 +499,4 @@ function declareWorkflow(options) {
 }
 
 //#endregion
-export { ActivityInputValidationError as a, QueryOutputValidationError as c, UpdateOutputValidationError as d, WorkerError as f, ActivityError as i, SignalInputValidationError as l, WorkflowOutputValidationError as m, declareWorkflow as n, ActivityOutputValidationError as o, WorkflowInputValidationError as p, ActivityDefinitionNotFoundError as r, QueryInputValidationError as s, declareActivitiesHandler as t, UpdateInputValidationError as u };
+export { ActivityInputValidationError as a, ChildWorkflowNotFoundError as c, SignalInputValidationError as d, UpdateInputValidationError as f, WorkflowOutputValidationError as g, WorkflowInputValidationError as h, ActivityError as i, QueryInputValidationError as l, WorkerError as m, declareWorkflow as n, ActivityOutputValidationError as o, UpdateOutputValidationError as p, ActivityDefinitionNotFoundError as r, ChildWorkflowError as s, declareActivitiesHandler as t, QueryOutputValidationError as u };