@pixel-point/toolcraft 0.0.18 → 0.0.19

package/templates/starter/scripts/toolcraft-verification-impact-support-resolution.test.mjs

@@ -1,195 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import {
-  createToolcraftFunctionalProofModel,
-} from "./toolcraft-functional-proof-model.mjs";
-import {
-  resolveToolcraftChangedVerificationImpact,
-} from "./toolcraft-verification-impact.mjs";
-import {
-  toolcraftVerificationInputRootFamilies,
-} from "./toolcraft-verification-input-roles.mjs";
-
-const hash = (value) => value.repeat(64);
-const catalog = Object.freeze({
-  acceptance: Object.freeze([
-    Object.freeze({
-      acceptanceId: "appearance.background",
-      contractHash: hash("a"),
-      domainId: "appearance",
-      file: "app-appearance.spec.ts",
-      testName: "browser: background",
-    }),
-    Object.freeze({
-      acceptanceId: "appearance.foreground",
-      contractHash: hash("b"),
-      domainId: "appearance",
-      file: "app-appearance.spec.ts",
-      testName: "browser: foreground",
-    }),
-    Object.freeze({
-      acceptanceId: "persistence.reload",
-      contractHash: hash("c"),
-      domainId: "persistence",
-      file: "app-persistence.spec.ts",
-      testName: "browser: persistence",
-    }),
-  ]),
-  performance: Object.freeze([]),
-  version: 2,
-});
-const model = createToolcraftFunctionalProofModel({
-  catalog,
-  inventory: { owners: [], version: 3 },
-});
-
-function graph(entries, reverse = {}) {
-  return Object.freeze({
-    entries: Object.freeze(entries),
-    reverse: new Map(
-      entries.map(({ repoPath }) => [
-        repoPath,
-        Object.freeze([...(reverse[repoPath] ?? [])]),
-      ]),
-    ),
-  });
-}
-
-function roles(roleByPath) {
-  return Object.freeze({
-    impactInventoryPath: "src/app/app-verification-impact.json",
-    productResourcePaths: Object.freeze([]),
-    productTestPaths: Object.freeze(Object.keys(roleByPath)),
-    proofModelPaths: Object.freeze([]),
-    roleByPath: Object.freeze({ ...roleByPath }),
-    rootFamily: "generated",
-    runtimeProductionPaths: Object.freeze([]),
-    semanticProofRootPaths:
-      toolcraftVerificationInputRootFamilies.generated
-        .semanticProofRootPaths,
-  });
-}
-
-function resolve({ changedFiles, entries, reverse, roleByPath }) {
-  return resolveToolcraftChangedVerificationImpact({
-    catalog,
-    changedFiles,
-    currentModel: model,
-    graph: graph(entries, reverse),
-    previousModel: model,
-    roles: roles(roleByPath),
-  });
-}
-
-test("a changed browser file selects its current acceptance domain", () => {
-  const browserPath = "e2e/app-appearance.spec.ts";
-  const result = resolve({
-    changedFiles: [browserPath],
-    entries: [{ owner: "product", repoPath: browserPath, role: "test" }],
-    roleByPath: { [browserPath]: "product-test" },
-  });
-
-  assert.deepEqual(result.acceptanceIds, [
-    "appearance.background",
-    "appearance.foreground",
-  ]);
-  assert.deepEqual(result.browserTestNames, [
-    "browser: background",
-    "browser: foreground",
-  ]);
-  assert.equal(result.buildRequired, true);
-});
-
-test("a shared browser helper selects only domains of affected browser files", () => {
-  const helperPath = "e2e/test-support/shared-fixture.ts";
-  const appearancePath = "e2e/app-appearance.spec.ts";
-  const persistencePath = "e2e/app-persistence.spec.ts";
-  const unrelatedUnitPath = "src/features/unrelated.test.ts";
-  const entries = [
-    { owner: "product", repoPath: helperPath, role: "test-support" },
-    { owner: "product", repoPath: appearancePath, role: "test" },
-    { owner: "product", repoPath: persistencePath, role: "test" },
-    { owner: "product", repoPath: unrelatedUnitPath, role: "test" },
-  ];
-  const roleByPath = {
-    [appearancePath]: "product-test",
-    [helperPath]: "product-test",
-    [persistencePath]: "product-test",
-    [unrelatedUnitPath]: "product-test",
-  };
-
-  const appearanceOnly = resolve({
-    changedFiles: [helperPath],
-    entries,
-    reverse: { [helperPath]: [appearancePath] },
-    roleByPath,
-  });
-  assert.deepEqual(appearanceOnly.acceptanceIds, [
-    "appearance.background",
-    "appearance.foreground",
-  ]);
-  assert.deepEqual(appearanceOnly.productTestFiles, []);
-
-  const bothDomains = resolve({
-    changedFiles: [helperPath],
-    entries,
-    reverse: {
-      [helperPath]: [appearancePath, persistencePath],
-    },
-    roleByPath,
-  });
-  assert.deepEqual(bothDomains.acceptanceIds, [
-    "appearance.background",
-    "appearance.foreground",
-    "persistence.reload",
-  ]);
-  assert.equal(
-    bothDomains.productTestFiles.includes(unrelatedUnitPath),
-    false,
-  );
-});
-
-test("test support without an executable importer fails with the exact path", () => {
-  const currentPath = "src/test-support/current-fixture.ts";
-  const deletedPath = "e2e/test-support/deleted-fixture.ts";
-  for (const [changedPath, entries, roleByPath] of [
-    [
-      currentPath,
-      [{ owner: "product", repoPath: currentPath, role: "test-support" }],
-      { [currentPath]: "product-test" },
-    ],
-    [deletedPath, [], {}],
-  ]) {
-    assert.throws(
-      () =>
-        resolve({
-          changedFiles: [changedPath],
-          entries,
-          roleByPath,
-        }),
-      new RegExp(changedPath.replaceAll(".", "\\."), "u"),
-    );
-  }
-});
-
-test("a support helper can select affected Vitest without browser widening", () => {
-  const helperPath = "src/test-support/unit-fixture.ts";
-  const unitPath = "src/features/output.test.ts";
-  const result = resolve({
-    changedFiles: [helperPath],
-    entries: [
-      { owner: "product", repoPath: helperPath, role: "test-support" },
-      { owner: "product", repoPath: unitPath, role: "test" },
-    ],
-    reverse: { [helperPath]: [unitPath] },
-    roleByPath: {
-      [helperPath]: "product-test",
-      [unitPath]: "product-test",
-    },
-  });
-
-  assert.deepEqual(result.productTestFiles, [unitPath]);
-  assert.deepEqual(result.browserTestNames, []);
-  assert.equal(result.buildRequired, false);
-});

