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

package/dist/esm-node/ultramodern-tooling/commands/migrate-strict-effect/io.js

@@ -0,0 +1,286 @@
+import "node:module";
+import node_fs from "node:fs";
+import node_os from "node:os";
+import node_path from "node:path";
+const stagingExcludedEntries = new Set([
+    '.git',
+    '.nx',
+    '.output',
+    'coverage',
+    'dist',
+    'node_modules'
+]);
+function lstatIfExists(filePath) {
+    try {
+        return node_fs.lstatSync(filePath);
+    } catch (error) {
+        if ('ENOENT' === error.code) return;
+        throw error;
+    }
+}
+function capturePath(filePath) {
+    const stat = lstatIfExists(filePath);
+    if (!stat) return;
+    const mode = 4095 & stat.mode;
+    if (stat.isFile()) return {
+        content: node_fs.readFileSync(filePath),
+        mode,
+        type: 'file'
+    };
+    if (stat.isDirectory()) {
+        const entries = new Map();
+        for (const entry of node_fs.readdirSync(filePath).sort((left, right)=>left.localeCompare(right))){
+            const snapshot = capturePath(node_path.join(filePath, entry));
+            if (snapshot) entries.set(entry, snapshot);
+        }
+        return {
+            entries,
+            mode,
+            type: 'directory'
+        };
+    }
+    if (stat.isSymbolicLink()) return {
+        mode,
+        target: node_fs.readlinkSync(filePath),
+        type: 'symlink'
+    };
+    throw new Error(`Unsupported migration transaction path: ${filePath}`);
+}
+function removePath(filePath) {
+    node_fs.rmSync(filePath, {
+        force: true,
+        recursive: true
+    });
+}
+function chmodSymlinkIfSupported(filePath, mode) {
+    if ('function' == typeof node_fs.lchmodSync) node_fs.lchmodSync(filePath, mode);
+}
+function restorePath(filePath, snapshot) {
+    if (!snapshot) return void removePath(filePath);
+    const current = lstatIfExists(filePath);
+    if ('file' === snapshot.type) {
+        if (!current?.isFile() || current.isSymbolicLink()) {
+            removePath(filePath);
+            node_fs.mkdirSync(node_path.dirname(filePath), {
+                recursive: true
+            });
+        }
+        node_fs.writeFileSync(filePath, snapshot.content);
+        node_fs.chmodSync(filePath, snapshot.mode);
+        return;
+    }
+    if ('symlink' === snapshot.type) {
+        if (!current?.isSymbolicLink() || node_fs.readlinkSync(filePath) !== snapshot.target) {
+            removePath(filePath);
+            node_fs.mkdirSync(node_path.dirname(filePath), {
+                recursive: true
+            });
+            node_fs.symlinkSync(snapshot.target, filePath);
+        }
+        chmodSymlinkIfSupported(filePath, snapshot.mode);
+        return;
+    }
+    if (!current?.isDirectory() || current.isSymbolicLink()) {
+        removePath(filePath);
+        node_fs.mkdirSync(filePath, {
+            recursive: true
+        });
+    }
+    for (const entry of node_fs.readdirSync(filePath))if (!snapshot.entries.has(entry)) removePath(node_path.join(filePath, entry));
+    for (const [entry, childSnapshot] of snapshot.entries)restorePath(node_path.join(filePath, entry), childSnapshot);
+    node_fs.chmodSync(filePath, snapshot.mode);
+}
+function copyWorkspaceEntry(sourcePath, destinationPath) {
+    const stat = node_fs.lstatSync(sourcePath);
+    if (stat.isDirectory()) {
+        node_fs.mkdirSync(destinationPath, {
+            mode: 4095 & stat.mode
+        });
+        for (const entry of node_fs.readdirSync(sourcePath))if (!stagingExcludedEntries.has(entry)) copyWorkspaceEntry(node_path.join(sourcePath, entry), node_path.join(destinationPath, entry));
+        node_fs.chmodSync(destinationPath, 4095 & stat.mode);
+        return;
+    }
+    if (stat.isFile()) {
+        node_fs.copyFileSync(sourcePath, destinationPath, node_fs.constants.COPYFILE_FICLONE);
+        node_fs.chmodSync(destinationPath, 4095 & stat.mode);
+        return;
+    }
+    if (stat.isSymbolicLink()) {
+        node_fs.symlinkSync(node_fs.readlinkSync(sourcePath), destinationPath);
+        chmodSymlinkIfSupported(destinationPath, 4095 & stat.mode);
+        return;
+    }
+    throw new Error(`Unsupported migration staging path: ${sourcePath}`);
+}
+function isPromiseLike(value) {
+    return ('object' == typeof value || 'function' == typeof value) && null !== value && 'function' == typeof value.then;
+}
+function createMigrationIo(workspaceRoot, dryRun) {
+    const absoluteWorkspaceRoot = node_path.resolve(workspaceRoot);
+    const plan = [];
+    let activeTransaction;
+    const rel = (p)=>(node_path.relative(absoluteWorkspaceRoot, p) || node_path.basename(p)).split(node_path.sep).join('/');
+    const assertWorkspacePath = (filePath)=>{
+        const absolutePath = node_path.resolve(filePath);
+        const relativePath = node_path.relative(absoluteWorkspaceRoot, absolutePath);
+        if ('' === relativePath || '..' === relativePath || relativePath.startsWith(`..${node_path.sep}`) || node_path.isAbsolute(relativePath)) throw new Error(`Refusing to mutate outside workspace: ${filePath}`);
+        return absolutePath;
+    };
+    const captureForRollback = (filePath)=>{
+        if (!activeTransaction || activeTransaction.snapshots.has(filePath)) return;
+        activeTransaction.snapshots.set(filePath, capturePath(filePath));
+        activeTransaction.order.push(filePath);
+    };
+    const captureMissingParents = (filePath)=>{
+        const missing = [];
+        let current = node_path.dirname(filePath);
+        while(current !== absoluteWorkspaceRoot && !lstatIfExists(current)){
+            missing.push(current);
+            current = node_path.dirname(current);
+        }
+        for (const missingDirectory of missing.reverse())captureForRollback(missingDirectory);
+    };
+    const rollback = (transaction)=>{
+        for (const filePath of [
+            ...transaction.order
+        ].reverse())restorePath(filePath, transaction.snapshots.get(filePath));
+    };
+    const finishWithError = (transaction, error)=>{
+        try {
+            rollback(transaction);
+        } catch (rollbackError) {
+            throw new Error(`Migration failed (${String(error)}) and rollback failed (${String(rollbackError)}).`);
+        } finally{
+            activeTransaction = void 0;
+        }
+        throw error;
+    };
+    const io = {
+        workspaceRoot: absoluteWorkspaceRoot,
+        dryRun,
+        plan,
+        write (filePath, content) {
+            const absolutePath = assertWorkspacePath(filePath);
+            if (node_fs.existsSync(absolutePath) && node_fs.readFileSync(absolutePath, 'utf-8') === content) return false;
+            if (dryRun) {
+                plan.push(`[dry-run] would write ${rel(absolutePath)}`);
+                return true;
+            }
+            captureMissingParents(absolutePath);
+            captureForRollback(absolutePath);
+            const current = lstatIfExists(absolutePath);
+            if (current?.isSymbolicLink()) {
+                const linkedPath = node_path.resolve(node_path.dirname(absolutePath), node_fs.readlinkSync(absolutePath));
+                let targetPath = linkedPath;
+                try {
+                    targetPath = node_fs.realpathSync.native(absolutePath);
+                } catch  {}
+                const absoluteTargetPath = assertWorkspacePath(targetPath);
+                captureMissingParents(absoluteTargetPath);
+                captureForRollback(absoluteTargetPath);
+            }
+            node_fs.mkdirSync(node_path.dirname(absolutePath), {
+                recursive: true
+            });
+            node_fs.writeFileSync(absolutePath, content, 'utf-8');
+            return true;
+        },
+        remove (filePath) {
+            const absolutePath = assertWorkspacePath(filePath);
+            if (!lstatIfExists(absolutePath)) return false;
+            if (dryRun) {
+                plan.push(`[dry-run] would delete ${rel(absolutePath)}`);
+                return true;
+            }
+            captureForRollback(absolutePath);
+            node_fs.rmSync(absolutePath);
+            return true;
+        },
+        log (message) {
+            if (dryRun) plan.push(`[dry-run] ${message}`);
+            else process.stdout.write(`[ultramodern] ${message}\n`);
+        },
+        transaction (operation, options) {
+            if (activeTransaction) throw new Error('Nested migration transactions are not supported.');
+            const transaction = {
+                order: [],
+                snapshots: new Map()
+            };
+            activeTransaction = transaction;
+            const finish = (result)=>{
+                try {
+                    if (options?.commitWhen && !options.commitWhen(result)) rollback(transaction);
+                    return result;
+                } finally{
+                    activeTransaction = void 0;
+                }
+            };
+            try {
+                const result = operation();
+                if (isPromiseLike(result)) return Promise.resolve(result).then((value)=>finish(value), (error)=>finishWithError(transaction, error));
+                return finish(result);
+            } catch (error) {
+                return finishWithError(transaction, error);
+            }
+        },
+        withStagedWorkspace (operation) {
+            const temporaryRoot = node_fs.mkdtempSync(node_path.join(node_os.tmpdir(), 'ultramodern-migration-'));
+            const stagedWorkspaceRoot = node_path.join(temporaryRoot, 'workspace');
+            try {
+                copyWorkspaceEntry(absoluteWorkspaceRoot, stagedWorkspaceRoot);
+                const result = operation(stagedWorkspaceRoot);
+                if (isPromiseLike(result)) return Promise.resolve(result).finally(()=>{
+                    node_fs.rmSync(temporaryRoot, {
+                        force: true,
+                        recursive: true
+                    });
+                });
+                node_fs.rmSync(temporaryRoot, {
+                    force: true,
+                    recursive: true
+                });
+                return result;
+            } catch (error) {
+                node_fs.rmSync(temporaryRoot, {
+                    force: true,
+                    recursive: true
+                });
+                throw error;
+            }
+        }
+    };
+    return io;
+}
+function readJsonFile(filePath) {
+    return JSON.parse(node_fs.readFileSync(filePath, 'utf-8'));
+}
+function writeJsonFile(io, filePath, value) {
+    return io.write(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+function writeJsonIfChanged(io, filePath, value) {
+    return io.write(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+function writeTextIfChanged(io, filePath, value) {
+    return io.write(filePath, value);
+}
+function listWorkspacePackageFiles(workspaceRoot) {
+    const packageFiles = [
+        'package.json'
+    ];
+    for (const directory of [
+        'apps',
+        'verticals',
+        'packages'
+    ]){
+        const absoluteDirectory = node_path.join(workspaceRoot, directory);
+        if (node_fs.existsSync(absoluteDirectory)) for (const entry of node_fs.readdirSync(absoluteDirectory, {
+            withFileTypes: true
+        })){
+            if (!entry.isDirectory()) continue;
+            const packageFile = `${directory}/${entry.name}/package.json`;
+            if (node_fs.existsSync(node_path.join(workspaceRoot, packageFile))) packageFiles.push(packageFile);
+        }
+    }
+    return packageFiles;
+}
+export { createMigrationIo, listWorkspacePackageFiles, readJsonFile, writeJsonFile, writeJsonIfChanged, writeTextIfChanged };

package/dist/esm-node/ultramodern-tooling/commands/migrate-strict-effect/package-cohort.js

@@ -0,0 +1,157 @@
+import "node:module";
+import { ULTRAMODERN_SINGLE_APP_MODERN_PACKAGES, ULTRAMODERN_WORKSPACE_MODERN_PACKAGES, modernPackageSpecifier } from "../../../ultramodern-package-source.js";
+import { ULTRAMODERN_PACKAGE_PINS } from "../../../ultramodern-workspace/policy.js";
+import { GENERATED_POSTINSTALL_SCRIPT, createWorkspaceAppPackageScripts, createWorkspaceRootPackageScripts } from "../../../ultramodern-workspace/workspace-script-plan.js";
+import { migratedWorkspaceScriptBasenames } from "../../../ultramodern-workspace/workspace-scripts.js";
+const modernPackageNames = new Set([
+    ...ULTRAMODERN_SINGLE_APP_MODERN_PACKAGES,
+    ...ULTRAMODERN_WORKSPACE_MODERN_PACKAGES
+]);
+function updateModernDependencies(packageJson, packageSource) {
+    let changed = false;
+    for (const section of [
+        'dependencies',
+        'devDependencies',
+        'peerDependencies',
+        'optionalDependencies'
+    ]){
+        const dependencies = packageJson[section];
+        if (!(!dependencies || 'object' != typeof dependencies || Array.isArray(dependencies))) for (const packageName of Object.keys(dependencies)){
+            if (!modernPackageNames.has(packageName)) continue;
+            const nextSpecifier = modernPackageSpecifier(packageName, packageSource);
+            if (dependencies[packageName] !== nextSpecifier) {
+                dependencies[packageName] = nextSpecifier;
+                changed = true;
+            }
+        }
+    }
+    return changed;
+}
+const generatedToolingDependencyPins = new Map(Object.entries({
+    ...ULTRAMODERN_PACKAGE_PINS.appDependencies,
+    ...ULTRAMODERN_PACKAGE_PINS.appDevDependencies,
+    ...ULTRAMODERN_PACKAGE_PINS.rootDevDependencies
+}));
+function updateGeneratedToolingDependencies(packageJson) {
+    let changed = false;
+    for (const section of [
+        'dependencies',
+        'devDependencies',
+        'peerDependencies',
+        'optionalDependencies'
+    ]){
+        const dependencies = packageJson[section];
+        if (!(!dependencies || 'object' != typeof dependencies || Array.isArray(dependencies))) {
+            for (const [packageName, version] of generatedToolingDependencyPins)if (Object.prototype.hasOwnProperty.call(dependencies, packageName) && dependencies[packageName] !== version) {
+                dependencies[packageName] = version;
+                changed = true;
+            }
+        }
+    }
+    return changed;
+}
+const cloudflareModernDeployCommand = 'MODERNJS_DEPLOY=cloudflare modern deploy';
+const cloudflareModernDeploySkipBuildCommand = `${cloudflareModernDeployCommand} --skip-build`;
+const cloudflareWranglerDeployCommand = 'wrangler deploy --config .output/wrangler.json';
+const cloudflareWranglerDeployInvalidSkipBuildCommand = `${cloudflareWranglerDeployCommand} --skip-build`;
+function removeStaleBackendFederationCommandSegments(command) {
+    return command.replace(/\s+&&\s+node\s+\S*scripts\/generate-node-backend-federation\.m[ct]s(?:\s+--app\s+\S+)?(?:\s+--target\s+\S+)?(?=\s+&&|$)/gu, '');
+}
+const CONDITIONAL_FRAMEWORK_ROOT_SCRIPTS = [
+    'node:backend-federation:generate',
+    'node:proof',
+    'zerops:materialize'
+];
+const splitScriptSegments = (command)=>command.split('&&').map((segment)=>segment.trim()).filter((segment)=>segment.length > 0);
+const scriptSegmentTarget = (segment)=>segment.replace(/^pnpm\s+/u, '').split(/\s+/u)[0] ?? segment;
+const FRAMEWORK_CHECK_TARGETS = new Set([
+    'format:check',
+    'lint',
+    'typecheck',
+    'skills:check',
+    'i18n:boundaries',
+    'api:check',
+    'contract:check',
+    'node:backend-federation:generate',
+    'node:proof',
+    'performance:readiness',
+    'bridge:check'
+]);
+function mergeAggregateCheckScript(consumer, framework) {
+    const frameworkSegments = splitScriptSegments(framework);
+    const consumerExtras = splitScriptSegments(consumer).filter((segment)=>!FRAMEWORK_CHECK_TARGETS.has(scriptSegmentTarget(segment)));
+    return [
+        ...consumerExtras,
+        ...frameworkSegments
+    ].join(' && ');
+}
+function rewriteMigratedScriptReferences(scripts) {
+    let changed = false;
+    const pattern = new RegExp(`(scripts/(?:${migratedWorkspaceScriptBasenames.join('|')}))\\.mjs`, 'gu');
+    for (const [name, value] of Object.entries(scripts)){
+        if ('string' != typeof value) continue;
+        const next = value.replace(pattern, '$1.mts');
+        if (next !== value) {
+            scripts[name] = next;
+            changed = true;
+        }
+    }
+    return changed;
+}
+function updateGeneratedPackageScripts(packageJson, options = {}) {
+    const scripts = packageJson.scripts;
+    if (!scripts || 'object' != typeof scripts || Array.isArray(scripts)) return false;
+    let changed = false;
+    const apps = options.apps ?? [];
+    const app = apps.find((candidate)=>`${candidate.directory}/package.json` === options.relativePackageFile);
+    const isRootPackage = 'package.json' === options.relativePackageFile;
+    if (isRootPackage && scripts.postinstall !== GENERATED_POSTINSTALL_SCRIPT) {
+        scripts.postinstall = GENERATED_POSTINSTALL_SCRIPT;
+        changed = true;
+    }
+    const expectedScripts = isRootPackage ? createWorkspaceRootPackageScripts(apps.filter((candidate)=>'shell' !== candidate.kind), {
+        shells: apps.filter((candidate)=>'shell' === candidate.kind)
+    }) : app ? createWorkspaceAppPackageScripts(app) : void 0;
+    if (expectedScripts) {
+        if (isRootPackage) {
+            for (const name of CONDITIONAL_FRAMEWORK_ROOT_SCRIPTS)if (!(name in expectedScripts) && name in scripts) {
+                delete scripts[name];
+                changed = true;
+            }
+        }
+        for (const [name, value] of Object.entries(expectedScripts)){
+            if (void 0 === value) continue;
+            const existingScript = scripts[name];
+            const nextValue = 'check' === name && 'string' == typeof existingScript ? mergeAggregateCheckScript(existingScript, value) : value;
+            if (scripts[name] !== nextValue) {
+                scripts[name] = nextValue;
+                changed = true;
+            }
+        }
+    }
+    if (rewriteMigratedScriptReferences(scripts)) changed = true;
+    const build = scripts.build;
+    if ('string' == typeof build) {
+        const nextBuild = removeStaleBackendFederationCommandSegments(build);
+        if (nextBuild !== build) {
+            scripts.build = nextBuild;
+            changed = true;
+        }
+    }
+    const cloudflareBuild = scripts['cloudflare:build'];
+    if ('string' == typeof cloudflareBuild) {
+        let nextCloudflareBuild = removeStaleBackendFederationCommandSegments(cloudflareBuild);
+        if (nextCloudflareBuild.includes(cloudflareModernDeployCommand) && !nextCloudflareBuild.includes(cloudflareModernDeploySkipBuildCommand)) nextCloudflareBuild = nextCloudflareBuild.replace(cloudflareModernDeployCommand, cloudflareModernDeploySkipBuildCommand);
+        if (nextCloudflareBuild !== cloudflareBuild) {
+            scripts['cloudflare:build'] = nextCloudflareBuild;
+            changed = true;
+        }
+    }
+    const cloudflareDeploy = scripts['cloudflare:deploy'];
+    if ('string' == typeof cloudflareDeploy && cloudflareDeploy.includes(cloudflareWranglerDeployInvalidSkipBuildCommand)) {
+        scripts['cloudflare:deploy'] = cloudflareDeploy.replace(cloudflareWranglerDeployInvalidSkipBuildCommand, cloudflareWranglerDeployCommand);
+        changed = true;
+    }
+    return changed;
+}
+export { updateGeneratedPackageScripts, updateGeneratedToolingDependencies, updateModernDependencies };

package/dist/esm-node/ultramodern-tooling/commands/migrate-strict-effect/package-source.js

@@ -0,0 +1,52 @@
+import "node:module";
+import { BLEEDINGDEV_PACKAGE_NAME_PREFIX, BLEEDINGDEV_PACKAGE_SCOPE, WORKSPACE_PACKAGE_VERSION } from "../../../ultramodern-package-source.js";
+import { isCreatePackageSourceCheckout } from "../../../ultramodern-release-cohort.js";
+import { hasFlag, readOption } from "../options.js";
+function createMigrationPackageSource(args, current) {
+    const workspaceRequested = hasFlag(args, '--workspace');
+    const explicitInstallRequested = !workspaceRequested && (current.packageSource?.strategy === 'install' || [
+        '--version',
+        '--ultramodern-package-version',
+        '--registry',
+        '--ultramodern-package-registry',
+        '--alias-scope',
+        '--ultramodern-package-scope',
+        '--alias-package-name-prefix',
+        '--ultramodern-package-name-prefix'
+    ].some((option)=>void 0 !== readOption(args, option)));
+    if (isCreatePackageSourceCheckout() && explicitInstallRequested) throw new Error('A local @modern-js/create source checkout cannot migrate an explicit install package source. Use --workspace locally or run the packed published package with its authenticated release cohort projection.');
+    const strategy = workspaceRequested || isCreatePackageSourceCheckout() ? 'workspace' : 'install';
+    const registry = readOption(args, '--registry') ?? readOption(args, '--ultramodern-package-registry');
+    const explicitAliasScope = readOption(args, '--alias-scope') ?? readOption(args, '--ultramodern-package-scope');
+    const aliasScope = explicitAliasScope ?? ('install' === strategy && void 0 === registry ? current.packageSource?.aliasScope ?? BLEEDINGDEV_PACKAGE_SCOPE : current.packageSource?.aliasScope);
+    const aliasPackageNamePrefix = readOption(args, '--alias-package-name-prefix') ?? readOption(args, '--ultramodern-package-name-prefix') ?? current.packageSource?.aliasPackageNamePrefix ?? (aliasScope ? BLEEDINGDEV_PACKAGE_NAME_PREFIX : void 0);
+    if ('workspace' === strategy) return {
+        strategy,
+        modernPackageVersion: WORKSPACE_PACKAGE_VERSION,
+        ...registry ? {
+            registry
+        } : {},
+        ...aliasScope ? {
+            aliasScope
+        } : {},
+        ...aliasPackageNamePrefix ? {
+            aliasPackageNamePrefix
+        } : {}
+    };
+    const version = readOption(args, '--version') ?? readOption(args, '--ultramodern-package-version') ?? current.packageSource?.modernPackageVersion;
+    if (!version || version === WORKSPACE_PACKAGE_VERSION) throw new Error('migrate-strict-effect needs --version <published-ultramodern-version> for install package source.');
+    return {
+        strategy,
+        modernPackageVersion: version,
+        ...registry ? {
+            registry
+        } : {},
+        ...aliasScope ? {
+            aliasScope
+        } : {},
+        ...aliasPackageNamePrefix ? {
+            aliasPackageNamePrefix
+        } : {}
+    };
+}
+export { createMigrationPackageSource };