@temporal-contract/client 0.0.2 → 0.0.4

package/dist/index.cjs

@@ -1,87 +1,78 @@
 let __temporalio_client = require("@temporalio/client");
+let __swan_io_boxed = require("@swan-io/boxed");
 
 //#region src/errors.ts
 /**
-* Base error class for typed client errors
+* Base class for all typed client errors with boxed pattern
 */
 var TypedClientError = class extends Error {
 	constructor(message) {
 		super(message);
-		this.name = "TypedClientError";
+		this.name = this.constructor.name;
 		if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
 	}
 };
 /**
-* Error thrown when a workflow is not found in the contract
+* Thrown when a workflow is not found in the contract
 */
 var WorkflowNotFoundError = class extends TypedClientError {
-	constructor(workflowName, availableWorkflows = []) {
-		const message = availableWorkflows.length > 0 ? `Workflow "${workflowName}" not found in contract. Available workflows: ${availableWorkflows.join(", ")}` : `Workflow "${workflowName}" not found in contract`;
-		super(message);
+	constructor(workflowName, availableWorkflows) {
+		super(`Workflow "${workflowName}" not found in contract. Available workflows: ${availableWorkflows.join(", ")}`);
 		this.workflowName = workflowName;
 		this.availableWorkflows = availableWorkflows;
-		this.name = "WorkflowNotFoundError";
 	}
 };
 /**
-* Error thrown when workflow input or output validation fails
+* Thrown when workflow input or output validation fails
 */
 var WorkflowValidationError = class extends TypedClientError {
-	constructor(workflowName, phase, issues) {
-		const message = issues.map((issue) => issue.message).join("; ");
-		super(`Validation failed for workflow "${workflowName}" ${phase}: ${message}`);
+	constructor(workflowName, direction, issues) {
+		super(`Validation failed for workflow "${workflowName}" ${direction}: ${JSON.stringify(issues)}`);
 		this.workflowName = workflowName;
-		this.phase = phase;
+		this.direction = direction;
 		this.issues = issues;
-		this.name = "WorkflowValidationError";
 	}
 };
 /**
-* Error thrown when query input or output validation fails
+* Thrown when query input or output validation fails
 */
 var QueryValidationError = class extends TypedClientError {
-	constructor(queryName, phase, issues) {
-		const message = issues.map((issue) => issue.message).join("; ");
-		super(`Validation failed for query "${queryName}" ${phase}: ${message}`);
+	constructor(queryName, direction, issues) {
+		super(`Validation failed for query "${queryName}" ${direction}: ${JSON.stringify(issues)}`);
 		this.queryName = queryName;
-		this.phase = phase;
+		this.direction = direction;
 		this.issues = issues;
-		this.name = "QueryValidationError";
 	}
 };
 /**
-* Error thrown when signal input validation fails
+* Thrown when signal input validation fails
 */
 var SignalValidationError = class extends TypedClientError {
 	constructor(signalName, issues) {
-		const message = issues.map((issue) => issue.message).join("; ");
-		super(`Validation failed for signal "${signalName}" input: ${message}`);
+		super(`Validation failed for signal "${signalName}": ${JSON.stringify(issues)}`);
 		this.signalName = signalName;
 		this.issues = issues;
-		this.name = "SignalValidationError";
 	}
 };
 /**
-* Error thrown when update input or output validation fails
+* Thrown when update input or output validation fails
 */
 var UpdateValidationError = class extends TypedClientError {
-	constructor(updateName, phase, issues) {
-		const message = issues.map((issue) => issue.message).join("; ");
-		super(`Validation failed for update "${updateName}" ${phase}: ${message}`);
+	constructor(updateName, direction, issues) {
+		super(`Validation failed for update "${updateName}" ${direction}: ${JSON.stringify(issues)}`);
 		this.updateName = updateName;
-		this.phase = phase;
+		this.direction = direction;
 		this.issues = issues;
-		this.name = "UpdateValidationError";
 	}
 };
 
 //#endregion
 //#region src/client.ts
 /**
-* Typed Temporal client based on a contract
+* Typed Temporal client with Result/Future pattern based on a contract
 *
 * Provides type-safe methods to start and execute workflows
-* defined in the contract.
+* defined in the contract, with explicit error handling using Result pattern.
 */
 var TypedClient = class TypedClient {
 	constructor(contract, client) {
@@ -89,7 +80,7 @@ var TypedClient = class TypedClient {
 		this.client = client;
 	}
 	/**
-	* Create a typed Temporal client from a contract
+	* Create a typed Temporal client with boxed pattern from a contract
 	*
 	* @example
 	* ```ts
@@ -101,7 +92,12 @@ var TypedClient = class TypedClient {
 	*
 	* const result = await client.executeWorkflow('processOrder', {
 	*   workflowId: 'order-123',
-	*   args: [...],
+	*   args: { ... },
+	* }).toPromise();
+	*
+	* result.match({
+	*   Ok: (output) => console.log('Success:', output),
+	*   Error: (error) => console.error('Failed:', error),
 	* });
 	* ```
 	*/
@@ -109,128 +105,289 @@ var TypedClient = class TypedClient {
 		return new TypedClient(contract, new __temporalio_client.Client(options));
 	}
 	/**
-	* Start a workflow and return a typed handle
+	* Start a workflow and return a typed handle with Future pattern
 	*
 	* @example
 	* ```ts
-	* const handle = await client.startWorkflow('processOrder', {
+	* const handleResult = await client.startWorkflow('processOrder', {
 	*   workflowId: 'order-123',
-	*   args: ['ORD-123', 'CUST-456', [{ productId: 'PROD-1', quantity: 2 }]],
+	*   args: { orderId: 'ORD-123' },
 	*   workflowExecutionTimeout: '1 day',
 	*   retry: { maximumAttempts: 3 },
-	* });
+	* }).toPromise();
 	*
-	* const result = await handle.result();
+	* handleResult.match({
+	*   Ok: async (handle) => {
+	*     const result = await handle.result().toPromise();
+	*     // ... handle result
+	*   },
+	*   Error: (error) => console.error('Failed to start:', error),
+	* });
 	* ```
 	*/
-	async startWorkflow(workflowName, { args, ...temporalOptions }) {
-		const definition = this.contract.workflows[workflowName];
-		if (!definition) throw new WorkflowNotFoundError(String(workflowName), Object.keys(this.contract.workflows));
-		const inputResult = await definition.input["~standard"].validate(args);
-		if (inputResult.issues) throw new WorkflowValidationError(String(workflowName), "input", inputResult.issues);
-		const validatedInput = inputResult.value;
-		const handle = await this.client.workflow.start(workflowName, {
-			...temporalOptions,
-			taskQueue: this.contract.taskQueue,
-			args: [validatedInput]
+	startWorkflow(workflowName, { args, ...temporalOptions }) {
+		return __swan_io_boxed.Future.make((resolve) => {
+			const definition = this.contract.workflows[workflowName];
+			if (!definition) {
+				resolve(__swan_io_boxed.Result.Error(new WorkflowNotFoundError(String(workflowName), Object.keys(this.contract.workflows))));
+				return;
+			}
+			(async () => {
+				const inputResult = await definition.input["~standard"].validate(args);
+				if (inputResult.issues) {
+					resolve(__swan_io_boxed.Result.Error(new WorkflowValidationError(String(workflowName), "input", inputResult.issues)));
+					return;
+				}
+				const validatedInput = inputResult.value;
+				try {
+					const handle = await this.client.workflow.start(workflowName, {
+						...temporalOptions,
+						taskQueue: this.contract.taskQueue,
+						args: [validatedInput]
+					});
+					const typedHandle = this.createTypedHandle(handle, definition);
+					resolve(__swan_io_boxed.Result.Ok(typedHandle));
+				} catch (error) {
+					resolve(__swan_io_boxed.Result.Error(new TypedClientError(`Failed to start workflow: ${error instanceof Error ? error.message : String(error)}`)));
+				}
+			})();
 		});
-		return this.createTypedHandle(handle, definition);
 	}
 	/**
-	* Execute a workflow (start and wait for result)
+	* Execute a workflow (start and wait for result) with Future/Result pattern
 	*
 	* @example
 	* ```ts
 	* const result = await client.executeWorkflow('processOrder', {
 	*   workflowId: 'order-123',
-	*   args: ['ORD-123', 'CUST-456', [{ productId: 'PROD-1', quantity: 2 }]],
+	*   args: { orderId: 'ORD-123' },
 	*   workflowExecutionTimeout: '1 day',
 	*   retry: { maximumAttempts: 3 },
-	* });
+	* }).toPromise();
 	*
-	* console.log(result.status); // fully typed!
+	* result.match({
+	*   Ok: (output) => console.log('Order processed:', output.status),
+	*   Error: (error) => console.error('Processing failed:', error),
+	* });
 	* ```
 	*/
-	async executeWorkflow(workflowName, { args, ...temporalOptions }) {
-		const definition = this.contract.workflows[workflowName];
-		if (!definition) throw new WorkflowNotFoundError(String(workflowName), Object.keys(this.contract.workflows));
-		const inputResult = await definition.input["~standard"].validate(args);
-		if (inputResult.issues) throw new WorkflowValidationError(String(workflowName), "input", inputResult.issues);
-		const validatedInput = inputResult.value;
-		const result = await this.client.workflow.execute(workflowName, {
-			...temporalOptions,
-			taskQueue: this.contract.taskQueue,
-			args: [validatedInput]
+	executeWorkflow(workflowName, { args, ...temporalOptions }) {
+		return __swan_io_boxed.Future.make((resolve) => {
+			const definition = this.contract.workflows[workflowName];
+			if (!definition) {
+				resolve(__swan_io_boxed.Result.Error(new WorkflowNotFoundError(String(workflowName), Object.keys(this.contract.workflows))));
+				return;
+			}
+			(async () => {
+				const inputResult = await definition.input["~standard"].validate(args);
+				if (inputResult.issues) {
+					resolve(__swan_io_boxed.Result.Error(new WorkflowValidationError(String(workflowName), "input", inputResult.issues)));
+					return;
+				}
+				const validatedInput = inputResult.value;
+				try {
+					const result = await this.client.workflow.execute(workflowName, {
+						...temporalOptions,
+						taskQueue: this.contract.taskQueue,
+						args: [validatedInput]
+					});
+					const outputResult = await definition.output["~standard"].validate(result);
+					if (outputResult.issues) {
+						resolve(__swan_io_boxed.Result.Error(new WorkflowValidationError(String(workflowName), "output", outputResult.issues)));
+						return;
+					}
+					resolve(__swan_io_boxed.Result.Ok(outputResult.value));
+				} catch (error) {
+					resolve(__swan_io_boxed.Result.Error(new TypedClientError(`Failed to execute workflow: ${error instanceof Error ? error.message : String(error)}`)));
+				}
+			})();
 		});
-		const outputResult = await definition.output["~standard"].validate(result);
-		if (outputResult.issues) throw new WorkflowValidationError(String(workflowName), "output", outputResult.issues);
-		return outputResult.value;
 	}
 	/**
-	* Get a handle to an existing workflow
+	* Get a handle to an existing workflow with Future/Result pattern
 	*
 	* @example
 	* ```ts
-	* const handle = await client.getHandle('processOrder', 'order-123');
-	* const result = await handle.result();
+	* const handleResult = await client.getHandle('processOrder', 'order-123').toPromise();
+	* handleResult.match({
+	*   Ok: async (handle) => {
+	*     const result = await handle.result().toPromise();
+	*     // ... handle result
+	*   },
+	*   Error: (error) => console.error('Failed to get handle:', error),
+	* });
 	* ```
 	*/
-	async getHandle(workflowName, workflowId) {
-		const definition = this.contract.workflows[workflowName];
-		if (!definition) throw new WorkflowNotFoundError(String(workflowName), Object.keys(this.contract.workflows));
-		const handle = this.client.workflow.getHandle(workflowId);
-		return this.createTypedHandle(handle, definition);
+	getHandle(workflowName, workflowId) {
+		return __swan_io_boxed.Future.make((resolve) => {
+			const definition = this.contract.workflows[workflowName];
+			if (!definition) {
+				resolve(__swan_io_boxed.Result.Error(new WorkflowNotFoundError(String(workflowName), Object.keys(this.contract.workflows))));
+				return;
+			}
+			try {
+				const handle = this.client.workflow.getHandle(workflowId);
+				const typedHandle = this.createTypedHandle(handle, definition);
+				resolve(__swan_io_boxed.Result.Ok(typedHandle));
+			} catch (error) {
+				resolve(__swan_io_boxed.Result.Error(new TypedClientError(`Failed to get workflow handle: ${error instanceof Error ? error.message : String(error)}`)));
+			}
+		});
 	}
 	createTypedHandle(handle, definition) {
 		const queries = {};
-		for (const [queryName, queryDef] of Object.entries(definition.queries ?? {})) queries[queryName] = async (args) => {
-			const inputResult = await queryDef.input["~standard"].validate(args);
-			if (inputResult.issues) throw new QueryValidationError(queryName, "input", inputResult.issues);
-			const result = await handle.query(queryName, inputResult.value);
-			const outputResult = await queryDef.output["~standard"].validate(result);
-			if (outputResult.issues) throw new QueryValidationError(queryName, "output", outputResult.issues);
-			return outputResult.value;
+		for (const [queryName, queryDef] of Object.entries(definition.queries ?? {})) queries[queryName] = (args) => {
+			return __swan_io_boxed.Future.make((resolve) => {
+				(async () => {
+					const inputResult = await queryDef.input["~standard"].validate(args);
+					if (inputResult.issues) {
+						resolve(__swan_io_boxed.Result.Error(new QueryValidationError(queryName, "input", inputResult.issues)));
+						return;
+					}
+					try {
+						const result = await handle.query(queryName, inputResult.value);
+						const outputResult = await queryDef.output["~standard"].validate(result);
+						if (outputResult.issues) {
+							resolve(__swan_io_boxed.Result.Error(new QueryValidationError(queryName, "output", outputResult.issues)));
+							return;
+						}
+						resolve(__swan_io_boxed.Result.Ok(outputResult.value));
+					} catch (error) {
+						resolve(__swan_io_boxed.Result.Error(new TypedClientError(`Query failed: ${error instanceof Error ? error.message : String(error)}`)));
+					}
+				})();
+			});
 		};
 		const signals = {};
-		for (const [signalName, signalDef] of Object.entries(definition.signals ?? {})) signals[signalName] = async (args) => {
-			const inputResult = await signalDef.input["~standard"].validate(args);
-			if (inputResult.issues) throw new SignalValidationError(signalName, inputResult.issues);
-			await handle.signal(signalName, inputResult.value);
+		for (const [signalName, signalDef] of Object.entries(definition.signals ?? {})) signals[signalName] = (args) => {
+			return __swan_io_boxed.Future.make((resolve) => {
+				(async () => {
+					const inputResult = await signalDef.input["~standard"].validate(args);
+					if (inputResult.issues) {
+						resolve(__swan_io_boxed.Result.Error(new SignalValidationError(signalName, inputResult.issues)));
+						return;
+					}
+					try {
+						await handle.signal(signalName, inputResult.value);
+						resolve(__swan_io_boxed.Result.Ok(void 0));
+					} catch (error) {
+						resolve(__swan_io_boxed.Result.Error(new TypedClientError(`Signal failed: ${error instanceof Error ? error.message : String(error)}`)));
+					}
+				})();
+			});
 		};
 		const updates = {};
-		for (const [updateName, updateDef] of Object.entries(definition.updates ?? {})) updates[updateName] = async (args) => {
-			const inputResult = await updateDef.input["~standard"].validate(args);
-			if (inputResult.issues) throw new UpdateValidationError(updateName, "input", inputResult.issues);
-			const result = await handle.executeUpdate(updateName, { args: [inputResult.value] });
-			const outputResult = await updateDef.output["~standard"].validate(result);
-			if (outputResult.issues) throw new UpdateValidationError(updateName, "output", outputResult.issues);
-			return outputResult.value;
+		for (const [updateName, updateDef] of Object.entries(definition.updates ?? {})) updates[updateName] = (args) => {
+			return __swan_io_boxed.Future.make((resolve) => {
+				(async () => {
+					const inputResult = await updateDef.input["~standard"].validate(args);
+					if (inputResult.issues) {
+						resolve(__swan_io_boxed.Result.Error(new UpdateValidationError(updateName, "input", inputResult.issues)));
+						return;
+					}
+					try {
+						const result = await handle.executeUpdate(updateName, { args: [inputResult.value] });
+						const outputResult = await updateDef.output["~standard"].validate(result);
+						if (outputResult.issues) {
+							resolve(__swan_io_boxed.Result.Error(new UpdateValidationError(updateName, "output", outputResult.issues)));
+							return;
+						}
+						resolve(__swan_io_boxed.Result.Ok(outputResult.value));
+					} catch (error) {
+						resolve(__swan_io_boxed.Result.Error(new TypedClientError(`Update failed: ${error instanceof Error ? error.message : String(error)}`)));
+					}
+				})();
+			});
 		};
 		return {
 			workflowId: handle.workflowId,
 			queries,
 			signals,
 			updates,
-			result: async () => {
-				const result = await handle.result();
-				const outputResult = await definition.output["~standard"].validate(result);
-				if (outputResult.issues) throw new WorkflowValidationError(handle.workflowId, "output", outputResult.issues);
-				return outputResult.value;
+			result: () => {
+				return __swan_io_boxed.Future.make((resolve) => {
+					(async () => {
+						try {
+							const result = await handle.result();
+							const outputResult = await definition.output["~standard"].validate(result);
+							if (outputResult.issues) {
+								resolve(__swan_io_boxed.Result.Error(new WorkflowValidationError(handle.workflowId, "output", outputResult.issues)));
+								return;
+							}
+							resolve(__swan_io_boxed.Result.Ok(outputResult.value));
+						} catch (error) {
+							resolve(__swan_io_boxed.Result.Error(new TypedClientError(`Workflow execution failed: ${error instanceof Error ? error.message : String(error)}`)));
+						}
+					})();
+				});
+			},
+			terminate: (reason) => {
+				return __swan_io_boxed.Future.make((resolve) => {
+					(async () => {
+						try {
+							await handle.terminate(reason);
+							resolve(__swan_io_boxed.Result.Ok(void 0));
+						} catch (error) {
+							resolve(__swan_io_boxed.Result.Error(new TypedClientError(`Terminate failed: ${error instanceof Error ? error.message : String(error)}`)));
+						}
+					})();
+				});
 			},
-			terminate: async (reason) => {
-				await handle.terminate(reason);
+			cancel: () => {
+				return __swan_io_boxed.Future.make((resolve) => {
+					(async () => {
+						try {
+							await handle.cancel();
+							resolve(__swan_io_boxed.Result.Ok(void 0));
+						} catch (error) {
+							resolve(__swan_io_boxed.Result.Error(new TypedClientError(`Cancel failed: ${error instanceof Error ? error.message : String(error)}`)));
+						}
+					})();
+				});
 			},
-			cancel: async () => {
-				await handle.cancel();
+			describe: () => {
+				return __swan_io_boxed.Future.make((resolve) => {
+					(async () => {
+						try {
+							const description = await handle.describe();
+							resolve(__swan_io_boxed.Result.Ok(description));
+						} catch (error) {
+							resolve(__swan_io_boxed.Result.Error(new TypedClientError(`Describe failed: ${error instanceof Error ? error.message : String(error)}`)));
+						}
+					})();
+				});
 			},
-			describe: () => handle.describe(),
 			fetchHistory: () => handle.fetchHistory()
 		};
 	}
 };
 
 //#endregion
+Object.defineProperty(exports, 'AsyncData', {
+  enumerable: true,
+  get: function () {
+    return __swan_io_boxed.AsyncData;
+  }
+});
+Object.defineProperty(exports, 'Future', {
+  enumerable: true,
+  get: function () {
+    return __swan_io_boxed.Future;
+  }
+});
+Object.defineProperty(exports, 'Option', {
+  enumerable: true,
+  get: function () {
+    return __swan_io_boxed.Option;
+  }
+});
 exports.QueryValidationError = QueryValidationError;
+Object.defineProperty(exports, 'Result', {
+  enumerable: true,
+  get: function () {
+    return __swan_io_boxed.Result;
+  }
+});
 exports.SignalValidationError = SignalValidationError;
 exports.TypedClient = TypedClient;
 exports.TypedClientError = TypedClientError;