netflix-conductor-utilities/dist/types.d.ts

Netflix conductor utilities

export declare enum TaskTimeoutPolicy {
    retry = "RETRY",
    timeOutWF = "TIME_OUT_WF",
    alertOnly = "ALERT_ONLY"
}
export declare enum TaskRetryLogic {
    fixed = "FIXED",
    exponentialBackoff = "EXPONENTIAL_BACKOFF"
}
/**
 * See: https://netflix.github.io/conductor/configuration/taskdef/
 */
export interface TaskMetadataDefinition {
    /**
     * Task Type. Unique name of the Task that resonates with it's function.
     *
     * Unique
     */
    name: string;
    /**
     * Description of the task
     */
    description?: string;
    /**
     * Email of owner
     */
    ownerEmail: string;
    /**
     * No. of retries to attempt when a Task is marked as failure
     *
     * defaults to 3
     */
    retryCount?: number;
    /**
     * Mechanism for the retries
     */
    retryLogic?: TaskRetryLogic;
    /**
     * Time to wait before retries
     *
     * defaults to 60 seconds
     */
    retryDelaySeconds?: number;
    /**
     * Task's timeout policy
     */
    timeoutPolicy?: TaskTimeoutPolicy;
    /**
     * Time in seconds, after which the task is marked as TIMED_OUT if not completed after transitioning to IN_PROGRESS
     * status for the first time
     *
     * No timeouts if set to 0
     */
    timeoutSeconds?: number;
    /**
     * Must be greater than 0 and less than timeoutSeconds. The task is rescheduled if not updated with a status after
     * this time (heartbeat mechanism). Useful when the worker polls for the task but fails to complete due to
     * errors/network failure.
     *
     * defaults to 3600
     */
    responseTimeoutSeconds?: number;
    /**
     * Array of keys of task's expected input. Used for documenting task's input.
     * See [Using inputKeys and outputKeys](https://netflix.github.io/conductor/configuration/taskdef/#using-inputkeys-and-outputkeys).
     *
     */
    inputKeys?: string[];
    /**
     * Array of keys of task's expected output. Used for documenting task's output
     */
    outputKeys?: string[];
    /**
     * See [Using inputTemplate below](https://netflix.github.io/conductor/configuration/taskdef/#using-inputtemplate).
     */
    inputTemplate?: any;
    /**
     * Number of tasks that can be executed at any given time.
     */
    concurrentExecLimit?: number;
    /**
     * See [Task Rate limits below](https://netflix.github.io/conductor/configuration/taskdef/#task-rate-limits).
     */
    rateLimitPerFrequency?: number;
    /**
     * See [Task Rate limits below](https://netflix.github.io/conductor/configuration/taskdef/#task-rate-limits).
     */
    rateLimitFrequencyInSeconds?: number;
}
export interface TaskDefinition extends TaskMetadataDefinition {
    createTime?: number;
}
type AnyWorkflowTaskMetadata = WorkflowTaskMetadata | SubWorkflowTaskMetadata | DecisionTaskMetadata | DynamicForkTaskMetadata | ForkTaskMetadata | EventTaskMetadata | HTTPTaskMetadata | ExclusiveJoinTaskMetadata | JoinTaskMetadata;
/**
 * See: https://netflix.github.io/conductor/configuration/workflowdef/#workflow-definition
 */
