@temporal-contract/worker 0.1.0 → 1.0.0

package/dist/workflow.d.mts

@@ -1,8 +1,40 @@
-import { a as ChildWorkflowNotFoundError, c as SignalInputValidationError, d as WorkflowInputValidationError, f as WorkflowOutputValidationError, g as WorkerInferOutput, h as WorkerInferInput, i as ChildWorkflowError, l as UpdateInputValidationError, m as ClientInferOutput, n as ActivityInputValidationError, o as QueryInputValidationError, p as ClientInferInput, r as ActivityOutputValidationError, s as QueryOutputValidationError, u as UpdateOutputValidationError } from "./errors-Vr-sKdW7.mjs";
+import { _ as WorkerInferOutput, a as ChildWorkflowNotFoundError, c as SignalInputValidationError, d as WorkflowCancelledError, f as WorkflowInputValidationError, g as WorkerInferInput, h as ClientInferOutput, i as ChildWorkflowError, l as UpdateInputValidationError, m as ClientInferInput, n as ActivityInputValidationError, o as QueryInputValidationError, p as WorkflowOutputValidationError, r as ActivityOutputValidationError, s as QueryOutputValidationError, u as UpdateOutputValidationError } from "./errors-DZhaNhwr.mjs";
+import { ActivityOptions, ChildWorkflowOptions, ContinueAsNewOptions, WorkflowInfo } from "@temporalio/workflow";
 import { Future, Result } from "@temporal-contract/boxed";
-import { ActivityOptions, ChildWorkflowOptions, WorkflowInfo } from "@temporalio/workflow";
 import { ActivityDefinition, ContractDefinition, QueryDefinition, SignalDefinition, UpdateDefinition, WorkflowDefinition } from "@temporal-contract/contract";
+import { StandardSchemaV1 } from "@standard-schema/spec";
 
+//#region src/handlers.d.ts
+/**
+ * Signal handler implementation
+ *
+ * Processes signal input and can optionally perform asynchronous operations.
+ * Should not return a value (signals are fire-and-forget).
+ */
+type SignalHandlerImplementation<TSignal extends SignalDefinition> = (args: WorkerInferInput<TSignal>) => void | Promise<void>;
+/**
+ * Query handler implementation
+ *
+ * Processes query input and returns a synchronous response.
+ * Must be synchronous to satisfy Temporal's query constraints.
+ */
+type QueryHandlerImplementation<TQuery extends QueryDefinition> = (args: WorkerInferInput<TQuery>) => WorkerInferOutput<TQuery>;
+/**
+ * Update handler implementation
+ *
+ * Processes update input and returns a validated response after modifying workflow state.
+ * Can perform asynchronous operations.
+ */
+type UpdateHandlerImplementation<TUpdate extends UpdateDefinition> = (args: WorkerInferInput<TUpdate>) => Promise<WorkerInferOutput<TUpdate>>;
+//#endregion
+//#region src/internal.d.ts
+/**
+ * Continue-as-new options the typed wrapper does not own. `workflowType` and
+ * `taskQueue` are derived from the contract; everything else is forwarded to
+ * Temporal's `makeContinueAsNewFunc`.
+ */
+type TypedContinueAsNewOptions = Omit<ContinueAsNewOptions, "workflowType" | "taskQueue">;
+//#endregion
 //#region src/workflow.d.ts
 /**
  * Create a typed workflow implementation with automatic validation
@@ -18,53 +50,62 @@ import { ActivityDefinition, ContractDefinition, QueryDefinition, SignalDefiniti
  * @example
  * ```ts
  * // workflows/processOrder.ts
- * import { declareWorkflow } from '@temporal-contract/worker';
+ * import { declareWorkflow } from '@temporal-contract/worker/workflow';
  * import myContract from '../contract';
  *
  * export const processOrder = declareWorkflow({
  *   workflowName: 'processOrder',
  *   contract: myContract,
- *   implementation: async (context, orderId, customerId) => {
+ *   activityOptions: {
+ *     startToCloseTimeout: '1 minute',
+ *   },
+ *   // Optional: override `activityOptions` for specific activities. Each
+ *   // entry shallow-merges over the workflow default — the override wins on
+ *   // every property it specifies, including the whole `retry` block.
+ *   activityOptionsByName: {
+ *     chargePayment: {
+ *       startToCloseTimeout: '5 minutes',
+ *       retry: { maximumAttempts: 5 },
+ *     },
+ *   },
+ *   implementation: async (context, args) => {
  *     // context.activities: typed activities (workflow + global)
  *     // context.info: WorkflowInfo
  *
- *     const inventory = await context.activities.validateInventory(orderId);
+ *     const inventory = await context.activities.validateInventory({
+ *       orderId: args.orderId,
+ *     });
  *
  *     if (!inventory.available) {
- *       throw new Error('Out of stock');
+ *       return { orderId: args.orderId, status: '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'
- *     );
+ *     const payment = await context.activities.chargePayment({
+ *       customerId: args.customerId,
+ *       amount: 100,
+ *     });
  *
  *     return {
- *       orderId,
+ *       orderId: args.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';
+ * import { createWorker } from '@temporal-contract/worker/worker';
+ * import { activities } from './activities';
+ * import myContract from './contract';
  *
- * const worker = await Worker.create({
- *   workflowsPath: require.resolve('./workflows'), // Imports processOrder
- *   activities: activitiesHandler.activities,
- *   taskQueue: activitiesHandler.contract.taskQueue,
+ * const worker = await createWorker({
+ *   contract: myContract,
+ *   connection,
+ *   workflowsPath: workflowsPathFromURL(import.meta.url, './workflows.js'),
+ *   activities,
  * });
  * ```
  */
