@temporal-contract/client 1.0.0 → 2.0.0

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { TypedSearchAttributes, WorkflowNotFoundError as WorkflowNotFoundError$1, defineSearchAttributeKey } from "@temporalio/common";
-import { Future, Result } from "@swan-io/boxed";
+import { ResultAsync, err, ok } from "neverthrow";
 import { WorkflowExecutionAlreadyStartedError, WorkflowFailedError as WorkflowFailedError$1 } from "@temporalio/client";
 //#region src/errors.ts
 /**
@@ -191,21 +191,19 @@ var UpdateValidationError = class extends TypedClientError {
 * In-package modules and tests import it directly via relative path.
 */
 /**
-* Wrap an async result-producing function in a `Future`, catching any
+* Wrap an async result-producing function in a `ResultAsync`, catching any
 * unhandled rejection as a `RuntimeClientError("unexpected", error)`.
 *
 * The work function is expected to handle its own domain errors and return
-* a `Result.Error(...)` for them; the catch here is a safety net for
-* thrown exceptions the work didn't anticipate.
+* an `err(...)` for them; the catch here is a safety net for thrown
+* exceptions the work didn't anticipate.
 *
 * Used by `client.ts` (workflow operations) and `schedule.ts` (schedule
 * operations) so the unexpected-rejection shape is identical across the
 * typed client surface.
 */
