@temporal-contract/worker 0.0.7 → 0.2.0

package/dist/activity-UOnp_bSX.d.mts

@@ -1,162 +0,0 @@
-import { g as WorkerInferOutput, h as WorkerInferInput } from "./errors-C1RFkCuD.mjs";
-import { ActivityDefinition, ContractDefinition } from "@temporal-contract/contract";
-import { Future, Result } from "@swan-io/boxed";
-
-//#region src/activity-utils.d.ts
-
-/**
- * Extract activity definitions for a specific workflow from a contract
- *
- * This includes both:
- * - Workflow-specific activities defined under workflow.activities
- * - Global activities defined under contract.activities
- *
- * @param contract - The contract definition
- * @param workflowName - The name of the workflow
- * @returns Activity definitions for the workflow (workflow-specific + global activities merged)
- *
- * @example
- * ```ts
- * const orderWorkflowActivities = getWorkflowActivities(myContract, 'processOrder');
- * // Returns: { processPayment: ActivityDef, reserveInventory: ActivityDef, sendEmail: ActivityDef }
- * // where sendEmail is a global activity
- * ```
- */
-declare function getWorkflowActivities<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]>(contract: TContract, workflowName: TWorkflowName): Record<string, ActivityDefinition>;
-/**
- * Extract all activity names for a specific workflow from a contract
- *
- * @param contract - The contract definition
- * @param workflowName - The name of the workflow
- * @returns Array of activity names (strings) available for the workflow
- *
- * @example
- * ```ts
- * const activityNames = getWorkflowActivityNames(myContract, 'processOrder');
- * // Returns: ['processPayment', 'reserveInventory', 'sendEmail']
- * ```
- */
-declare function getWorkflowActivityNames<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]>(contract: TContract, workflowName: TWorkflowName): string[];
-/**
- * Check if an activity belongs to a specific workflow
- *
- * @param contract - The contract definition
- * @param workflowName - The name of the workflow
- * @param activityName - The name of the activity to check
- * @returns True if the activity is available for the workflow, false otherwise
- *
- * @example
- * ```ts
- * if (isWorkflowActivity(myContract, 'processOrder', 'processPayment')) {
- *   // Activity is available for this workflow
- * }
- * ```
- */
-declare function isWorkflowActivity<TContract extends ContractDefinition, TWorkflowName extends keyof TContract["workflows"]>(contract: TContract, workflowName: TWorkflowName, activityName: string): boolean;
-/**
- * Get all workflow names from a contract
- *
- * @param contract - The contract definition
- * @returns Array of workflow names defined in the contract
- *
- * @example
- * ```ts
- * const workflows = getWorkflowNames(myContract);
- * // Returns: ['processOrder', 'processRefund']
- * ```
- */
-declare function getWorkflowNames<TContract extends ContractDefinition>(contract: TContract): Array<keyof TContract["workflows"]>;
-//#endregion
-//#region src/activity.d.ts
-/**
- * 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;
-  constructor(code: string, message: string, cause?: unknown);
-}
-/**
- * Activity implementation using Future/Result pattern
- *
- * Returns Future<Result<Output, ActivityError>> for explicit error handling instead of throwing exceptions.
- * All errors must be wrapped in ActivityError to enable proper retry policies.
- */
-type BoxedActivityImplementation<TActivity extends ActivityDefinition> = (args: WorkerInferInput<TActivity>) => Future<Result<WorkerInferOutput<TActivity>, ActivityError>>;
-/**
- * Map of all activity implementations for a contract (global + all workflow-specific)
- */
-type ContractBoxedActivitiesImplementations<TContract extends ContractDefinition> = (TContract["activities"] extends Record<string, ActivityDefinition> ? BoxedActivitiesImplementations<TContract["activities"]> : {}) & { [TWorkflow in keyof TContract["workflows"]]: TContract["workflows"][TWorkflow]["activities"] extends Record<string, ActivityDefinition> ? BoxedActivitiesImplementations<TContract["workflows"][TWorkflow]["activities"]> : {} };
-type BoxedActivitiesImplementations<TActivities extends Record<string, ActivityDefinition>> = { [K in keyof TActivities]: BoxedActivityImplementation<TActivities[K]> };
-/**
- * Options for creating activities handler
- */
-interface DeclareActivitiesHandlerOptions<TContract extends ContractDefinition> {
-  contract: TContract;
-  activities: ContractBoxedActivitiesImplementations<TContract>;
-}
-type ActivityImplementation<TActivity extends ActivityDefinition> = (args: WorkerInferInput<TActivity>) => Promise<WorkerInferOutput<TActivity>>;
-type ActivitiesImplementations<TActivities extends Record<string, ActivityDefinition>> = { [K in keyof TActivities]: ActivityImplementation<TActivities[K]> };
-type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
-/**
- * Activities handler ready for Temporal Worker
- *
- * Flat structure: all activities (global + all workflow-specific) are at the root level
- */
-type ActivitiesHandler<TContract extends ContractDefinition> = (TContract["activities"] extends Record<string, ActivityDefinition> ? ActivitiesImplementations<TContract["activities"]> : {}) & UnionToIntersection<{ [TWorkflow in keyof TContract["workflows"]]: TContract["workflows"][TWorkflow]["activities"] extends Record<string, ActivityDefinition> ? ActivitiesImplementations<TContract["workflows"][TWorkflow]["activities"]> : {} }[keyof TContract["workflows"]]>;
-/**
- * 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 activities = 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: activities,
- *   taskQueue: contract.taskQueue,
- * });
- * ```
- */
-declare function declareActivitiesHandler<TContract extends ContractDefinition>(options: DeclareActivitiesHandlerOptions<TContract>): ActivitiesHandler<TContract>;
-//#endregion
-export { getWorkflowActivityNames as a, getWorkflowActivities as i, ActivityError as n, getWorkflowNames as o, declareActivitiesHandler as r, isWorkflowActivity as s, ActivitiesHandler as t };