@temporalio/client/lib/interceptors.d.ts

Temporal.io SDK Client sub-package

/**
 * Definitions for Connection interceptors.
 *
 * @module
 */
import type { Duration, SearchAttributePair, TypedSearchAttributes } from '@temporalio/common';
import { Headers, Next } from '@temporalio/common';
import type { temporal } from '@temporalio/proto';
import type { NexusOperationHandle } from './nexus-client';
import type { NexusOperationExecutionCount, NexusOperationExecutionDescription, NexusOperationExecution, NexusOperationIdConflictPolicy, NexusOperationIdReusePolicy } from './nexus-types';
import type { CompiledScheduleOptions } from './schedule-types';
import type { ActivityExecutionDescription, ActivityExecutionInfo, CountActivityExecutions, DescribeWorkflowExecutionResponse, RequestCancelWorkflowExecutionResponse, TerminateWorkflowExecutionResponse, WorkflowExecution } from './types';
import type { CompiledWorkflowOptions, WorkflowUpdateOptions } from './workflow-options';
import type { ActivityHandle, ActivityOptions } from './activity-client';
export { Headers, Next };
/** Input for WorkflowClientInterceptor.start */
export interface WorkflowStartInput {
    /** Name of Workflow to start */
    readonly workflowType: string;
    readonly headers: Headers;
    readonly options: CompiledWorkflowOptions;
}
/** Input for WorkflowClientInterceptor.update */
export interface WorkflowStartUpdateInput {
    readonly updateName: string;
    readonly args: unknown[];
    readonly workflowExecution: WorkflowExecution;
    readonly firstExecutionRunId?: string;
    readonly headers: Headers;
    readonly options: WorkflowUpdateOptions;
}
/** Output for WorkflowClientInterceptor.startWithDetails */
export interface WorkflowStartOutput {
    readonly runId: string;
    readonly eagerlyStarted: boolean;
}
/** Output for WorkflowClientInterceptor.startUpdate */
export interface WorkflowStartUpdateOutput {
    readonly updateId: string;
    readonly workflowRunId: string;
    readonly outcome?: temporal.api.update.v1.IOutcome;
}
/**
 * Input for WorkflowClientInterceptor.startUpdateWithStart
 */
export interface WorkflowStartUpdateWithStartInput {
    readonly workflowType: string;
    readonly workflowStartOptions: CompiledWorkflowOptions;
    readonly workflowStartHeaders: Headers;
    readonly updateName: string;
    readonly updateArgs: unknown[];
    readonly updateOptions: WorkflowUpdateOptions;
    readonly updateHeaders: Headers;
}
/**
 * Output for WorkflowClientInterceptor.startUpdateWithStart
 */
export interface WorkflowStartUpdateWithStartOutput {
    readonly workflowExecution: WorkflowExecution;
    readonly updateId: string;
    readonly updateOutcome?: temporal.api.update.v1.IOutcome;
}
/** Input for WorkflowClientInterceptor.signal */
export interface WorkflowSignalInput {
    readonly signalName: string;
    readonly args: unknown[];
    readonly workflowExecution: WorkflowExecution;
    readonly headers: Headers;
}
/** Input for WorkflowClientInterceptor.signalWithStart */
export interface WorkflowSignalWithStartInput {
    readonly workflowType: string;
    readonly signalName: string;
    readonly signalArgs: unknown[];
    readonly headers: Headers;
    readonly options: CompiledWorkflowOptions;
}
/** Input for WorkflowClientInterceptor.query */
export interface WorkflowQueryInput {
    readonly queryType: string;
    readonly args: unknown[];
    readonly workflowExecution: WorkflowExecution;
    readonly queryRejectCondition?: temporal.api.enums.v1.QueryRejectCondition;
    readonly headers: Headers;
}
/** Input for WorkflowClientInterceptor.terminate */
export interface WorkflowTerminateInput {
    readonly workflowExecution: WorkflowExecution;
    readonly reason?: string;
    readonly details?: unknown[];
    readonly firstExecutionRunId?: string;
}
/** Input for WorkflowClientInterceptor.cancel */
export interface WorkflowCancelInput {
    readonly workflowExecution: WorkflowExecution;
    readonly firstExecutionRunId?: string;
}
/** Input for WorkflowClientInterceptor.describe */
export interface WorkflowDescribeInput {
    readonly workflowExecution: WorkflowExecution;
}
/**
 * Implement any of these methods to intercept {@link WorkflowClient} outbound calls
 *
 * @experimental Standalone Activities are experimental. APIs may be subject to change.
 */
