@ykdz/template 0.0.5 → 0.0.7

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/package-addition.js

@@ -1,10 +1,11 @@
 import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { builtInPresetProjections, findBuiltInPresetProjection, } from "../templates/registry.js";
 import { validateProjectBlueprint, } from "./declarations.js";
 import { collectGeneratedManifestCatalogReferences, pnpmWorkspaceYamlWithCatalogDependencies, } from "./dependency-catalog.js";
 import { PackageAdditionSupport } from "./package-addition-support.js";
 import { assertTypeScriptPackageBoundaryForLinkIntent, packageTurboTasks, planPackageLinks, } from "./package-linking.js";
+import { findBuiltInPresetSourceManifestPreset, loadBuiltInPresetSourceManifest, } from "./preset-source.js";
+import { defaultPackagePathForPresetSourcePackageAddition, planPresetSourcePackageAddition, } from "./projection-capabilities.js";
 import { renderProject } from "./renderer.js";
 function projectNameFromBlueprint(blueprint, fallbackProjectName) {
     const firstPackage = blueprint.packages?.[0];
@@ -74,16 +75,10 @@ function validateExplicitPackagePath(packagePath) {
     }
     return packagePath;
 }
-function defaultPackagePathForPreset(preset, packageLeafName) {
-    return preset === "ts-lib"
-        ? `packages/${packageLeafName}`
-        : `apps/${packageLeafName}`;
-}
 function supportedPackageAdditionPresetNames() {
-    return builtInPresetProjections
-        .filter((projection) => projection.metadata.packageAdditionSupport ===
-        PackageAdditionSupport.Supported)
-        .map((projection) => projection.metadata.name);
+    return loadBuiltInPresetSourceManifest()
+        .presets.filter((preset) => preset.packageAdditionSupport === PackageAdditionSupport.Supported)
+        .map((preset) => preset.name);
 }
 function formatUnsupportedPackageAdditionPresetError(preset) {
     return [
@@ -627,28 +622,26 @@ export async function addPackage(options) {
     const repositoryMetadata = await readGeneratedRepositoryPackageMetadata(root);
     const projectName = projectNameFromBlueprint(blueprint, repositoryMetadata.projectName);
     const packageName = `@${projectName}/${options.name}`;
-    const packagePath = options.path
-        ? validateExplicitPackagePath(options.path)
-        : defaultPackagePathForPreset(options.preset, options.name);
-    const projection = findBuiltInPresetProjection(options.preset);
-    if (!projection) {
+    const preset = findBuiltInPresetSourceManifestPreset(options.preset);
+    if (!preset) {
         throw new Error(`Unknown preset for Package Addition: ${options.preset}`);
     }
-    if (projection.metadata.packageAdditionSupport !==
-        PackageAdditionSupport.Supported) {
+    if (preset.packageAdditionSupport !== PackageAdditionSupport.Supported) {
         throw new Error(formatUnsupportedPackageAdditionPresetError(options.preset));
     }
-    const packageAddition = projection.capabilities?.packageAddition;
-    if (!packageAddition) {
-        throw new Error(`Preset ${options.preset} declares Package Addition support but has no Package Addition implementation`);
-    }
-    const additionPlan = await packageAddition.planPackageAddition({
-        root,
-        blueprint,
-        packageLeafName: options.name,
-        packageName,
-        packagePath,
-        nodeVersion: repositoryMetadata.nodeVersion,
+    const packagePath = options.path
+        ? validateExplicitPackagePath(options.path)
+        : defaultPackagePathForPresetSourcePackageAddition(preset, options.name);
+    const additionPlan = await planPresetSourcePackageAddition({
+        preset,
+        addition: {
+            root,
+            blueprint,
+            packageLeafName: options.name,
+            packageName,
+            packagePath,
+            nodeVersion: repositoryMetadata.nodeVersion,
+        },
     });
     const requiresSharedOxcConfiguration = additionPlan.sourceRoots?.sharedOxc !== undefined;
     assertNoPackageConflict(blueprint, packageName, additionPlan.packagePath);
@@ -663,7 +656,7 @@ export async function addPackage(options) {
         packageLinkIntents,
     });
     await assertMissingPackagePath(additionPlan.packagePath, path.join(root, additionPlan.packagePath));
-    const rootUpdatePlan = await planRootUpdates(root, blueprint, packageName, additionPlan.packagePath, additionPlan.packageRole, additionPlan.packageSourcePreset, packageLinkIntents, additionPlan.workspacePackageGlob, packageAdditionCatalogDependencies(additionPlan.operations), requiresSharedOxcConfiguration, additionPlan.operations);
+    const rootUpdatePlan = await planRootUpdates(root, blueprint, packageName, additionPlan.packagePath, additionPlan.packageRole, additionPlan.packageSourcePreset, packageLinkIntents, additionPlan.workspaceMembershipGlob ?? additionPlan.workspacePackageGlob, packageAdditionCatalogDependencies(additionPlan.operations), requiresSharedOxcConfiguration, additionPlan.operations);
     await mkdir(path.join(root, additionPlan.packagePath), { recursive: true });
     await ensureRootOxcConfiguration({
         root,

package/dist/src/preset-projection.d.ts

@@ -16,6 +16,7 @@ export type PresetPackageAdditionOptions = {
 export type PresetPackageAdditionPlan = {
     readonly packagePath: string;
     readonly workspacePackageGlob: string;
+    readonly workspaceMembershipGlob?: string;
     readonly packageRole: PackageRole;
     readonly packageSourcePreset: PackageSourcePreset;
     readonly sourceRoot: string;