@temporal-contract/worker 0.0.4 → 0.0.6

package/dist/handler-D9BllGor.cjs

@@ -1,481 +0,0 @@
-let __temporalio_workflow = require("@temporalio/workflow");
-
-//#region src/errors.ts
-/**
-* Base error class for worker errors
-*/
-var WorkerError = class extends Error {
-	constructor(message, cause) {
-		super(message, { cause });
-		this.name = "WorkerError";
-		if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
-	}
-};
-/**
-* Activity error class that should be used to wrap all technical exceptions
-* Forces proper error handling and enables retry policies
-*/
-var ActivityError = class ActivityError extends Error {
-	code;
-	cause;
-	constructor(code, message, cause) {
-		super(message, { cause });
-		this.code = code;
-		this.cause = cause;
-		this.name = "ActivityError";
-		if (Error.captureStackTrace) Error.captureStackTrace(this, ActivityError);
-	}
-};
-/**
-* Error thrown when an activity definition is not found in the contract
-*/
-var ActivityDefinitionNotFoundError = class extends WorkerError {
-	constructor(activityName, availableDefinitions = []) {
-		const available = availableDefinitions.length > 0 ? availableDefinitions.join(", ") : "none";
-		super(`Activity definition not found for: "${activityName}". Available activities: ${available}`);
-		this.activityName = activityName;
-		this.availableDefinitions = availableDefinitions;
-		this.name = "ActivityDefinitionNotFoundError";
-	}
-};
-/**
-* Error thrown when activity input validation fails
-*/
-var ActivityInputValidationError = class extends WorkerError {
-	constructor(activityName, issues) {
-		const message = issues.map((issue) => issue.message).join("; ");
-		super(`Activity "${activityName}" input validation failed: ${message}`);
-		this.activityName = activityName;
-		this.issues = issues;
-		this.name = "ActivityInputValidationError";
-	}
-};
-/**
-* Error thrown when activity output validation fails
-*/
-var ActivityOutputValidationError = class extends WorkerError {
-	constructor(activityName, issues) {
-		const message = issues.map((issue) => issue.message).join("; ");
-		super(`Activity "${activityName}" output validation failed: ${message}`);
-		this.activityName = activityName;
-		this.issues = issues;
-		this.name = "ActivityOutputValidationError";
-	}
-};
-/**
-* Error thrown when workflow input validation fails
-*/
-var WorkflowInputValidationError = class extends WorkerError {
-	constructor(workflowName, issues) {
-		const message = issues.map((issue) => issue.message).join("; ");
-		super(`Workflow "${workflowName}" input validation failed: ${message}`);
-		this.workflowName = workflowName;
-		this.issues = issues;
-		this.name = "WorkflowInputValidationError";
-	}
-};
-/**
-* Error thrown when workflow output validation fails
-*/
-var WorkflowOutputValidationError = class extends WorkerError {
-	constructor(workflowName, issues) {
-		const message = issues.map((issue) => issue.message).join("; ");
-		super(`Workflow "${workflowName}" output validation failed: ${message}`);
-		this.workflowName = workflowName;
-		this.issues = issues;
-		this.name = "WorkflowOutputValidationError";
-	}
-};
-/**
-* Error thrown when signal input validation fails
-*/
-var SignalInputValidationError = class extends WorkerError {
-	constructor(signalName, issues) {
-		const message = issues.map((issue) => issue.message).join("; ");
-		super(`Signal "${signalName}" input validation failed: ${message}`);
-		this.signalName = signalName;
-		this.issues = issues;
-		this.name = "SignalInputValidationError";
-	}
-};
-/**
-* Error thrown when query input validation fails
-*/
-var QueryInputValidationError = class extends WorkerError {
-	constructor(queryName, issues) {
-		const message = issues.map((issue) => issue.message).join("; ");
-		super(`Query "${queryName}" input validation failed: ${message}`);
-		this.queryName = queryName;
-		this.issues = issues;
-		this.name = "QueryInputValidationError";
-	}
-};
-/**
-* Error thrown when query output validation fails
-*/
-var QueryOutputValidationError = class extends WorkerError {
-	constructor(queryName, issues) {
-		const message = issues.map((issue) => issue.message).join("; ");
-		super(`Query "${queryName}" output validation failed: ${message}`);
-		this.queryName = queryName;
-		this.issues = issues;
-		this.name = "QueryOutputValidationError";
-	}
-};
-/**
-* Error thrown when update input validation fails
-*/
-var UpdateInputValidationError = class extends WorkerError {
-	constructor(updateName, issues) {
-		const message = issues.map((issue) => issue.message).join("; ");
-		super(`Update "${updateName}" input validation failed: ${message}`);
-		this.updateName = updateName;
-		this.issues = issues;
-		this.name = "UpdateInputValidationError";
-	}
-};
-/**
-* Error thrown when update output validation fails
-*/
-var UpdateOutputValidationError = class extends WorkerError {
-	constructor(updateName, issues) {
-		const message = issues.map((issue) => issue.message).join("; ");
-		super(`Update "${updateName}" output validation failed: ${message}`);
-		this.updateName = updateName;
-		this.issues = issues;
-		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 Error(`Activity implementation not found for: "${activityName}". Available activities: ${Object.keys(rawActivities).length > 0 ? Object.keys(rawActivities).join(", ") : "none"}`);
-		const wrappedActivity = 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;
-		};
-		validatedActivities[activityName] = wrappedActivity;
-	}
-	return validatedActivities;
-}
-/**
-* Create a typed activities handler with automatic validation and Result pattern
-*
-* This wraps all activity implementations with:
-* - Validation at network boundaries
-* - Result<T, ActivityError> pattern for explicit error handling
-* - Automatic conversion from Result to Promise (throwing on Error)
-*
-* TypeScript ensures ALL activities (global + workflow-specific) are implemented.
-*
-* Use this to create the activities object for the Temporal Worker.
-*
-* @example
-* ```ts
-* import { declareActivitiesHandler, ActivityError } from '@temporal-contract/worker/activity';
-* import { Result, Future } from '@swan-io/boxed';
-* import myContract from './contract';
-*
-* export const activitiesHandler = declareActivitiesHandler({
-*   contract: myContract,
-*   activities: {
-*     // Activity returns Result instead of throwing
-*     // All technical exceptions must be wrapped in ActivityError for retry policies
-*     sendEmail: (args) => {
-*       return Future.make(async resolve => {
-*         try {
-*           await emailService.send(args);
-*           resolve(Result.Ok({ sent: true }));
-*         } catch (error) {
-*           // Wrap technical errors in ActivityError to enable retries
-*           resolve(Result.Error(
-*             new ActivityError(
-*               'EMAIL_SEND_FAILED',
-*               'Failed to send email',
-*               error // Original error as cause for debugging
-*             )
-*           ));
-*         }
-*       });
-*     },
-*   },
-* });
-*
-* // 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 (...args) => {
-			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();
-			if (result.isOk()) {
-				const outputResult = await activityDef.output["~standard"].validate(result.value);
-				if (outputResult.issues) throw new ActivityOutputValidationError(activityName, outputResult.issues);
-				return outputResult.value;
-			} else throw result.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;
-		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);
-		const result = await implementation({
-			activities: contextActivities,
-			info: (0, __temporalio_workflow.workflowInfo)()
-		}, validatedInput);
-		const outputResult = await definition.output["~standard"].validate(result);
-		if (outputResult.issues) throw new WorkflowOutputValidationError(String(workflowName), outputResult.issues);
-		return outputResult.value;
-	};
-}
-
-//#endregion
-Object.defineProperty(exports, 'ActivityDefinitionNotFoundError', {
-  enumerable: true,
-  get: function () {
-    return ActivityDefinitionNotFoundError;
-  }
-});
-Object.defineProperty(exports, 'ActivityError', {
-  enumerable: true,
-  get: function () {
-    return ActivityError;
-  }
-});
-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;
-  }
-});