@@ -72,55 +113,65 @@ declare function declareWorkflow<TContract extends ContractDefinition, TWorkflow
   workflowName,
   contract,
   implementation,
-  activityOptions
+  activityOptions,
+  activityOptionsByName
 }: DeclareWorkflowOptions<TContract, TWorkflowName>): (...args: unknown[]) => Promise<WorkerInferOutput<TContract["workflows"][TWorkflowName]>>;
 /**
- * Signal handler implementation
- *
- * Processes signal input and can optionally perform asynchronous operations.
- * Should not return a value (signals are fire-and-forget).
- */
-type SignalHandlerImplementation<TSignal extends SignalDefinition> = (args: WorkerInferInput<TSignal>) => void | Promise<void>;
-/**
- * Query handler implementation
- *
- * Processes query input and returns a synchronous response.
- * Must be synchronous to satisfy Temporal's query constraints.
- */
-type QueryHandlerImplementation<TQuery extends QueryDefinition> = (args: WorkerInferInput<TQuery>) => WorkerInferOutput<TQuery>;
-/**
- * Update handler implementation
- *
- * Processes update input and returns a validated response after modifying workflow state.
- * Can perform asynchronous operations.
+ * Union of all activity names available to a workflow — the workflow-local
+ * activities plus the contract's global activities.
  */
-type UpdateHandlerImplementation<TUpdate extends UpdateDefinition> = (args: WorkerInferInput<TUpdate>) => Promise<WorkerInferOutput<TUpdate>>;
+type ActivityNamesFor<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]> = (TContract["workflows"][TWorkflowName]["activities"] extends Record<string, ActivityDefinition> ? keyof TContract["workflows"][TWorkflowName]["activities"] & string : never) | (TContract["activities"] extends Record<string, ActivityDefinition> ? keyof TContract["activities"] & string : never);
 /**
  * Options for declaring a workflow implementation
  */
