@temporal-contract/worker 0.0.4 → 0.0.6

package/dist/worker.cjs

@@ -0,0 +1,65 @@
+let _temporalio_worker = require("@temporalio/worker");
+let node_url = require("node:url");
+let node_path = require("node:path");
+
+//#region src/worker.ts
+/**
+* Create a typed Temporal worker with contract-based configuration
+*
+* This helper simplifies worker creation by:
+* - Using the contract's task queue automatically
+* - Providing type-safe configuration
+*
+* @example
+* ```ts
+* import { NativeConnection } from '@temporalio/worker';
+* import { createWorker } from '@temporal-contract/worker/worker';
+* import { activities } from './activities';
+* import myContract from './contract';
+*
+* const connection = await NativeConnection.connect({
+*   address: 'localhost:7233',
+* });
+*
+* const worker = await createWorker({
+*   contract: myContract,
+*   connection,
+*   workflowsPath: require.resolve('./workflows'),
+*   activities,
+* });
+*
+* await worker.run();
+* ```
+*/
+async function createWorker(options) {
+	const { contract, activities, ...workerOptions } = options;
+	return await _temporalio_worker.Worker.create({
+		...workerOptions,
+		activities,
+		taskQueue: contract.taskQueue
+	});
+}
+/**
+* Helper to create a workflowsPath from a file URL
+*
+* Useful for creating the workflowsPath option when using ES modules
+*
+* @example
+* ```ts
+* import { workflowsPathFromURL } from '@temporal-contract/worker/worker';
+*
+* const worker = await createWorker({
+*   contract: myContract,
+*   connection,
+*   workflowsPath: workflowsPathFromURL(import.meta.url, './workflows'),
+*   activities,
+* });
+* ```
+*/
+function workflowsPathFromURL(baseURL, relativePath) {
+	return (0, node_url.fileURLToPath)(new URL(`${relativePath}${(0, node_path.extname)(baseURL)}`, baseURL));
+}
+
+//#endregion
+exports.createWorker = createWorker;
+exports.workflowsPathFromURL = workflowsPathFromURL;

package/dist/worker.d.cts

@@ -0,0 +1,68 @@
+import { ActivitiesHandler } from "./activity.cjs";
+import { ContractDefinition } from "@temporal-contract/contract";
+import { Worker, WorkerOptions } from "@temporalio/worker";
+
+//#region src/worker.d.ts
+
+/**
+ * Options for creating a Temporal worker
+ */
+interface CreateWorkerOptions<TContract extends ContractDefinition> extends Omit<WorkerOptions, "activities" | "taskQueue"> {
+  /**
+   * The contract definition for this worker
+   */
+  contract: TContract;
+  /**
+   * Activities handler for this worker
+   */
+  activities: ActivitiesHandler<TContract>;
+}
+/**
+ * Create a typed Temporal worker with contract-based configuration
+ *
+ * This helper simplifies worker creation by:
+ * - Using the contract's task queue automatically
+ * - Providing type-safe configuration
+ *
+ * @example
+ * ```ts
+ * import { NativeConnection } from '@temporalio/worker';
+ * import { createWorker } from '@temporal-contract/worker/worker';
+ * import { activities } from './activities';
+ * import myContract from './contract';
+ *
+ * const connection = await NativeConnection.connect({
+ *   address: 'localhost:7233',
+ * });
+ *
+ * const worker = await createWorker({
+ *   contract: myContract,
+ *   connection,
+ *   workflowsPath: require.resolve('./workflows'),
+ *   activities,
+ * });
+ *
+ * await worker.run();
+ * ```
+ */
+declare function createWorker<TContract extends ContractDefinition>(options: CreateWorkerOptions<TContract>): Promise<Worker>;
+/**
+ * Helper to create a workflowsPath from a file URL
+ *
+ * Useful for creating the workflowsPath option when using ES modules
+ *
+ * @example
+ * ```ts
+ * import { workflowsPathFromURL } from '@temporal-contract/worker/worker';
+ *
+ * const worker = await createWorker({
+ *   contract: myContract,
+ *   connection,
+ *   workflowsPath: workflowsPathFromURL(import.meta.url, './workflows'),
+ *   activities,
+ * });
+ * ```
+ */
+declare function workflowsPathFromURL(baseURL: string, relativePath: string): string;
+//#endregion
+export { CreateWorkerOptions, createWorker, workflowsPathFromURL };

