《移动游戏产品的架构·网络、资源与热更新》13.2 交付流水线与发布门禁

// file: src/delivery/pipeline.ts
// tier: L1
// verify: node --test test/delivery/pipeline.test.ts
export type StageId = "build" | "sign" | "upload" | "gray" | "full" | "rollback";

export interface Stage {
  readonly id: StageId;
  readonly requires: readonly StageId[];
  readonly check: string;
}

export const PIPELINE: readonly Stage[] = [
  { id: "build", requires: [], check: "artifacts hashed" },
  { id: "sign", requires: ["build"], check: "signature verified" },
  { id: "upload", requires: ["sign"], check: "cdn checksum matched" },
  { id: "gray", requires: ["upload"], check: "gray metrics within budget" },
  { id: "full", requires: ["gray"], check: "convergence reached" },
  { id: "rollback", requires: ["upload"], check: "previous version available" },
];

export interface PipelineReport {
  readonly ready: readonly StageId[];
  readonly blocked: readonly StageId[];
  readonly unknown: readonly string[];
}

export function validatePipeline(stages: readonly Stage[]): readonly string[] {
  const problems: string[] = [];
  const ids = new Set<string>();
  for (const stage of stages) {
    if (ids.has(stage.id)) {
      problems.push(`duplicate stage: ${stage.id}`);
    }
    ids.add(stage.id);
  }
  for (const stage of stages) {
    for (const dep of stage.requires) {
      if (!ids.has(dep)) {
        problems.push(`unknown dependency: ${stage.id} -> ${dep}`);
      }
    }
  }
  return problems;
}

export function topoOrder(stages: readonly Stage[]): readonly StageId[] {
  const byId = new Map(stages.map((stage) => [stage.id, stage]));
  const visiting = new Set<StageId>();
  const done = new Set<StageId>();
  const order: StageId[] = [];

  function visit(id: StageId): void {
    if (done.has(id)) {
      return;
    }
    if (visiting.has(id)) {
      throw new Error(`cycle detected at ${id}`);
    }
    const stage = byId.get(id);
    if (!stage) {
      throw new Error(`unknown stage: ${id}`);
    }
    visiting.add(id);
    for (const dep of stage.requires) {
      visit(dep);
    }
    visiting.delete(id);
    done.add(id);
    order.push(id);
  }

  for (const stage of stages) {
    visit(stage.id);
  }
  return order;
}

export function evaluatePipeline(
  stages: readonly Stage[],
  completed: readonly string[],
): PipelineReport {
  const done = new Set(completed);
  const known = new Set(stages.map((stage) => stage.id));
  const unknown = completed.filter((id) => !known.has(id));
  const ready: StageId[] = [];
  const blocked: StageId[] = [];

  for (const stage of stages) {
    if (done.has(stage.id)) {
      continue;
    }
    const satisfied = stage.requires.every((dep) => done.has(dep));
    if (satisfied) {
      ready.push(stage.id);
    } else {
      blocked.push(stage.id);
    }
  }
  return { ready, blocked, unknown };
}

export function formatPipeline(stages: readonly Stage[]): string {
  const header = "stage\trequires\tcheck";
  const rows = stages.map(
    (stage) => `${stage.id}\t${stage.requires.join(",") || "-"}\t${stage.check}`,
  );
  return [header, ...rows].join("\n");
}