@temporal-contract/worker 0.0.4 → 0.0.6

package/dist/handler-DThqdaaS.d.mts

@@ -1,316 +0,0 @@
-import { ActivityOptions, WorkflowInfo } from "@temporalio/workflow";
-import { Future, Result } from "@swan-io/boxed";
-import { ActivityDefinition, ContractDefinition, QueryDefinition, SignalDefinition, UpdateDefinition, WorkerInferInput, WorkerInferOutput, WorkerInferWorkflowContextActivities } from "@temporal-contract/contract";
-import { StandardSchemaV1 } from "@standard-schema/spec";
-
-//#region src/errors.d.ts
-/**
- * Base error class for worker errors
- */
-declare class WorkerError extends Error {
-  constructor(message: string, cause?: unknown);
-}
-/**
- * Activity error class that should be used to wrap all technical exceptions
- * Forces proper error handling and enables retry policies
- */
-declare class ActivityError extends Error {
-  readonly code: string;
-  readonly cause?: unknown;
-  constructor(code: string, 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>);
-}
-//#endregion
-//#region src/handler.d.ts
-/**
- * Workflow context with typed activities (workflow + global) and workflow info
- * Note: activities is typed as 'any' to work around TypeScript generic type inference limitations with Zod tuples
- */
-interface WorkflowContext<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]> {
-  activities: WorkerInferWorkflowContextActivities<TContract, TWorkflowName>;
-  info: WorkflowInfo;
-}
-/**
- * Workflow implementation function (receives context + typed args as tuple)
- * Note: We use 'any' for args to work around TypeScript limitations with generic Zod tuple inference
- * The actual type will be enforced at runtime by Zod validation
- */
-type WorkflowImplementation<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]> = (context: WorkflowContext<TContract, TWorkflowName>, args: WorkerInferInput<TContract["workflows"][TWorkflowName]>) => Promise<WorkerInferOutput<TContract["workflows"][TWorkflowName]>>;
-/**
- * Activity implementation using Result pattern
- * Returns Future<Result<Output, ActivityError>> instead of throwing exceptions
- */
-type BoxedActivityImplementation<TActivity extends ActivityDefinition> = (args: WorkerInferInput<TActivity>) => Future<Result<WorkerInferOutput<TActivity>, ActivityError>>;
-/**
- * Signal handler implementation
- */
-type SignalHandlerImplementation<TSignal extends SignalDefinition> = (args: WorkerInferInput<TSignal>) => void | Promise<void>;
-/**
- * Query handler implementation
- */
-type QueryHandlerImplementation<TQuery extends QueryDefinition> = (args: WorkerInferInput<TQuery>) => WorkerInferOutput<TQuery>;
-/**
- * Update handler implementation
- */
-type UpdateHandlerImplementation<TUpdate extends UpdateDefinition> = (args: WorkerInferInput<TUpdate>) => Promise<WorkerInferOutput<TUpdate>>;
-/**
- * Map of all activity implementations for a contract (global + all workflow-specific)
- */
-type ActivityImplementations<T extends ContractDefinition> = (T["activities"] extends Record<string, ActivityDefinition> ? { [K in keyof T["activities"]]: BoxedActivityImplementation<T["activities"][K]> } : {}) & UnionToIntersection<{ [K in keyof T["workflows"]]: T["workflows"][K]["activities"] extends Record<string, ActivityDefinition> ? { [A in keyof T["workflows"][K]["activities"]]: BoxedActivityImplementation<T["workflows"][K]["activities"][A]> } : {} }[keyof T["workflows"]]>;
-/**
- * Utility type to convert union to intersection
- */
-type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
-/**
- * Options for creating activities handler
- */
-interface DeclareActivitiesHandlerOptions<T extends ContractDefinition> {
-  contract: T;
-  activities: ActivityImplementations<T>;
-}
-/**
- * Activities handler ready for Temporal Worker
- */
-interface ActivitiesHandler<T extends ContractDefinition> {
-  contract: T;
-  activities: Record<string, (...args: unknown[]) => Promise<unknown>>;
-}
-/**
- * Options for declaring a workflow implementation
- */
-interface 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.
-   * These will be merged with the default startToCloseTimeout of 60 seconds.
-   * 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
-   *
-   * @example
-   * ```ts
-   * activityOptions: {
-   *   startToCloseTimeout: '5m',
-   *   retry: { maximumAttempts: 3 }
-   * }
-   * ```
-   */
-  activityOptions?: ActivityOptions;
-  /**
-   * Signal handlers (if defined in workflow)
-   */
-  signals?: TContract["workflows"][TWorkflowName]["signals"] extends Record<string, SignalDefinition> ? { [K in keyof TContract["workflows"][TWorkflowName]["signals"]]: SignalHandlerImplementation<TContract["workflows"][TWorkflowName]["signals"][K]> } : never;
-  /**
-   * Query handlers (if defined in workflow)
-   */
-  queries?: TContract["workflows"][TWorkflowName]["queries"] extends Record<string, QueryDefinition> ? { [K in keyof TContract["workflows"][TWorkflowName]["queries"]]: QueryHandlerImplementation<TContract["workflows"][TWorkflowName]["queries"][K]> } : never;
-  /**
-   * Update handlers (if defined in workflow)
-   */
-  updates?: TContract["workflows"][TWorkflowName]["updates"] extends Record<string, UpdateDefinition> ? { [K in keyof TContract["workflows"][TWorkflowName]["updates"]]: UpdateHandlerImplementation<TContract["workflows"][TWorkflowName]["updates"][K]> } : never;
-}
-/**
- * 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 activitiesHandler = 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: activitiesHandler.activities,
- *   taskQueue: activitiesHandler.contract.taskQueue,
- * });
- * ```
- */
-declare function declareActivitiesHandler<T extends ContractDefinition>(options: DeclareActivitiesHandlerOptions<T>): ActivitiesHandler<T>;
-/**
- * Create a typed workflow implementation with automatic validation
- *
- * This wraps a workflow implementation with:
- * - Input/output validation
- * - Typed workflow context with activities
- * - Workflow info access
- *
- * Workflows must be defined in separate files and imported by the Temporal Worker
- * via workflowsPath.
- *
- * @example
- * ```ts
- * // workflows/processOrder.ts
- * import { declareWorkflow } from '@temporal-contract/worker';
- * import myContract from '../contract';
- *
- * export const processOrder = declareWorkflow({
- *   workflowName: 'processOrder',
- *   contract: myContract,
- *   implementation: async (context, orderId, customerId) => {
- *     // context.activities: typed activities (workflow + global)
- *     // context.info: WorkflowInfo
- *
- *     const inventory = await context.activities.validateInventory(orderId);
- *
- *     if (!inventory.available) {
- *       throw new Error('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'
- *     );
- *
- *     return {
- *       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';
- *
- * const worker = await Worker.create({
- *   workflowsPath: require.resolve('./workflows'), // Imports processOrder
- *   activities: activitiesHandler.activities,
- *   taskQueue: activitiesHandler.contract.taskQueue,
- * });
- * ```
- */
-declare function declareWorkflow<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]>(options: DeclareWorkflowOptions<TContract, TWorkflowName>): (args: WorkerInferInput<TContract["workflows"][TWorkflowName]>) => Promise<WorkerInferOutput<TContract["workflows"][TWorkflowName]>>;
-//#endregion
-export { WorkflowInputValidationError as C, WorkerError as S, QueryInputValidationError as _, DeclareWorkflowOptions as a, UpdateInputValidationError as b, UpdateHandlerImplementation as c, declareActivitiesHandler as d, declareWorkflow as f, ActivityOutputValidationError as g, ActivityInputValidationError as h, DeclareActivitiesHandlerOptions as i, WorkflowContext as l, ActivityError as m, ActivityImplementations as n, QueryHandlerImplementation as o, ActivityDefinitionNotFoundError as p, BoxedActivityImplementation as r, SignalHandlerImplementation as s, ActivitiesHandler as t, WorkflowImplementation as u, QueryOutputValidationError as v, WorkflowOutputValidationError as w, UpdateOutputValidationError as x, SignalInputValidationError as y };