@ykdz/template 0.0.4 → 0.0.6

package/dist/src/generated-scenarios.js

@@ -0,0 +1,361 @@
+import { readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import { execa } from "execa";
+import { assembleGenerationContext } from "./generation-context.js";
+import { renderPlaywrightBrowserInstallCommand, } from "./module-graph.js";
+import { planNextStepInstructions } from "./next-step-instructions.js";
+import { findPresetSourceManifestPreset } from "./preset-source.js";
+import { blueprintForPresetSourcePreset, projectPresetSourcePreset, } from "./projection-capabilities.js";
+const defaultDeterministicToolchainEnv = {
+    TEMPLATE_TOOLCHAIN_RESOLUTION: "bundled-fallback",
+};
+const defaultFixtureConcurrency = 2;
+export function createExclusiveLock() {
+    let tail = Promise.resolve();
+    return {
+        async run(callback) {
+            const previous = tail;
+            let release;
+            tail = new Promise((resolve) => {
+                release = resolve;
+            });
+            await previous;
+            try {
+                return await callback();
+            }
+            finally {
+                release();
+            }
+        },
+    };
+}
+export function generatedScenarioId(scenario) {
+    if (!scenario.addedPreset) {
+        return scenario.basePreset;
+    }
+    if (scenario.linkFrom && scenario.linkFrom.length > 0) {
+        const linkFromId = scenario.linkFrom
+            .map((packagePath) => packagePath.replaceAll("/", "-"))
+            .join("-");
+        return `${scenario.basePreset}-add-${scenario.addedPreset}-link-from-${linkFromId}`;
+    }
+    return `${scenario.basePreset}-add-${scenario.addedPreset}`;
+}
+export function generatedScenarioLabel(scenario) {
+    if (!scenario.addedPreset) {
+        return scenario.basePreset;
+    }
+    if (scenario.linkFrom && scenario.linkFrom.length > 0) {
+        return `${scenario.basePreset} + ${scenario.addedPreset} linked from ${scenario.linkFrom.join(", ")}`;
+    }
+    return `${scenario.basePreset} + ${scenario.addedPreset}`;
+}
+function scenario(set, input) {
+    return {
+        set,
+        basePreset: input.basePreset,
+        addedPreset: input.addedPreset,
+        linkFrom: input.linkFrom ? [...input.linkFrom] : undefined,
+        id: generatedScenarioId(input),
+        label: generatedScenarioLabel(input),
+    };
+}
+export function selectGeneratedScenarios(manifest, set) {
+    const contract = manifest.fixtureMatrix;
+    if (!contract) {
+        throw new Error(`Preset Source ${manifest.name} does not declare a Fixture Matrix Contract`);
+    }
+    const initScenarios = contract.initSupport.map((support) => scenario(set, { basePreset: support.preset }));
+    if (set === "init") {
+        return { runnable: initScenarios, skipped: [] };
+    }
+    const matrixScenarios = contract.supportedCombinations.map((combination) => scenario(set, {
+        basePreset: combination.basePreset,
+        addedPreset: combination.addedPreset,
+        linkFrom: combination.linkFrom,
+    }));
+    const skipped = contract.semanticSkips.map((skip) => ({
+        set,
+        basePreset: skip.basePreset,
+        addedPreset: skip.addedPreset,
+        id: generatedScenarioId(skip),
+        label: generatedScenarioLabel(skip),
+        reason: skip.reason,
+    }));
+    return {
+        runnable: matrixScenarios,
+        skipped,
+    };
+}
+export function packageLeafNameForAddedPreset(manifest, presetName) {
+    const support = manifest.fixtureMatrix?.packageAdditionSupport.find((entry) => entry.preset === presetName);
+    if (!support) {
+        throw new Error(`Missing fixture Package Addition leaf name for preset: ${presetName}`);
+    }
+    return support.packageLeafName;
+}
+export async function defaultGeneratedScenarioCommandRunner(command, args, cwd, options = {}) {
+    const prefix = options.logPrefix ? `[${options.logPrefix}] ` : "";
+    console.log(`${prefix}$ ${[command, ...args].join(" ")}`);
+    await execa(command, [...args], {
+        cwd,
+        env: options.env,
+        stdio: "inherit",
+    });
+}
+async function generateScenario(scenario, workspace, options) {
+    const projectDir = path.join(workspace, `fixture-${scenario.id}`);
+    await options.runCommand("pnpm", [
+        "exec",
+        "tsx",
+        options.cliPath,
+        "init",
+        projectDir,
+        "--preset",
+        scenario.basePreset,
+        "--yes",
+    ], options.repoRoot, {
+        env: options.deterministicToolchainEnv,
+        logPrefix: scenario.label,
+    });
+    return projectDir;
+}
+async function applyPackageAddition(manifest, scenario, projectDir, options) {
+    if (!scenario.addedPreset) {
+        return undefined;
+    }
+    const packageLeafName = packageLeafNameForAddedPreset(manifest, scenario.addedPreset);
+    const beforeConsumerSources = await linkedConsumerSourceSnapshots(projectDir, scenario.linkFrom ?? []);
+    await options.runCommand("pnpm", [
+        "exec",
+        "tsx",
+        options.cliPath,
+        "add",
+        "package",
+        "--preset",
+        scenario.addedPreset,
+        "--name",
+        packageLeafName,
+        ...linkFromArgs(scenario.linkFrom ?? []),
+    ], projectDir, { logPrefix: scenario.label });
+    await assertLinkedConsumerSourcesUnchanged(projectDir, beforeConsumerSources);
+    return readAddedPackagePath(projectDir, packageLeafName);
+}
+function linkFromArgs(packagePaths) {
+    return packagePaths.flatMap((packagePath) => ["--link-from", packagePath]);
+}
+async function linkedConsumerSourceSnapshots(projectDir, packagePaths) {
+    const snapshots = new Map();
+    for (const packagePath of packagePaths) {
+        snapshots.set(packagePath, await sourceFileSnapshot(path.join(projectDir, packagePath, "src")));
+    }
+    return snapshots;
+}
+async function sourceFileSnapshot(sourceDir, currentDir = sourceDir) {
+    const snapshot = {};
+    const entries = await readdir(currentDir, { withFileTypes: true });
+    for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+        const entryPath = path.join(currentDir, entry.name);
+        if (entry.isDirectory()) {
+            Object.assign(snapshot, await sourceFileSnapshot(sourceDir, entryPath));
+            continue;
+        }
+        if (entry.isFile()) {
+            snapshot[path.relative(sourceDir, entryPath)] = await readFile(entryPath, "utf8");
+        }
+    }
+    return snapshot;
+}
+async function assertLinkedConsumerSourcesUnchanged(projectDir, beforeSnapshots) {
+    for (const [packagePath, beforeSnapshot] of beforeSnapshots) {
+        const afterSnapshot = await sourceFileSnapshot(path.join(projectDir, packagePath, "src"));
+        if (JSON.stringify(afterSnapshot) !== JSON.stringify(beforeSnapshot)) {
+            throw new Error(`Package Link Intent fixture modified consumer source files for ${packagePath}`);
+        }
+    }
+}
+async function readAddedPackagePath(projectDir, packageLeafName) {
+    const blueprint = JSON.parse(await readFile(path.join(projectDir, ".template", "blueprint.json"), "utf8"));
+    const packageDefinition = blueprint.packages?.find((pkg) => path.basename(pkg.path) === packageLeafName);
+    if (!packageDefinition) {
+        throw new Error(`Package Addition fixture did not record package leaf ${packageLeafName}`);
+    }
+    return packageDefinition.path;
+}
+function projectionPlanForPreset(presetName, projectDir, manifest, options, packageScope) {
+    const preset = findPresetSourceManifestPreset(manifest, presetName);
+    if (!preset?.projection) {
+        throw new Error(`Missing Preset Projection for fixture preset ${presetName}`);
+    }
+    const blueprint = blueprintForPresetSourcePreset(preset, {
+        targetDir: projectDir,
+        scope: packageScope,
+    });
+    return projectPresetSourcePreset({
+        preset,
+        context: assembleGenerationContext({
+            targetDir: projectDir,
+            blueprint,
+            toolchain: {
+                nodeLtsMajor: { kind: "NodeLtsMajor", value: "24" },
+                packageManagerPin: { kind: "PackageManagerPin", value: "pnpm@10.0.0" },
+                source: "bundled-fallback",
+                diagnostics: [],
+            },
+        }),
+    });
+}
+function machineVerifiableNextStepsForPreset(presetName, projectDir, manifest, options) {
+    const projectionPlan = projectionPlanForPreset(presetName, projectDir, manifest, options);
+    const plan = planNextStepInstructions({
+        targetDir: projectDir,
+        projectionPlan,
+    });
+    return plan.steps
+        .filter((step) => step.machineVerifiable && step.kind === "command")
+        .map((step) => ({
+        id: step.id,
+        command: step.command,
+        args: step.args,
+        cwd: step.cwd,
+        display: step.display,
+    }));
+}
+function addedPresetEnvironmentNeeds(manifest, scenario, projectDir, addedPackagePath, options) {
+    if (!scenario.addedPreset || !addedPackagePath) {
+        return [];
+    }
+    return projectionPlanForPreset(scenario.addedPreset, projectDir, manifest, options, path.basename(projectDir)).checkPlan.environmentNeeds.map((need) => {
+        if (need.owner.kind !== "package-boundary") {
+            return need;
+        }
+        return {
+            ...need,
+            owner: { kind: "package-boundary", path: addedPackagePath },
+        };
+    });
+}
+function environmentNeedStep(need, projectDir) {
+    const display = renderPlaywrightBrowserInstallCommand(need);
+    const [command, ...args] = display.split(" ");
+    return {
+        id: `install-${need.owner.path}-playwright-browsers`,
+        command,
+        args,
+        cwd: projectDir,
+        display,
+    };
+}
+export function generatedScenarioQualityGateSteps(manifest, scenario, projectDir, addedPackagePath, options) {
+    const normalizedOptions = normalizeRunnerOptions(options);
+    const steps = machineVerifiableNextStepsForPreset(scenario.basePreset, projectDir, manifest, normalizedOptions);
+    const addedEnvironmentSteps = addedPresetEnvironmentNeeds(manifest, scenario, projectDir, addedPackagePath, normalizedOptions).map((need) => environmentNeedStep(need, projectDir));
+    const existingDisplays = new Set(steps.map((step) => step.display));
+    const extraEnvironmentSteps = addedEnvironmentSteps.filter((step) => !existingDisplays.has(step.display));
+    if (extraEnvironmentSteps.length === 0) {
+        return steps;
+    }
+    const rootCheckIndex = steps.findIndex((step) => step.id === "run-root-check");
+    if (rootCheckIndex === -1) {
+        return [...steps, ...extraEnvironmentSteps];
+    }
+    return [
+        ...steps.slice(0, rootCheckIndex),
+        ...extraEnvironmentSteps,
+        ...steps.slice(rootCheckIndex),
+    ];
+}
+async function runGeneratedScenarioQualityGate(manifest, scenario, projectDir, addedPackagePath, options) {
+    const steps = generatedScenarioQualityGateSteps(manifest, scenario, projectDir, addedPackagePath, options);
+    const requiresSerializedPlaywrightRootCheck = steps.some((step) => step.id.endsWith("-playwright-browsers"));
+    for (const step of steps) {
+        const env = step.id === "run-root-check" ? { CI: "1" } : undefined;
+        const runStep = async () => {
+            await options.runCommand(step.command, [...step.args], step.cwd, {
+                env,
+                logPrefix: scenario.label,
+            });
+        };
+        if (step.id === "run-root-check" && requiresSerializedPlaywrightRootCheck) {
+            await options.rootCheckLock.run(runStep);
+            continue;
+        }
+        await runStep();
+    }
+}
+async function checkGeneratedScenario(manifest, scenario, workspace, options) {
+    options.reporter.info?.(`\n== ${scenario.label} ==`);
+    const projectDir = await generateScenario(scenario, workspace, options);
+    const addedPackagePath = await applyPackageAddition(manifest, scenario, projectDir, options);
+    await runGeneratedScenarioQualityGate(manifest, scenario, projectDir, addedPackagePath, options);
+}
+export function fixtureConcurrency(scenarioCount) {
+    const rawValue = process.env.TEMPLATE_FIXTURE_CONCURRENCY;
+    if (rawValue === undefined || rawValue === "") {
+        return Math.min(defaultFixtureConcurrency, scenarioCount);
+    }
+    const value = Number(rawValue);
+    if (!Number.isInteger(value) || value < 1) {
+        throw new Error("TEMPLATE_FIXTURE_CONCURRENCY must be a positive integer");
+    }
+    return Math.min(value, scenarioCount);
+}
+export function errorForFailedGeneratedScenario(scenario, error) {
+    if (error instanceof Error) {
+        return new Error(`Fixture scenario failed: ${scenario.label}`, {
+            cause: error,
+        });
+    }
+    return new Error(`Fixture scenario failed: ${scenario.label}: ${String(error)}`);
+}
+function normalizeRunnerOptions(options) {
+    return {
+        repoRoot: options.repoRoot,
+        cliPath: options.cliPath,
+        runCommand: options.runCommand ?? defaultGeneratedScenarioCommandRunner,
+        reporter: options.reporter ?? {
+            info: console.log,
+            error: console.error,
+        },
+        deterministicToolchainEnv: options.deterministicToolchainEnv ?? defaultDeterministicToolchainEnv,
+        rootCheckLock: options.rootCheckLock ?? createExclusiveLock(),
+    };
+}
+export async function runGeneratedScenariosConcurrently(manifest, scenarios, workspace, concurrency, options) {
+    const normalizedOptions = normalizeRunnerOptions(options);
+    let nextScenarioIndex = 0;
+    let firstFailure;
+    async function worker() {
+        while (firstFailure === undefined) {
+            const scenario = scenarios[nextScenarioIndex];
+            nextScenarioIndex += 1;
+            if (!scenario) {
+                return;
+            }
+            try {
+                await checkGeneratedScenario(manifest, scenario, workspace, normalizedOptions);
+            }
+            catch (error) {
+                firstFailure ??= errorForFailedGeneratedScenario(scenario, error);
+                return;
+            }
+        }
+    }
+    await Promise.all(Array.from({ length: concurrency }, async () => {
+        await worker();
+    }));
+    if (firstFailure) {
+        throw firstFailure;
+    }
+}
+export async function runGeneratedScenarioSet(manifest, set, workspace, options) {
+    const normalizedOptions = normalizeRunnerOptions(options);
+    const selection = selectGeneratedScenarios(manifest, set);
+    const concurrency = fixtureConcurrency(selection.runnable.length);
+    for (const skippedScenario of selection.skipped) {
+        normalizedOptions.reporter.info?.(`-- Skipping ${skippedScenario.label}: ${skippedScenario.reason}`);
+    }
+    normalizedOptions.reporter.info?.(`Checking ${selection.runnable.length} fixture scenarios with concurrency ${concurrency}.`);
+    await runGeneratedScenariosConcurrently(manifest, selection.runnable, workspace, concurrency, normalizedOptions);
+    return selection;
+}

