@bleedingdev/modern-js-create 3.5.0-ultramodern.9 → 3.5.0-ultramodern.90

package/dist/esm-node/ultramodern-workspace/overlay-baseline-guard.js

@@ -0,0 +1,351 @@
+import "node:module";
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { yaml } from "@modern-js/utils";
+import { isRecord } from "./types.js";
+import { EFFECT_VERSION, REACT_DOM_VERSION, REACT_VERSION, TAILWIND_VERSION, TANSTACK_ROUTER_CORE_VERSION, TANSTACK_ROUTER_VERSION } from "./versions.js";
+const BASELINE_DEPENDENCY_PINS = Object.freeze({
+    react: REACT_VERSION,
+    'react-dom': REACT_DOM_VERSION,
+    '@tanstack/react-router': TANSTACK_ROUTER_VERSION,
+    '@tanstack/router-core': TANSTACK_ROUTER_CORE_VERSION,
+    effect: EFFECT_VERSION,
+    tailwindcss: TAILWIND_VERSION
+});
+const FORBIDDEN_SHELL_ARTIFACT_SEGMENTS = [
+    'api',
+    'server',
+    'backend-federation.config.ts'
+];
+const IGNORED_WALK_DIRECTORIES = new Set([
+    '.git',
+    '.nx',
+    '.output',
+    'coverage',
+    'dist',
+    'dist-cloudflare',
+    'node_modules'
+]);
+class OverlayBaselineRelaxationError extends Error {
+    constructor(generator, violations){
+        super([
+            `UltraModern CodeSmith overlay relaxed the Platform Baseline: ${generator}`,
+            ...violations.map((violation)=>`  - ${violation.path}: ${violation.detail}`)
+        ].join('\n')), this.code = 'ULTRAMODERN_OVERLAY_BASELINE_RELAXATION';
+        this.name = 'OverlayBaselineRelaxationError';
+        this.generator = generator;
+        this.violations = violations;
+    }
+}
+function walkFiles(root, predicate) {
+    const matches = [];
+    const queue = [
+        root
+    ];
+    while(queue.length > 0){
+        const current = queue.shift();
+        let entries;
+        try {
+            entries = node_fs.readdirSync(current, {
+                withFileTypes: true
+            });
+        } catch  {
+            continue;
+        }
+        for (const entry of entries){
+            const absolute = node_path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                if (!IGNORED_WALK_DIRECTORIES.has(entry.name)) queue.push(absolute);
+                continue;
+            }
+            const relative = node_path.relative(root, absolute).split(node_path.sep).join('/');
+            if (predicate(relative)) matches.push(relative);
+        }
+    }
+    return matches.sort();
+}
+function isPackageManifest(relativePath) {
+    return 'package.json' === relativePath || relativePath.endsWith('/package.json');
+}
+const DEPENDENCY_SECTIONS = [
+    'dependencies',
+    'devDependencies',
+    'peerDependencies',
+    'optionalDependencies'
+];
+function readPackageJson(workspaceRoot, packageJsonRelativePath) {
+    const parsed = JSON.parse(node_fs.readFileSync(node_path.join(workspaceRoot, packageJsonRelativePath), 'utf-8'));
+    return isRecord(parsed) ? parsed : {};
+}
+function dependencyEntries(parsed) {
+    const entries = [];
+    for (const section of DEPENDENCY_SECTIONS){
+        const group = parsed[section];
+        if (isRecord(group)) {
+            for (const [name, value] of Object.entries(group))if ('string' == typeof value) entries.push({
+                section,
+                name,
+                value
+            });
+        }
+    }
+    return entries;
+}
+function baselineDependencyFromKey(key) {
+    const candidate = key.trim().split('>').at(-1) ?? '';
+    return Object.keys(BASELINE_DEPENDENCY_PINS).find((dependency)=>candidate === dependency || candidate.startsWith(`${dependency}@`));
+}
+function collectPolicyEntries(value, prefix, entries) {
+    if (!isRecord(value)) return;
+    for (const [key, child] of Object.entries(value)){
+        const childPath = '' === prefix ? key : `${prefix}.${key}`;
+        const dependency = baselineDependencyFromKey(key);
+        if (void 0 !== dependency && 'string' == typeof child) entries.push({
+            path: childPath,
+            dependency,
+            value: child
+        });
+        if (isRecord(child)) collectPolicyEntries(child, childPath, entries);
+    }
+}
+function policyRoots(parsed) {
+    const pnpm = isRecord(parsed.pnpm) ? parsed.pnpm : void 0;
+    return [
+        [
+            'overrides',
+            parsed.overrides
+        ],
+        [
+            'resolutions',
+            parsed.resolutions
+        ],
+        [
+            'pnpm.overrides',
+            pnpm?.overrides
+        ],
+        [
+            'catalog',
+            parsed.catalog
+        ],
+        [
+            'catalogs',
+            parsed.catalogs
+        ],
+        [
+            'pnpm.catalog',
+            pnpm?.catalog
+        ],
+        [
+            'pnpm.catalogs',
+            pnpm?.catalogs
+        ]
+    ];
+}
+function baselinePolicyEntries(parsed) {
+    const entries = [];
+    for (const [prefix, value] of policyRoots(parsed))if (void 0 !== value) collectPolicyEntries(value, prefix, entries);
+    return entries;
+}
+function readPnpmWorkspaceYaml(workspaceRoot) {
+    try {
+        const parsed = yaml.load(node_fs.readFileSync(node_path.join(workspaceRoot, 'pnpm-workspace.yaml'), 'utf-8'));
+        return isRecord(parsed) ? parsed : {};
+    } catch  {
+        return {};
+    }
+}
+function collectCatalogValues(parsed) {
+    const values = new Map();
+    const collect = (value, prefix)=>{
+        if (!isRecord(value)) return;
+        for (const [key, child] of Object.entries(value)){
+            const childPath = '' === prefix ? key : `${prefix}.${key}`;
+            if ('string' == typeof child) {
+                values.set(key, child);
+                values.set(childPath, child);
+            } else collect(child, childPath);
+        }
+    };
+    for (const [prefix, value] of policyRoots(parsed).filter(([prefix])=>/catalog/u.test(prefix)))collect(value ?? {}, prefix);
+    return values;
+}
+function resolveCatalogReference(value, catalogValues) {
+    if (!value.startsWith('catalog:')) return value;
+    return catalogValues.get(value.slice(8)) ?? value;
+}
+function parseNpmAlias(value) {
+    if (!value.startsWith('npm:')) return;
+    const target = value.slice(4);
+    const separator = target.startsWith('@') ? target.indexOf('@', 1) : target.indexOf('@');
+    if (-1 === separator) return {
+        name: target,
+        range: void 0
+    };
+    return {
+        name: target.slice(0, separator),
+        range: target.slice(separator + 1)
+    };
+}
+function baselineSpecMatches(value, dependency) {
+    const expected = BASELINE_DEPENDENCY_PINS[dependency];
+    if (value === expected) return true;
+    const alias = parseNpmAlias(value);
+    return alias?.name === dependency && alias.range === expected;
+}
+function baselinePinsFromParsed(parsed) {
+    const pins = {};
+    for (const section of DEPENDENCY_SECTIONS){
+        const group = parsed[section];
+        if (isRecord(group)) for (const dependency of Object.keys(BASELINE_DEPENDENCY_PINS)){
+            const value = group[dependency];
+            if ('string' == typeof value) pins[`${section}.${dependency}`] = value;
+        }
+    }
+    return pins;
+}
+function readBaselinePins(workspaceRoot, packageJsonRelativePath) {
+    return baselinePinsFromParsed(readPackageJson(workspaceRoot, packageJsonRelativePath));
+}
+function captureOverlayBaselineSnapshot(workspaceRoot, shellPackageDirectories) {
+    const baselinePinsByManifest = {};
+    const baselinePolicyPinsByManifest = {};
+    for (const manifest of walkFiles(workspaceRoot, isPackageManifest)){
+        const parsed = readPackageJson(workspaceRoot, manifest);
+        baselinePinsByManifest[manifest] = readBaselinePins(workspaceRoot, manifest);
+        baselinePolicyPinsByManifest[manifest] = Object.fromEntries(baselinePolicyEntries(parsed).map((entry)=>[
+                entry.path,
+                entry.value
+            ]));
+    }
+    const shellFiles = new Set();
+    for (const shellDir of shellPackageDirectories){
+        const absolute = node_path.join(workspaceRoot, shellDir);
+        if (node_fs.existsSync(absolute)) for (const file of walkFiles(absolute, ()=>true))shellFiles.add(`${shellDir}/${file}`);
+    }
+    return {
+        baselinePinsByManifest,
+        baselinePolicyPinsByManifest,
+        baselineWorkspacePolicyPins: Object.fromEntries(baselinePolicyEntries(readPnpmWorkspaceYaml(workspaceRoot)).map((entry)=>[
+                entry.path,
+                entry.value
+            ])),
+        shellPackageDirectories,
+        shellFiles
+    };
+}
+function collectPolicyViolations(parsed, beforePolicyPins, displayPath) {
+    const violations = [];
+    const currentPolicyEntries = baselinePolicyEntries(parsed);
+    const currentPolicyPins = Object.fromEntries(currentPolicyEntries.map((entry)=>[
+            entry.path,
+            entry.value
+        ]));
+    for (const [policyPath, previous] of Object.entries(beforePolicyPins)){
+        if (Object.hasOwn(currentPolicyPins, policyPath)) continue;
+        const dependency = baselineDependencyFromKey(policyPath.split('.').at(-1) ?? '') ?? policyPath.split('.').at(-1) ?? policyPath;
+        const expected = BASELINE_DEPENDENCY_PINS[dependency];
+        if (void 0 !== expected) violations.push({
+            kind: 'baseline-version-relaxation',
+            path: `${displayPath}#${policyPath}`,
+            detail: `overlay removed baseline policy "${policyPath}" from "${previous}"; Platform Baseline pin is "${expected}"`
+        });
+    }
+    const catalogValues = collectCatalogValues(parsed);
+    for (const entry of currentPolicyEntries){
+        const resolvedVersion = resolveCatalogReference(entry.value, catalogValues);
+        const expected = BASELINE_DEPENDENCY_PINS[entry.dependency];
+        if (!baselineSpecMatches(resolvedVersion, entry.dependency)) violations.push({
+            kind: 'baseline-version-relaxation',
+            path: `${displayPath}#${entry.path}`,
+            detail: `overlay policy "${entry.path}" pins baseline dependency "${entry.dependency}" at "${entry.value}"; Platform Baseline pin is "${expected}"`
+        });
+    }
+    return violations;
+}
+function collectVersionViolations(workspaceRoot, snapshot) {
+    const violations = [];
+    const manifests = new Set([
+        ...walkFiles(workspaceRoot, isPackageManifest),
+        ...Object.keys(snapshot.baselinePinsByManifest)
+    ]);
+    for (const manifest of manifests){
+        let parsed;
+        try {
+            parsed = readPackageJson(workspaceRoot, manifest);
+        } catch  {
+            parsed = {};
+        }
+        const pins = baselinePinsFromParsed(parsed);
+        const before = snapshot.baselinePinsByManifest[manifest] ?? {};
+        for (const key of Object.keys(before)){
+            if (Object.hasOwn(pins, key)) continue;
+            const separator = key.indexOf('.');
+            const section = key.slice(0, separator);
+            const dependency = key.slice(separator + 1);
+            const expected = BASELINE_DEPENDENCY_PINS[dependency];
+            violations.push({
+                kind: 'baseline-version-relaxation',
+                path: manifest,
+                detail: `overlay removed baseline dependency "${dependency}" from ${section}; Platform Baseline pin is "${expected}"`
+            });
+        }
+        const catalogValues = collectCatalogValues(parsed);
+        for (const [key, version] of Object.entries(pins)){
+            const dependency = key.slice(key.indexOf('.') + 1);
+            const expected = BASELINE_DEPENDENCY_PINS[dependency];
+            const previous = before[key];
+            const resolvedVersion = resolveCatalogReference(version, catalogValues);
+            const matches = baselineSpecMatches(resolvedVersion, dependency);
+            if (void 0 !== previous || matches) {
+                if (void 0 !== previous && version !== previous && !matches) violations.push({
+                    kind: 'baseline-version-relaxation',
+                    path: manifest,
+                    detail: `overlay changed baseline dependency "${dependency}" from "${previous}" to "${version}"; Platform Baseline pin is "${expected}"`
+                });
+            } else violations.push({
+                kind: 'baseline-version-relaxation',
+                path: manifest,
+                detail: `overlay added baseline dependency "${dependency}" at "${version}"; Platform Baseline pin is "${expected}"`
+            });
+        }
+        for (const entry of dependencyEntries(parsed)){
+            const alias = parseNpmAlias(entry.value);
+            if (void 0 === alias) continue;
+            const expected = BASELINE_DEPENDENCY_PINS[alias.name];
+            if (void 0 !== expected && alias.range !== expected) violations.push({
+                kind: 'baseline-version-relaxation',
+                path: manifest,
+                detail: `overlay alias "${entry.name}" resolves to baseline dependency "${alias.name}" at "${entry.value}"; Platform Baseline pin is "${expected}"`
+            });
+        }
+        violations.push(...collectPolicyViolations(parsed, snapshot.baselinePolicyPinsByManifest?.[manifest] ?? {}, manifest));
+    }
+    violations.push(...collectPolicyViolations(readPnpmWorkspaceYaml(workspaceRoot), snapshot.baselineWorkspacePolicyPins ?? {}, 'pnpm-workspace.yaml'));
+    return violations;
+}
+function collectForbiddenShellArtifactViolations(workspaceRoot, snapshot) {
+    const violations = [];
+    for (const shellDir of snapshot.shellPackageDirectories){
+        const absolute = node_path.join(workspaceRoot, shellDir);
+        if (node_fs.existsSync(absolute)) for (const file of walkFiles(absolute, ()=>true)){
+            const relative = `${shellDir}/${file}`;
+            if (snapshot.shellFiles.has(relative)) continue;
+            const segments = file.split('/');
+            const forbidden = FORBIDDEN_SHELL_ARTIFACT_SEGMENTS.find((segment)=>segments.includes(segment) || file === segment);
+            if (forbidden) violations.push({
+                kind: 'forbidden-shell-artifact',
+                path: relative,
+                detail: `overlay introduced a forbidden thin-shell artifact class "${forbidden}" into shell package ${shellDir}`
+            });
+        }
+    }
+    return violations;
+}
+function assertOverlayPreservedBaseline(options) {
+    const violations = [
+        ...collectVersionViolations(options.workspaceRoot, options.snapshot),
+        ...collectForbiddenShellArtifactViolations(options.workspaceRoot, options.snapshot)
+    ];
+    if (violations.length > 0) throw new OverlayBaselineRelaxationError(options.generator, violations);
+}
+export { BASELINE_DEPENDENCY_PINS, OverlayBaselineRelaxationError, assertOverlayPreservedBaseline, captureOverlayBaselineSnapshot };