package/dist/worker.d.mts

@@ -0,0 +1,68 @@
+import { ActivitiesHandler } from "./activity.mjs";
+import { Worker, WorkerOptions } from "@temporalio/worker";
+import { ContractDefinition } from "@temporal-contract/contract";
+
+//#region src/worker.d.ts
+
+/**
+ * Options for creating a Temporal worker
+ */
+interface CreateWorkerOptions<TContract extends ContractDefinition> extends Omit<WorkerOptions, "activities" | "taskQueue"> {
+  /**
+   * The contract definition for this worker
+   */
+  contract: TContract;
+  /**
+   * Activities handler for this worker
+   */
+  activities: ActivitiesHandler<TContract>;
+}
+/**
+ * Create a typed Temporal worker with contract-based configuration
+ *
+ * This helper simplifies worker creation by:
+ * - Using the contract's task queue automatically
+ * - Providing type-safe configuration
+ *
+ * @example
+ * ```ts
+ * import { NativeConnection } from '@temporalio/worker';
+ * import { createWorker } from '@temporal-contract/worker/worker';
+ * import { activities } from './activities';
+ * import myContract from './contract';
+ *
+ * const connection = await NativeConnection.connect({
+ *   address: 'localhost:7233',
+ * });
+ *
+ * const worker = await createWorker({
+ *   contract: myContract,
+ *   connection,
+ *   workflowsPath: require.resolve('./workflows'),
+ *   activities,
+ * });
+ *
+ * await worker.run();
+ * ```
+ */
+declare function createWorker<TContract extends ContractDefinition>(options: CreateWorkerOptions<TContract>): Promise<Worker>;
+/**
+ * Helper to create a workflowsPath from a file URL
+ *
+ * Useful for creating the workflowsPath option when using ES modules
+ *
+ * @example
+ * ```ts
+ * import { workflowsPathFromURL } from '@temporal-contract/worker/worker';
+ *
+ * const worker = await createWorker({
+ *   contract: myContract,
+ *   connection,
+ *   workflowsPath: workflowsPathFromURL(import.meta.url, './workflows'),
+ *   activities,
+ * });
+ * ```
+ */
+declare function workflowsPathFromURL(baseURL: string, relativePath: string): string;
+//#endregion
+export { CreateWorkerOptions, createWorker, workflowsPathFromURL };

package/dist/worker.mjs

@@ -0,0 +1,64 @@
+import { Worker } from "@temporalio/worker";
+import { fileURLToPath } from "node:url";
+import { extname } from "node:path";
+
+//#region src/worker.ts
+/**
+* Create a typed Temporal worker with contract-based configuration
+*
+* This helper simplifies worker creation by:
+* - Using the contract's task queue automatically
+* - Providing type-safe configuration
+*
+* @example
+* ```ts
+* import { NativeConnection } from '@temporalio/worker';
+* import { createWorker } from '@temporal-contract/worker/worker';
+* import { activities } from './activities';
+* import myContract from './contract';
+*
+* const connection = await NativeConnection.connect({
+*   address: 'localhost:7233',
+* });
+*
+* const worker = await createWorker({
+*   contract: myContract,
+*   connection,
+*   workflowsPath: require.resolve('./workflows'),
+*   activities,
+* });
+*
+* await worker.run();
+* ```
+*/
+async function createWorker(options) {
+	const { contract, activities, ...workerOptions } = options;
+	return await Worker.create({
+		...workerOptions,
+		activities,
+		taskQueue: contract.taskQueue
+	});
+}
+/**
+* Helper to create a workflowsPath from a file URL
+*
+* Useful for creating the workflowsPath option when using ES modules
+*
+* @example
+* ```ts
+* import { workflowsPathFromURL } from '@temporal-contract/worker/worker';
+*
+* const worker = await createWorker({
+*   contract: myContract,
+*   connection,
+*   workflowsPath: workflowsPathFromURL(import.meta.url, './workflows'),
+*   activities,
+* });
+* ```
+*/
+function workflowsPathFromURL(baseURL, relativePath) {
+	return fileURLToPath(new URL(`${relativePath}${extname(baseURL)}`, baseURL));
+}
+
+//#endregion
+export { createWorker, workflowsPathFromURL };

