rest-pipeline-js 1.0.5 → 1.0.6

package/README.md

@@ -1,5 +1,8 @@
+## Утсновка
 
-
+```sh
+npm i rest-pipeline-js
+```
 
 ## Возможности и API
 

package/dist/pipeline-orchestrator.d.ts

@@ -1,31 +1,127 @@
-import type { PipelineConfig, PipelineResult } from './types';
+import type { PipelineConfig } from './types';
+/**
+ * Событие шага pipeline (для хуков)
+ */
+export type PipelineStepEvent = {
+    /** Индекс шага */
+    stepIndex: number;
+    /** Ключ шага */
+    stepKey: string;
+    /** Статус шага */
+    status: import('./types').PipelineStepStatus;
+    /** Данные результата (если успех) */
+    data?: any;
+    /** Ошибка (если error) */
+    error?: import('./types').ApiError;
+    /** Снимок всех результатов на момент события */
+    stageResults: Record<string, import('./types').PipelineStepResult>;
+};
+/**
+ * Callback для подписки на события этапов pipeline
+ */
+export type PipelineStepEventHandler = (event: PipelineStepEvent) => void | Promise<void>;
 export declare class PipelineOrchestrator {
-    private config;
     private progress;
     private errorHandler;
     private executor;
     private sharedData;
-    constructor(config: PipelineConfig, httpConfig: import('./types').HttpConfig, sharedData?: Record<string, unknown>);
+    private onStepStartHandlers;
+    private onStepFinishHandlers;
+    private onStepErrorHandlers;
+    /** Универсальные подписчики событий: ключ — имя события */
+    private eventHandlers;
+    /** Встроенные логи */
+    private logs;
+    private stageResults;
+    private stageResultsListeners;
+    private autoReset;
+    /** AbortController для отмены пайплайна */
+    private abortController;
+    private config;
+    constructor(config: PipelineConfig, httpConfig: import('./types').HttpConfig, sharedData?: Record<string, unknown>, options?: {
+        autoReset?: boolean;
+    });
+    /**
+     * Подписка на изменения stageResults (реактивно)
+     */
+    subscribeStageResults(listener: (results: Record<string, import('./types').PipelineStepResult>) => void): () => void;
+    /**
+     * Универсальная подписка на события: step:<key>, progress, log и др.
+     */
+    on(event: string, handler: (...args: any[]) => void | Promise<void>): () => void;
+    /**
+     * Вызов всех обработчиков события
+     */
+    private emit;
+    /**
+     * Получить логи пайплайна
+     */
+    getLogs(): {
+        type: string;
+        message: string;
+        data?: any;
+        timestamp: Date;
+    }[];
+    private notifyStageResults;
+    /**
+     * Повторно выполнить только один шаг пайплайна (без полного рестарта)
+     * @param stepKey ключ шага
+     * @param options дополнительные опции (например, onStepPause, externalSignal)
+     */
+    rerunStep(stepKey: string, options?: {
+        onStepPause?: (stepIndex: number, stepResult: unknown, stageResults: Record<string, import('./types').PipelineStepResult>) => Promise<unknown> | unknown;
+        externalSignal?: AbortSignal;
+    }): Promise<import('./types').PipelineStepResult | undefined>;
+    /**
+     * Отменить выполнение пайплайна (вызывает ошибку AbortError)
+     */
+    abort(): void;
+    /**
+     * Проверить, был ли пайплайн отменён
+     */
+    isAborted(): boolean;
+    /**
+     * Подписка на событие начала шага
+     */
+    onStepStart(handler: PipelineStepEventHandler): () => void;
+    /**
+     * Подписка на событие успешного завершения шага
+     */
+    onStepFinish(handler: PipelineStepEventHandler): () => void;
+    /**
+     * Подписка на событие ошибки шага
+     */
+    onStepError(handler: PipelineStepEventHandler): () => void;
+    private emitStepStart;
+    private emitStepFinish;
+    private emitStepError;
     /**
      * Подписаться на изменения прогресса выполнения pipeline
      * @param listener функция-обработчик изменений
      * @returns функция для отписки
      */
     subscribeProgress(listener: (progress: import('./types').PipelineProgress) => void): () => void;
+    /**
+     * Подписка на прогресс с фильтрацией по этапу (stepKey) или общий
+     */
+    subscribeStepProgress(stepKey: string, listener: (status: import('./types').PipelineStepStatus) => void): () => void;
     /**
      * Получить текущий прогресс выполнения pipeline (snapshot, не реактивный)
      */
     getProgress(): {
         currentStage: number;
         totalStages: number;
-        stageStatuses: Array<"pending" | "in-progress" | "success" | "error" | "skipped">;
+        stageStatuses: Array<import("./types").PipelineStepStatus>;
     };
     /**
-     * @param onStepPause
-     *   Необязательный callback, вызывается после каждого шага (до перехода к следующему).
-     *   Позволяет приостановить выполнение, запросить подтверждение пользователя или изменить результат шага.
-     *   Должен вернуть (optionally изменённый) результат шага или промис с ним.
-     *   Если не передан — пайплайн работает как раньше.
+     * Возвращает текущий снимок состояния прогресса (не реактивный).
+     * Для отслеживания изменений используйте subscribeProgress.
+     */
+    getProgressRef(): import("./types").PipelineProgress;
+    /**
+     * Запустить выполнение пайплайна
+     * @param onStepPause callback для пользовательской паузы между шагами
+     * @param externalSignal внешний AbortSignal (опционально)
      */
-    run(onStepPause?: (stepIndex: number, stepResult: unknown, results: unknown[]) => Promise<unknown> | unknown): Promise<PipelineResult>;
+    run(onStepPause?: (stepIndex: number, stepResult: unknown, stageResults: Record<string, import('./types').PipelineStepResult>) => Promise<unknown> | unknown, externalSignal?: AbortSignal): Promise<import('./types').PipelineResult>;
 }

