rest-pipeline-js 1.0.2 → 1.0.3

package/dist/error-handler.d.ts

@@ -0,0 +1,7 @@
+export declare class ErrorHandler {
+    handle(error: any, stageKey: string): {
+        type: string;
+        error: any;
+        stageKey: string;
+    };
+}

package/dist/error-handler.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorHandler = void 0;
+class ErrorHandler {
+    handle(error, stageKey) {
+        // TODO: реализовать классификацию и обработку ошибок
+        return { type: 'unknown', error, stageKey };
+    }
+}
+exports.ErrorHandler = ErrorHandler;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './rest-client';
+export * from './types';
+export * from './request-executor';
+export * from './error-handler';
+export * from './progress-tracker';
+export * from './pipeline-orchestrator';

package/dist/index.js

@@ -0,0 +1,23 @@
+"use strict";
+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 });
+// Barrel file for pipeline-js module
+__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/pipeline-orchestrator.d.ts

@@ -0,0 +1,31 @@
+import type { PipelineConfig, PipelineResult } from './types';
+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>);
+    /**
+     * Подписаться на изменения прогресса выполнения pipeline
+     * @param listener функция-обработчик изменений
+     * @returns функция для отписки
+     */
+    subscribeProgress(listener: (progress: import('./types').PipelineProgress) => void): () => void;
+    /**
+     * Получить текущий прогресс выполнения pipeline (snapshot, не реактивный)
+     */
+    getProgress(): {
+        currentStage: number;
+        totalStages: number;
+        stageStatuses: Array<"pending" | "in-progress" | "success" | "error" | "skipped">;
+    };
+    /**
+     * @param onStepPause
+     *   Необязательный callback, вызывается после каждого шага (до перехода к следующему).
+     *   Позволяет приостановить выполнение, запросить подтверждение пользователя или изменить результат шага.
+     *   Должен вернуть (optionally изменённый) результат шага или промис с ним.
+     *   Если не передан — пайплайн работает как раньше.
+     */
+    run(onStepPause?: (stepIndex: number, stepResult: unknown, results: unknown[]) => Promise<unknown> | unknown): Promise<PipelineResult>;
+}

package/dist/pipeline-orchestrator.js

@@ -0,0 +1,99 @@
+"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");
+// import { metricsBus } from '@/core/metrics/metrics-bus';
+class PipelineOrchestrator {
+    constructor(config, httpConfig, sharedData = {}) {
+        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;
+    }
+    /**
+     * Подписаться на изменения прогресса выполнения pipeline
+     * @param listener функция-обработчик изменений
+     * @returns функция для отписки
+     */
+    subscribeProgress(listener) {
+        return this.progress.subscribe(listener);
+    }
+    /**
+     * Получить текущий прогресс выполнения pipeline (snapshot, не реактивный)
+     */
+    getProgress() {
+        return this.progress.getProgress();
+    }
+    /**
+     * @param onStepPause
+     *   Необязательный callback, вызывается после каждого шага (до перехода к следующему).
+     *   Позволяет приостановить выполнение, запросить подтверждение пользователя или изменить результат шага.
+     *   Должен вернуть (optionally изменённый) результат шага или промис с ним.
+     *   Если не передан — пайплайн работает как раньше.
+     */
+    async run(onStepPause) {
+        const results = [];
+        const errors = [];
+        let success = true;
+        for (let i = 0; i < this.config.stages.length; i++) {
+            const stage = this.config.stages[i];
+            this.progress.updateStage(i, 'in-progress');
+            if (!stage) {
+                this.progress.updateStage(i, 'skipped');
+                results.push(undefined);
+                continue;
+            }
+            // Проверка условия выполнения этапа
+            if (stage.condition && !stage.condition(results[i - 1], results, this.sharedData)) {
+                this.progress.updateStage(i, 'skipped');
+                results.push(undefined);
+                continue;
+            }
+            try {
+                let stepResult;
+                // Всегда передаём (prev, allResults) в request — best practice для pipeline
+                if (typeof stage.request === 'function') {
+                    stepResult = await stage.request(results[i - 1], results);
+                }
+                else if (stage.key) {
+                    const res = await this.executor.execute(stage.key, undefined, stage.retryCount, stage.timeoutMs);
+                    stepResult = res.data;
+                }
+                else {
+                    stepResult = undefined;
+                }
+                // --- Пользовательская пауза/подтверждение/изменение результата ---
+                if (onStepPause) {
+                    stepResult = await onStepPause(i, stepResult, results);
+                }
+                results.push(stepResult);
+                this.progress.updateStage(i, 'success');
+                // ...existing code...
+            }
+            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);
+                }
+                errors.push(handled);
+                this.progress.updateStage(i, 'error');
+                success = false;
+                break;
+            }
+        }
+        return { results, errors, success };
+    }
+}
+exports.PipelineOrchestrator = PipelineOrchestrator;