-interface DeclareWorkflowOptions<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]> {
+type DeclareWorkflowOptions<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]> = {
   workflowName: TWorkflowName;
   contract: TContract;
   implementation: WorkflowImplementation<TContract, TWorkflowName>;
   /**
-   * Default activity options applied to all activities in this workflow.
-   * For more control, you can override specific Temporal ActivityOptions like:
-   * - startToCloseTimeout: Maximum time for activity execution
-   * - scheduleToCloseTimeout: End-to-end timeout including queuing
-   * - scheduleToStartTimeout: Maximum time activity can wait in queue
-   * - heartbeatTimeout: Time between heartbeats before considering activity dead
-   * - retry: Retry policy for failed activities
+   * Default activity options applied to every activity reachable from this
+   * workflow (workflow-local + global) unless overridden in
+   * {@link activityOptionsByName}. See Temporal's `ActivityOptions` for the
+   * full set of fields:
+   * - `startToCloseTimeout`: Maximum time for a single attempt to run
+   * - `scheduleToCloseTimeout`: End-to-end timeout including queuing and retries
+   * - `scheduleToStartTimeout`: Maximum time the activity can wait in the queue
+   * - `heartbeatTimeout`: Time between heartbeats before the activity is considered dead
+   * - `retry`: Retry policy for failed activities
    *
    * @example
    * ```ts
    * activityOptions: {
    *   startToCloseTimeout: '5m',
-   *   retry: { maximumAttempts: 3 }
+   *   retry: { maximumAttempts: 3 },
    * }
    * ```
    */
   activityOptions: ActivityOptions;
-}
+  /**
+   * Per-activity `ActivityOptions` overrides. Each entry shallow-merges over
+   * {@link activityOptions} for that activity only — the override wins on
+   * every property it specifies, replacing the default value (including the
+   * entire nested `retry` block when present, matching Temporal's
+   * single-options-per-`proxyActivities`-call semantics).
+   *
+   * Activity names are typed against the contract; typos surface as TypeScript
+   * errors rather than running silently with the default options.
+   *
+   * @example
+   * ```ts
+   * activityOptions: { startToCloseTimeout: '1 minute' }, // default
+   * activityOptionsByName: {
+   *   chargePayment: {
+   *     startToCloseTimeout: '5 minutes',
+   *     retry: { maximumAttempts: 5 },
+   *   },
+   *   fastValidation: { startToCloseTimeout: '5 seconds' },
+   * },
+   * ```
+   */
+  activityOptionsByName?: Partial<Record<ActivityNamesFor<TContract, TWorkflowName>, ActivityOptions>>;
+};
 /**
  * Workflow implementation function
  *
@@ -137,7 +188,7 @@ type WorkflowImplementation<TContract extends ContractDefinition, TWorkflowName
  * - Signal, query, and update handler registration
  * - Child workflow execution capabilities
  */
-interface WorkflowContext<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]> {
+type WorkflowContext<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]> = {
   activities: WorkflowInferWorkflowContextActivities<TContract, TWorkflowName>;
   info: WorkflowInfo;
   /**
@@ -254,7 +305,79 @@ interface WorkflowContext<TContract extends ContractDefinition, TWorkflowName ex
    * ```
    */
   executeChildWorkflow: <TChildContract extends ContractDefinition, TChildWorkflowName extends keyof TChildContract["workflows"]>(contract: TChildContract, workflowName: TChildWorkflowName, options: TypedChildWorkflowOptions<TChildContract, TChildWorkflowName>) => Future<Result<ClientInferOutput<TChildContract["workflows"][TChildWorkflowName]>, ChildWorkflowError>>;
-}
+  /**
+   * Run `fn` inside a cancellable Temporal scope. If the workflow (or an
+   * ancestor scope) is cancelled while `fn` is in flight, the resulting
+   * Future resolves to `Result.Error(WorkflowCancelledError)` instead of
+   * rejecting — letting callers handle cancellation explicitly, typically
+   * to perform a graceful exit from the current step.
+   *
+   * Non-cancellation errors thrown by `fn` propagate as Future rejections
+   * unchanged, preserving their identity for upstream `try/catch` blocks.
+   *
+   * @example
+   * ```ts
+   * implementation: async (context, args) => {
+   *   const result = await context.cancellableScope(async () => {
+   *     return context.activities.processStep(args);
+   *   });
+   *
+   *   if (result.isError()) {
+   *     // workflow was cancelled — perform cleanup that must not be cancelled:
+   *     await context.nonCancellableScope(async () => {
+   *       await context.activities.releaseResources(args);
+   *     });
+   *     return { status: "cancelled" };
+   *   }
+   *
+   *   return { status: "ok" };
+   * }
+   * ```
+   */
+  cancellableScope: <T>(fn: () => T | Promise<T>) => Future<Result<T, WorkflowCancelledError>>;
+  /**
+   * Run `fn` inside a non-cancellable Temporal scope. Cancellation requests
+   * from outside the scope are ignored for its duration — the idiomatic way
+   * to perform cleanup work that must not be interrupted.
+   *
+   * Returns the same `Future<Result<...>>` shape as
+   * {@link WorkflowContext.cancellableScope} for symmetry; the
+   * `Result.Error` branch only triggers when cancellation is raised from
+   * *inside* the scope, which is rare.
+   */
+  nonCancellableScope: <T>(fn: () => T | Promise<T>) => Future<Result<T, WorkflowCancelledError>>;
+  /**
+   * Continue this workflow execution as a new run, optionally with a different
+   * workflow type from another contract.
+   *
+   * Args are validated against the destination workflow's input schema before
+   * Temporal's `continueAsNew` is invoked. On validation failure, throws a
+   * {@link WorkflowInputValidationError}; on success, Temporal terminates the
+   * current execution and starts a fresh one — which is why the function
+   * never returns normally (`Promise<never>`).
+   *
+   * Idiomatic usage:
+   *
+   * @example
+   * ```ts
+   * // Same workflow, validated args
+   * implementation: async (context, args) => {
+   *   if (shouldRoll(args)) {
+   *     return context.continueAsNew({ ...args, retryCount: args.retryCount + 1 });
+   *   }
+   *   return ...;
+   * }
+   *
+   * // Cross-contract continueAsNew (less common — taskQueue and workflow type
+   * // come from the other contract)
+   * return context.continueAsNew(otherContract, "otherWorkflow", { ...newArgs });
+   * ```
+   */
+  continueAsNew: {
+    /** Same-workflow continuation — args typed against this workflow's input. */(args: ClientInferInput<TContract["workflows"][TWorkflowName]>, options?: TypedContinueAsNewOptions): Promise<never>; /** Cross-contract continuation — args typed against the destination workflow. */
+    <TOtherContract extends ContractDefinition, TOtherWorkflowName extends keyof TOtherContract["workflows"]>(contract: TOtherContract, workflowName: TOtherWorkflowName, args: ClientInferInput<TOtherContract["workflows"][TOtherWorkflowName]>, options?: TypedContinueAsNewOptions): Promise<never>;
+  };
+};
 /**
  * Options for starting a child workflow
  */