package/dist/pipeline-orchestrator.js

@@ -4,14 +4,204 @@ exports.PipelineOrchestrator = void 0;
 const error_handler_1 = require("./error-handler");
 const progress_tracker_1 = require("./progress-tracker");
 const request_executor_1 = require("./request-executor");
-// import { metricsBus } from '@/core/metrics/metrics-bus';
 class PipelineOrchestrator {
-    constructor(config, httpConfig, sharedData = {}) {
+    constructor(config, httpConfig, sharedData = {}, options = {}) {
+        var _a;
+        this.onStepStartHandlers = [];
+        this.onStepFinishHandlers = [];
+        this.onStepErrorHandlers = [];
+        /** Универсальные подписчики событий: ключ — имя события */
+        this.eventHandlers = {};
+        /** Встроенные логи */
+        this.logs = [];
+        this.stageResults = {};
+        this.stageResultsListeners = [];
+        /** AbortController для отмены пайплайна */
+        this.abortController = null;
         this.config = config;
         this.progress = new progress_tracker_1.ProgressTracker(config.stages.length);
         this.errorHandler = new error_handler_1.ErrorHandler();
         this.executor = new request_executor_1.RequestExecutor(httpConfig);
         this.sharedData = sharedData;
+        this.autoReset = (_a = options.autoReset) !== null && _a !== void 0 ? _a : false;
+    }
+    /**
+     * Подписка на изменения stageResults (реактивно)
+     */
+    subscribeStageResults(listener) {
+        this.stageResultsListeners.push(listener);
+        // Немедленно уведомляем нового подписчика о текущем состоянии
+        listener({ ...this.stageResults });
+        return () => {
+            this.stageResultsListeners = this.stageResultsListeners.filter(l => l !== listener);
+        };
+    }
+    /**
+     * Универсальная подписка на события: step:<key>, progress, log и др.
+     */
+    on(event, handler) {
+        if (!this.eventHandlers[event])
+            this.eventHandlers[event] = [];
+        this.eventHandlers[event].push(handler);
+        return () => {
+            this.eventHandlers[event] = this.eventHandlers[event].filter(h => h !== handler);
+        };
+    }
+    /**
+     * Вызов всех обработчиков события
+     */
+    async emit(event, ...args) {
+        if (this.eventHandlers[event]) {
+            for (const handler of this.eventHandlers[event]) {
+                await handler(...args);
+            }
+        }
+    }
+    /**
+     * Получить логи пайплайна
+     */
+    getLogs() {
+        return [...this.logs];
+    }
+    notifyStageResults() {
+        for (const listener of this.stageResultsListeners) {
+            listener({ ...this.stageResults });
+        }
+    }
+    /**
+     * Повторно выполнить только один шаг пайплайна (без полного рестарта)
+     * @param stepKey ключ шага
+     * @param options дополнительные опции (например, onStepPause, externalSignal)
+     */
+    async rerunStep(stepKey, options) {
+        var _a;
+        const i = this.config.stages.findIndex(s => s.key === stepKey);
+        if (i === -1)
+            return undefined;
+        const stage = this.config.stages[i];
+        const key = stage.key;
+        const signal = options === null || options === void 0 ? void 0 : options.externalSignal;
+        this.logs.push({ type: 'log', message: `rerunStep:${key}:start`, timestamp: new Date(), data: { stepIndex: i } });
+        await this.emit('log', { type: 'rerunStep:start', stepKey: key, stepIndex: i });
+        this.stageResults[key] = { status: 'pending' };
+        this.notifyStageResults();
+        this.progress.updateStage(i, 'loading');
+        await this.emitStepStart({ stepIndex: i, stepKey: key, status: 'loading', stageResults: { ...this.stageResults } });
+        await this.emit(`step:${key}:start`, { stepIndex: i, stepKey: key, status: 'loading', stageResults: { ...this.stageResults } });
+        try {
+            let stepResult;
+            if (typeof stage.request === 'function') {
+                stepResult = await stage.request(i > 0 ? (_a = this.stageResults[this.config.stages[i - 1].key]) === null || _a === void 0 ? void 0 : _a.data : undefined, this.stageResults);
+            }
+            else {
+                const res = await this.executor.execute(stage.key, undefined, stage.retryCount, stage.timeoutMs);
+                stepResult = res.data;
+            }
+            if (options === null || options === void 0 ? void 0 : options.onStepPause) {
+                stepResult = await options.onStepPause(i, stepResult, this.stageResults);
+            }
+            this.stageResults[key] = { status: 'success', data: stepResult };
+            this.notifyStageResults();
+            this.progress.updateStage(i, 'success');
+            await this.emitStepFinish({ stepIndex: i, stepKey: key, status: 'success', data: stepResult, stageResults: { ...this.stageResults } });
+            await this.emit(`step:${key}:success`, { stepIndex: i, stepKey: key, status: 'success', data: stepResult, stageResults: { ...this.stageResults } });
+            this.logs.push({ type: 'log', message: `rerunStep:${key}:success`, timestamp: new Date(), data: { stepIndex: i, data: stepResult } });
+            await this.emit('log', { type: 'rerunStep:success', stepKey: key, stepIndex: i, data: stepResult });
+            return this.stageResults[key];
+        }
+        catch (err) {
+            let handled;
+            if (stage && typeof stage.errorHandler === 'function') {
+                handled = stage.errorHandler(err, stage.key, this.sharedData);
+            }
+            else if (stage) {
+                handled = this.errorHandler.handle(err, stage.key);
+            }
+            else {
+                handled = this.errorHandler.handle(err, 'unknown');
+            }
+            if (!handled && stage) {
+                handled = this.errorHandler.handle(err, stage.key);
+            }
+            const { toApiError } = await import('./rest-client.js');
+            const apiError = toApiError(handled !== null && handled !== void 0 ? handled : err);
+            this.stageResults[key] = { status: 'error', error: apiError };
+            this.notifyStageResults();
+            this.progress.updateStage(i, 'error');
+            await this.emitStepError({ stepIndex: i, stepKey: key, status: 'error', error: apiError, stageResults: { ...this.stageResults } });
+            await this.emit(`step:${key}:error`, { stepIndex: i, stepKey: key, status: 'error', error: apiError, stageResults: { ...this.stageResults } });
+            this.logs.push({ type: 'error', message: `rerunStep:${key}:error`, timestamp: new Date(), data: { stepIndex: i, error: apiError } });
+            await this.emit('log', { type: 'rerunStep:error', stepKey: key, stepIndex: i, error: apiError });
+            return this.stageResults[key];
+        }
+    }
+    /**
+     * Отменить выполнение пайплайна (вызывает ошибку AbortError)
+     */
+    abort() {
+        if (this.abortController) {
+            this.abortController.abort();
+        }
+    }
+    /**
+     * Проверить, был ли пайплайн отменён
+     */
+    isAborted() {
+        var _a, _b;
+        return (_b = (_a = this.abortController) === null || _a === void 0 ? void 0 : _a.signal.aborted) !== null && _b !== void 0 ? _b : false;
+    }
+    /**
+     * Подписка на событие начала шага
+     */
+    onStepStart(handler) {
+        this.onStepStartHandlers.push(handler);
+        return () => {
+            this.onStepStartHandlers = this.onStepStartHandlers.filter(h => h !== handler);
+        };
+    }
+    /**
+     * Подписка на событие успешного завершения шага
+     */
+    onStepFinish(handler) {
+        this.onStepFinishHandlers.push(handler);
+        return () => {
+            this.onStepFinishHandlers = this.onStepFinishHandlers.filter(h => h !== handler);
+        };
+    }
+    /**
+     * Подписка на событие ошибки шага
+     */
+    onStepError(handler) {
+        this.onStepErrorHandlers.push(handler);
+        return () => {
+            this.onStepErrorHandlers = this.onStepErrorHandlers.filter(h => h !== handler);
+        };
+    }
+    async emitStepStart(event) {
+        for (const handler of this.onStepStartHandlers) {
+            await handler(event);
+        }
+        // Гибкая подписка на step:<key>:start
+        await this.emit(`step:${event.stepKey}:start`, event);
+        // Логирование
+        this.logs.push({ type: 'log', message: `step:${event.stepKey}:start`, timestamp: new Date(), data: event });
+        await this.emit('log', { type: 'step:start', ...event });
+    }
+    async emitStepFinish(event) {
+        for (const handler of this.onStepFinishHandlers) {
+            await handler(event);
+        }
+        await this.emit(`step:${event.stepKey}:success`, event);
+        this.logs.push({ type: 'log', message: `step:${event.stepKey}:success`, timestamp: new Date(), data: event });
+        await this.emit('log', { type: 'step:success', ...event });
+    }
+    async emitStepError(event) {
+        for (const handler of this.onStepErrorHandlers) {
+            await handler(event);
+        }
+        await this.emit(`step:${event.stepKey}:error`, event);
+        this.logs.push({ type: 'error', message: `step:${event.stepKey}:error`, timestamp: new Date(), data: event });
+        await this.emit('log', { type: 'step:error', ...event });
     }
     /**
      * Подписаться на изменения прогресса выполнения pipeline
@@ -21,6 +211,12 @@ class PipelineOrchestrator {
     subscribeProgress(listener) {
         return this.progress.subscribe(listener);
     }
+    /**
+     * Подписка на прогресс с фильтрацией по этапу (stepKey) или общий
+     */
+    subscribeStepProgress(stepKey, listener) {
+        return this.on(`step:${stepKey}:progress`, listener);
+    }
     /**
      * Получить текущий прогресс выполнения pipeline (snapshot, не реактивный)
      */
@@ -28,35 +224,82 @@ class PipelineOrchestrator {
         return this.progress.getProgress();
     }
     /**
-     * @param onStepPause
-     *   Необязательный callback, вызывается после каждого шага (до перехода к следующему).
-     *   Позволяет приостановить выполнение, запросить подтверждение пользователя или изменить результат шага.
-     *   Должен вернуть (optionally изменённый) результат шага или промис с ним.
-     *   Если не передан — пайплайн работает как раньше.
+     * Возвращает текущий снимок состояния прогресса (не реактивный).
+     * Для отслеживания изменений используйте subscribeProgress.
      */
-    async run(onStepPause) {
-        const results = [];
-        const errors = [];
+    getProgressRef() {
+        return this.progress.getProgressRef();
+    }
+    /**
+     * Запустить выполнение пайплайна
+     * @param onStepPause callback для пользовательской паузы между шагами
+     * @param externalSignal внешний AbortSignal (опционально)
+     */
+    async run(onStepPause, externalSignal) {
+        var _a, _b, _c;
+        if (this.autoReset) {
+            this.stageResults = {};
+            this.notifyStageResults();
+        }
         let success = true;
+        // Создаём новый AbortController для этого запуска
+        this.abortController = new AbortController();
+        const signal = externalSignal !== null && externalSignal !== void 0 ? externalSignal : this.abortController.signal;
         for (let i = 0; i < this.config.stages.length; i++) {
+            if (signal.aborted) {
+                // Прерываем выполнение, если был вызван abort
+                const { toApiError } = await import('./rest-client.js');
+                const apiError = toApiError({ message: 'Pipeline aborted', code: 'ABORTED' });
+                const key = ((_a = this.config.stages[i]) === null || _a === void 0 ? void 0 : _a.key) || `stage${i}`;
+                this.stageResults[key] = { status: 'error', error: apiError };
+                this.notifyStageResults();
+                this.progress.updateStage(i, 'error');
+                this.logs.push({ type: 'error', message: `abort:${key}`, timestamp: new Date(), data: { stepIndex: i, error: apiError } });
+                await this.emit('log', { type: 'abort', stepKey: key, stepIndex: i, error: apiError });
+                await this.emitStepError({
+                    stepIndex: i,
+                    stepKey: key,
+                    status: 'error',
+                    error: apiError,
+                    stageResults: { ...this.stageResults },
+                });
+                success = false;
+                break;
+            }
             const stage = this.config.stages[i];
-            this.progress.updateStage(i, 'in-progress');
+            const key = (stage === null || stage === void 0 ? void 0 : stage.key) || `stage${i}`;
+            this.stageResults[key] = { status: 'pending' };
+            this.notifyStageResults();
+            this.progress.updateStage(i, 'loading');
+            // Гибкая подписка на прогресс шага
+            await this.emit(`step:${key}:progress`, 'loading');
+            // emit step start
+            await this.emitStepStart({
+                stepIndex: i,
+                stepKey: key,
+                status: 'loading',
+                stageResults: { ...this.stageResults },
+            });
             if (!stage) {
                 this.progress.updateStage(i, 'skipped');
-                results.push(undefined);
+                this.stageResults[key] = { status: 'skipped' };
+                this.notifyStageResults();
+                await this.emit(`step:${key}:progress`, 'skipped');
                 continue;
             }
             // Проверка условия выполнения этапа
-            if (stage.condition && !stage.condition(results[i - 1], results, this.sharedData)) {
+            if (stage.condition && !stage.condition(i > 0 ? (_b = this.stageResults[this.config.stages[i - 1].key]) === null || _b === void 0 ? void 0 : _b.data : undefined, this.stageResults, this.sharedData)) {
                 this.progress.updateStage(i, 'skipped');
-                results.push(undefined);
+                this.stageResults[key] = { status: 'skipped' };
+                this.notifyStageResults();
+                await this.emit(`step:${key}:progress`, 'skipped');
                 continue;
             }
             try {
                 let stepResult;
                 // Всегда передаём (prev, allResults) в request — best practice для pipeline
                 if (typeof stage.request === 'function') {
-                    stepResult = await stage.request(results[i - 1], results);
+                    stepResult = await stage.request(i > 0 ? (_c = this.stageResults[this.config.stages[i - 1].key]) === null || _c === void 0 ? void 0 : _c.data : undefined, this.stageResults);
                 }
                 else if (stage.key) {
                     const res = await this.executor.execute(stage.key, undefined, stage.retryCount, stage.timeoutMs);
@@ -67,11 +310,20 @@ class PipelineOrchestrator {
                 }
                 // --- Пользовательская пауза/подтверждение/изменение результата ---
                 if (onStepPause) {
-                    stepResult = await onStepPause(i, stepResult, results);
+                    stepResult = await onStepPause(i, stepResult, this.stageResults);
                 }
-                results.push(stepResult);
+                this.stageResults[key] = { status: 'success', data: stepResult };
+                this.notifyStageResults();
                 this.progress.updateStage(i, 'success');
-                // ...existing code...
+                await this.emit(`step:${key}:progress`, 'success');
+                // emit step finish
+                await this.emitStepFinish({
+                    stepIndex: i,
+                    stepKey: key,
+                    status: 'success',
+                    data: stepResult,
+                    stageResults: { ...this.stageResults },
+                });
             }
             catch (err) {
                 let handled;
@@ -87,13 +339,26 @@ class PipelineOrchestrator {
                 if (!handled && stage) {
                     handled = this.errorHandler.handle(err, stage.key);
                 }
-                errors.push(handled);
+                // Унификация: всегда ApiError
+                const { toApiError } = await import('./rest-client.js');
+                const apiError = toApiError(handled !== null && handled !== void 0 ? handled : err);
+                this.stageResults[key] = { status: 'error', error: apiError };
+                this.notifyStageResults();
                 this.progress.updateStage(i, 'error');
+                await this.emit(`step:${key}:progress`, 'error');
+                // emit step error
+                await this.emitStepError({
+                    stepIndex: i,
+                    stepKey: key,
+                    status: 'error',
+                    error: apiError,
+                    stageResults: { ...this.stageResults },
+                });
                 success = false;
                 break;
             }
         }
-        return { results, errors, success };
+        return { stageResults: { ...this.stageResults }, success };
     }
 }
 exports.PipelineOrchestrator = PipelineOrchestrator;

package/dist/progress-tracker.d.ts

@@ -4,11 +4,16 @@ export declare class ProgressTracker {
     private progress;
     private listeners;
     constructor(totalStages: number);
+    /**
+     * Возвращает текущий снимок состояния прогресса (не реактивный).
+     * Для отслеживания изменений используйте subscribeProgress.
+     */
+    getProgressRef(): PipelineProgress;
     updateStage(stage: number, status: PipelineProgress['stageStatuses'][number]): void;
     getProgress(): {
         currentStage: number;
         totalStages: number;
-        stageStatuses: Array<"pending" | "in-progress" | "success" | "error" | "skipped">;
+        stageStatuses: Array<import("./types").PipelineStepStatus>;
     };
     subscribe(listener: ProgressListener): () => void;
     private notify;

package/dist/progress-tracker.js

@@ -10,6 +10,13 @@ class ProgressTracker {
             stageStatuses: Array(totalStages).fill('pending'),
         };
     }
+    /**
+     * Возвращает текущий снимок состояния прогресса (не реактивный).
+     * Для отслеживания изменений используйте subscribeProgress.
+     */
+    getProgressRef() {
+        return this.progress;
+    }
     updateStage(stage, status) {
         this.progress.stageStatuses[stage] = status;
         this.progress.currentStage = stage;

package/dist/types.d.ts

@@ -63,24 +63,64 @@ export type RestRequestConfig = import('axios').AxiosRequestConfig & {
     skipRateLimit?: boolean;
     requestId?: string;
 };
-export type PipelineStageConfig<Input, Output> = {
+/**
+ * Конфиг одного шага (этапа) pipeline
+ * @template Input Тип входных данных шага
+ * @template Output Тип результата шага
+ */
+export type PipelineStageConfig<Input = any, Output = any> = {
+    /** Уникальный ключ шага */
     key: string;
-    request: (input: Input, allResults?: any) => Promise<Output>;
-    condition?: (input: Input, prevResults: any, sharedData?: Record<string, any>) => boolean;
+    /** Асинхронная функция-запрос шага */
+    request: (input: Input, allResults?: Record<string, PipelineStepResult>) => Promise<Output>;
+    /** Условие выполнения шага */
+    condition?: (input: Input, prevResults: Record<string, PipelineStepResult>, sharedData?: Record<string, any>) => boolean;
+    /** Количество попыток при ошибке */
     retryCount?: number;
+    /** Таймаут шага (мс) */
     timeoutMs?: number;
+    /** Обработчик ошибок шага */
     errorHandler?: (error: any, stageKey: string, sharedData?: Record<string, any>) => any;
 };
+/**
+ * Статус выполнения шага pipeline
+ */
+export type PipelineStepStatus = 'pending' | 'loading' | 'success' | 'error' | 'skipped';
+/**
+ * Результат выполнения шага pipeline
+ */
+export type PipelineStepResult = {
+    /** Статус шага */
+    status: PipelineStepStatus;
+    /** Данные результата (если успех) */
+    data?: any;
+    /** Ошибка (если error) */
+    error?: import('./types').ApiError;
+};
+/**
+ * Конфиг всего pipeline (массив этапов)
+ */
 export type PipelineConfig = {
-    stages: PipelineStageConfig<any, any>[];
+    stages: PipelineStageConfig[];
 };
+/**
+ * Прогресс выполнения pipeline
+ */
 export type PipelineProgress = {
     currentStage: number;
     totalStages: number;
-    stageStatuses: Array<'pending' | 'in-progress' | 'success' | 'error' | 'skipped'>;
+    stageStatuses: Array<PipelineStepStatus>;
 };
+/**
+ * Результаты всех шагов pipeline (ключ — имя шага)
+ */
+export type PipelineStageResults = Record<string, PipelineStepResult>;
+/**
+ * Итоговый результат выполнения pipeline
+ */
 export type PipelineResult = {
-    results: any[];
-    errors: any[];
+    /** Результаты по шагам */
+    stageResults: PipelineStageResults;
+    /** true, если pipeline завершился успешно */
     success: boolean;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rest-pipeline-js",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "Pipeline Orchestration Utilities for JavaScript REST API Clients",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",