export interface WorkflowClientInterceptor {
    /**
     * Intercept a service call to startWorkflowExecution
     *
     * If you implement this method,
     * {@link signalWithStart} most likely needs to be implemented too
     *
     * @deprecated in favour of {@link startWithDetails}
     */
    start?: (input: WorkflowStartInput, next: Next<this, 'start'>) => Promise<string>;
    /**
     * Intercept a service call to startWorkflowExecution
     *
     * This method returns start details via {@link WorkflowStartOutput}.
     *
     * If you implement this method,
     * {@link signalWithStart} most likely needs to be implemented too
     */
    startWithDetails?: (input: WorkflowStartInput, next: Next<this, 'startWithDetails'>) => Promise<WorkflowStartOutput>;
    /**
     * Intercept a service call to updateWorkflowExecution
     */
    startUpdate?: (input: WorkflowStartUpdateInput, next: Next<this, 'startUpdate'>) => Promise<WorkflowStartUpdateOutput>;
    /**
     * Intercept a service call to startUpdateWithStart
     */
    startUpdateWithStart?: (input: WorkflowStartUpdateWithStartInput, next: Next<this, 'startUpdateWithStart'>) => Promise<WorkflowStartUpdateWithStartOutput>;
    /**
     * Intercept a service call to signalWorkflowExecution
     *
     * If you implement this method,
     * {@link signalWithStart} most likely needs to be implemented too
     */
    signal?: (input: WorkflowSignalInput, next: Next<this, 'signal'>) => Promise<void>;
    /**
     * Intercept a service call to signalWithStartWorkflowExecution
     */
    signalWithStart?: (input: WorkflowSignalWithStartInput, next: Next<this, 'signalWithStart'>) => Promise<string>;
    /**
     * Intercept a service call to queryWorkflow
     */
    query?: (input: WorkflowQueryInput, next: Next<this, 'query'>) => Promise<unknown>;
    /**
     * Intercept a service call to terminateWorkflowExecution
     */
    terminate?: (input: WorkflowTerminateInput, next: Next<this, 'terminate'>) => Promise<TerminateWorkflowExecutionResponse>;
    /**
     * Intercept a service call to requestCancelWorkflowExecution
     */
    cancel?: (input: WorkflowCancelInput, next: Next<this, 'cancel'>) => Promise<RequestCancelWorkflowExecutionResponse>;
    /**
     * Intercept a service call to describeWorkflowExecution
     */
    describe?: (input: WorkflowDescribeInput, next: Next<this, 'describe'>) => Promise<DescribeWorkflowExecutionResponse>;
}
/** @deprecated: Use {@link WorkflowClientInterceptor} instead */
export type WorkflowClientCallsInterceptor = WorkflowClientInterceptor;
/** @deprecated */
export interface WorkflowClientCallsInterceptorFactoryInput {
    workflowId: string;
    runId?: string;
}
/**
 * A function that takes {@link CompiledWorkflowOptions} and returns an interceptor
 *
 * @deprecated: Please define interceptors directly, without factory
 */
export interface WorkflowClientCallsInterceptorFactory {
    (input: WorkflowClientCallsInterceptorFactoryInput): WorkflowClientCallsInterceptor;
}
/**
 * A mapping of interceptor type of a list of factory functions
 *
 * @deprecated: Please define interceptors directly, without factory
 */
