@wpkernel/pipeline 0.12.2-beta.0 → 0.12.3-beta.2

package/dist/internal/pipeline-runner.js

@@ -1,261 +1,343 @@
-import { maybeThen as x, maybeTry as F } from "../async-utils.js";
-import { createDependencyGraph as U } from "../dependency-graph.js";
-import { executeHelpers as C } from "../executor.js";
-import { buildExecutionSnapshot as v, assertAllHelpersExecuted as A } from "./helper-execution.js";
-import { initExtensionCoordinator as B } from "./extension-coordinator.js";
-/**
- * @wpkernel/pipeline
- * @license EUPL-1.2
- */
-function j(r) {
-  return {
-    prepareContext: (s) => {
-      const a = r.options.createBuildOptions(s), n = r.options.createContext(s);
-      r.diagnosticManager.setReporter(n.reporter);
-      const l = r.options.createFragmentState({
-        options: s,
-        context: n,
-        buildOptions: a
-      }), m = U(
-        r.fragmentEntries,
-        {
-          onMissingDependency: ({ dependant: t, dependencyKey: e }) => {
-            const o = t.helper;
-            r.diagnosticManager.flagMissingDependency(
-              o,
-              e,
-              r.fragmentKind
-            ), r.diagnosticManager.flagUnusedHelper(
-              o,
-              r.fragmentKind,
-              `could not execute because dependency "${e}" was not found`,
-              o.dependsOn
-            );
-          },
-          onUnresolvedHelpers: ({ unresolved: t }) => {
-            for (const e of t) {
-              const o = e.helper;
-              r.diagnosticManager.flagUnusedHelper(
-                o,
-                r.fragmentKind,
-                "could not execute because its dependencies never resolved",
-                o.dependsOn
-              );
-            }
-          }
-        },
-        r.createError
-      ).order, c = [], b = (t) => {
-        const e = t.helper;
-        c.push({
-          id: t.id,
-          index: c.length,
-          key: e.key,
-          kind: e.kind,
-          mode: e.mode,
-          priority: e.priority,
-          dependsOn: e.dependsOn,
-          origin: e.origin
-        });
-      }, p = {
-        onMissingDependency: ({ dependant: t, dependencyKey: e }) => {
-          const o = t.helper;
-          r.diagnosticManager.flagMissingDependency(
-            o,
-            e,
-            r.builderKind
-          ), r.diagnosticManager.flagUnusedHelper(
-            o,
-            r.builderKind,
-            `could not execute because dependency "${e}" was not found`,
-            o.dependsOn
+import { maybeThen as b, composeK as j } from "../async-utils.js";
+import { createDependencyGraph as x } from "../dependency-graph.js";
+import { buildExecutionSnapshot as u, assertAllHelpersExecuted as E } from "./helper-execution.js";
+import { initExtensionCoordinator as I } from "./extension-coordinator.js";
+import { isHalt as g, makeFinalizeResultStage as J, makeCommitStage as Q, makeHelperStageFactory as W, makeAfterFragmentsStage as X, makeFinalizeFragmentsStage as Y, runRollbackToHalt as Z } from "./pipeline-program-utils.js";
+const h = "after-fragments";
+function ar(o) {
+  const p = (r) => ({
+    __halt: !0,
+    error: r
+  }), k = (r) => {
+    const t = o.options.createBuildOptions(r), n = o.options.createContext(r);
+    o.diagnosticManager.setReporter(n.reporter);
+    const l = o.options.createFragmentState({
+      options: r,
+      context: n,
+      buildOptions: t
+    }), c = x(
+      o.fragmentEntries,
+      {
+        providedKeys: o.options.fragmentProvidedKeys,
+        onMissingDependency: ({ dependant: e, dependencyKey: i }) => {
+          const a = e.helper;
+          o.diagnosticManager.flagMissingDependency(
+            a,
+            i,
+            o.fragmentKind
+          ), o.diagnosticManager.flagUnusedHelper(
+            a,
+            o.fragmentKind,
+            `could not execute because dependency "${i}" was not found`,
+            a.dependsOn
           );
         },
-        onUnresolvedHelpers: ({ unresolved: t }) => {
-          for (const e of t) {
-            const o = e.helper;
-            r.diagnosticManager.flagUnusedHelper(
-              o,
-              r.builderKind,
+        onUnresolvedHelpers: ({ unresolved: e }) => {
+          for (const i of e) {
+            const a = i.helper;
+            o.diagnosticManager.flagUnusedHelper(
+              a,
+              o.fragmentKind,
               "could not execute because its dependencies never resolved",
-              o.dependsOn
+              a.dependsOn
             );
           }
         }
-      }, E = r.options.createExtensionHookOptions ?? ((t) => ({
-        context: t.context,
-        options: t.options,
-        artifact: t.artifact,
-        lifecycle: t.lifecycle
-      })), y = (t, e) => E({
-        context: n,
-        options: s,
-        buildOptions: a,
-        artifact: t,
-        lifecycle: e
-      }), M = r.options.onExtensionRollbackError ?? ((t) => {
-        const { reporter: e } = t.context, o = e.warn;
-        typeof o == "function" && o.call(e, "Pipeline extension rollback failed.", {
-          error: t.error,
-          errorName: t.errorMetadata.name,
-          errorMessage: t.errorMetadata.message,
-          errorStack: t.errorMetadata.stack,
-          errorCause: t.errorMetadata.cause,
-          extensions: t.extensionKeys,
-          hookKeys: t.hookSequence
-        });
+      },
+      o.createError
+    ).order, s = [], m = (e) => {
+      const i = e.helper;
+      s.push({
+        id: e.id,
+        index: s.length,
+        key: i.key,
+        kind: i.kind,
+        mode: i.mode,
+        priority: i.priority,
+        dependsOn: i.dependsOn,
+        origin: i.origin
       });
-      return {
-        runOptions: s,
-        buildOptions: a,
-        context: n,
-        draft: l,
-        fragmentOrder: m,
-        steps: c,
-        pushStep: b,
-        builderGraphOptions: p,
-        buildHookOptions: y,
-        handleRollbackError: M
-      };
-    },
-    executeRun: (s) => {
-      const {
-        runOptions: a,
-        buildOptions: n,
-        context: l,
-        draft: m,
-        fragmentOrder: c,
-        steps: b,
-        pushStep: p,
-        builderGraphOptions: E,
-        buildHookOptions: y,
-        handleRollbackError: M
-      } = s;
-      let t = v(
-        r.builderEntries,
-        /* @__PURE__ */ new Set(),
-        r.builderKind
-      );
-      const e = C(
-        c,
-        (o) => r.options.createFragmentArgs({
-          helper: o.helper,
-          options: a,
-          context: l,
-          buildOptions: n,
-          draft: m
-        }),
-        (o, g, u) => o.apply(g, u),
-        (o) => p(o)
-      );
-      return x(e, (o) => {
-        r.diagnosticManager.reviewUnusedHelpers(
-          r.fragmentEntries,
-          o,
-          r.fragmentKind
-        );
-        const g = v(
-          r.fragmentEntries,
-          o,
-          r.fragmentKind
-        );
-        A(
-          r.fragmentEntries,
-          g,
-          r.fragmentKind,
-          r.diagnosticManager.describeHelper,
-          r.createError
-        );
-        let u = r.options.finalizeFragmentState({
-          draft: m,
-          options: a,
-          context: l,
-          buildOptions: n,
-          helpers: { fragments: g }
-        });
-        const D = U(
-          r.builderEntries,
-          E,
-          r.createError
-        ).order, H = B(
-          ({ error: f, extensionKeys: h, hookSequence: R, errorMetadata: K }) => M({
-            error: f,
-            extensionKeys: h,
-            hookSequence: R,
-            errorMetadata: K,
-            context: l
-          })
-        ), w = "after-fragments", O = H.runLifecycle(
-          w,
-          {
-            hooks: r.extensionHooks,
-            hookOptions: y(u, w)
-          }
+    }, f = {
+      providedKeys: o.options.builderProvidedKeys,
+      onMissingDependency: ({ dependant: e, dependencyKey: i }) => {
+        const a = e.helper;
+        o.diagnosticManager.flagMissingDependency(
+          a,
+          i,
+          o.builderKind
+        ), o.diagnosticManager.flagUnusedHelper(
+          a,
+          o.builderKind,
+          `could not execute because dependency "${i}" was not found`,
+          a.dependsOn
         );
-        return x(O, (f) => {
-          u = f.artifact;
-          const h = () => H.createRollbackHandler(
-            f
-          ), R = h(), K = (i) => {
-            r.diagnosticManager.reviewUnusedHelpers(
-              r.builderEntries,
-              i,
-              r.builderKind
-            );
-            const d = v(
-              r.builderEntries,
-              i,
-              r.builderKind
-            );
-            A(
-              r.builderEntries,
-              d,
-              r.builderKind,
-              r.diagnosticManager.describeHelper,
-              r.createError
-            ), t = d;
-            const k = () => r.resolveRunResult({
-              artifact: u,
-              diagnostics: [
-                ...r.diagnosticManager.readDiagnostics()
-              ],
-              steps: b,
-              context: l,
-              buildOptions: n,
-              options: a,
-              helpers: {
-                fragments: g,
-                builders: t
-              }
-            }), S = h();
-            return x(
-              F(
-                () => H.commit(f),
-                S
-              ),
-              k
-            );
-          };
-          return F(() => x(
-            C(
-              D,
-              (i) => r.options.createBuilderArgs({
-                helper: i.helper,
-                options: a,
-                context: l,
-                buildOptions: n,
-                artifact: u
-              }),
-              (i, d, k) => i.apply(d, k),
-              (i) => p(i)
-            ),
-            K
-          ), R);
-        });
+      },
+      onUnresolvedHelpers: ({ unresolved: e }) => {
+        for (const i of e) {
+          const a = i.helper;
+          o.diagnosticManager.flagUnusedHelper(
+            a,
+            o.builderKind,
+            "could not execute because its dependencies never resolved",
+            a.dependsOn
+          );
+        }
+      }
+    }, N = o.options.createExtensionHookOptions ?? ((e) => ({
+      context: e.context,
+      options: e.options,
+      artifact: e.artifact,
+      lifecycle: e.lifecycle
+    })), $ = (e, i) => N({
+      context: n,
+      options: r,
+      buildOptions: t,
+      artifact: e,
+      lifecycle: i
+    }), q = o.options.onExtensionRollbackError ?? ((e) => {
+      const { reporter: i } = e.context, a = i.warn;
+      typeof a == "function" && a.call(i, "Pipeline extension rollback failed.", {
+        error: e.error,
+        errorName: e.errorMetadata.name,
+        errorMessage: e.errorMetadata.message,
+        errorStack: e.errorMetadata.stack,
+        errorCause: e.errorMetadata.cause,
+        extensions: e.extensionKeys,
+        hookKeys: e.hookSequence
       });
+    });
+    return {
+      runOptions: r,
+      buildOptions: t,
+      context: n,
+      draft: l,
+      fragmentOrder: c,
+      steps: s,
+      pushStep: m,
+      builderGraphOptions: f,
+      buildHookOptions: $,
+      handleRollbackError: q
+    };
+  }, R = (r, t, n) => {
+    o.diagnosticManager.reviewUnusedHelpers(
+      r.fragmentEntries,
+      t,
+      o.fragmentKind
+    );
+    const l = u(
+      r.fragmentEntries,
+      t,
+      o.fragmentKind
+    );
+    return E(
+      r.fragmentEntries,
+      l,
+      o.fragmentKind,
+      o.diagnosticManager.describeHelper,
+      o.createError
+    ), {
+      ...r,
+      fragmentVisited: t,
+      fragmentExecution: l,
+      fragmentRollbacks: n
+    };
+  }, H = (r, t, n) => {
+    o.diagnosticManager.reviewUnusedHelpers(
+      r.builderEntries,
+      t,
+      o.builderKind
+    );
+    const l = u(
+      r.builderEntries,
+      t,
+      o.builderKind
+    );
+    return E(
+      r.builderEntries,
+      l,
+      o.builderKind,
+      o.diagnosticManager.describeHelper,
+      o.createError
+    ), {
+      ...r,
+      builderVisited: t,
+      builderExecution: l,
+      builderRollbacks: n
+    };
+  }, O = (r, t) => o.options.createFragmentArgs({
+    helper: t.helper,
+    options: r.runOptions,
+    context: r.context,
+    buildOptions: r.buildOptions,
+    draft: r.draft
+  }), y = (r, t) => o.options.createBuilderArgs({
+    helper: t.helper,
+    options: r.runOptions,
+    context: r.context,
+    buildOptions: r.buildOptions,
+    artifact: r.artifact
+  }), M = (r) => (t) => O(r, t), F = (r) => (t) => y(r, t), K = (r) => r.fragmentRollbacks, S = (r) => r.builderRollbacks ?? [], d = (r) => ({
+    context: r.context,
+    extensionCoordinator: r.extensionCoordinator,
+    extensionState: r.extensionState
+  }), A = (r) => r.fragmentExecution ?? u(
+    r.fragmentEntries,
+    r.fragmentVisited,
+    o.fragmentKind
+  ), P = (r) => {
+    const { extensionCoordinator: t, extensionState: n } = r;
+    if (!(!t || !n))
+      return t.commit(n);
+  }, v = (r) => ({
+    context: r.context,
+    rollbackContext: d(r),
+    helperRollbacks: r.builderRollbacks ?? [],
+    onHelperRollbackError: o.options.onHelperRollbackError
+  }), w = (r, t) => Z(
+    {
+      rollbackPlan: v(r),
+      halt: p
+    },
+    t
+  ), B = (r) => (t) => {
+    const n = I(
+      ({ error: c, extensionKeys: s, hookSequence: m, errorMetadata: f }) => r.handleRollbackError({
+        error: c,
+        extensionKeys: s,
+        hookSequence: m,
+        errorMetadata: f,
+        context: t.context
+      })
+    ), l = n.runLifecycle(
+      h,
+      {
+        hooks: o.extensionHooks,
+        hookOptions: r.buildHookOptions(
+          t.artifact,
+          h
+        )
+      }
+    );
+    return b(
+      l,
+      (c) => ({
+        ...t,
+        artifact: c.artifact,
+        extensionCoordinator: n,
+        extensionState: c
+      })
+    );
+  }, U = (r) => r.helpers ?? {
+    fragments: r.fragmentExecution ?? u(
+      r.fragmentEntries,
+      r.fragmentVisited,
+      o.fragmentKind
+    ),
+    builders: r.builderExecution ?? u(
+      r.builderEntries,
+      r.builderVisited,
+      o.builderKind
+    )
+  }, z = (r) => ({
+    ...r,
+    helpers: U(r),
+    diagnostics: [
+      ...o.diagnosticManager.readDiagnostics()
+    ]
+  }), D = Y({
+    isHalt: g,
+    snapshotFragments: A,
+    applyArtifact: (r, t) => ({
+      ...r,
+      artifact: o.options.finalizeFragmentState({
+        draft: r.draft,
+        options: r.runOptions,
+        context: r.context,
+        buildOptions: r.buildOptions,
+        helpers: {
+          fragments: t
+        }
+      }),
+      fragmentExecution: t
+    })
+  }), T = (r) => X({
+    isHalt: g,
+    execute: B(r)
+  }), G = Q({
+    isHalt: g,
+    commit: P,
+    rollbackToHalt: w
+  }), V = J({
+    isHalt: g,
+    finalize: z
+  }), _ = {
+    getOrder: (r) => r.fragmentOrder,
+    makeArgs: M,
+    onVisited: (r, t, n) => R(r, t, n),
+    readRollbacks: K
+  }, C = {
+    getOrder: (r) => r.builderOrder,
+    makeArgs: F,
+    onVisited: (r, t, n) => H(r, t, n),
+    readRollbacks: S
+  }, L = (r) => {
+    const t = W({
+      pushStep: r.pushStep,
+      toRollbackContext: d,
+      halt: p,
+      isHalt: g,
+      onHelperRollbackError: o.options.onHelperRollbackError
+    }), n = t(_), l = t(C), c = [
+      V,
+      G,
+      l,
+      T(r),
+      D,
+      n
+    ];
+    return j(...c);
+  };
+  return {
+    prepareContext: k,
+    executeRun: (r) => {
+      const t = x(
+        o.builderEntries,
+        r.builderGraphOptions,
+        o.createError
+      ).order, n = {
+        context: r.context,
+        reporter: r.context.reporter,
+        runOptions: r.runOptions,
+        buildOptions: r.buildOptions,
+        fragmentEntries: o.fragmentEntries,
+        builderEntries: o.builderEntries,
+        fragmentOrder: r.fragmentOrder,
+        builderOrder: t,
+        fragmentVisited: /* @__PURE__ */ new Set(),
+        builderVisited: /* @__PURE__ */ new Set(),
+        draft: r.draft,
+        artifact: null,
+        steps: r.steps,
+        diagnostics: [],
+        fragmentRollbacks: [],
+        builderRollbacks: []
+      }, l = L(r), c = (s) => {
+        if (g(s))
+          throw s.error ?? new Error("Pipeline halted");
+        return o.resolveRunResult({
+          artifact: s.artifact,
+          diagnostics: s.diagnostics,
+          steps: s.steps,
+          context: s.context,
+          buildOptions: s.buildOptions,
+          options: s.runOptions,
+          helpers: s.helpers
+        });
+      };
+      return b(l(n), c);
     }
   };
 }
 export {
-  j as initPipelineRunner
+  ar as initPipelineRunner
 };

package/dist/internal/pipeline-runner.types.d.ts

@@ -1,6 +1,8 @@
 import { CreateDependencyGraphOptions, RegisteredHelper } from '../dependency-graph';
 import { ErrorFactory } from '../error-factory';
-import { CreatePipelineOptions, Helper, HelperApplyOptions, HelperKind, MaybePromise, PipelineDiagnostic, PipelineExecutionMetadata, PipelineExtensionHookOptions, PipelineExtensionLifecycle, PipelineExtensionRollbackErrorMetadata, PipelineReporter, PipelineStep } from '../types';
+import { CreatePipelineOptions, Helper, HelperApplyOptions, HelperExecutionSnapshot, HelperKind, MaybePromise, PipelineDiagnostic, PipelineExecutionMetadata, PipelineExtensionHookOptions, PipelineExtensionLifecycle, PipelineExtensionRollbackErrorMetadata, PipelineReporter, PipelineStep } from '../types';
+import { PipelineRollback } from '../rollback';
+import { ExtensionCoordinator, ExtensionLifecycleState } from './extension-coordinator.types';
 import { DiagnosticManager } from './diagnostic-manager.types';
 import { ExtensionHookEntry } from '../extensions';
 /**
@@ -75,5 +77,91 @@ export interface PipelineRunner<TRunOptions, TBuildOptions, TContext extends {
         helperArgs: HelperApplyOptions<unknown, unknown, unknown>;
     };
 }
+/**
+ * Closed-world state threaded through composed pipeline programs. While the implementation still
+ * mutates some nested values (e.g. `steps`), every program returns a new state value to keep the
+ * orchestrator closed under composition.
+ *
+ * @category Pipeline
+ * @internal
+ */
+export interface PipelineState<TRunOptions, TBuildOptions, TContext extends {
+    reporter: TReporter;
+}, TReporter extends PipelineReporter, TDraft, TArtifact, TDiagnostic extends PipelineDiagnostic, TFragmentInput, TFragmentOutput, TBuilderInput, TBuilderOutput, TFragmentKind extends HelperKind, TBuilderKind extends HelperKind, TFragmentHelper extends Helper<TContext, TFragmentInput, TFragmentOutput, TReporter, TFragmentKind>, TBuilderHelper extends Helper<TContext, TBuilderInput, TBuilderOutput, TReporter, TBuilderKind>> {
+    readonly context: TContext;
+    readonly reporter: TReporter;
+    readonly runOptions: TRunOptions;
+    readonly buildOptions: TBuildOptions;
+    readonly fragmentEntries: RegisteredHelper<TFragmentHelper>[];
+    readonly builderEntries: RegisteredHelper<TBuilderHelper>[];
+    readonly fragmentOrder: RegisteredHelper<TFragmentHelper>[];
+    readonly builderOrder: RegisteredHelper<TBuilderHelper>[];
+    readonly fragmentVisited: Set<string>;
+    readonly builderVisited: Set<string>;
+    readonly draft: TDraft;
+    readonly artifact: TArtifact | null;
+    readonly steps: PipelineStep[];
+    readonly diagnostics: TDiagnostic[];
+    readonly fragmentExecution?: HelperExecutionSnapshot<TFragmentKind>;
+    readonly builderExecution?: HelperExecutionSnapshot<TBuilderKind>;
+    readonly helpers?: PipelineExecutionMetadata<TFragmentKind, TBuilderKind>;
+    readonly fragmentRollbacks?: Array<{
+        readonly helper: TFragmentHelper;
+        readonly rollback: PipelineRollback;
+    }>;
+    readonly builderRollbacks?: Array<{
+        readonly helper: TBuilderHelper;
+        readonly rollback: PipelineRollback;
+    }>;
+    readonly extensionCoordinator?: ExtensionCoordinator<TContext, TRunOptions, TArtifact>;
+    readonly extensionState?: ExtensionLifecycleState<TContext, TRunOptions, TArtifact>;
+}
 export type { ExtensionHookEntry };
+export type RollbackCapableCoordinator<TContext, TOptions, TArtifact> = {
+    createRollbackHandler: <TResult>(state: ExtensionLifecycleState<TContext, TOptions, TArtifact>) => (error: unknown) => MaybePromise<TResult>;
+};
+export type RollbackEntry<THelper> = {
+    readonly helper: THelper;
+    readonly rollback: PipelineRollback;
+};
+export type Halt<TRunResult> = {
+    readonly __halt: true;
+    readonly error?: unknown;
+    readonly result?: TRunResult;
+};
+export type RollbackContext<TContext, TOptions, TArtifact> = {
+    readonly context: TContext;
+    readonly extensionCoordinator?: RollbackCapableCoordinator<TContext, TOptions, TArtifact>;
+    readonly extensionState?: ExtensionLifecycleState<TContext, TOptions, TArtifact>;
+};
+export type HelperInvokeOptions<THelper, TInput, TOutput, TContext, TReporter extends PipelineReporter> = {
+    readonly helper: THelper;
+    readonly args: HelperApplyOptions<TContext, TInput, TOutput, TReporter>;
+    readonly next: () => MaybePromise<void>;
+};
+export type StageEnv<TState, TRunResult, TContext, TOptions, TArtifact, TReporter extends PipelineReporter> = {
+    pushStep: (entry: RegisteredHelper<unknown>) => void;
+    toRollbackContext: (state: TState) => RollbackContext<TContext, TOptions, TArtifact>;
+    halt: (error?: unknown) => Halt<TRunResult>;
+    isHalt: (value: unknown) => value is Halt<TRunResult>;
+    onHelperRollbackError?: (options: {
+        readonly error: unknown;
+        readonly helper: Helper<TContext, unknown, unknown, TReporter, HelperKind>;
+        readonly errorMetadata: PipelineExtensionRollbackErrorMetadata;
+        readonly context: TContext;
+    }) => void;
+};
+export type HelperRollbackPlan<TContext, TOptions, TArtifact, THelper extends {
+    key: string;
+}> = {
+    readonly context: TContext;
+    readonly rollbackContext: RollbackContext<TContext, TOptions, TArtifact>;
+    readonly helperRollbacks: readonly RollbackEntry<THelper>[];
+    readonly onHelperRollbackError?: (options: {
+        readonly error: unknown;
+        readonly helper: THelper;
+        readonly errorMetadata: PipelineExtensionRollbackErrorMetadata;
+        readonly context: TContext;
+    }) => void;
+};
 //# sourceMappingURL=pipeline-runner.types.d.ts.map