export interface WorkflowMetadataDefinition {
    /**
     * Name of the workflow
     */
    name: string;
    /**
     * Description of the workflow
     */
    description?: string;
    /**
     * Email of owner
     */
    ownerEmail: string;
    /**
     * Numeric field used to identify the version of the schema. Use incrementing numbers
     *
     * When starting a workflow execution, if not specified, the definition with highest version is used
     */
    version?: number;
    /**
     * An array of task definitions as described below.
     */
    tasks: AnyWorkflowTaskMetadata[];
    /**
     * List of input parameters. Used for documenting the required inputs to workflow
     */
    inputParameters?: string[];
    /**
     * JSON template used to generate the output of the workflow
     *
     * If not specified, the output is defined as the output of the last executed task
     */
    outputParameters?: object;
    /**
     * String; Workflow to be run on current Workflow failure. Useful for cleanup or post actions on failure.
     */
    failureWorkflow?: string;
    /**
     * Current Conductor Schema version. schemaVersion 1 is discontinued.
     *
     * Must be 2
     */
    schemaVersion?: number;
    /**
     * Boolean flag to allow Workflow restarts
     * defaults to true
     */
    restartable?: boolean;
    /**
     * If true, every workflow that gets terminated or completed will send a notification.
     * See [below](https://netflix.github.io/conductor/configuration/workflowdef/#workflow-notifications)
     *
     * optional (false by default)
     */
    workflowStatusListenerEnabled?: boolean;
}
export interface WorkflowDefinition extends WorkflowMetadataDefinition {
    createTime?: number;
}
export declare enum WorkflowTaskType {
    simple = "SIMPLE",
    subWorkflow = "SUB_WORKFLOW",
    decision = "DECISION",
    event = "EVENT",
    http = "HTTP",
    forkJoin = "FORK_JOIN",
    forkJoinDynamic = "FORK_JOIN_DYNAMIC",
    join = "JOIN",
    exclusiveJoin = "EXCLUSIVE_JOIN",
    wait = "WAIT",
    dynamic = "DYNAMIC",
    lambda = "LAMBDA",
    terminate = "TERMINATE",
    kafkaPublish = "KAFKA_PUBLISH",
    doWhile = "DO_WHILE"
}
export interface WorkflowTaskMetadata {
    /**
     * Name of the task. MUST be registered as a task with Conductor before starting the workflow
     */
    name: string;
    /**
     * Alias used to refer the task within the workflow. MUST be unique within workflow.
     */
    taskReferenceName: string;
    /**
     * Type of task. SIMPLE for tasks executed by remote workers, or one of the system task types
     */
    type: WorkflowTaskType;
    /**
     * Description of the task
     */
    description?: string;
    /**
     * true or false. When set to true - workflow continues even if the task fails. The status of the task is reflected
     * as COMPLETED_WITH_ERRORS
     *
     * Defaults to false
     */
    optional?: boolean;
    /**
     * JSON template that defines the input given to the task
     *
     * See [Wiring Inputs and Outputs for details](https://netflix.github.io/conductor/configuration/workflowdef/#wiring-inputs-and-outputs)
     */
    inputParameters?: object;
    /**
     * See [Task Domains for more information](https://netflix.github.io/conductor/configuration/taskdomains/).
     */
    domain?: object;
}
/**
 * See [Sub Workflow](https://netflix.github.io/conductor/configuration/systask/#sub-workflow)
 */
export interface SubWorkflowTaskMetadata extends WorkflowTaskMetadata {
    subWorkflowParam: {
        name: string;
        version?: number;
        taskToDomain?: object;
    };
}
export interface DecisionCaseMap {
    [caseName: string]: AnyWorkflowTaskMetadata[];
}
/**
 * See [Decision](https://netflix.github.io/conductor/configuration/systask/#decision)
 */
export interface DecisionTaskMetadata extends WorkflowTaskMetadata {
    caseValueParam: string;
    decisionCases: DecisionCaseMap;
    defaultCase?: AnyWorkflowTaskMetadata[];
    caseExpression: string;
}
/**
 * See [Dynamic Fork](https://netflix.github.io/conductor/configuration/systask/#dynamic-fork)
 */
export interface DynamicForkTaskMetadata extends WorkflowTaskMetadata {
    dynamicForkTasksParam: string;
    dynamicForkTasksInputParamName: string;
}
/**
 * See [Fork](https://netflix.github.io/conductor/configuration/systask/#fork)
 */
export interface ForkTaskMetadata extends WorkflowTaskMetadata {
    forkTasks: AnyWorkflowTaskMetadata[][];
}
/**
 * See [Event](https://netflix.github.io/conductor/configuration/systask/#event)
 */
export interface EventTaskMetadata extends WorkflowTaskMetadata {
    sink: string;
    asyncComplete: boolean;
}
/**
 * See [HTTP](https://netflix.github.io/conductor/configuration/systask/#http)
 */
export interface HTTPTaskMetadata extends WorkflowTaskMetadata {
    http_request: {
        uri: string;
        method: string;
        accept?: string;
        contentType?: string;
        headers?: object;
        body?: any;
        vipAddress?: string;
        asyncComplete?: boolean;
    };
}
/**
 * See [Join](https://netflix.github.io/conductor/configuration/systask/#join)
 */
