rest-pipeline-js 1.2.5 → 1.2.6

package/dist/cjs/error-handler.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorHandler = void 0;
+class ErrorHandler {
+    handle(error, _stageKey) {
+        return {
+            message: error instanceof Error ? error.message : String(error !== null && error !== void 0 ? error : 'Unknown error'),
+            status: typeof (error === null || error === void 0 ? void 0 : error.status) === 'number' ? error.status : undefined,
+        };
+    }
+}
+exports.ErrorHandler = ErrorHandler;

package/dist/cjs/index.js

@@ -0,0 +1,23 @@
+"use strict";
+// Barrel file for pipeline-js module (core only — no Vue/React)
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./rest-client"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./request-executor"), exports);
+__exportStar(require("./error-handler"), exports);
+__exportStar(require("./progress-tracker"), exports);
+__exportStar(require("./pipeline-orchestrator"), exports);

package/dist/cjs/pipeline-orchestrator.js

@@ -0,0 +1,565 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+const rest_client_1 = require("./rest-client");
+class PipelineOrchestrator {
+    constructor(params) {
+        var _a, _b, _c, _d;
+        this.onStepStartHandlers = [];
+        this.onStepFinishHandlers = [];
+        this.onStepErrorHandlers = [];
+        /** Универсальные подписчики событий: ключ — имя события */
+        this.eventHandlers = {};
+        /** Встроенные логи */
+        this.logs = [];
+        this.stageResults = {};
+        this.stageResultsListeners = [];
+        /** AbortController для отмены пайплайна */
+        this.abortController = null;
+        this.config = params.config;
+        this.progress = new progress_tracker_1.ProgressTracker(params.config.stages.length);
+        this.errorHandler = new error_handler_1.ErrorHandler();
+        this.executor = new request_executor_1.RequestExecutor((_a = params.httpConfig) !== null && _a !== void 0 ? _a : {});
+        this.sharedData = (_b = params.sharedData) !== null && _b !== void 0 ? _b : {};
+        this.autoReset = (_d = (_c = params.options) === null || _c === void 0 ? void 0 : _c.autoReset) !== null && _d !== void 0 ? _d : 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, _b;
+        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,
+        });
+        // Получаем url для шага, аналогично run
+        let stepUrl = undefined;
+        if (typeof stage.request === "string") {
+            stepUrl = stage.request;
+        }
+        else if (typeof stage.request === "function") {
+            try {
+                const reqResult = await stage.request({
+                    prev: i > 0
+                        ? (_a = this.stageResults[this.config.stages[i - 1].key]) === null || _a === void 0 ? void 0 : _a.data
+                        : undefined,
+                    allResults: this.stageResults,
+                    sharedData: this.sharedData,
+                });
+                if (typeof reqResult === "string") {
+                    stepUrl = reqResult;
+                }
+            }
+            catch {
+                // ignore errors here, url не обязателен
+            }
+        }
+        else {
+            stepUrl = key;
+        }
+        this.stageResults[key] = { status: "pending", url: stepUrl };
+        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({
+                    prev: i > 0
+                        ? (_b = this.stageResults[this.config.stages[i - 1].key]) === null || _b === void 0 ? void 0 : _b.data
+                        : undefined,
+                    allResults: this.stageResults,
+                    sharedData: this.sharedData,
+                });
+            }
+            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",
+                url: stepUrl,
+                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({
+                    error: err,
+                    key: stage.key,
+                    sharedData: 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 apiError = (0, rest_client_1.toApiError)(handled !== null && handled !== void 0 ? handled : err);
+            this.stageResults[key] = {
+                status: "error",
+                url: stepUrl,
+                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
+     * @param listener функция-обработчик изменений
+     * @returns функция для отписки
+     */
+    subscribeProgress(listener) {
+        return this.progress.subscribe(listener);
+    }
+    /**
+     * Подписка на прогресс с фильтрацией по этапу (stepKey) или общий
+     */
+    subscribeStepProgress(stepKey, listener) {
+        return this.on(`step:${stepKey}:progress`, listener);
+    }
+    /**
+     * Получить текущий прогресс выполнения pipeline (snapshot, не реактивный)
+     */
+    getProgress() {
+        return this.progress.getProgress();
+    }
+    /**
+     * Возвращает текущий снимок состояния прогресса (не реактивный).
+     * Для отслеживания изменений используйте subscribeProgress.
+     */
+    getProgressRef() {
+        return this.progress.getProgressRef();
+    }
+    /**
+     * Запустить выполнение пайплайна
+     * @param onStepPause callback для пользовательской паузы между шагами
+     * @param externalSignal внешний AbortSignal (опционально)
+     */
+    async run(onStepPause, externalSignal) {
+        var _a, _b, _c, _d, _e;
+        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 apiError = (0, rest_client_1.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];
+            const key = (stage === null || stage === void 0 ? void 0 : stage.key) || `stage${i}`;
+            // Получаем url команды для шага
+            let stepUrl = undefined;
+            if (typeof stage.request === "string") {
+                stepUrl = stage.request;
+            }
+            else if (typeof stage.request === "function") {
+                try {
+                    const reqResult = await stage.request({
+                        prev: i > 0
+                            ? (_b = this.stageResults[this.config.stages[i - 1].key]) === null || _b === void 0 ? void 0 : _b.data
+                            : undefined,
+                        allResults: this.stageResults,
+                        sharedData: this.sharedData,
+                    });
+                    if (typeof reqResult === "string") {
+                        stepUrl = reqResult;
+                    }
+                }
+                catch {
+                    // ignore errors here, url не обязателен
+                }
+            }
+            else {
+                stepUrl = key;
+            }
+            this.stageResults[key] = { status: "pending", url: stepUrl };
+            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 },
+            });
+            try {
+                let stepResult;
+                // --- pauseBeforeMs (пауза перед выполнением команды) ---
+                if (typeof stage.pauseBefore === "number" && stage.pauseBefore > 0) {
+                    await new Promise((resolve) => setTimeout(resolve, stage.pauseBefore));
+                }
+                // --- before (pre-processing) ---
+                let prevInput = i > 0
+                    ? (_c = this.stageResults[this.config.stages[i - 1].key]) === null || _c === void 0 ? void 0 : _c.data
+                    : undefined;
+                if (typeof stage.before === "function") {
+                    const beforeResult = await stage.before({
+                        prev: prevInput,
+                        allResults: this.stageResults,
+                        sharedData: this.sharedData,
+                    });
+                    if (typeof beforeResult !== "undefined") {
+                        prevInput = beforeResult;
+                    }
+                }
+                // --- request ---
+                if (typeof stage.request === "function") {
+                    const reqResult = await stage.request({
+                        prev: prevInput,
+                        allResults: this.stageResults,
+                        sharedData: this.sharedData,
+                    });
+                    if (typeof reqResult === "string") {
+                        const res = await this.executor.execute(reqResult, undefined, stage.retryCount, stage.timeoutMs);
+                        stepResult = res.data;
+                    }
+                    else {
+                        stepResult = reqResult;
+                    }
+                }
+                else if (stage.key) {
+                    const res = await this.executor.execute(stage.key, undefined, stage.retryCount, stage.timeoutMs);
+                    stepResult = res.data;
+                }
+                else {
+                    stepResult = undefined;
+                }
+                // --- after (post-processing) ---
+                if (typeof stage.after === "function") {
+                    stepResult = await stage.after({
+                        result: stepResult,
+                        allResults: this.stageResults,
+                        sharedData: this.sharedData,
+                    });
+                }
+                // --- pauseAfterMs (пауза после выполнения команды) ---
+                if (typeof stage.pauseAfter === "number" && stage.pauseAfter > 0) {
+                    await new Promise((resolve) => setTimeout(resolve, stage.pauseAfter));
+                }
+                // --- Пользовательская пауза/подтверждение/изменение результата ---
+                if (onStepPause) {
+                    stepResult = await onStepPause(i, stepResult, this.stageResults);
+                }
+                this.stageResults[key] = {
+                    status: "success",
+                    data: stepResult,
+                    url: (_d = this.stageResults[key]) === null || _d === void 0 ? void 0 : _d.url,
+                };
+                this.notifyStageResults();
+                this.progress.updateStage(i, "success");
+                await this.emit(`step:${key}:progress`, "success");
+                await this.emitStepFinish({
+                    stepIndex: i,
+                    stepKey: key,
+                    status: "success",
+                    data: stepResult,
+                    stageResults: { ...this.stageResults },
+                });
+            }
+            catch (err) {
+                let handled;
+                if (stage && typeof stage.errorHandler === "function") {
+                    handled = stage.errorHandler({
+                        error: err,
+                        key: stage.key,
+                        sharedData: 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 apiError = (0, rest_client_1.toApiError)(handled !== null && handled !== void 0 ? handled : err);
+                this.stageResults[key] = {
+                    status: "error",
+                    error: apiError,
+                    url: (_e = this.stageResults[key]) === null || _e === void 0 ? void 0 : _e.url,
+                };
+                this.notifyStageResults();
+                this.progress.updateStage(i, "error");
+                await this.emit(`step:${key}:progress`, "error");
+                await this.emitStepError({
+                    stepIndex: i,
+                    stepKey: key,
+                    status: "error",
+                    error: apiError,
+                    stageResults: { ...this.stageResults },
+                });
+                success = false;
+                break;
+            }
+        }
+        return { stageResults: { ...this.stageResults }, success };
+    }
+    /**
+     * Очистить stageResults и уведомить подписчиков
+     */
+    clearStageResults() {
+        this.stageResults = {};
+        this.notifyStageResults();
+        // Корректно сбрасываем прогресс
+        this.progress.reset();
+    }
+}
+exports.PipelineOrchestrator = PipelineOrchestrator;

package/dist/cjs/progress-tracker.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProgressTracker = void 0;
+class ProgressTracker {
+    constructor(totalStages) {
+        this.listeners = [];
+        this.progress = {
+            currentStage: 0,
+            totalStages,
+            stageStatuses: Array(totalStages).fill("pending"),
+        };
+    }
+    reset() {
+        this.progress.currentStage = 0;
+        this.progress.stageStatuses = Array(this.progress.totalStages).fill("pending");
+        this.notify();
+    }
+    /**
+     * Возвращает текущий снимок состояния прогресса (не реактивный).
+     * Для отслеживания изменений используйте subscribeProgress.
+     */
+    getProgressRef() {
+        return this.progress;
+    }
+    updateStage(stage, status) {
+        this.progress.stageStatuses[stage] = status;
+        this.progress.currentStage = stage;
+        this.notify();
+    }
+    getProgress() {
+        return { ...this.progress };
+    }
+    subscribe(listener) {
+        this.listeners.push(listener);
+        // Немедленно уведомляем нового подписчика о текущем состоянии
+        listener({ ...this.progress });
+        return () => {
+            this.listeners = this.listeners.filter((l) => l !== listener);
+        };
+    }
+    notify() {
+        for (const listener of this.listeners) {
+            listener({ ...this.progress });
+        }
+    }
+}
+exports.ProgressTracker = ProgressTracker;

package/dist/cjs/react.js

@@ -0,0 +1,29 @@
+"use strict";
+// Entry point: core + React. Import from "rest-pipeline-js/react".
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRerunPipelineStepReact = exports.usePipelineLogsReact = exports.usePipelineStepEventReact = exports.useRestClientReact = exports.usePipelineRunReact = exports.usePipelineProgressReact = void 0;
+__exportStar(require("./index"), exports);
+var usePipelineProgress_react_1 = require("./usePipelineProgress-react");
+Object.defineProperty(exports, "usePipelineProgressReact", { enumerable: true, get: function () { return usePipelineProgress_react_1.usePipelineProgressReact; } });
+var usePipelineRun_react_1 = require("./usePipelineRun-react");
+Object.defineProperty(exports, "usePipelineRunReact", { enumerable: true, get: function () { return usePipelineRun_react_1.usePipelineRunReact; } });
+var useRestClient_react_1 = require("./useRestClient-react");
+Object.defineProperty(exports, "useRestClientReact", { enumerable: true, get: function () { return useRestClient_react_1.useRestClientReact; } });
+var usePipelineStepEvents_react_1 = require("./usePipelineStepEvents-react");
+Object.defineProperty(exports, "usePipelineStepEventReact", { enumerable: true, get: function () { return usePipelineStepEvents_react_1.usePipelineStepEventReact; } });
+Object.defineProperty(exports, "usePipelineLogsReact", { enumerable: true, get: function () { return usePipelineStepEvents_react_1.usePipelineLogsReact; } });
+Object.defineProperty(exports, "useRerunPipelineStepReact", { enumerable: true, get: function () { return usePipelineStepEvents_react_1.useRerunPipelineStepReact; } });