export interface WorkflowClientInterceptors {
    /** @deprecated */
    calls?: WorkflowClientCallsInterceptorFactory[];
}
/**
 * Implement any of these methods to intercept {@link ScheduleClient} outbound calls
 */
export interface ScheduleClientInterceptor {
    /**
     * Intercept a service call to CreateSchedule
     */
    create?: (input: CreateScheduleInput, next: Next<this, 'create'>) => Promise<CreateScheduleOutput>;
}
/**
 * Input for {@link ScheduleClientInterceptor.create}
 */
export interface CreateScheduleInput {
    readonly headers: Headers;
    readonly options: CompiledScheduleOptions;
}
export type CreateScheduleOutput = {
    readonly conflictToken: Uint8Array;
};
/**
 * Implement any of these methods to intercept NexusClient outbound calls.
 */
export interface NexusClientInterceptor {
    /** Intercept a call to {@link NexusServiceClient.startOperation}. */
    startOperation?: (input: StartNexusOperationInput, next: Next<this, 'startOperation'>) => Promise<NexusOperationHandle>;
    /** Intercept {@link NexusOperationHandle.result}. */
    getResult?: (input: GetNexusOperationResultInput, next: Next<this, 'getResult'>) => Promise<unknown>;
    /** Intercept {@link NexusOperationHandle.describe}. */
    describe?: (input: DescribeNexusOperationInput, next: Next<this, 'describe'>) => Promise<NexusOperationExecutionDescription>;
    /** Intercept {@link NexusOperationHandle.cancel}. */
    cancel?: (input: CancelNexusOperationInput, next: Next<this, 'cancel'>) => Promise<void>;
    /** Intercept {@link NexusOperationHandle.terminate}. */
    terminate?: (input: TerminateNexusOperationInput, next: Next<this, 'terminate'>) => Promise<void>;
    /** Intercept {@link NexusClient.list}. */
    list?: (input: ListNexusOperationsInput, next: Next<this, 'list'>) => AsyncIterable<NexusOperationExecution>;
    /** Intercept {@link NexusClient.count}. */
    count?: (input: CountNexusOperationsInput, next: Next<this, 'count'>) => Promise<NexusOperationExecutionCount>;
}
/** Input for {@link NexusClientInterceptor.startOperation}. */
export interface StartNexusOperationInput {
    readonly endpoint: string;
    readonly service: string;
    readonly operation: string;
    readonly id: string;
    readonly arg: unknown;
    readonly scheduleToCloseTimeout?: Duration;
    readonly scheduleToStartTimeout?: Duration;
    readonly startToCloseTimeout?: Duration;
    readonly summary?: string;
    readonly idReusePolicy?: NexusOperationIdReusePolicy;
    readonly idConflictPolicy?: NexusOperationIdConflictPolicy;
    readonly searchAttributes?: SearchAttributePair[] | TypedSearchAttributes;
    readonly headers?: Record<string, string>;
}
/** Input for {@link NexusClientInterceptor.getResult}. */
export interface GetNexusOperationResultInput {
    readonly operationId: string;
    readonly runId?: string;
}
/** Input for {@link NexusClientInterceptor.describe}. */
export interface DescribeNexusOperationInput {
    readonly operationId: string;
    readonly runId?: string;
}
/** Input for {@link NexusClientInterceptor.cancel}. */
export interface CancelNexusOperationInput {
    readonly operationId: string;
    readonly runId?: string;
    readonly reason?: string;
}
/** Input for {@link NexusClientInterceptor.terminate}. */
export interface TerminateNexusOperationInput {
    readonly operationId: string;
    readonly runId?: string;
    readonly reason?: string;
}
/** Input for {@link NexusClientInterceptor.list}. */
export interface ListNexusOperationsInput {
    readonly query?: string;
    readonly pageSize?: number;
}
/** Input for {@link NexusClientInterceptor.count}. */
export interface CountNexusOperationsInput {
    readonly query?: string;
}
/**
 * Interceptors for any high-level SDK client.
 */
