@temporal-contract/worker 0.0.4 → 0.0.6

package/dist/handler-B7B5QHez.mjs

@@ -1,398 +0,0 @@
-import { defineQuery, defineSignal, defineUpdate, proxyActivities, setHandler, workflowInfo } from "@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) 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);
-		const result = await implementation({
-			activities: contextActivities,
-			info: workflowInfo()
-		}, validatedInput);
-		const outputResult = await definition.output["~standard"].validate(result);
-		if (outputResult.issues) throw new WorkflowOutputValidationError(String(workflowName), outputResult.issues);
-		return outputResult.value;
-	};
-}
-
-//#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 };