package/dist/src/module-graph.d.ts

@@ -7,7 +7,7 @@ export type WorkspaceOrchestrationOwner = {
     readonly path: ".";
 };
 export type ComponentOwner = PackageBoundaryOwner | WorkspaceOrchestrationOwner;
-export type CheckComponentKind = "typescript-typecheck" | "oxc-lint" | "oxc-format-check" | "build" | "unit-test" | "e2e-test" | "turbo-check" | "turbo-package-check" | "rustfmt-check" | "cargo-clippy" | "cargo-test";
+export type CheckComponentKind = "typescript-typecheck" | "oxc-lint" | "oxc-format-check" | "build" | "unit-test" | "e2e-test" | "turbo-check" | "turbo-package-typecheck" | "turbo-package-build" | "turbo-package-test" | "turbo-package-e2e-test" | "turbo-package-check" | "rustfmt-check" | "cargo-clippy" | "cargo-test";
 export type FixComponentKind = "oxc-format-write" | "oxc-lint-fix" | "turbo-fix" | "turbo-package-fix" | "rustfmt-write";
 export type CheckEnvironmentNeed = {
     readonly kind: "playwright-browser-assets";

package/dist/src/module-graph.js

@@ -20,6 +20,14 @@ function renderCheckComponentCommand(component) {
             return "pnpm run test:e2e";
         case "turbo-check":
             return "turbo run check";
+        case "turbo-package-typecheck":
+            return `turbo run typecheck ${renderTurboPackageFilter(component.owner)}`;
+        case "turbo-package-build":
+            return `turbo run build ${renderTurboPackageFilter(component.owner)}`;
+        case "turbo-package-test":
+            return `turbo run test ${renderTurboPackageFilter(component.owner)}`;
+        case "turbo-package-e2e-test":
+            return `turbo run test:e2e ${renderTurboPackageFilter(component.owner)}`;
         case "turbo-package-check":
             return `turbo run check ${renderTurboPackageFilter(component.owner)}`;
         case "rustfmt-check":
@@ -51,8 +59,8 @@ export function renderFixCommand(plan) {
     return plan.components.map(renderFixComponentCommand).join(" && ");
 }
 export function renderPlaywrightBrowserInstallCommand(need) {
-    if (need.owner.path === "apps/web") {
-        return `pnpm --filter ./apps/web exec playwright install ${need.browser}`;
+    if (need.owner.kind === "package-boundary" && need.owner.path !== ".") {
+        return `pnpm --filter ./${need.owner.path} exec playwright install ${need.browser}`;
     }
     return `pnpm exec playwright install ${need.browser}`;
 }

package/dist/src/package-addition-support.d.ts

@@ -0,0 +1,5 @@
+export declare const PackageAdditionSupport: {
+    readonly Supported: "supported";
+    readonly Unsupported: "unsupported";
+};
+export type PackageAdditionSupport = (typeof PackageAdditionSupport)[keyof typeof PackageAdditionSupport];

package/dist/src/package-addition-support.js

@@ -0,0 +1,4 @@
+export const PackageAdditionSupport = {
+    Supported: "supported",
+    Unsupported: "unsupported",
+};

package/dist/src/package-addition.d.ts

@@ -3,5 +3,6 @@ export type AddPackageOptions = {
     preset: string;
     name: string;
     path?: string;
+    linkFrom?: readonly string[];
 };
 export declare function addPackage(options: AddPackageOptions): Promise<void>;