package/dist/progress-tracker.d.ts

@@ -0,0 +1,16 @@
+import type { PipelineProgress } from './types';
+type ProgressListener = (progress: PipelineProgress) => void;
+export declare class ProgressTracker {
+    private progress;
+    private listeners;
+    constructor(totalStages: number);
+    updateStage(stage: number, status: PipelineProgress['stageStatuses'][number]): void;
+    getProgress(): {
+        currentStage: number;
+        totalStages: number;
+        stageStatuses: Array<"pending" | "in-progress" | "success" | "error" | "skipped">;
+    };
+    subscribe(listener: ProgressListener): () => void;
+    private notify;
+}
+export {};

package/dist/progress-tracker.js

@@ -0,0 +1,35 @@
+"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'),
+        };
+    }
+    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/request-executor.d.ts

@@ -0,0 +1,9 @@
+import type { RestRequestConfig, HttpConfig, ApiResponse } from './types';
+export declare class RequestExecutor {
+    private client;
+    constructor(httpConfig: HttpConfig);
+    /**
+     * Выполнение одного запроса с поддержкой retry и таймаута
+     */
+    execute<T = any>(command: string, reqConfig?: RestRequestConfig, retryCount?: number, timeoutMs?: number): Promise<ApiResponse<T>>;
+}

package/dist/request-executor.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestExecutor = void 0;
+const rest_client_1 = require("./rest-client");
+class RequestExecutor {
+    constructor(httpConfig) {
+        this.client = (0, rest_client_1.getRestClient)(httpConfig);
+    }
+    /**
+     * Выполнение одного запроса с поддержкой retry и таймаута
+     */
+    async execute(command, reqConfig, retryCount = 0, timeoutMs = 10000) {
+        let attempt = 0;
+        let lastError = null;
+        while (attempt <= retryCount) {
+            try {
+                const result = await Promise.race([
+                    this.client.request(command, reqConfig),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout')), timeoutMs)),
+                ]);
+                return result;
+            }
+            catch (err) {
+                lastError = err;
+                attempt++;
+                if (attempt > retryCount)
+                    throw lastError;
+            }
+        }
+        throw lastError;
+    }
+}
+exports.RequestExecutor = RequestExecutor;

package/dist/rest-client.d.ts

@@ -0,0 +1,14 @@
+import type { HttpConfig, ApiError, ApiResponse, RestRequestConfig } from './types';
+type RestClient = ReturnType<typeof createRestClient>;
+export declare function toApiError(error: unknown): ApiError;
+export declare function createRestClient(config: HttpConfig): {
+    request: <T = unknown>(command: string, req?: RestRequestConfig) => Promise<ApiResponse<T>>;
+    get: <T = unknown>(command: string, config?: Omit<RestRequestConfig, "method">) => Promise<ApiResponse<T>>;
+    post: <T = unknown>(command: string, data?: unknown, config?: Omit<RestRequestConfig, "method" | "data">) => Promise<ApiResponse<T>>;
+    put: <T = unknown>(command: string, data?: unknown, config?: Omit<RestRequestConfig, "method" | "data">) => Promise<ApiResponse<T>>;
+    delete: <T = unknown>(command: string, config?: Omit<RestRequestConfig, "method">) => Promise<ApiResponse<T>>;
+    cancellableRequest: <T = unknown>(key: string, command: string, config?: any) => Promise<ApiResponse<T>>;
+    cancelRequest: (key: string) => void;
+};
+export declare function getRestClient(config: HttpConfig): RestClient;
+export {};

package/dist/rest-client.js