package/dist/esm-node/ultramodern-workspace/overlays.js

@@ -1,7 +1,22 @@
 import "node:module";
 import { spawnSync } from "node:child_process";
+import node_fs from "node:fs";
 import { createRequire } from "node:module";
+import node_path from "node:path";
+import { assertOverlayPreservedBaseline, captureOverlayBaselineSnapshot } from "./overlay-baseline-guard.js";
 const overlays_require = createRequire(import.meta.url);
+function resolveShellPackageDirectories(workspaceRoot) {
+    const appsRoot = node_path.join(workspaceRoot, 'apps');
+    let entries;
+    try {
+        entries = node_fs.readdirSync(appsRoot, {
+            withFileTypes: true
+        });
+    } catch  {
+        return [];
+    }
+    return entries.filter((entry)=>entry.isDirectory()).map((entry)=>`apps/${entry.name}`).sort();
+}
 const overlayRunnerSource = `
 const fs = require('node:fs');
 
@@ -25,11 +40,19 @@ const fs = require('node:fs');
 `;
 function runCodeSmithOverlays(options) {
     if (!options.overlays?.length) return;
-    for (const overlay of options.overlays)runCodeSmithOverlay({
-        workspaceRoot: options.workspaceRoot,
-        overlay,
-        config: createOverlayRuntimeConfig(options.workspaceRoot, options.result)
-    });
+    const snapshot = captureOverlayBaselineSnapshot(options.workspaceRoot, resolveShellPackageDirectories(options.workspaceRoot));
+    for (const overlay of options.overlays){
+        runCodeSmithOverlay({
+            workspaceRoot: options.workspaceRoot,
+            overlay,
+            config: createOverlayRuntimeConfig(options.workspaceRoot, options.result)
+        });
+        assertOverlayPreservedBaseline({
+            workspaceRoot: options.workspaceRoot,
+            generator: overlay.generator,
+            snapshot
+        });
+    }
 }
 function runCodeSmithOverlay(options) {
     const result = spawnSync(process.execPath, [