@@ -264,7 +387,7 @@ type TypedChildWorkflowOptions<TChildContract extends ContractDefinition, TChild
 /**
  * Typed handle for a child workflow with Future/Result pattern
  */
-interface TypedChildWorkflowHandle<TWorkflow extends WorkflowDefinition> {
+type TypedChildWorkflowHandle<TWorkflow extends WorkflowDefinition> = {
   /**
    * Get child workflow result with Result pattern
    */
@@ -273,7 +396,7 @@ interface TypedChildWorkflowHandle<TWorkflow extends WorkflowDefinition> {
    * Child workflow ID
    */
   workflowId: string;
-}
+};
 /**
  * Activity function signature from workflow execution perspective
  *
@@ -293,6 +416,7 @@ type WorkflowInferWorkflowActivities<T extends WorkflowDefinition> = T["activiti
  *
  * Combines workflow-specific activities with global contract activities
  */
-type WorkflowInferWorkflowContextActivities<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]> = WorkflowInferWorkflowActivities<TContract["workflows"][TWorkflowName]> & WorkflowInferActivities<TContract>;
+type WorkflowInferWorkflowContextActivities<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]> = WorkflowInferWorkflowActivities<TContract["workflows"][TWorkflowName]> & WorkflowInferActivities<TContract>; //# sourceMappingURL=workflow.d.ts.map
 //#endregion
-export { ActivityInputValidationError, ActivityOutputValidationError, ChildWorkflowError, ChildWorkflowNotFoundError, QueryInputValidationError, QueryOutputValidationError, SignalInputValidationError, UpdateInputValidationError, UpdateOutputValidationError, WorkflowInputValidationError, WorkflowOutputValidationError, declareWorkflow };
+export { ActivityInputValidationError, ActivityOutputValidationError, ChildWorkflowError, ChildWorkflowNotFoundError, QueryInputValidationError, QueryOutputValidationError, SignalInputValidationError, UpdateInputValidationError, UpdateOutputValidationError, WorkflowCancelledError, WorkflowInputValidationError, WorkflowOutputValidationError, declareWorkflow };
+//# sourceMappingURL=workflow.d.mts.map

package/dist/workflow.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.d.mts","names":[],"sources":["../src/handlers.ts","../src/internal.ts","../src/workflow.ts"],"mappings":"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"}