package/dist/workflow.cjs

@@ -1,11 +1,256 @@
-const require_handler = require('./handler-D9BllGor.cjs');
+const require_errors = require('./errors-DjSZg-93.cjs');
+let _temporal_contract_boxed = require("@temporal-contract/boxed");
+let _temporalio_workflow = require("@temporalio/workflow");
 
-exports.QueryInputValidationError = require_handler.QueryInputValidationError;
-exports.QueryOutputValidationError = require_handler.QueryOutputValidationError;
-exports.SignalInputValidationError = require_handler.SignalInputValidationError;
-exports.UpdateInputValidationError = require_handler.UpdateInputValidationError;
-exports.UpdateOutputValidationError = require_handler.UpdateOutputValidationError;
-exports.WorkerError = require_handler.WorkerError;
-exports.WorkflowInputValidationError = require_handler.WorkflowInputValidationError;
-exports.WorkflowOutputValidationError = require_handler.WorkflowOutputValidationError;
-exports.declareWorkflow = require_handler.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 require_errors.WorkflowInputValidationError(String(workflowName), inputResult.issues);
+		const validatedInput = inputResult.value;
+		let contextActivities = {};
+		if (definition.activities || contract.activities) contextActivities = createValidatedActivities((0, _temporalio_workflow.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 _temporal_contract_boxed.Result.Error(new require_errors.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 require_errors.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 require_errors.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 require_errors.ChildWorkflowError(`Child workflow execution failed: ${error instanceof Error ? error.message : String(error)}`, error)));
+							}
+						})();
+					});
+				}
+			};
+		}
+		function createStartChildWorkflow(childContract, childWorkflowName, options) {
+			return _temporal_contract_boxed.Future.make((resolve) => {
+				(async () => {
+					const validationResult = await getAndValidateChildWorkflow(childContract, childWorkflowName, options.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;
+						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 require_errors.ChildWorkflowError(`Failed to start child workflow: ${error instanceof Error ? error.message : String(error)}`, error)));
+					}
+				})();
+			});
+		}
+		function createExecuteChildWorkflow(childContract, childWorkflowName, options) {
+			return _temporal_contract_boxed.Future.make((resolve) => {
+				(async () => {
+					const validationResult = await getAndValidateChildWorkflow(childContract, childWorkflowName, options.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;
+						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 require_errors.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$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 require_errors.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$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 require_errors.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 require_errors.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$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 require_errors.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 require_errors.UpdateOutputValidationError(updateName, outputResult$1.issues);
+				return outputResult$1.value;
+			});
+		}
+		const result = await implementation({
+			activities: contextActivities,
+			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 require_errors.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 require_errors.ActivityInputValidationError(activityName, inputResult.issues);
+			const result = await rawActivity(inputResult.value);
+			const outputResult = await activityDef.output["~standard"].validate(result);
+			if (outputResult.issues) throw new require_errors.ActivityOutputValidationError(activityName, outputResult.issues);
+			return outputResult.value;
+		};
+	}
+	return validatedActivities;
+}
+
+//#endregion
+exports.ActivityInputValidationError = require_errors.ActivityInputValidationError;
+exports.ActivityOutputValidationError = require_errors.ActivityOutputValidationError;
+exports.ChildWorkflowError = require_errors.ChildWorkflowError;
+exports.ChildWorkflowNotFoundError = require_errors.ChildWorkflowNotFoundError;
+exports.QueryInputValidationError = require_errors.QueryInputValidationError;
+exports.QueryOutputValidationError = require_errors.QueryOutputValidationError;
+exports.SignalInputValidationError = require_errors.SignalInputValidationError;
+exports.UpdateInputValidationError = require_errors.UpdateInputValidationError;
+exports.UpdateOutputValidationError = require_errors.UpdateOutputValidationError;
+exports.WorkflowInputValidationError = require_errors.WorkflowInputValidationError;
+exports.WorkflowOutputValidationError = require_errors.WorkflowOutputValidationError;
+exports.declareWorkflow = declareWorkflow;