@@ -0,0 +1,168 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toApiError = toApiError;
+exports.createRestClient = createRestClient;
+exports.getRestClient = getRestClient;
+const axios_1 = __importDefault(require("axios"));
+function toApiError(error) {
+    var _a;
+    if (axios_1.default.isCancel(error)) {
+        return {
+            message: 'Запрос был отменен',
+            code: 'REQUEST_CANCELLED',
+        };
+    }
+    if (axios_1.default.isAxiosError(error)) {
+        const axiosError = error;
+        return {
+            message: axiosError.message,
+            code: axiosError.code,
+            status: (_a = axiosError.response) === null || _a === void 0 ? void 0 : _a.status,
+            timestamp: new Date(),
+        };
+    }
+    if (error instanceof Error) {
+        return {
+            message: error.message,
+            timestamp: new Date(),
+        };
+    }
+    return {
+        message: 'Произошла неизвестная ошибка',
+        timestamp: new Date(),
+    };
+}
+const restClientCache = new Map();
+function createRestClient(config) {
+    const httpClient = axios_1.default.create({
+        baseURL: config.baseURL,
+        timeout: config.timeout,
+        headers: config.headers,
+        withCredentials: config.withCredentials,
+    });
+    // ...реализация rate limit, cache, interceptors, request, etc. (скопировать из rest.ts при необходимости)
+    // Для краткости: реализуйте полный функционал по мере необходимости.
+    async function request(command, req) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        const reqId = (_a = req === null || req === void 0 ? void 0 : req.requestId) !== null && _a !== void 0 ? _a : Math.random().toString(36).slice(2);
+        const methodUpper = ((_b = req === null || req === void 0 ? void 0 : req.method) !== null && _b !== void 0 ? _b : 'GET').toUpperCase();
+        const fullUrl = `${config.baseURL}${command}`;
+        (_d = (_c = config.metrics) === null || _c === void 0 ? void 0 : _c.onRequestStart) === null || _d === void 0 ? void 0 : _d.call(_c, {
+            id: reqId,
+            method: methodUpper,
+            url: fullUrl,
+            timestamp: Date.now(),
+            requestBody: req === null || req === void 0 ? void 0 : req.data,
+            requestParams: req === null || req === void 0 ? void 0 : req.params,
+            requestHeaders: req === null || req === void 0 ? void 0 : req.headers,
+        });
+        const startTs = Date.now();
+        try {
+            const response = await httpClient.request({
+                url: command,
+                ...req,
+            });
+            const payload = {
+                data: response.data,
+                status: response.status,
+                statusText: response.statusText,
+                headers: response.headers,
+            };
+            const duration = Date.now() - startTs;
+            // --- вычисление размера ответа ---
+            let responseBytes = undefined;
+            const headers = response.headers;
+            const contentLengthHeader = headers['content-length'] || headers['Content-Length'] || undefined;
+            const parsedLength = contentLengthHeader ? Number(contentLengthHeader) : undefined;
+            if (Number.isFinite(parsedLength) && parsedLength !== 0) {
+                responseBytes = parsedLength;
+            }
+            else {
+                try {
+                    const raw = response.data;
+                    if (typeof raw === 'string') {
+                        responseBytes = new TextEncoder().encode(raw).length;
+                    }
+                    else if (raw !== undefined) {
+                        const str = JSON.stringify(raw);
+                        responseBytes = new TextEncoder().encode(str).length;
+                    }
+                }
+                catch {
+                    // ignore sizing errors
+                }
+            }
+            (_f = (_e = config.metrics) === null || _e === void 0 ? void 0 : _e.onRequestEnd) === null || _f === void 0 ? void 0 : _f.call(_e, {
+                id: reqId,
+                durationMs: duration,
+                status: response.status,
+                bytes: responseBytes,
+                responseBody: response.data,
+                responseHeaders: response.headers,
+            });
+            return payload;
+        }
+        catch (error) {
+            const duration = Date.now() - startTs;
+            (_h = (_g = config.metrics) === null || _g === void 0 ? void 0 : _g.onRequestEnd) === null || _h === void 0 ? void 0 : _h.call(_g, {
+                id: reqId,
+                durationMs: duration,
+                error: toApiError(error),
+            });
+            throw error;
+        }
+    }
+    // --- Реализация cancellableRequest ---
+    const cancelTokenSources = new Map();
+    function cancelRequest(key) {
+        const source = cancelTokenSources.get(key);
+        if (source) {
+            source.cancel(`Запрос отменен по ключу: ${key}`);
+            cancelTokenSources.delete(key);
+        }
+    }
+    async function cancellableRequest(key, command, config) {
+        cancelRequest(key);
+        const axios = await import('axios');
+        const source = axios.default.CancelToken.source();
+        cancelTokenSources.set(key, source);
+        try {
+            return await request(command, {
+                ...config,
+                cancelToken: source.token,
+            });
+        }
+        finally {
+            cancelTokenSources.delete(key);
+        }
+    }
+    return {
+        request,
+        get: (command, config) => request(command, { ...config, method: 'GET' }),
+        post: (command, data, config) => request(command, { ...config, method: 'POST', data }),
+        put: (command, data, config) => request(command, { ...config, method: 'PUT', data }),
+        delete: (command, config) => request(command, { ...config, method: 'DELETE' }),
+        cancellableRequest,
+        cancelRequest,
+    };
+}
+function getRestClient(config) {
+    var _a, _b;
+    const key = JSON.stringify({
+        baseURL: config.baseURL,
+        timeout: config.timeout,
+        withCredentials: config.withCredentials,
+        headers: (_a = config.headers) !== null && _a !== void 0 ? _a : {},
+        retry: (_b = config.retry) !== null && _b !== void 0 ? _b : {},
+        metrics: !!config.metrics,
+    });
+    const cachedClient = restClientCache.get(key);
+    if (cachedClient)
+        return cachedClient;
+    const client = createRestClient(config);
+    restClientCache.set(key, client);
+    return client;
+}

