@temporal-contract/client 0.0.2 → 0.0.4

package/dist/index.mjs

@@ -1,87 +1,78 @@
 import { Client } from "@temporalio/client";
+import { AsyncData, Future, Future as Future$1, Option, Result, Result as Result$1 } from "@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,125 +105,262 @@ var TypedClient = class TypedClient {
 		return new TypedClient(contract, new 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 Future$1.make((resolve) => {
+			const definition = this.contract.workflows[workflowName];
+			if (!definition) {
+				resolve(Result$1.Error(new WorkflowNotFoundError(String(workflowName), Object.keys(this.contract.workflows))));
+				return;
+			}
+			(async () => {
+				const inputResult = await definition.input["~standard"].validate(args);
+				if (inputResult.issues) {
+					resolve(Result$1.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(Result$1.Ok(typedHandle));
+				} catch (error) {
+					resolve(Result$1.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 Future$1.make((resolve) => {
+			const definition = this.contract.workflows[workflowName];
+			if (!definition) {
+				resolve(Result$1.Error(new WorkflowNotFoundError(String(workflowName), Object.keys(this.contract.workflows))));
+				return;
+			}
+			(async () => {
+				const inputResult = await definition.input["~standard"].validate(args);
+				if (inputResult.issues) {
+					resolve(Result$1.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(Result$1.Error(new WorkflowValidationError(String(workflowName), "output", outputResult.issues)));
+						return;
+					}
+					resolve(Result$1.Ok(outputResult.value));
+				} catch (error) {
+					resolve(Result$1.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 Future$1.make((resolve) => {
+			const definition = this.contract.workflows[workflowName];
+			if (!definition) {
+				resolve(Result$1.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(Result$1.Ok(typedHandle));
+			} catch (error) {
+				resolve(Result$1.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 Future$1.make((resolve) => {
+				(async () => {
+					const inputResult = await queryDef.input["~standard"].validate(args);
+					if (inputResult.issues) {
+						resolve(Result$1.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(Result$1.Error(new QueryValidationError(queryName, "output", outputResult.issues)));
+							return;
+						}
+						resolve(Result$1.Ok(outputResult.value));
+					} catch (error) {
+						resolve(Result$1.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 Future$1.make((resolve) => {
+				(async () => {
+					const inputResult = await signalDef.input["~standard"].validate(args);
+					if (inputResult.issues) {
+						resolve(Result$1.Error(new SignalValidationError(signalName, inputResult.issues)));
+						return;
+					}
+					try {
+						await handle.signal(signalName, inputResult.value);
+						resolve(Result$1.Ok(void 0));
+					} catch (error) {
+						resolve(Result$1.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 Future$1.make((resolve) => {
+				(async () => {
+					const inputResult = await updateDef.input["~standard"].validate(args);
+					if (inputResult.issues) {
+						resolve(Result$1.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(Result$1.Error(new UpdateValidationError(updateName, "output", outputResult.issues)));
+							return;
+						}
+						resolve(Result$1.Ok(outputResult.value));
+					} catch (error) {
+						resolve(Result$1.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 Future$1.make((resolve) => {
+					(async () => {
+						try {
+							const result = await handle.result();
+							const outputResult = await definition.output["~standard"].validate(result);
+							if (outputResult.issues) {
+								resolve(Result$1.Error(new WorkflowValidationError(handle.workflowId, "output", outputResult.issues)));
+								return;
+							}
+							resolve(Result$1.Ok(outputResult.value));
+						} catch (error) {
+							resolve(Result$1.Error(new TypedClientError(`Workflow execution failed: ${error instanceof Error ? error.message : String(error)}`)));
+						}
+					})();
+				});
+			},
+			terminate: (reason) => {
+				return Future$1.make((resolve) => {
+					(async () => {
+						try {
+							await handle.terminate(reason);
+							resolve(Result$1.Ok(void 0));
+						} catch (error) {
+							resolve(Result$1.Error(new TypedClientError(`Terminate failed: ${error instanceof Error ? error.message : String(error)}`)));
+						}
+					})();
+				});
 			},
-			terminate: async (reason) => {
-				await handle.terminate(reason);
+			cancel: () => {
+				return Future$1.make((resolve) => {
+					(async () => {
+						try {
+							await handle.cancel();
+							resolve(Result$1.Ok(void 0));
+						} catch (error) {
+							resolve(Result$1.Error(new TypedClientError(`Cancel failed: ${error instanceof Error ? error.message : String(error)}`)));
+						}
+					})();
+				});
 			},
-			cancel: async () => {
-				await handle.cancel();
+			describe: () => {
+				return Future$1.make((resolve) => {
+					(async () => {
+						try {
+							const description = await handle.describe();
+							resolve(Result$1.Ok(description));
+						} catch (error) {
+							resolve(Result$1.Error(new TypedClientError(`Describe failed: ${error instanceof Error ? error.message : String(error)}`)));
+						}
+					})();
+				});
 			},
-			describe: () => handle.describe(),
 			fetchHistory: () => handle.fetchHistory()
 		};
 	}
 };
 
 //#endregion
-export { QueryValidationError, SignalValidationError, TypedClient, TypedClientError, UpdateValidationError, WorkflowNotFoundError, WorkflowValidationError };
+export { AsyncData, Future, Option, QueryValidationError, Result, SignalValidationError, TypedClient, TypedClientError, UpdateValidationError, WorkflowNotFoundError, WorkflowValidationError };

package/package.json

@@ -1,8 +1,15 @@
 {
   "name": "@temporal-contract/client",
-  "version": "0.0.2",
-  "type": "module",
-  "description": "Client utilities for consuming temporal-contract workflows",
+  "version": "0.0.4",
+  "description": "Client utilities with Result/Future pattern for consuming temporal-contract workflows",
+  "keywords": [
+    "temporal",
+    "typescript",
+    "contract",
+    "client",
+    "result",
+    "future"
+  ],
   "homepage": "https://github.com/btravers/temporal-contract#readme",
   "bugs": {
     "url": "https://github.com/btravers/temporal-contract/issues"
@@ -12,17 +19,9 @@
     "url": "https://github.com/btravers/temporal-contract.git",
     "directory": "packages/client"
   },
-  "author": "Benoit TRAVERS <benoit.travers.frgmail.com>",
   "license": "MIT",
-  "keywords": [
-    "temporal",
-    "typescript",
-    "contract",
-    "client"
-  ],
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.mjs",
-  "types": "./dist/index.d.mts",
+  "author": "Benoit TRAVERS <benoit.travers.frgmail.com>",
+  "type": "module",
   "exports": {
     ".": {
       "import": {
@@ -36,28 +35,35 @@
     },
     "./package.json": "./package.json"
   },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist"
+  ],
   "dependencies": {
     "@standard-schema/spec": "1.0.0",
-    "@temporal-contract/contract": "0.0.2"
+    "@swan-io/boxed": "3.2.1",
+    "@temporal-contract/contract": "0.0.4"
   },
   "devDependencies": {
     "@temporalio/client": "1.13.2",
-    "@types/node": "24.10.2",
+    "@types/node": "25.0.1",
     "@vitest/coverage-v8": "4.0.15",
-    "tsdown": "0.17.2",
+    "tsdown": "0.17.3",
     "typescript": "5.9.3",
     "vitest": "4.0.15",
     "zod": "4.1.13",
-    "@temporal-contract/tsconfig": "0.0.2"
+    "@temporal-contract/tsconfig": "0.0.4"
   },
   "peerDependencies": {
     "@temporalio/client": ">=1.13.0 <2.0.0"
   },
   "scripts": {
-    "dev": "tsdown src/index.ts --format cjs,esm --dts --watch",
     "build": "tsdown src/index.ts --format cjs,esm --dts --clean",
-    "typecheck": "tsc --noEmit",
+    "dev": "tsdown src/index.ts --format cjs,esm --dts --watch",
     "test": "vitest run",
-    "test:watch": "vitest"
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
   }
 }

package/.turbo/turbo-build.log

@@ -1,17 +0,0 @@
-
-> @temporal-contract/client@0.0.2 build /home/runner/work/temporal-contract/temporal-contract/packages/client
-> tsdown src/index.ts --format cjs,esm --dts --clean
-
-ℹ tsdown v0.17.2 powered by rolldown v1.0.0-beta.53
-ℹ entry: src/index.ts
-ℹ tsconfig: tsconfig.json
-ℹ Build start
-ℹ [CJS] dist/index.cjs  8.83 kB │ gzip: 1.84 kB
-ℹ [CJS] 1 files, total: 8.83 kB
-ℹ [CJS] dist/index.d.cts  7.02 kB │ gzip: 1.67 kB
-ℹ [CJS] 1 files, total: 7.02 kB
-✔ Build complete in 4263ms
-ℹ [ESM] dist/index.mjs    8.60 kB │ gzip: 1.81 kB
-ℹ [ESM] dist/index.d.mts  7.02 kB │ gzip: 1.67 kB
-ℹ [ESM] 2 files, total: 15.62 kB
-✔ Build complete in 4270ms

package/CHANGELOG.md

@@ -1,9 +0,0 @@
-# @temporal-contract/client
-
-## 0.0.2
-
-### Patch Changes
-
-- Release version 0.0.2
-- Updated dependencies
-  - @temporal-contract/contract@0.0.2