rest-pipeline-js 1.3.7: плагины, stream-шаги, fluent builder и метрики pipeline

import { createPipeline } from "rest-pipeline-js";

const orchestrator = createPipeline(
  [
    { key: "fetchUser",    request: async () => fetchUser() },
    { key: "processData",  request: async ({ prev }) => process(prev) },
    { key: "save",         request: async ({ prev }) => save(prev) },
  ],
  {
    httpConfig:      { baseURL: "https://api.example.com" },
    sharedData:      { userId: 42 },
    pipelineOptions: { continueOnError: false },
    metrics:         { onStepDuration: ({ stepKey, durationMs }) => log(stepKey, durationMs) },
  },
);

await orchestrator.run();

import { pipe } from "rest-pipeline-js";

const orchestrator = pipe()
  .step({ key: "auth", request: async () => getToken() })
  .step({
    key: "fetchUser",
    condition: ({ prev }) => !!prev,
    request: async ({ prev }) => fetchUser(prev),
  })
  .parallel([
    { key: "loadPosts",  request: async () => fetchPosts() },
    { key: "loadNotifs", request: async () => fetchNotifications() },
  ])
  .step({
    key: "render",
    request: async ({ allResults }) => render(allResults),
  })
  .build({
    httpConfig: { baseURL: "https://api.example.com" },
  });

import { validatePipelineConfig } from "rest-pipeline-js";

const { valid, errors } = validatePipelineConfig({
  stages: [
    { key: "step1", request: async () => data },
    { key: "step1", request: async () => other }, // дубликат!
    { key: "",      request: async () => null   }, // пустой ключ!
    { key: "step3", retryCount: -1              }, // отрицательное значение!
  ],
});

if (!valid) {
  console.error(errors);
  // [
  //   '[root] duplicate stage key: "step1"',
  //   '[root] stage key must be a non-empty string (got: "")',
  //   '[root] stage "step3": retryCount must be a non-negative number',
  // ]
}

const orchestrator = new PipelineOrchestrator<"fetchUser" | "processData" | "save">({
  config: { stages: [ /* ... */ ] },
});

// IDE подскажет допустимые варианты:
orchestrator.on("step:fetchUser:success", (event) => { ... });
orchestrator.rerunStep("processData");
orchestrator.subscribeStepProgress("save", (status) => { ... });

// Опечатка → ошибка компиляции:
orchestrator.on("step:fetchUzer:success", handler); // ❌ TypeScript не пропустит

<!-- Vue -->
<script setup>
import { usePipelineStageResultVue } from "rest-pipeline-js/vue";

const userResult = usePipelineStageResultVue(orchestrator, "fetchUser");
// userResult.value?.status === "success"
// userResult.value?.data — данные шага
// userResult.value?.error — ошибка шага
</script>

<template>
  <div v-if="userResult?.status === 'loading'">Загрузка...</div>
  <div v-else-if="userResult?.status === 'error'">{{ userResult.error.message }}</div>
  <div v-else-if="userResult?.status === 'success'">{{ userResult.data }}</div>
</template>

// React
import { usePipelineStageResultReact } from "rest-pipeline-js/react";

function UserCard() {
  const result = usePipelineStageResultReact(orchestrator, "fetchUser");

  if (!result || result.status === "pending") return <Skeleton />;
  if (result.status === "error")             return <ErrorView error={result.error} />;
  return <User data={result.data} />;
}

const orchestrator = new PipelineOrchestrator({
  config: {
    stages: [ /* ... */ ],
    metrics: {
      onPipelineStart: ({ timestamp }) => {
        console.log("Pipeline started at", new Date(timestamp).toISOString());
        perfTimer.start("pipeline");
      },
      onPipelineEnd: ({ durationMs, success, stageResults }) => {
        analytics.track("pipeline_complete", { durationMs, success });
        if (!success) {
          const failed = Object.entries(stageResults)
            .filter(([, r]) => r.status === "error")
            .map(([key]) => key);
          Sentry.captureMessage(`Pipeline failed at: ${failed.join(", ")}`);
        }
      },
      onStepDuration: ({ stepKey, durationMs, status }) => {
        // Логируем каждый шаг — видно, где тормозит
        datadog.histogram("pipeline.step.duration", durationMs, { step: stepKey, status });
      },
    },
  },
});