package/dist/types.d.ts

@@ -0,0 +1,86 @@
+export interface RetryConfig {
+    attempts: number;
+    delayMs: number;
+    backoffMultiplier: number;
+    retriableStatus?: number[];
+}
+export type RetryOptions = Partial<RetryConfig>;
+export interface CacheConfig {
+    enabled: boolean;
+    ttlMs: number;
+}
+export interface RateLimitConfig {
+    maxConcurrent?: number;
+    maxRequestsPerInterval?: number;
+    intervalMs?: number;
+}
+export interface MetricsHandler {
+    onRequestStart?: (info: {
+        id: string;
+        method?: string;
+        url?: string;
+        timestamp: number;
+        requestBody?: unknown;
+        requestParams?: unknown;
+        requestHeaders?: Record<string, string>;
+    }) => void;
+    onRequestEnd?: (info: {
+        id: string;
+        durationMs: number;
+        status?: number;
+        error?: ApiError;
+        bytes?: number;
+        responseBody?: unknown;
+        responseHeaders?: Record<string, string>;
+    }) => void;
+}
+export interface HttpConfig {
+    baseURL: string;
+    timeout?: number;
+    headers?: Record<string, string>;
+    withCredentials?: boolean;
+    retry?: RetryOptions;
+    cache?: CacheConfig;
+    rateLimit?: RateLimitConfig;
+    metrics?: MetricsHandler;
+}
+export interface ApiError {
+    message: string;
+    code?: string | number;
+    status?: number;
+    timestamp?: Date;
+}
+export interface ApiResponse<T = unknown> {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+}
+export type RestRequestConfig = import('axios').AxiosRequestConfig & {
+    useCache?: boolean;
+    cacheTtlMs?: number;
+    cacheKey?: string;
+    skipRateLimit?: boolean;
+    requestId?: string;
+};
+export type PipelineStageConfig<Input, Output> = {
+    key: string;
+    request: (input: Input, allResults?: any) => Promise<Output>;
+    condition?: (input: Input, prevResults: any, sharedData?: Record<string, any>) => boolean;
+    retryCount?: number;
+    timeoutMs?: number;
+    errorHandler?: (error: any, stageKey: string, sharedData?: Record<string, any>) => any;
+};
+export type PipelineConfig = {
+    stages: PipelineStageConfig<any, any>[];
+};
+export type PipelineProgress = {
+    currentStage: number;
+    totalStages: number;
+    stageStatuses: Array<'pending' | 'in-progress' | 'success' | 'error' | 'skipped'>;
+};
+export type PipelineResult = {
+    results: any[];
+    errors: any[];
+    success: boolean;
+};

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "rest-pipeline-js",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Pipeline Orchestration Utilities for JavaScript REST API Clients",
-  "main": "src/rest-client.js",
+  "main": "dist/index.js",
   "types": "src/types.ts",
   "scripts": {
     "build": "tsc",

package/tsconfig.json

@@ -2,7 +2,8 @@
 {
   "compilerOptions": {
     "target": "ES2019",
-    "module": "commonjs",
+    "module": "NodeNext",
+    "moduleResolution": "nodenext",
     "declaration": true,
     "outDir": "dist",
     "strict": true,