-function makeFuture(work) {
-	return Future.make((resolve) => {
-		work().then(resolve).catch((e) => resolve(Result.Error(new RuntimeClientError("unexpected", e))));
-	});
+function makeResultAsync(work) {
+	return new ResultAsync(work().catch((e) => err(new RuntimeClientError("unexpected", e))));
 }
 /**
 * Map a thrown error from `client.workflow.start` / `signalWithStart` into
@@ -274,9 +272,9 @@ var TypedScheduleClient = class {
 	create(workflowName, options) {
 		const work = async () => {
 			const definition = this.contract.workflows[workflowName];
-			if (!definition) return Result.Error(new WorkflowNotFoundError(String(workflowName), Object.keys(this.contract.workflows)));
+			if (!definition) return err(new WorkflowNotFoundError(String(workflowName), Object.keys(this.contract.workflows)));
 			const inputResult = await definition.input["~standard"].validate(options.args);
-			if (inputResult.issues) return Result.Error(new WorkflowValidationError(String(workflowName), "input", inputResult.issues));
+			if (inputResult.issues) return err(new WorkflowValidationError(String(workflowName), "input", inputResult.issues));
 			try {
 				const overrides = options.action ?? {};
 				const action = {
@@ -293,20 +291,19 @@ var TypedScheduleClient = class {
 					...overrides.staticDetails !== void 0 ? { staticDetails: overrides.staticDetails } : {},
 					...overrides.staticSummary !== void 0 ? { staticSummary: overrides.staticSummary } : {}
 				};
-				const handle = await this.scheduleClient.create({
+				return ok(wrapScheduleHandle(await this.scheduleClient.create({
 					scheduleId: options.scheduleId,
 					spec: options.spec,
 					action,
 					...options.policies !== void 0 ? { policies: options.policies } : {},
 					...options.state !== void 0 ? { state: options.state } : {},
 					...options.memo !== void 0 ? { memo: options.memo } : {}
-				});
-				return Result.Ok(wrapScheduleHandle(handle));
+				})));
 			} catch (error) {
-				return Result.Error(new RuntimeClientError("schedule.create", error));
+				return err(new RuntimeClientError("schedule.create", error));
 			}
 		};
-		return makeFuture(work);
+		return makeResultAsync(work);
 	}
 	/**
 	* Get a typed handle to an existing schedule. Does not validate that the
@@ -320,11 +317,11 @@ var TypedScheduleClient = class {
 function wrapScheduleHandle(handle) {
 	return {
 		scheduleId: handle.scheduleId,
-		pause: (note) => Future.fromPromise(handle.pause(note)).mapError((error) => new RuntimeClientError("schedule.pause", error)).mapOk(() => void 0),
-		unpause: (note) => Future.fromPromise(handle.unpause(note)).mapError((error) => new RuntimeClientError("schedule.unpause", error)).mapOk(() => void 0),
-		trigger: (overlap) => Future.fromPromise(handle.trigger(overlap)).mapError((error) => new RuntimeClientError("schedule.trigger", error)).mapOk(() => void 0),
-		delete: () => Future.fromPromise(handle.delete()).mapError((error) => new RuntimeClientError("schedule.delete", error)).mapOk(() => void 0),
-		describe: () => Future.fromPromise(handle.describe()).mapError((error) => new RuntimeClientError("schedule.describe", error))
+		pause: (note) => ResultAsync.fromPromise(handle.pause(note), (error) => new RuntimeClientError("schedule.pause", error)).map(() => void 0),
+		unpause: (note) => ResultAsync.fromPromise(handle.unpause(note), (error) => new RuntimeClientError("schedule.unpause", error)).map(() => void 0),
+		trigger: (overlap) => ResultAsync.fromPromise(handle.trigger(overlap), (error) => new RuntimeClientError("schedule.trigger", error)).map(() => void 0),
+		delete: () => ResultAsync.fromPromise(handle.delete(), (error) => new RuntimeClientError("schedule.delete", error)).map(() => void 0),
+		describe: () => ResultAsync.fromPromise(handle.describe(), (error) => new RuntimeClientError("schedule.describe", error))
 	};
 }
 //#endregion
@@ -354,7 +351,7 @@ function toTypedSearchAttributes(workflowDef, values) {
 	return pairs.length > 0 ? new TypedSearchAttributes(pairs) : void 0;
 }
 /**
-* Typed Temporal client with Result/Future pattern based on a contract
+* Typed Temporal client with neverthrow Result/ResultAsync pattern based on a contract
 *
 * Provides type-safe methods to start and execute workflows
 * defined in the contract, with explicit error handling using Result pattern.
@@ -378,10 +375,10 @@ var TypedClient = class TypedClient {
 	*   args: { orderId: "sweep" },
 	* });
 	*
-	* result.match({
-	*   Ok: async (handle) => { await handle.pause("maintenance"); },
-	*   Error: (error) => console.error("schedule create failed", error),
-	* });
+	* result.match(
+	*   async (handle) => { await handle.pause("maintenance"); },
+	*   (error) => console.error("schedule create failed", error),
+	* );
 	* ```
 	*/
 	schedule;
@@ -392,7 +389,7 @@ var TypedClient = class TypedClient {
 		this.schedule = new TypedScheduleClient(contract, client.schedule);
 	}
 	/**
-	* Create a typed Temporal client with boxed pattern from a contract
+	* Create a typed Temporal client with neverthrow pattern from a contract
 	*
 	* @example
 	* ```ts
@@ -405,17 +402,17 @@ var TypedClient = class TypedClient {
 	*   args: { ... },
 	* });
 	*
-	* result.match({
-	*   Ok: (output) => console.log('Success:', output),
-	*   Error: (error) => console.error('Failed:', error),
-	* });
+	* result.match(
+	*   (output) => console.log('Success:', output),
+	*   (error) => console.error('Failed:', error),
+	* );
 	* ```
 	*/
 	static create(contract, client) {
 		return new TypedClient(contract, client);
 	}
 	/**
-	* Start a workflow and return a typed handle with Future pattern
+	* Start a workflow and return a typed handle with ResultAsync pattern
 	*
 	* @example
 	* ```ts
@@ -426,21 +423,21 @@ var TypedClient = class TypedClient {
 	*   retry: { maximumAttempts: 3 },
 	* });
 	*
-	* handleResult.match({
-	*   Ok: async (handle) => {
+	* handleResult.match(
+	*   async (handle) => {
 	*     const result = await handle.result();
 	*     // ... handle result
 	*   },
-	*   Error: (error) => console.error('Failed to start:', error),
-	* });
+	*   (error) => console.error('Failed to start:', error),
+	* );
 	* ```
 	*/
 	startWorkflow(workflowName, { args, searchAttributes, ...temporalOptions }) {
 		const work = async () => {
 			const definition = this.contract.workflows[workflowName];
-			if (!definition) return Result.Error(createWorkflowNotFoundError(workflowName, this.contract));
+			if (!definition) return err(createWorkflowNotFoundError(workflowName, this.contract));
 			const inputResult = await definition.input["~standard"].validate(args);
-			if (inputResult.issues) return Result.Error(createWorkflowValidationError(workflowName, "input", inputResult.issues));
+			if (inputResult.issues) return err(createWorkflowValidationError(workflowName, "input", inputResult.issues));
 			const typedSearchAttributes = toTypedSearchAttributes(definition, searchAttributes);
 			try {
 				const handle = await this.client.workflow.start(workflowName, {
@@ -449,12 +446,12 @@ var TypedClient = class TypedClient {
 					args: [inputResult.value],
 					...typedSearchAttributes ? { typedSearchAttributes } : {}
 				});
-				return Result.Ok(this.createTypedHandle(handle, definition));
+				return ok(this.createTypedHandle(handle, definition));
 			} catch (error) {
-				return Result.Error(classifyStartError("startWorkflow", error));
+				return err(classifyStartError("startWorkflow", error));
 			}
 		};
-		return makeFuture(work);
+		return makeResultAsync(work);
 	}
 	/**
 	* Send a signal to a workflow, starting it first if it doesn't already exist.
@@ -476,22 +473,22 @@ var TypedClient = class TypedClient {
 	*   signalArgs: { reason: 'duplicate' },
 	* });
 	*
-	* result.match({
-	*   Ok: (handle) => console.log('signaled run', handle.signaledRunId),
-	*   Error: (error) => console.error('signalWithStart failed', error),
-	* });
+	* result.match(
+	*   (handle) => console.log('signaled run', handle.signaledRunId),
+	*   (error) => console.error('signalWithStart failed', error),
+	* );
 	* ```
 	*/
 	signalWithStart(workflowName, { args, signalName, signalArgs, searchAttributes, ...temporalOptions }) {
 		const work = async () => {
 			const definition = this.contract.workflows[workflowName];
-			if (!definition) return Result.Error(createWorkflowNotFoundError(workflowName, this.contract));
+			if (!definition) return err(createWorkflowNotFoundError(workflowName, this.contract));
 			const inputResult = await definition.input["~standard"].validate(args);
-			if (inputResult.issues) return Result.Error(createWorkflowValidationError(workflowName, "input", inputResult.issues));
+			if (inputResult.issues) return err(createWorkflowValidationError(workflowName, "input", inputResult.issues));
 			const signalDef = definition.signals?.[signalName];
-			if (!signalDef) return Result.Error(new SignalValidationError(signalName, [{ message: `Signal "${signalName}" is not declared on workflow "${String(workflowName)}".` }]));
+			if (!signalDef) return err(new SignalValidationError(signalName, [{ message: `Signal "${signalName}" is not declared on workflow "${String(workflowName)}".` }]));
 			const signalInputResult = await signalDef.input["~standard"].validate(signalArgs);
-			if (signalInputResult.issues) return Result.Error(new SignalValidationError(signalName, signalInputResult.issues));
+			if (signalInputResult.issues) return err(new SignalValidationError(signalName, signalInputResult.issues));
 			const typedSearchAttributes = toTypedSearchAttributes(definition, searchAttributes);
 			try {
 				const handle = await this.client.workflow.signalWithStart(workflowName, {
@@ -502,19 +499,18 @@ var TypedClient = class TypedClient {
 					signalArgs: [signalInputResult.value],
 					...typedSearchAttributes ? { typedSearchAttributes } : {}
 				});
-				const typed = this.createTypedHandle(handle, definition);
-				return Result.Ok({
-					...typed,
+				return ok({
+					...this.createTypedHandle(handle, definition),
 					signaledRunId: handle.signaledRunId
 				});
 			} catch (error) {
-				return Result.Error(classifyStartError("signalWithStart", error));
+				return err(classifyStartError("signalWithStart", error));
 			}
 		};
-		return makeFuture(work);
+		return makeResultAsync(work);
 	}
 	/**
-	* Execute a workflow (start and wait for result) with Future/Result pattern
+	* Execute a workflow (start and wait for result) with ResultAsync pattern
 	*
 	* @example
 	* ```ts
@@ -525,18 +521,18 @@ var TypedClient = class TypedClient {
 	*   retry: { maximumAttempts: 3 },
 	* });
 	*
-	* result.match({
-	*   Ok: (output) => console.log('Order processed:', output.status),
-	*   Error: (error) => console.error('Processing failed:', error),
-	* });
+	* result.match(
+	*   (output) => console.log('Order processed:', output.status),
+	*   (error) => console.error('Processing failed:', error),
+	* );
 	* ```
 	*/
 	executeWorkflow(workflowName, { args, searchAttributes, ...temporalOptions }) {
 		const work = async () => {
 			const definition = this.contract.workflows[workflowName];
-			if (!definition) return Result.Error(createWorkflowNotFoundError(workflowName, this.contract));
+			if (!definition) return err(createWorkflowNotFoundError(workflowName, this.contract));
 			const inputResult = await definition.input["~standard"].validate(args);
-			if (inputResult.issues) return Result.Error(createWorkflowValidationError(workflowName, "input", inputResult.issues));
+			if (inputResult.issues) return err(createWorkflowValidationError(workflowName, "input", inputResult.issues));
 			const typedSearchAttributes = toTypedSearchAttributes(definition, searchAttributes);
 			try {
 				const result = await this.client.workflow.execute(workflowName, {
@@ -546,44 +542,44 @@ var TypedClient = class TypedClient {
 					...typedSearchAttributes ? { typedSearchAttributes } : {}
 				});
 				const outputResult = await definition.output["~standard"].validate(result);
-				if (outputResult.issues) return Result.Error(createWorkflowValidationError(workflowName, "output", outputResult.issues));
-				return Result.Ok(outputResult.value);
+				if (outputResult.issues) return err(createWorkflowValidationError(workflowName, "output", outputResult.issues));
+				return ok(outputResult.value);
 			} catch (error) {
-				if (error instanceof WorkflowExecutionAlreadyStartedError) return Result.Error(new WorkflowAlreadyStartedError(error.workflowType, error.workflowId, error));
-				if (error instanceof WorkflowFailedError$1) return Result.Error(new WorkflowFailedError(temporalOptions.workflowId, error.cause));
-				if (error instanceof WorkflowNotFoundError$1) return Result.Error(new WorkflowExecutionNotFoundError(error.workflowId || temporalOptions.workflowId, error.runId, error));
-				return Result.Error(createRuntimeClientError("executeWorkflow", error));
+				if (error instanceof WorkflowExecutionAlreadyStartedError) return err(new WorkflowAlreadyStartedError(error.workflowType, error.workflowId, error));
+				if (error instanceof WorkflowFailedError$1) return err(new WorkflowFailedError(temporalOptions.workflowId, error.cause));
+				if (error instanceof WorkflowNotFoundError$1) return err(new WorkflowExecutionNotFoundError(error.workflowId || temporalOptions.workflowId, error.runId, error));
+				return err(createRuntimeClientError("executeWorkflow", error));
 			}
 		};
-		return makeFuture(work);
+		return makeResultAsync(work);
 	}
 	/**
-	* Get a handle to an existing workflow with Future/Result pattern
+	* Get a handle to an existing workflow with ResultAsync pattern
 	*
 	* @example
 	* ```ts
 	* const handleResult = await client.getHandle('processOrder', 'order-123');
-	* handleResult.match({
-	*   Ok: async (handle) => {
+	* handleResult.match(
+	*   async (handle) => {
 	*     const result = await handle.result();
 	*     // ... handle result
 	*   },
-	*   Error: (error) => console.error('Failed to get handle:', error),
-	* });
+	*   (error) => console.error('Failed to get handle:', error),
+	* );
 	* ```
 	*/
 	getHandle(workflowName, workflowId) {
 		const work = async () => {
 			const definition = this.contract.workflows[workflowName];
-			if (!definition) return Result.Error(createWorkflowNotFoundError(workflowName, this.contract));
+			if (!definition) return err(createWorkflowNotFoundError(workflowName, this.contract));
 			try {
 				const handle = this.client.workflow.getHandle(workflowId);
-				return Result.Ok(this.createTypedHandle(handle, definition));
+				return ok(this.createTypedHandle(handle, definition));
 			} catch (error) {
-				return Result.Error(createRuntimeClientError("getHandle", error));
+				return err(createRuntimeClientError("getHandle", error));
 			}
 		};
-		return makeFuture(work);
+		return makeResultAsync(work);
 	}
 	createTypedHandle(workflowHandle, definition) {
 		const queries = buildValidatedProxy({
@@ -622,18 +618,18 @@ var TypedClient = class TypedClient {
 					try {
 						const result = await workflowHandle.result();
 						const outputResult = await definition.output["~standard"].validate(result);
-						if (outputResult.issues) return Result.Error(new WorkflowValidationError(workflowHandle.workflowId, "output", outputResult.issues));
-						return Result.Ok(outputResult.value);
+						if (outputResult.issues) return err(new WorkflowValidationError(workflowHandle.workflowId, "output", outputResult.issues));
+						return ok(outputResult.value);
 					} catch (error) {
-						return Result.Error(classifyResultError("result", error, workflowHandle.workflowId));
+						return err(classifyResultError("result", error, workflowHandle.workflowId));
 					}
 				};
-				return makeFuture(work);
+				return makeResultAsync(work);
 			},
-			terminate: (reason) => Future.fromPromise(workflowHandle.terminate(reason)).mapError((error) => classifyHandleError("terminate", error, workflowHandle.workflowId)).mapOk(() => void 0),
-			cancel: () => Future.fromPromise(workflowHandle.cancel()).mapError((error) => classifyHandleError("cancel", error, workflowHandle.workflowId)).mapOk(() => void 0),
-			describe: () => Future.fromPromise(workflowHandle.describe()).mapError((error) => classifyHandleError("describe", error, workflowHandle.workflowId)),
-			fetchHistory: () => Future.fromPromise(workflowHandle.fetchHistory()).mapError((error) => classifyHandleError("fetchHistory", error, workflowHandle.workflowId))
+			terminate: (reason) => ResultAsync.fromPromise(workflowHandle.terminate(reason), (error) => classifyHandleError("terminate", error, workflowHandle.workflowId)).map(() => void 0),
+			cancel: () => ResultAsync.fromPromise(workflowHandle.cancel(), (error) => classifyHandleError("cancel", error, workflowHandle.workflowId)).map(() => void 0),
+			describe: () => ResultAsync.fromPromise(workflowHandle.describe(), (error) => classifyHandleError("describe", error, workflowHandle.workflowId)),
+			fetchHistory: () => ResultAsync.fromPromise(workflowHandle.fetchHistory(), (error) => classifyHandleError("fetchHistory", error, workflowHandle.workflowId))
 		};
 	}
 };
@@ -647,7 +643,7 @@ function createWorkflowValidationError(workflowName, direction, issues) {
 	return new WorkflowValidationError(String(workflowName), direction, issues);
 }
 /**
-* Build a `{ name: (args) => Future<Result<...>> }` proxy for a contract's
+* Build a `{ name: (args) => ResultAsync<...> }` proxy for a contract's
 * queries/signals/updates. The three call sites differ only in how they
 * invoke Temporal and whether they validate output, so the shared
 * input-validate → invoke → output-validate → wrap-Result pipeline lives
@@ -659,19 +655,19 @@ function buildValidatedProxy({ defs, operation, workflowId, makeValidationError,
 	for (const [name, def] of Object.entries(defs)) proxy[name] = (args) => {
 		const work = async () => {
 			const inputResult = await def.input["~standard"].validate(args);
-			if (inputResult.issues) return Result.Error(makeValidationError(name, "input", inputResult.issues));
+			if (inputResult.issues) return err(makeValidationError(name, "input", inputResult.issues));
 			try {
 				const result = await invoke(name, inputResult.value);
 				const outputSchema = validateOutput(def);
-				if (!outputSchema) return Result.Ok(result);
+				if (!outputSchema) return ok(result);
 				const outputResult = await outputSchema["~standard"].validate(result);
-				if (outputResult.issues) return Result.Error(makeValidationError(name, "output", outputResult.issues));
-				return Result.Ok(outputResult.value);
+				if (outputResult.issues) return err(makeValidationError(name, "output", outputResult.issues));
+				return ok(outputResult.value);
 			} catch (error) {
-				return Result.Error(classifyHandleError(operation, error, workflowId));
+				return err(classifyHandleError(operation, error, workflowId));
 			}
 		};
-		return makeFuture(work);
+		return makeResultAsync(work);
 	};
 	return proxy;
 }