durable-execution-orpc-utils/build/server.d.ts

oRPC utilities for durable-execution to create a separate server process for durable execution

import { type FriendlyClientOptions } from '@orpc/client';
import { type AnySchema, type ErrorMap, type InferSchemaInput, type InferSchemaOutput, type Meta } from '@orpc/contract';
import { type Builder, type ClientContext, type Context, type DecoratedProcedure, type ProcedureClient, type Schema } from '@orpc/server';
import { type CommonTaskOptions, type DurableExecutor, type Task, type TaskEnqueueOptions, type TaskExecution } from 'durable-execution';
/**
 * A record of tasks. This type signals to the client which tasks are available to be enqueued.
 *
 * @example
 * ```ts
 * const tasks = {
 *   task1: task1,
 *   task2: task2,
 * }
 * ```
 */
export type AnyTasks = Record<string, Task<unknown, unknown>>;
/**
 * Creates a router for task procedures. Two procedures are created:
 * - `enqueueTask` - Enqueues a task
 * - `getTaskExecution` - Gets the execution of a task
 *
 * @param osBuilder - The ORPC builder to use.
 * @param executor - The durable executor to use.
 * @returns A router for task procedures.
 */
export declare function createTasksRouter<TInitialContext extends Context, TCurrentContext extends Context, TErrorMap extends ErrorMap, TMeta extends Meta, TBuilder extends Builder<TInitialContext, TCurrentContext, Schema<unknown, unknown>, Schema<unknown, unknown>, TErrorMap, TMeta>>(osBuilder: TBuilder, executor: DurableExecutor): {
    enqueueTask: DecoratedProcedure<TInitialContext, TCurrentContext, Schema<{
        taskId: string;
        input: unknown;
        options?: TaskEnqueueOptions;
    }, {
        taskId: string;
        input: unknown;
        options?: TaskEnqueueOptions;
    }>, Schema<string, string>, TErrorMap, TMeta>;
    getTaskExecution: DecoratedProcedure<TInitialContext, TCurrentContext, Schema<{
        taskId: string;
        executionId: string;
    }, {
        taskId: string;
        executionId: string;
    }>, Schema<TaskExecution, TaskExecution>, TErrorMap, TMeta>;
};
/**
 * Converts a client procedure to a task. This is useful when you want to use a client procedure as
 * a task on the server. The `run` function of the task will call the client procedure.
 *
 * @param executor - The durable executor to use.
 * @param taskOptions - The options to use.
 * @param procedure - The procedure to convert.
 * @param rest - The client options.
 * @returns A task.
 */
export declare function convertClientProcedureToTask<TClientContext extends ClientContext, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap>(executor: DurableExecutor, taskOptions: CommonTaskOptions, procedure: ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap>, ...rest: Record<never, never> extends TClientContext ? [options?: FriendlyClientOptions<TClientContext>] : [options: FriendlyClientOptions<TClientContext>]): Task<InferSchemaInput<TInputSchema>, InferSchemaOutput<TOutputSchema>>;
//# sourceMappingURL=server.d.ts.map