@usehelical/workflows 0.0.1-alpha.14 → 0.0.1-alpha.16

package/dist/index.d.ts

@@ -1,25 +1,173 @@
-import { W as WorkflowEntry, Q as QueueEntry, R as RunWorkflowOptions, a as Run, b as RunStatus, c as RunResult, d as QueueWorkflowOptions, M as MessageDefinition, S as StateDefinition } from './run-BCTOgHFp.js';
+import { R as RunStatus, W as WorkflowDefinition, Q as QueueDefinition, a as WorkflowSignature, M as MessageDefinition, S as StateDefinition } from './state-DygxhGtl.js';
+
+declare enum ErrorType {
+    INVALID_WORKFLOW_TRANSITION = "INVALID_WORKFLOW_TRANSITION",
+    RUN_CANCELLED = "RUN_CANCELLED",
+    RUN_NOT_FOUND = "RUN_NOT_FOUND",
+    RUN_OUTSIDE_OF_WORKFLOW = "RUN_OUTSIDE_OF_WORKFLOW",
+    FATAL_ERROR = "FATAL_ERROR",
+    NO_MESSAGE_AVAILABLE = "NO_MESSAGE_AVAILABLE",
+    MAX_RETRIES_EXCEEDED = "MAX_RETRIES_EXCEEDED",
+    ERROR_THAT_SHOULD_NEVER_HAPPEN = "ERROR_THAT_SHOULD_NEVER_HAPPEN",
+    SERIALIZATION_ERROR = "SERIALIZATION_ERROR",
+    MAX_RECOVERY_ATTEMPTS_EXCEEDED = "MAX_RECOVERY_ATTEMPTS_EXCEEDED",
+    WORKFLOW_NOT_FOUND = "WORKFLOW_NOT_FOUND",
+    TIMEOUT = "TIMEOUT",
+    CANCEL = "CANCEL",
+    DEADLINE = "DEADLINE",
+    RUN_NOT_CANCELLABLE = "RUN_NOT_CANCELLABLE",
+    QUEUE_NOT_FOUND = "QUEUE_NOT_FOUND"
+}
+type ErrorReason = 'timeout' | 'deadline' | 'cancel' | 'unhandled' | 'max_recovery_attempts_exceeded' | 'workflow_not_found' | 'unknown' | 'run_not_found' | 'outside_workflow_context' | 'fatal_error' | 'max_retries_exceeded' | 'serialization_error';
+declare class BaseError extends Error {
+    readonly reason: ErrorReason;
+    constructor(message: string, reason: ErrorReason);
+}
+declare class RunTimedOutError extends BaseError {
+    constructor();
+}
+declare class UnknownError extends BaseError {
+    constructor(message?: string);
+}
+declare class RunDeadlineExceededError extends BaseError {
+    constructor();
+}
+declare class RunCancelledError extends BaseError {
+    constructor();
+}
+declare class MaxRecoveryAttemptsExceededError extends BaseError {
+    constructor(runId: string, attempts: number);
+}
+declare class OperationTimedOutError extends BaseError {
+    constructor(operationName: string);
+}
+declare class RunNotFoundError extends BaseError {
+    constructor(runId: string);
+}
+declare class RunOutsideOfWorkflowError extends BaseError {
+    constructor();
+}
+declare class FatalError extends BaseError {
+    constructor(message: string);
+}
+declare class MaxRetriesExceededError extends BaseError {
+    readonly attemptErrors: Error[];
+    readonly stepName: string;
+    readonly maxAttempts: number;
+    constructor(stepName: string, maxAttempts: number, errors: Error[]);
+}
+declare class SerializationError extends BaseError {
+    constructor(message: string);
+}
+declare class WorkflowNotFoundError extends BaseError {
+    constructor(workflowName: string);
+}
+
+type RunResult<TReturn> = {
+    error: BaseError | Error;
+    success: false;
+} | {
+    data: TReturn;
+    success: true;
+};
+interface Run<TReturn = unknown> {
+    id: string;
+    getStatus: () => Promise<RunStatus>;
+    waitForResult: () => Promise<RunResult<TReturn>>;
+}
+
+type RunWorkflowOptions = {
+    timeout?: number;
+    deadline?: number;
+    id?: string;
+};
+
+type QueueWorkflowOptions = {
+    timeout?: number;
+    deadline?: number;
+    priority?: number;
+    partitionKey?: string;
+    id?: string;
+    deduplicationId?: string;
+};
 
 type CreateInstanceOptions = {
     instanceId?: string;
     connectionString: string;
 };