export interface ClientInterceptors {
    workflow?: WorkflowClientInterceptors | WorkflowClientInterceptor[];
    schedule?: ScheduleClientInterceptor[];
    nexus?: NexusClientInterceptor[];
    activity?: ActivityClientInterceptor[];
}
/**
 * Implement any of these methods to intercept {@link ActivityClient} outbound calls
 *
 * @experimental Standalone Activities are experimental. APIs may be subject to change.
 */
export interface ActivityClientInterceptor {
    /**
     * Intercept a service call to startActivityExecution
     */
    start?: (input: ActivityStartInput, next: Next<this, 'start'>) => Promise<ActivityHandle>;
    /**
     * Intercept a service call to pollActivityExecution
     */
    getResult?: (input: ActivityGetResultInput, next: Next<this, 'getResult'>) => Promise<any>;
    /**
     * Intercept a service call to describeActivityExecution
     */
    describe?: (input: ActivityDescribeInput, next: Next<this, 'describe'>) => Promise<ActivityExecutionDescription>;
    /**
     * Intercept a service call to requestCancelActivityExecution
     */
    cancel?: (input: ActivityCancelInput, next: Next<this, 'cancel'>) => Promise<void>;
    /**
     * Intercept a service call to terminateActivityExecution
     */
    terminate?: (input: ActivityTerminateInput, next: Next<this, 'terminate'>) => Promise<void>;
    /**
     * Intercept a service call to listActivityExecutions
     */
    list?: (input: ActivityListInput, next: Next<this, 'list'>) => AsyncIterable<ActivityExecutionInfo>;
    /**
     * Intercept a service call to countActivityExecutions
     */
    count?: (input: ActivityCountInput, next: Next<this, 'count'>) => Promise<CountActivityExecutions>;
}
/**
 * Input for {@link ActivityClientInterceptor.start}
 *
 * @experimental Standalone Activities are experimental. APIs may be subject to change.
 */
export interface ActivityStartInput {
    readonly activityType: string;
    readonly options: ActivityOptions;
    readonly headers: Headers;
}
/**
 * Input for {@link ActivityClientInterceptor.getResult}
 *
 * @experimental Standalone Activities are experimental. APIs may be subject to change.
 */
export interface ActivityGetResultInput {
    readonly activityId: string;
    readonly activityRunId: string;
    readonly headers: Headers;
}
/**
 * Input for {@link ActivityClientInterceptor.describe}
 *
 * @experimental Standalone Activities are experimental. APIs may be subject to change.
 */
export interface ActivityDescribeInput {
    readonly activityId: string;
    readonly activityRunId: string;
    readonly headers: Headers;
}
/**
 * Input for {@link ActivityClientInterceptor.cancel}
 *
 * @experimental Standalone Activities are experimental. APIs may be subject to change.
 */
export interface ActivityCancelInput {
    readonly activityId: string;
    readonly activityRunId: string;
    readonly reason: string;
    readonly headers: Headers;
}
/**
 * Input for {@link ActivityClientInterceptor.terminate}
 *
 * @experimental Standalone Activities are experimental. APIs may be subject to change.
 */
export interface ActivityTerminateInput {
    readonly activityId: string;
    readonly activityRunId: string;
    readonly reason: string;
    readonly headers: Headers;
}
/**
 * Input for {@link ActivityClientInterceptor.list}
 *
 * @experimental Standalone Activities are experimental. APIs may be subject to change.
 */
export interface ActivityListInput {
    readonly query: string;
    readonly headers: Headers;
}
/**
 * Input for {@link ActivityClientInterceptor.count}
 *
 * @experimental Standalone Activities are experimental. APIs may be subject to change.
 */
export interface ActivityCountInput {
    readonly query: string;
    readonly headers: Headers;
}