export interface JoinTaskMetadata extends WorkflowTaskMetadata {
    joinOn: string[];
}
/**
 * See [Exclusive Join](https://netflix.github.io/conductor/configuration/systask/#exclusive-join)
 */
export interface ExclusiveJoinTaskMetadata extends WorkflowTaskMetadata {
    joinOn: string[];
    defaultExclusiveJoinTask: string[];
}
export interface WorkflowTask extends WorkflowTaskMetadata {
    startDelay: number;
    taskDefinition: TaskDefinition;
    asyncComplete: boolean;
}
export declare enum WorkflowStatus {
    running = "RUNNING",
    completed = "COMPLETED",
    failed = "FAILED",
    timedOut = "TIMED_OUT",
    terminated = "TERMINATED",
    paused = "PAUSED"
}
export interface Workflow<INPUT = any, OUTPUT = any> {
    createTime: number;
    endTime: number;
    priority: number;
    schemaVersion: number;
    startTime: number;
    status: WorkflowStatus;
    updateTime: number;
    version: number;
    workflowDefinition: WorkflowDefinition;
    workflowId: string;
    workflowName: string;
    workflowType: string;
    workflowVersion: number;
    tasks: Task[];
    input?: INPUT;
    output?: OUTPUT;
}
export interface Task {
    callbackAfterSeconds: number;
    callbackFromWorker: boolean;
    endTime: number;
    executed: boolean;
    pollCount: number;
    queueWaitTime: number;
    rateLimitFrequencyInSeconds: number;
    rateLimitPerFrequency: number;
    referenceTaskName: string;
    responseTimeoutSeconds: number;
    retried: boolean;
    retryCount: number;
    scheduledTime: number;
    seq: number;
    startDelayInSeconds: number;
    startTime: number;
    status: TaskState;
    taskDefinition: TaskDefinition;
    taskDefName: string;
    taskId: string;
    taskStatus: TaskState;
    taskType: string;
    updateTime: 0;
    workflowInstanceId: string;
    workflowPriority: number;
    workflowTask: WorkflowTask;
    workflowType: number;
}
export interface PollTask {
    taskType: string;
    status: TaskState;
    inputData?: any;
    referenceTaskName: string;
    retryCount: number;
    seq: number;
    correlationId: string;
    pollCount: number;
    taskDefName: string;
    scheduledTime: number;
    startTime: number;
    endTime: number;
    updateTime: number;
    startDelayInSeconds: number;
    retried: boolean;
    executed: boolean;
    callbackFromWorker: boolean;
    responseTimeoutSeconds: number;
    workflowInstanceId: string;
    workflowType: string;
    taskId: string;
    callbackAfterSeconds: number;
    workerId: string;
    workflowTask: WorkflowTask;
    rateLimitPerFrequency: number;
    rateLimitFrequencyInSeconds: number;
    workflowPriority: number;
    taskDefinition: TaskDefinition;
    queueWaitTime: number;
    taskStatus: TaskState;
}
export declare enum TaskState {
    scheduled = "SCHEDULED",
    inProgress = "IN_PROGRESS",
    failed = "FAILED",
    completed = "COMPLETED",
    cancelled = "CANCELLED",
    timedOut = "TIMED_OUT",
    skipped = "SKIPPED"
}
export interface RunningTaskCoreInfo {
    workflowInstanceId: string;
    taskId: string;
}
export interface UpdatingTaskResult<Result = any> extends RunningTaskCoreInfo {
    status: TaskState;
    callbackAfterSeconds: number;
    reasonForIncompletion?: string;
    outputData?: Result;
    logs?: {
        log: string;
        createdTime: number;
    }[];
}
export interface ConductorSDKOptions {
    apiEndpoint?: string;
}
/**
 * See https://netflix.github.io/conductor/apispec/#start-workflow-request
 */
export interface StartWorkflowOptions {
    /**
     * Name of the workflow
     */
    name: string;
    /**
     * Version
     */
    version?: number;
    /**
     *  correlation Id
     */
    correlationId?: string;
    /**
     * Priority
     */
    priority?: number;
    input?: object;
    taskToDomain?: object;
}
export {};