@temporal-contract/worker 0.0.5 → 0.0.7

package/dist/activity.mjs

@@ -1,3 +1,183 @@
-import { a as ActivityInputValidationError, i as ActivityError, m as WorkerError, o as ActivityOutputValidationError, r as ActivityDefinitionNotFoundError, t as declareActivitiesHandler } from "./handler-DFFpSaGN.mjs";
+import { n as ActivityInputValidationError, r as ActivityOutputValidationError, t as ActivityDefinitionNotFoundError } from "./errors-BqVTpfcf.mjs";
 
-export { ActivityDefinitionNotFoundError, ActivityError, ActivityInputValidationError, ActivityOutputValidationError, WorkerError, declareActivitiesHandler };
+//#region src/activity-utils.ts
+/**
+* Extract activity definitions for a specific workflow from a contract
+*
+* This includes both:
+* - Workflow-specific activities defined under workflow.activities
+* - Global activities defined under contract.activities
+*
+* @param contract - The contract definition
+* @param workflowName - The name of the workflow
+* @returns Activity definitions for the workflow (workflow-specific + global activities merged)
+*
+* @example
+* ```ts
+* const orderWorkflowActivities = getWorkflowActivities(myContract, 'processOrder');
+* // Returns: { processPayment: ActivityDef, reserveInventory: ActivityDef, sendEmail: ActivityDef }
+* // where sendEmail is a global activity
+* ```
+*/
+function getWorkflowActivities(contract, workflowName) {
+	const workflowActivities = contract.workflows[workflowName]?.activities || {};
+	return {
+		...contract.activities || {},
+		...workflowActivities
+	};
+}
+/**
+* Extract all activity names for a specific workflow from a contract
+*
+* @param contract - The contract definition
+* @param workflowName - The name of the workflow
+* @returns Array of activity names (strings) available for the workflow
+*
+* @example
+* ```ts
+* const activityNames = getWorkflowActivityNames(myContract, 'processOrder');
+* // Returns: ['processPayment', 'reserveInventory', 'sendEmail']
+* ```
+*/
+function getWorkflowActivityNames(contract, workflowName) {
+	const activities = getWorkflowActivities(contract, workflowName);
+	return Object.keys(activities);
+}
+/**
+* Check if an activity belongs to a specific workflow
+*
+* @param contract - The contract definition
+* @param workflowName - The name of the workflow
+* @param activityName - The name of the activity to check
+* @returns True if the activity is available for the workflow, false otherwise
+*
+* @example
+* ```ts
+* if (isWorkflowActivity(myContract, 'processOrder', 'processPayment')) {
+*   // Activity is available for this workflow
+* }
+* ```
+*/
+function isWorkflowActivity(contract, workflowName, activityName) {
+	return activityName in getWorkflowActivities(contract, workflowName);
+}
+/**
+* Get all workflow names from a contract
+*
+* @param contract - The contract definition
+* @returns Array of workflow names defined in the contract
+*
+* @example
+* ```ts
+* const workflows = getWorkflowNames(myContract);
+* // Returns: ['processOrder', 'processRefund']
+* ```
+*/
+function getWorkflowNames(contract) {
+	return Object.keys(contract.workflows);
+}
+
+//#endregion
+//#region src/activity.ts
+/**
+* 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 {
+	constructor(code, message, cause) {
+		super(message, { cause });
+		this.code = code;
+		this.name = "ActivityError";
+		if (Error.captureStackTrace) Error.captureStackTrace(this, ActivityError);
+	}
+};
+/**
+* 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 activities = 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: activities,
+*   taskQueue: contract.taskQueue,
+* });
+* ```
+*/
+function declareActivitiesHandler(options) {
+	const { contract, activities } = options;
+	const wrappedActivities = {};
+	function makeWrapped(activityName, activityDef, activityImpl) {
+		return 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);
+			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;
+		};
+	}
+	if (contract.activities) for (const [activityName, impl] of Object.entries(activities)) {
+		if (contract.workflows && activityName in contract.workflows) continue;
+		const activityDef = contract.activities[activityName];
+		if (!activityDef) throw new ActivityDefinitionNotFoundError(activityName, Object.keys(contract.activities));
+		wrappedActivities[activityName] = makeWrapped(activityName, activityDef, impl);
+	}
+	if (contract.workflows) for (const [workflowName, workflowDef] of Object.entries(contract.workflows)) {
+		const wfActivitiesImpl = activities[workflowName];
+		if (!wfActivitiesImpl) continue;
+		const wfDefs = workflowDef.activities ?? {};
+		for (const [activityName, impl] of Object.entries(wfActivitiesImpl)) {
+			const activityDef = wfDefs[activityName];
+			if (!activityDef) throw new ActivityDefinitionNotFoundError(`${workflowName}.${activityName}`, Object.keys(wfDefs));
+			wrappedActivities[activityName] = makeWrapped(`${workflowName}.${activityName}`, activityDef, impl);
+		}
+	}
+	return wrappedActivities;
+}
+
+//#endregion
+export { ActivityDefinitionNotFoundError, ActivityError, ActivityInputValidationError, ActivityOutputValidationError, declareActivitiesHandler, getWorkflowActivities, getWorkflowActivityNames, getWorkflowNames, isWorkflowActivity };