-type CreateInstanceParams = {
-    workflows: Record<string, WorkflowEntry<any, any>>;
-    queues?: Record<string, QueueEntry>;
+type createExecutorParams<TWorkflows extends Array<WorkflowDefinition<unknown[], unknown>>, TQueues extends Array<QueueDefinition>> = {
+    workflows: TWorkflows;
+    queues?: TQueues;
     options: CreateInstanceOptions;
 };
-declare function createInstance(props: CreateInstanceParams): {
-    runWorkflow: <TArgs extends unknown[], TReturn>(wf: WorkflowEntry<TArgs, TReturn> | string, args?: TArgs, options?: RunWorkflowOptions) => Promise<Run<TReturn>>;
-    cancelRun: (runId: string) => Promise<void>;
-    resumeRun: (runId: string) => Promise<Run<void>>;
-    getRun: (runId: string) => Promise<Run<unknown>>;
-    getRunStatus: (runId: string) => Promise<RunStatus>;
-    waitForRunResult: <TReturn>(runId: string) => Promise<RunResult<TReturn>>;
-    queueWorkflow: <TArgs extends unknown[], TReturn>(queue: QueueEntry | string, wf: WorkflowEntry<TArgs, TReturn> | string, args?: TArgs, options?: QueueWorkflowOptions) => Promise<Run<TReturn>>;
-    sendMessage: <T>(target: Run | string, name: MessageDefinition<T>, data: T) => Promise<void>;
-    getState: <T>(target: Run | string, key: StateDefinition<T> | string) => Promise<T>;
-};
-type Instance = ReturnType<typeof createInstance>;
+type ExtractNames<T extends readonly {
+    name: string;
+}[]> = T[number]['name'];
+interface WorkflowOperations<TWorkflows extends readonly WorkflowSignature<unknown[], unknown>[], TQueues extends readonly QueueDefinition[]> {
+    queueWorkflow<TQueue extends Extract<TQueues[number], {
+        name: ExtractNames<TQueues>;
+    }> = Extract<TQueues[number], {
+        name: ExtractNames<TQueues>;
+    }>, TWorkflow extends Extract<TWorkflows[number], {
+        name: ExtractNames<TWorkflows>;
+    }> = Extract<TWorkflows[number], {
+        name: ExtractNames<TWorkflows>;
+    }>, TArgs extends unknown[] = TWorkflow extends WorkflowSignature<infer A extends unknown[], unknown> ? A : never, TReturn = TWorkflow extends WorkflowSignature<unknown[], infer R> ? R : never>(queue: TQueue, wf: TWorkflow, args: TArgs, options?: QueueWorkflowOptions): Promise<Run<TReturn>>;
+    queueWorkflow<QK extends ExtractNames<TQueues>, WK extends ExtractNames<TWorkflows>, TWorkflow extends Extract<TWorkflows[number], {
+        name: WK;
+    }> = Extract<TWorkflows[number], {
+        name: WK;
+    }>, TReturn = TWorkflow extends WorkflowSignature<unknown[], infer R> ? R : never>(queue: QK, wf: WK, options: QueueWorkflowOptions): Promise<Run<TReturn>>;
+    queueWorkflow<QK extends ExtractNames<TQueues>, WK extends ExtractNames<TWorkflows>, TWorkflow extends Extract<TWorkflows[number], {
+        name: WK;
+    }> = Extract<TWorkflows[number], {
+        name: WK;
+    }>, TReturn = TWorkflow extends WorkflowSignature<unknown[], infer R> ? R : never>(queue: QK, wf: WK): Promise<Run<TReturn>>;
+    cancelRun(runId: string): Promise<void>;
+    resumeRun(runId: string): Promise<void>;
+    getRun<TWorkflow extends WorkflowSignature<unknown[], unknown>>(runId: string): Promise<Run<TWorkflow extends WorkflowSignature<unknown[], infer R> ? R : never>>;
+    getRun<TReturn>(runId: string): Promise<Run<TReturn>>;
+    getRunStatus(runId: string): Promise<string>;
+    waitForRunResult<TWorkflow extends WorkflowSignature<unknown[], unknown>>(runId: string): Promise<RunResult<TWorkflow extends WorkflowSignature<unknown[], infer R> ? R : never>>;
+    waitForRunResult<TReturn>(runId: string): Promise<RunResult<TReturn>>;
+    sendMessage<T>(target: Run | string, name: MessageDefinition<T>, data: T): Promise<void>;
+    getState<T>(target: Run | string, key: StateDefinition<T> | string): Promise<T | undefined>;
+}
+interface Executor<TWorkflows extends Array<WorkflowDefinition<unknown[], unknown>>, TQueues extends Array<QueueDefinition>> extends WorkflowOperations<TWorkflows, TQueues> {
+    runWorkflow<TWorkflow extends WorkflowDefinition<any[], any> & {
+        name: ExtractNames<TWorkflows>;
+    }, TReturn = TWorkflow extends WorkflowDefinition<any[], infer R> ? R : never>(wf: TWorkflow): Promise<Run<TReturn>>;
+    runWorkflow<TWorkflow extends WorkflowDefinition<any[], any> & {
+        name: ExtractNames<TWorkflows>;
+    }, TReturn = TWorkflow extends WorkflowDefinition<any[], infer R> ? R : never>(wf: TWorkflow, options: RunWorkflowOptions): Promise<Run<TReturn>>;
+    runWorkflow<TWorkflow extends WorkflowDefinition<any[], any> & {
+        name: ExtractNames<TWorkflows>;
+    }, TArgs extends any[] = TWorkflow extends WorkflowDefinition<infer A extends unknown[], unknown> ? A : never, TReturn = TWorkflow extends WorkflowDefinition<any[], infer R> ? R : never>(wf: TWorkflow, args: TArgs, options?: RunWorkflowOptions): Promise<Run<TReturn>>;
+}
+declare function createExecutor<TWorkflows extends Array<WorkflowDefinition<any[], any>>, TQueues extends Array<QueueDefinition>>(props: createExecutorParams<TWorkflows, TQueues>): Executor<TWorkflows, TQueues>;
+type Instance = ReturnType<typeof createExecutor>;
+
+type ExtractWorkflows<T> = T extends Executor<infer W, any> ? W : never;
+type ExtractQueues<T> = T extends Executor<any, infer Q> ? Q : never;
+type QueuesProxy<TQueues extends Record<string, QueueDefinition>> = {
+    [K in keyof TQueues]: {
+        name: K;
+        definition: TQueues[K];
+    };
+};
+type WorkflowsProxy<TWorkflows extends Record<string, WorkflowDefinition<unknown[], unknown>>> = {
+    [K in keyof TWorkflows]: {
+        name: K;
+        definition: TWorkflows[K];
+    };
+};
+interface Client<TWorkflows extends Record<string, WorkflowDefinition<unknown[], unknown>>, TQueues extends Record<string, QueueDefinition>> extends WorkflowOperations<ExtractWorkflows<TWorkflows>, ExtractQueues<TQueues>> {
+    workflows: WorkflowsProxy<TWorkflows>;
+    queues: QueuesProxy<TQueues>;
+}
+type ClientOptions = {
+    connectionString: string;
+};
+declare function createClient<TExecutor extends Executor<any, any>>(options: ClientOptions): Client<ExtractWorkflows<TExecutor>, ExtractQueues<TExecutor>>;
 
-export { type CreateInstanceParams, type Instance, createInstance };
+export { BaseError, type ErrorReason, ErrorType, type Executor, FatalError, type Instance, MaxRecoveryAttemptsExceededError, MaxRetriesExceededError, OperationTimedOutError, RunCancelledError, RunDeadlineExceededError, RunNotFoundError, RunOutsideOfWorkflowError, RunTimedOutError, SerializationError, UnknownError, WorkflowNotFoundError, type WorkflowOperations, createClient, createExecutor, type createExecutorParams };