import type { PipelineLogEventType } from "rest-pipeline-js";

function handleLog(event: { type: PipelineLogEventType; stepKey?: string; error?: any }) {
  switch (event.type) {
    case "step:success":    console.log("✓", event.stepKey); break;
    case "step:error":      console.error("✗", event.stepKey, event.error); break;
    case "pipeline:retry":  console.warn("↺ retry", (event as any).attempt); break;
  }
}

orchestrator.on("log", handleLog);

// Плагин логирования — пакуем один раз, переиспользуем везде
const loggingPlugin = {
  name: "logging",
  install(orchestrator) {
    const offLog = orchestrator.on("log", (event) => {
      if (event.type === "step:start")   console.log(`→ [${event.stepKey}]`);
      if (event.type === "step:success") console.log(`✓ [${event.stepKey}]`);
      if (event.type === "step:error")   console.error(`✗ [${event.stepKey}]`, event.error);
    });

    // Возвращаем cleanup — вызовется при orchestrator.destroy()
    return () => offLog();
  },
};

const orchestrator = new PipelineOrchestrator({
  config: {
    stages: [ /* ... */ ],
    options: {
      plugins: [loggingPlugin, analyticsPlugin, sentryPlugin],
    },
  },
});

// Когда оркестратор больше не нужен:
orchestrator.destroy();

type PipelinePlugin = {
  name: string;
  install(orchestrator: PipelineOrchestrator): void | (() => void);
};

const localStorageAdapter = {
  save: (state) => localStorage.setItem("pipeline:state", JSON.stringify(state)),
  load: () => {
    const raw = localStorage.getItem("pipeline:state");
    return raw ? JSON.parse(raw) : null;
  },
};

const orchestrator = new PipelineOrchestrator({
  config: {
    stages: [ /* ... */ ],
    options: { persistAdapter: localStorageAdapter },
  },
});

// run() загружает сохранённое состояние в начале
// После каждого успешного шага — сохраняет текущее
await orchestrator.run();

type PipelineStateAdapter = {
  save(state: PipelineExportedState): void | Promise<void>;
  load(): PipelineExportedState | null | Promise<PipelineExportedState | null>;
};

const orchestrator = createPipeline([
  {
    key: "auth",
    request: async () => await getToken(),
  },
  {
    key: "liveData",
    // stream получает те же параметры, что и обычный request
    stream: async function* ({ prev, sharedData }) {
      // prev — результат шага "auth" (токен)
      const source = new EventSource(`/api/events?token=${prev}`);

      try {
        yield* eventSourceToAsyncIterable(source);
      } finally {
        source.close();
      }
    },
    // Вызывается для каждого чанка немедленно — не ждёт завершения потока
    onChunk: (chunk, sharedData) => {
      sharedData.buffer = (sharedData.buffer ?? "") + chunk;
      updateUI(sharedData.buffer);
    },
  },
  {
    key: "finalize",
    request: async ({ allResults }) => {
      // allResults.liveData.data — массив всех накопленных чанков
      return allResults.liveData.data.join("");
    },
  },
]);

// Передаём нативный fetch как адаптер
const fetchAdapter = {
  async request(config) {
    const url = `${config.baseURL ?? ""}${config.url ?? ""}`;
    const res = await fetch(url, {
      method:  config.method ?? "GET",
      body:    config.data ? JSON.stringify(config.data) : undefined,
      headers: { "Content-Type": "application/json", ...config.headers },
      signal:  config.signal,
    });
    const data = await res.json();
    return {
      data,
      status:     res.status,
      statusText: res.statusText,
      headers:    Object.fromEntries(res.headers.entries()),
    };
  },
};

const client = createRestClient({
  baseURL: "https://api.example.com",
  adapter: fetchAdapter,
  // Все остальные фичи работают поверх адаптера без изменений:
  auth:           { getToken: async () => token },
  interceptors:   { request: [addCorrelationId] },
  sanitizeHeaders: true,
  retry:          { attempts: 3, delayMs: 500, backoffMultiplier: 2 },
});

type HttpAdapter = {
  request<T = unknown>(
    config: RestRequestConfig & { baseURL?: string }
  ): Promise<ApiResponse<T>>;
};

const results = orchestrator.getStageResults();
console.log(results.fetchUser?.data);
console.log(results.processData?.status);

npm i rest-pipeline-js@1.3.7