package/templates/starter/scripts/toolcraft-verification-impact.d.mts

@@ -1,132 +0,0 @@
-import type {
-  ToolcraftDeliveryCatalog,
-  ToolcraftVerificationImpactInventory,
-} from "./toolcraft-verification-impact-inventory.mjs";
-export type {
-  ToolcraftDeliveryCatalog,
-  ToolcraftVerificationImpactFunctionalOwner,
-  ToolcraftVerificationImpactInventory,
-  ToolcraftVerificationImpactOwner,
-  ToolcraftVerificationImpactPerformanceOwner,
-} from "./toolcraft-verification-impact-inventory.mjs";
-
-export type ToolcraftVerificationImpact = Readonly<{
-  acceptanceIds: readonly string[];
-  browserTestNames: readonly string[];
-  buildRequired: boolean;
-  performanceCandidates: Readonly<{
-    passIds: readonly string[];
-    pathIds: readonly string[];
-    testNames: readonly string[];
-  }>;
-  productTestFiles: readonly string[];
-}>;
-
-export type ToolcraftProductVerificationSourceEntry = Readonly<{
-  absolutePath: string;
-  owner: "framework" | "platform" | "product";
-  repoPath: string;
-  role: "generated" | "production" | "test" | "test-support";
-}>;
-
-export type ToolcraftProductVerificationSourceInventory = Readonly<{
-  entries: readonly ToolcraftProductVerificationSourceEntry[];
-  filesystemViolations: readonly Readonly<{
-    reason: string;
-    repoPath: string;
-  }>[];
-}>;
-
-export type ToolcraftProductVerificationGraph = Readonly<{
-  entries: readonly ToolcraftProductVerificationSourceEntry[];
-  forward: ReadonlyMap<string, readonly string[]>;
-  reverse: ReadonlyMap<string, readonly string[]>;
-}>;
-
-export type ToolcraftProductVerificationContext = Readonly<{
-  frameworkOwnedPaths: readonly string[];
-  graph: ToolcraftProductVerificationGraph;
-  inputRoles: import("./toolcraft-verification-input-roles.mjs").ToolcraftVerificationInputRoles;
-  sourceInventory: ToolcraftProductVerificationSourceInventory;
-}>;
-
-export {
-  TOOLCRAFT_VERIFICATION_IMPACT_VERSION,
-} from "./toolcraft-verification-impact-inventory.mjs";
-
-export function collectToolcraftProductVerificationSources(
-  rootDir: string,
-): Promise<Readonly<{
-  frameworkOwnedPaths: readonly string[];
-  sourceInventory: ToolcraftProductVerificationSourceInventory;
-}>>;
-
-export function createToolcraftProductVerificationContext(
-  rootDir: string,
-): Promise<ToolcraftProductVerificationContext>;
-
-export function createToolcraftProductVerificationContextCore(options: {
-  dependencies: Readonly<{
-    classifyInputRoles(
-      graph: ToolcraftProductVerificationGraph,
-    ): import("./toolcraft-verification-input-roles.mjs").ToolcraftVerificationInputRoles;
-    collectFrameworkOwnedPaths(rootDir: string): Promise<readonly string[]>;
-    collectSourceInventory(options: {
-      includeResourceFiles: boolean;
-      protectedFilePaths: readonly string[];
-      rootDir: string;
-      sourceRoots: readonly string[];
-    }): Promise<ToolcraftProductVerificationSourceInventory>;
-    createDefaultAliases(rootDir: string): readonly unknown[];
-    createDependencyGraph(options: {
-      aliases: readonly unknown[];
-      analyzedEntryPaths: readonly string[];
-      entries: readonly unknown[];
-      rootDir: string;
-      sourceRecordMode: "imports-only";
-    }): Promise<ToolcraftProductVerificationGraph>;
-    loadAliases(options: {
-      rootDir: string;
-      tsconfigPaths: readonly string[];
-    }): Promise<readonly unknown[]>;
-  }>;
-  rootDir: string;
-}): Promise<ToolcraftProductVerificationContext>;
-
-export function validateToolcraftVerificationImpactInventory(
-  value: unknown,
-  options: {
-    catalog: ToolcraftDeliveryCatalog;
-    requiredOwnerPaths: readonly string[];
-  },
-): {
-  errors: string[];
-  inventory?: ToolcraftVerificationImpactInventory;
-};
-
-export function readToolcraftVerificationImpactInventory(
-  rootDir: string,
-  options: {
-    catalog: ToolcraftDeliveryCatalog;
-    inputRoles: import("./toolcraft-verification-input-roles.mjs").ToolcraftVerificationInputRoles;
-  },
-): Promise<Readonly<{
-  inventory: ToolcraftVerificationImpactInventory;
-  path: string;
-}>>;
-
-export function resolveToolcraftChangedVerificationImpact(options: {
-  catalog: ToolcraftDeliveryCatalog;
-  changedFiles: readonly string[];
-  currentModel: import("./toolcraft-functional-proof-model.mjs").ToolcraftFunctionalProofModel;
-  graph: Readonly<{
-    entries: readonly Readonly<{
-      owner: "framework" | "platform" | "product";
-      repoPath: string;
-      role: "generated" | "production" | "test" | "test-support";
-    }>[];
-    reverse: ReadonlyMap<string, readonly string[]>;
-  }>;
-  previousModel: import("./toolcraft-functional-proof-model.mjs").ToolcraftFunctionalProofModel;
-  roles: import("./toolcraft-verification-input-roles.mjs").ToolcraftVerificationInputRoles;
-}): ToolcraftVerificationImpact;