package/dist/errors-BqVTpfcf.mjs

@@ -0,0 +1,155 @@
+//#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);
+	}
+};
+/**
+* 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";
+	}
+};
+/**
+* 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
+export { ChildWorkflowNotFoundError as a, SignalInputValidationError as c, WorkflowInputValidationError as d, WorkflowOutputValidationError as f, ChildWorkflowError as i, UpdateInputValidationError as l, ActivityInputValidationError as n, QueryInputValidationError as o, ActivityOutputValidationError as r, QueryOutputValidationError as s, ActivityDefinitionNotFoundError as t, UpdateOutputValidationError as u };

package/dist/errors-BqYWpdvd.d.cts

@@ -0,0 +1,137 @@
+import { AnySchema } from "@temporal-contract/contract";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/types.d.ts
+
+/**
+ * Infer input type from a definition (worker perspective)
+ * Worker receives the output type (after input schema parsing/transformation)
+ */
+type WorkerInferInput<T extends {
+  input: AnySchema;
+}> = StandardSchemaV1.InferOutput<T["input"]>;
+/**
+ * Infer output type from a definition (worker perspective)
+ * Worker returns the input type (before output schema parsing/transformation)
+ */
+type WorkerInferOutput<T extends {
+  output: AnySchema;
+}> = StandardSchemaV1.InferInput<T["output"]>;
+/**
+ * Infer input type from a definition (client perspective)
+ * Client sends the input type (before input schema parsing/transformation)
+ */
+type ClientInferInput<T extends {
+  input: AnySchema;
+}> = StandardSchemaV1.InferInput<T["input"]>;
+/**
+ * Infer output type from a definition (client perspective)
+ * Client receives the output type (after output schema parsing/transformation)
+ */
+type ClientInferOutput<T extends {
+  output: AnySchema;
+}> = StandardSchemaV1.InferOutput<T["output"]>;
+//#endregion
+//#region src/errors.d.ts
+/**
+ * Base error class for worker errors
+ */
+declare abstract class WorkerError extends Error {
+  protected constructor(message: string, cause?: unknown);
+}
+/**
+ * Error thrown when an activity definition is not found in the contract
+ */
+declare class ActivityDefinitionNotFoundError extends WorkerError {
+  readonly activityName: string;
+  readonly availableDefinitions: readonly string[];
+  constructor(activityName: string, availableDefinitions?: readonly string[]);
+}
+/**
+ * Error thrown when activity input validation fails
+ */
+declare class ActivityInputValidationError extends WorkerError {
+  readonly activityName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(activityName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when activity output validation fails
+ */
+declare class ActivityOutputValidationError extends WorkerError {
+  readonly activityName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(activityName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when workflow input validation fails
+ */
+declare class WorkflowInputValidationError extends WorkerError {
+  readonly workflowName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(workflowName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when workflow output validation fails
+ */
+declare class WorkflowOutputValidationError extends WorkerError {
+  readonly workflowName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(workflowName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when signal input validation fails
+ */
+declare class SignalInputValidationError extends WorkerError {
+  readonly signalName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(signalName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when query input validation fails
+ */
+declare class QueryInputValidationError extends WorkerError {
+  readonly queryName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(queryName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when query output validation fails
+ */
+declare class QueryOutputValidationError extends WorkerError {
+  readonly queryName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(queryName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when update input validation fails
+ */
+declare class UpdateInputValidationError extends WorkerError {
+  readonly updateName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(updateName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when update output validation fails
+ */
+declare class UpdateOutputValidationError extends WorkerError {
+  readonly updateName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(updateName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when a child workflow is not found in the contract
+ */
+declare class ChildWorkflowNotFoundError extends WorkerError {
+  readonly workflowName: string;
+  readonly availableWorkflows: readonly string[];
+  constructor(workflowName: string, availableWorkflows?: readonly string[]);
+}
+/**
+ * Generic error for child workflow operations
+ */
+declare class ChildWorkflowError extends WorkerError {
+  constructor(message: string, cause?: unknown);
+}
+//#endregion
+export { ChildWorkflowNotFoundError as a, SignalInputValidationError as c, WorkflowInputValidationError as d, WorkflowOutputValidationError as f, WorkerInferOutput as g, WorkerInferInput as h, ChildWorkflowError as i, UpdateInputValidationError as l, ClientInferOutput as m, ActivityInputValidationError as n, QueryInputValidationError as o, ClientInferInput as p, ActivityOutputValidationError as r, QueryOutputValidationError as s, ActivityDefinitionNotFoundError as t, UpdateOutputValidationError as u };

package/dist/errors-C1RFkCuD.d.mts

@@ -0,0 +1,137 @@
+import { AnySchema } from "@temporal-contract/contract";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/types.d.ts
+
+/**
+ * Infer input type from a definition (worker perspective)
+ * Worker receives the output type (after input schema parsing/transformation)
+ */
+type WorkerInferInput<T extends {
+  input: AnySchema;
+}> = StandardSchemaV1.InferOutput<T["input"]>;
+/**
+ * Infer output type from a definition (worker perspective)
+ * Worker returns the input type (before output schema parsing/transformation)
+ */
+type WorkerInferOutput<T extends {
+  output: AnySchema;
+}> = StandardSchemaV1.InferInput<T["output"]>;
+/**
+ * Infer input type from a definition (client perspective)
+ * Client sends the input type (before input schema parsing/transformation)
+ */
+type ClientInferInput<T extends {
+  input: AnySchema;
+}> = StandardSchemaV1.InferInput<T["input"]>;
+/**
+ * Infer output type from a definition (client perspective)
+ * Client receives the output type (after output schema parsing/transformation)
+ */
+type ClientInferOutput<T extends {
+  output: AnySchema;
+}> = StandardSchemaV1.InferOutput<T["output"]>;
+//#endregion
+//#region src/errors.d.ts
+/**
+ * Base error class for worker errors
+ */
+declare abstract class WorkerError extends Error {
+  protected constructor(message: string, cause?: unknown);
+}
+/**
+ * Error thrown when an activity definition is not found in the contract
+ */
+declare class ActivityDefinitionNotFoundError extends WorkerError {
+  readonly activityName: string;
+  readonly availableDefinitions: readonly string[];
+  constructor(activityName: string, availableDefinitions?: readonly string[]);
+}
+/**
+ * Error thrown when activity input validation fails
+ */
+declare class ActivityInputValidationError extends WorkerError {
+  readonly activityName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(activityName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when activity output validation fails
+ */
+declare class ActivityOutputValidationError extends WorkerError {
+  readonly activityName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(activityName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when workflow input validation fails
+ */
+declare class WorkflowInputValidationError extends WorkerError {
+  readonly workflowName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(workflowName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when workflow output validation fails
+ */
+declare class WorkflowOutputValidationError extends WorkerError {
+  readonly workflowName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(workflowName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when signal input validation fails
+ */
+declare class SignalInputValidationError extends WorkerError {
+  readonly signalName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(signalName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when query input validation fails
+ */
+declare class QueryInputValidationError extends WorkerError {
+  readonly queryName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(queryName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when query output validation fails
+ */
+declare class QueryOutputValidationError extends WorkerError {
+  readonly queryName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(queryName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when update input validation fails
+ */
+declare class UpdateInputValidationError extends WorkerError {
+  readonly updateName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(updateName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when update output validation fails
+ */
+declare class UpdateOutputValidationError extends WorkerError {
+  readonly updateName: string;
+  readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(updateName: string, issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * Error thrown when a child workflow is not found in the contract
+ */
+declare class ChildWorkflowNotFoundError extends WorkerError {
+  readonly workflowName: string;
+  readonly availableWorkflows: readonly string[];
+  constructor(workflowName: string, availableWorkflows?: readonly string[]);
+}
+/**
+ * Generic error for child workflow operations
+ */
+declare class ChildWorkflowError extends WorkerError {
+  constructor(message: string, cause?: unknown);
+}
+//#endregion
+export { ChildWorkflowNotFoundError as a, SignalInputValidationError as c, WorkflowInputValidationError as d, WorkflowOutputValidationError as f, WorkerInferOutput as g, WorkerInferInput as h, ChildWorkflowError as i, UpdateInputValidationError as l, ClientInferOutput as m, ActivityInputValidationError as n, QueryInputValidationError as o, ClientInferInput as p, ActivityOutputValidationError as r, QueryOutputValidationError as s, ActivityDefinitionNotFoundError as t, UpdateOutputValidationError as u };