@temporal-contract/worker 0.0.1

package/dist/handler-B3KY0uDx.cjs

@@ -0,0 +1,492 @@
+let __temporalio_workflow = require("@temporalio/workflow");
+let zod = require("zod");
+
+//#region src/errors.ts
+/**
+* Base error class for worker errors
+*/
+var WorkerError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "WorkerError";
+		if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
+	}
+};
+/**
+* Error thrown when an activity implementation is not found
+*/
+var ActivityImplementationNotFoundError = class extends WorkerError {
+	constructor(activityName, availableActivities) {
+		super(`Activity implementation not found for: "${activityName}". Available activities: ${availableActivities.length > 0 ? availableActivities.join(", ") : "none"}`);
+		this.activityName = activityName;
+		this.availableActivities = availableActivities;
+		this.name = "ActivityImplementationNotFoundError";
+	}
+};
+/**
+* Error thrown when an activity definition is not found in the contract
+*/
+var ActivityDefinitionNotFoundError = class extends WorkerError {
+	constructor(activityName, availableDefinitions) {
+		super(`Activity definition not found in contract for: "${activityName}". Available definitions: ${availableDefinitions.length > 0 ? availableDefinitions.join(", ") : "none"}`);
+		this.activityName = activityName;
+		this.availableDefinitions = availableDefinitions;
+		this.name = "ActivityDefinitionNotFoundError";
+	}
+};
+/**
+* Error thrown when activity input validation fails
+*/
+var ActivityInputValidationError = class extends WorkerError {
+	constructor(activityName, zodError) {
+		super(`Activity "${activityName}" input validation failed: ${zodError.message}`);
+		this.activityName = activityName;
+		this.zodError = zodError;
+		this.name = "ActivityInputValidationError";
+	}
+};
+/**
+* Error thrown when activity output validation fails
+*/
+var ActivityOutputValidationError = class extends WorkerError {
+	constructor(activityName, zodError) {
+		super(`Activity "${activityName}" output validation failed: ${zodError.message}`);
+		this.activityName = activityName;
+		this.zodError = zodError;
+		this.name = "ActivityOutputValidationError";
+	}
+};
+/**
+* Error thrown when workflow input validation fails
+*/
+var WorkflowInputValidationError = class extends WorkerError {
+	constructor(workflowName, zodError) {
+		super(`Workflow "${workflowName}" input validation failed: ${zodError.message}`);
+		this.workflowName = workflowName;
+		this.zodError = zodError;
+		this.name = "WorkflowInputValidationError";
+	}
+};
+/**
+* Error thrown when workflow output validation fails
+*/
+var WorkflowOutputValidationError = class extends WorkerError {
+	constructor(workflowName, zodError) {
+		super(`Workflow "${workflowName}" output validation failed: ${zodError.message}`);
+		this.workflowName = workflowName;
+		this.zodError = zodError;
+		this.name = "WorkflowOutputValidationError";
+	}
+};
+/**
+* Error thrown when signal input validation fails
+*/
+var SignalInputValidationError = class extends WorkerError {
+	constructor(signalName, zodError) {
+		super(`Signal "${signalName}" input validation failed: ${zodError.message}`);
+		this.signalName = signalName;
+		this.zodError = zodError;
+		this.name = "SignalInputValidationError";
+	}
+};
+/**
+* Error thrown when query input validation fails
+*/
+var QueryInputValidationError = class extends WorkerError {
+	constructor(queryName, zodError) {
+		super(`Query "${queryName}" input validation failed: ${zodError.message}`);
+		this.queryName = queryName;
+		this.zodError = zodError;
+		this.name = "QueryInputValidationError";
+	}
+};
+/**
+* Error thrown when query output validation fails
+*/
+var QueryOutputValidationError = class extends WorkerError {
+	constructor(queryName, zodError) {
+		super(`Query "${queryName}" output validation failed: ${zodError.message}`);
+		this.queryName = queryName;
+		this.zodError = zodError;
+		this.name = "QueryOutputValidationError";
+	}
+};
+/**
+* Error thrown when update input validation fails
+*/
+var UpdateInputValidationError = class extends WorkerError {
+	constructor(updateName, zodError) {
+		super(`Update "${updateName}" input validation failed: ${zodError.message}`);
+		this.updateName = updateName;
+		this.zodError = zodError;
+		this.name = "UpdateInputValidationError";
+	}
+};
+/**
+* Error thrown when update output validation fails
+*/
+var UpdateOutputValidationError = class extends WorkerError {
+	constructor(updateName, zodError) {
+		super(`Update "${updateName}" output validation failed: ${zodError.message}`);
+		this.updateName = updateName;
+		this.zodError = zodError;
+		this.name = "UpdateOutputValidationError";
+	}
+};
+
+//#endregion
+//#region src/handler.ts
+/**
+* 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 ActivityImplementationNotFoundError(activityName, Object.keys(rawActivities));
+		validatedActivities[activityName] = async (input) => {
+			let validatedInput;
+			try {
+				validatedInput = activityDef.input.parse(input);
+			} catch (error) {
+				if (error instanceof zod.ZodError) throw new ActivityInputValidationError(activityName, error);
+				throw error;
+			}
+			const result = await rawActivity(validatedInput);
+			try {
+				return activityDef.output.parse(result);
+			} catch (error) {
+				if (error instanceof zod.ZodError) throw new ActivityOutputValidationError(activityName, error);
+				throw error;
+			}
+		};
+	}
+	return validatedActivities;
+}
+/**
+* Create a typed activities handler with automatic validation
+*
+* This wraps all activity implementations with Zod validation at network boundaries.
+* TypeScript ensures ALL activities (global + workflow-specific) are implemented.
+*
+* Use this to create the activities object for the Temporal Worker.
+*
+* @example
+* ```ts
+* import { declareActivitiesHandler } from '@temporal-contract/worker';
+* import myContract from './contract';
+*
+* export const activitiesHandler = declareActivitiesHandler({
+*   contract: myContract,
+*   activities: {
+*     // Global activities
+*     sendEmail: async (to, subject, body) => {
+*       await emailService.send({ to, subject, body });
+*       return { sent: true };
+*     },
+*     // Workflow-specific activities
+*     validateInventory: async (orderId) => {
+*       const available = await inventory.check(orderId);
+*       return { available };
+*     },
+*   },
+* });
+*
+* // Use with Temporal Worker
+* import { Worker } from '@temporalio/worker';
+*
+* const worker = await Worker.create({
+*   workflowsPath: require.resolve('./workflows'),
+*   activities: activitiesHandler.activities,
+*   taskQueue: activitiesHandler.contract.taskQueue,
+* });
+* ```
+*/
+function declareActivitiesHandler(options) {
+	const { contract, activities } = options;
+	const wrappedActivities = {};
+	const allDefinitions = [];
+	if (contract.activities) allDefinitions.push(...Object.keys(contract.activities));
+	for (const workflow of Object.values(contract.workflows)) if (workflow.activities) allDefinitions.push(...Object.keys(workflow.activities));
+	for (const [activityName, activityImpl] of Object.entries(activities)) {
+		let activityDef;
+		if (contract.activities?.[activityName]) activityDef = contract.activities[activityName];
+		else for (const workflow of Object.values(contract.workflows)) if (workflow.activities?.[activityName]) {
+			activityDef = workflow.activities[activityName];
+			break;
+		}
+		if (!activityDef) throw new ActivityDefinitionNotFoundError(activityName, allDefinitions);
+		wrappedActivities[activityName] = async (input) => {
+			let validatedInput;
+			try {
+				validatedInput = activityDef.input.parse(input);
+			} catch (error) {
+				if (error instanceof zod.ZodError) throw new ActivityInputValidationError(activityName, error);
+				throw error;
+			}
+			const result = await activityImpl(validatedInput);
+			try {
+				return activityDef.output.parse(result);
+			} catch (error) {
+				if (error instanceof zod.ZodError) throw new ActivityOutputValidationError(activityName, error);
+				throw error;
+			}
+		};
+	}
+	return {
+		contract,
+		activities: wrappedActivities
+	};
+}
+/**
+* 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(options) {
+	const { workflowName, contract, implementation, activityOptions, signals, queries, updates } = options;
+	const definition = contract.workflows[workflowName];
+	return async (args) => {
+		const singleArg = Array.isArray(args) ? args[0] : args;
+		let validatedInput;
+		try {
+			validatedInput = definition.input.parse(singleArg);
+		} catch (error) {
+			if (error instanceof zod.ZodError) throw new WorkflowInputValidationError(String(workflowName), error);
+			throw error;
+		}
+		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;
+					let validatedInput$1;
+					try {
+						validatedInput$1 = signalDef.input.parse(input);
+					} catch (error) {
+						if (error instanceof zod.ZodError) throw new SignalInputValidationError(signalName, error);
+						throw error;
+					}
+					await handler(validatedInput$1);
+				});
+			}
+		}
+		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;
+					let validatedInput$1;
+					try {
+						validatedInput$1 = queryDef.input.parse(input);
+					} catch (error) {
+						if (error instanceof zod.ZodError) throw new QueryInputValidationError(queryName, error);
+						throw error;
+					}
+					const result$1 = handler(validatedInput$1);
+					try {
+						return queryDef.output.parse(result$1);
+					} catch (error) {
+						if (error instanceof zod.ZodError) throw new QueryOutputValidationError(queryName, error);
+						throw error;
+					}
+				});
+			}
+		}
+		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;
+					let validatedInput$1;
+					try {
+						validatedInput$1 = updateDef.input.parse(input);
+					} catch (error) {
+						if (error instanceof zod.ZodError) throw new UpdateInputValidationError(updateName, error);
+						throw error;
+					}
+					const result$1 = await handler(validatedInput$1);
+					try {
+						return updateDef.output.parse(result$1);
+					} catch (error) {
+						if (error instanceof zod.ZodError) throw new UpdateOutputValidationError(updateName, error);
+						throw error;
+					}
+				});
+			}
+		}
+		let contextActivities = {};
+		if (definition.activities || contract.activities) contextActivities = createValidatedActivities((0, __temporalio_workflow.proxyActivities)({
+			startToCloseTimeout: activityOptions?.startToCloseTimeout ?? 6e4,
+			...activityOptions
+		}), definition.activities, contract.activities);
+		const result = await implementation({
+			activities: contextActivities,
+			info: (0, __temporalio_workflow.workflowInfo)()
+		}, validatedInput);
+		try {
+			return definition.output.parse(result);
+		} catch (error) {
+			if (error instanceof zod.ZodError) throw new WorkflowOutputValidationError(String(workflowName), error);
+			throw error;
+		}
+	};
+}
+
+//#endregion
+Object.defineProperty(exports, 'ActivityDefinitionNotFoundError', {
+  enumerable: true,
+  get: function () {
+    return ActivityDefinitionNotFoundError;
+  }
+});
+Object.defineProperty(exports, 'ActivityImplementationNotFoundError', {
+  enumerable: true,
+  get: function () {
+    return ActivityImplementationNotFoundError;
+  }
+});
+Object.defineProperty(exports, 'ActivityInputValidationError', {
+  enumerable: true,
+  get: function () {
+    return ActivityInputValidationError;
+  }
+});
+Object.defineProperty(exports, 'ActivityOutputValidationError', {
+  enumerable: true,
+  get: function () {
+    return ActivityOutputValidationError;
+  }
+});
+Object.defineProperty(exports, 'QueryInputValidationError', {
+  enumerable: true,
+  get: function () {
+    return QueryInputValidationError;
+  }
+});
+Object.defineProperty(exports, 'QueryOutputValidationError', {
+  enumerable: true,
+  get: function () {
+    return QueryOutputValidationError;
+  }
+});
+Object.defineProperty(exports, 'SignalInputValidationError', {
+  enumerable: true,
+  get: function () {
+    return SignalInputValidationError;
+  }
+});
+Object.defineProperty(exports, 'UpdateInputValidationError', {
+  enumerable: true,
+  get: function () {
+    return UpdateInputValidationError;
+  }
+});
+Object.defineProperty(exports, 'UpdateOutputValidationError', {
+  enumerable: true,
+  get: function () {
+    return UpdateOutputValidationError;
+  }
+});
+Object.defineProperty(exports, 'WorkerError', {
+  enumerable: true,
+  get: function () {
+    return WorkerError;
+  }
+});
+Object.defineProperty(exports, 'WorkflowInputValidationError', {
+  enumerable: true,
+  get: function () {
+    return WorkflowInputValidationError;
+  }
+});
+Object.defineProperty(exports, 'WorkflowOutputValidationError', {
+  enumerable: true,
+  get: function () {
+    return WorkflowOutputValidationError;
+  }
+});
+Object.defineProperty(exports, 'declareActivitiesHandler', {
+  enumerable: true,
+  get: function () {
+    return declareActivitiesHandler;
+  }
+});
+Object.defineProperty(exports, 'declareWorkflow', {
+  enumerable: true,
+  get: function () {
+    return declareWorkflow;
+  }
+});