package/templates/starter/scripts/toolcraft-verification-impact.mjs

@@ -1,169 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-
-import { collectToolcraftSourceInventory } from "./toolcraft-source-inventory.mjs";
-import {
-  collectToolcraftFrameworkOwnedLocalPaths,
-} from "./toolcraft-source-ownership.mjs";
-import {
-  createToolcraftLocalDependencyGraph,
-} from "./toolcraft-local-dependency-graph.mjs";
-import {
-  createToolcraftDefaultSourceAliases,
-  loadToolcraftLocalModuleAliases,
-} from "./toolcraft-product-dependency-resolution.mjs";
-import {
-  classifyToolcraftVerificationInputRoles,
-  toolcraftVerificationSourceRoots,
-} from "./toolcraft-verification-input-roles.mjs";
-import {
-  TOOLCRAFT_VERIFICATION_IMPACT_VERSION,
-  validateToolcraftVerificationImpactInventory,
-} from "./toolcraft-verification-impact-inventory.mjs";
-import {
-  resolveToolcraftChangedVerificationImpact,
-} from "./toolcraft-verification-impact-resolution.mjs";
-
-export {
-  TOOLCRAFT_VERIFICATION_IMPACT_VERSION,
-  resolveToolcraftChangedVerificationImpact,
-  validateToolcraftVerificationImpactInventory,
-};
-
-function createImmutableSourceInventory(sourceInventory) {
-  return Object.freeze({
-    entries: Object.freeze(
-      sourceInventory.entries.map((entry) =>
-        Object.freeze({ ...entry }),
-      ),
-    ),
-    filesystemViolations: Object.freeze(
-      sourceInventory.filesystemViolations.map((violation) =>
-        Object.freeze({ ...violation }),
-      ),
-    ),
-  });
-}
-
-const compareCodeUnits = (left, right) =>
-  left < right ? -1 : left > right ? 1 : 0;
-
-function shouldAnalyzeVerificationEntry({ owner, repoPath, role }) {
-  return (
-    owner === "product" ||
-    role === "test" ||
-    role === "test-support" ||
-    repoPath.startsWith("src/app/")
-  );
-}
-
-async function collectProductVerificationSources(
-  { collectFrameworkOwnedPaths, collectSourceInventory },
-  rootDir,
-) {
-  const frameworkOwnedPaths = Object.freeze(
-    [...new Set(
-      await collectFrameworkOwnedPaths(rootDir),
-    )].sort(compareCodeUnits),
-  );
-  const collected = await collectSourceInventory({
-    includeResourceFiles: true,
-    protectedFilePaths: frameworkOwnedPaths,
-    rootDir,
-    sourceRoots: toolcraftVerificationSourceRoots,
-  });
-  const sourceInventory = createImmutableSourceInventory(collected);
-  return Object.freeze({ frameworkOwnedPaths, sourceInventory });
-}
-
-const defaultSourceDependencies = Object.freeze({
-  collectFrameworkOwnedPaths:
-    collectToolcraftFrameworkOwnedLocalPaths,
-  collectSourceInventory: collectToolcraftSourceInventory,
-});
-
-const defaultContextDependencies = Object.freeze({
-  ...defaultSourceDependencies,
-  classifyInputRoles: classifyToolcraftVerificationInputRoles,
-  createDefaultAliases: createToolcraftDefaultSourceAliases,
-  createDependencyGraph: createToolcraftLocalDependencyGraph,
-  loadAliases: loadToolcraftLocalModuleAliases,
-});
-
-export function collectToolcraftProductVerificationSources(rootDir) {
-  return collectProductVerificationSources(
-    defaultSourceDependencies,
-    rootDir,
-  );
-}
-
-export async function createToolcraftProductVerificationContextCore({
-  dependencies,
-  rootDir,
-}) {
-  const { frameworkOwnedPaths, sourceInventory } =
-    await collectProductVerificationSources(dependencies, rootDir);
-  const configuredAliases = await dependencies.loadAliases({
-    rootDir,
-    tsconfigPaths: ["tsconfig.json"],
-  });
-  const graph = await dependencies.createDependencyGraph({
-    aliases: [
-      ...configuredAliases,
-      ...dependencies.createDefaultAliases(rootDir),
-    ],
-    analyzedEntryPaths: sourceInventory.entries
-      .filter(shouldAnalyzeVerificationEntry)
-      .map(({ repoPath }) => repoPath),
-    entries: sourceInventory.entries,
-    rootDir,
-    sourceRecordMode: "imports-only",
-  });
-  const inputRoles = dependencies.classifyInputRoles(graph);
-  return Object.freeze({
-    frameworkOwnedPaths,
-    graph,
-    inputRoles,
-    sourceInventory,
-  });
-}
-
-export function createToolcraftProductVerificationContext(rootDir) {
-  return createToolcraftProductVerificationContextCore({
-    dependencies: defaultContextDependencies,
-    rootDir,
-  });
-}
-
-export async function readToolcraftVerificationImpactInventory(
-  rootDir,
-  { catalog, inputRoles },
-) {
-  const inventoryPath = path.join(rootDir, inputRoles.impactInventoryPath);
-  let value;
-  try {
-    value = JSON.parse(await fs.readFile(inventoryPath, "utf8"));
-  } catch (error) {
-    if (error instanceof SyntaxError) {
-      throw new Error(
-        "Toolcraft verification impact inventory is malformed JSON.",
-      );
-    }
-    throw error;
-  }
-  const requiredOwnerPaths = [
-    ...inputRoles.runtimeProductionPaths,
-    ...inputRoles.productResourcePaths,
-  ];
-  const validation = validateToolcraftVerificationImpactInventory(value, {
-    catalog,
-    requiredOwnerPaths,
-  });
-  if (validation.errors.length > 0) {
-    throw new Error(validation.errors.join("\n"));
-  }
-  return Object.freeze({
-    inventory: validation.inventory,
-    path: inventoryPath,
-  });
-}