nx-factory-cli 2.1.29 → 2.2.2

package/dist/commands/migrate.js

@@ -4,7 +4,7 @@ import { loadConfig, resolveScope, saveConfig, } from "../config.js";
 import { detectPackageManager, pmWorkspaceProtocol } from "../exec.js";
 import { pathExists, writeJson } from "../files.js";
 import { MonorepoRootNotFoundError, requireMonorepoRoot, } from "../resolve-root.js";
-import { appTsConfig, packageTsConfig, rootTsConfigBase, rootTsConfigSolution, typescriptPackageJson, typescriptPresets, } from "../tsconfigs.js";
+import { appTsConfig, packageTsConfig, rootTsConfigBase, typescriptPackageJson, typescriptPresets, } from "../tsconfigs.js";
 import { c, createStepRunner, printError, printSection, printSuccess, q, } from "../ui.js";
 export async function migrateCommand(options) {
     // ── Resolve monorepo root ──────────────────────────────────────────────────
@@ -51,97 +51,92 @@ export async function migrateCommand(options) {
     const scope = resolveScope(cfg);
     const detectedPm = await detectPackageManager(root);
     const pm = detectedPm ?? cfg?.pkgManager ?? "pnpm";
-    const answers = options.yes
-        ? {
-            proceed: true,
-            migrateTypescriptTooling: true,
-            packagesToMakeInternal: [],
-            uiVisibility: "internal",
-            removeJsExtensions: false,
-            cleanupBackups: false,
-        }
-        : await inquirer
-            .prompt([
+    const defaultAnswers = {
+        migrateTypescriptTooling: true,
+        packagesToMakeInternal: [],
+        uiVisibility: "internal",
+        removeJsExtensions: false,
+        cleanupBackups: false,
+    };
+    let answers = { ...defaultAnswers };
+    if (!options.yes) {
+        const proceedPrompt = await inquirer.prompt([
             {
                 type: "confirm",
                 name: "proceed",
                 message: q("Apply all migrations?", "a backup of each changed file will be written as <file>.migration-backup"),
                 default: true,
             },
-            {
-                type: "confirm",
-                name: "migrateTypescriptTooling",
-                message: q("Migrate TypeScript tooling package?", "move packages/typescript to tooling/typescript and refresh tsconfig presets"),
-                default: true,
-                when: !status.hasToolingTypescriptPackage ||
-                    status.hasLegacyTypescriptPackage ||
-                    !status.hasToolingTypescriptBaseExtendsRoot ||
-                    !status.hasToolingTypescriptTsconfigExportAlias,
-            },
-            {
-                type: "checkbox",
-                name: "packagesToMakeInternal",
-                message: q("Select packages to make internal", "selected packages will get private:true in package.json"),
-                choices: status.publicPackagesEligibleForInternalization.map((pkgName) => ({ name: pkgName, value: pkgName })),
-                when: status.publicPackagesEligibleForInternalization.length > 0,
-            },
-            {
-                type: "select",
-                name: "uiVisibility",
-                message: q("UI package visibility", "internal = workspace only · public = published to npm"),
-                choices: [
-                    {
-                        name: "internal  — private: true, workspace only",
-                        value: "internal",
-                    },
-                    { name: "public    — will be published to npm", value: "public" },
-                ],
-                default: "internal",
-                when: !status.hasUiPackageVisibility,
-            },
-            {
-                type: "confirm",
-                name: "removeJsExtensions",
-                message: q("Remove .js extensions from internal package imports?", `found ${status.internalPackagesWithJsExtensions.length} package(s) with .js extensions — safe to remove for Bundler resolution`),
-                default: status.internalPackagesWithJsExtensions.length > 0,
-                when: status.internalPackagesWithJsExtensions.length > 0,
-            },
-            {
-                type: "confirm",
-                name: "cleanupBackups",
-                message: q(`Delete ${status.backupFileCount} existing .migration-backup file(s)?`, "these are from a previous migration run"),
-                default: false,
-                when: !options.yes && status.backupFileCount > 0,
-            },
-        ])
-            .catch((err) => {
-            if (err.message?.includes("User force closed")) {
-                console.log(c.dim("\n  Migration cancelled.\n"));
-                process.exit(0);
-            }
-            throw err;
-        });
-    // Ensure proceed is defined with proper default
-    const proceedAnswer = answers.proceed ?? true;
-    if (!proceedAnswer) {
-        console.log(c.dim("\n  Migration cancelled.\n"));
-        return;
+        ]);
+        if (!proceedPrompt.proceed) {
+            console.log(c.dim("\n  Migration cancelled.\n"));
+            return;
+        }
+        answers = {
+            ...defaultAnswers,
+            ...(await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "migrateTypescriptTooling",
+                    message: q("Migrate TypeScript tooling package?", "move packages/typescript to tooling/typescript and refresh tsconfig presets"),
+                    default: true,
+                    when: !status.hasToolingTypescriptPackage ||
+                        status.hasLegacyTypescriptPackage ||
+                        !status.hasToolingTypescriptBaseExtendsRoot ||
+                        !status.hasToolingTypescriptTsconfigExportAlias,
+                },
+                {
+                    type: "checkbox",
+                    name: "packagesToMakeInternal",
+                    message: q("Select packages to make internal", "selected packages will get private:true in package.json"),
+                    choices: status.publicPackagesEligibleForInternalization.map((pkgName) => ({ name: pkgName, value: pkgName })),
+                    when: status.publicPackagesEligibleForInternalization.length > 0,
+                },
+                {
+                    type: "select",
+                    name: "uiVisibility",
+                    message: q("UI package visibility", "internal = workspace only · public = published to npm"),
+                    choices: [
+                        {
+                            name: "internal  — private: true, workspace only",
+                            value: "internal",
+                        },
+                        { name: "public    — will be published to npm", value: "public" },
+                    ],
+                    default: "internal",
+                    when: !status.hasUiPackageVisibility,
+                },
+                {
+                    type: "confirm",
+                    name: "removeJsExtensions",
+                    message: q("Remove .js extensions from internal package imports?", `found ${status.internalPackagesWithJsExtensions.length} package(s) with .js extensions — safe to remove for Bundler resolution`),
+                    default: status.internalPackagesWithJsExtensions.length > 0,
+                    when: status.internalPackagesWithJsExtensions.length > 0,
+                },
+                {
+                    type: "confirm",
+                    name: "cleanupBackups",
+                    message: q(`Delete ${status.backupFileCount} existing .migration-backup file(s)?`, "these are from a previous migration run"),
+                    default: false,
+                    when: status.backupFileCount > 0,
+                },
+            ])),
+        };
     }
-    const uiVisibility = (answers.uiVisibility ??
-        "internal");
-    const shouldMigrateTypescriptTooling = (answers.migrateTypescriptTooling ?? true) &&
+    const uiVisibility = answers.uiVisibility;
+    const shouldMigrateTypescriptTooling = answers.migrateTypescriptTooling &&
         (!status.hasToolingTypescriptPackage ||
             status.hasLegacyTypescriptPackage ||
             !status.hasToolingTypescriptBaseExtendsRoot ||
             !status.hasToolingTypescriptTsconfigExportAlias);
-    const packagesToMakeInternal = answers.packagesToMakeInternal ?? [];
-    const removeJsExtensions = answers.removeJsExtensions ?? false;
-    const cleanupBackupsNow = options.yes
-        ? false
-        : (answers.cleanupBackups ?? false);
+    const packagesToMakeInternal = answers.packagesToMakeInternal;
+    const removeJsExtensions = answers.removeJsExtensions;
+    const cleanupBackupsNow = options.yes ? false : answers.cleanupBackups;
     // ── Count steps dynamically ───────────────────────────────────────────────
     let totalSteps = 0;
-    if (!status.hasTsConfigBase)
+    if (status.hasLegacyRootTsConfig)
+        totalSteps++;
+    else if (!status.hasTsConfigBase)
         totalSteps++;
     if (shouldMigrateTypescriptTooling)
         totalSteps++;
@@ -161,7 +156,6 @@ export async function migrateCommand(options) {
         totalSteps++;
     if (!status.hasConfig || !status.hasUiPackageVisibility)
         totalSteps++;
-    totalSteps += 1; // always update solution tsconfig.json
     if (removeJsExtensions && status.internalPackagesWithJsExtensions.length > 0)
         totalSteps++;
     if (cleanupBackupsNow && status.backupFileCount > 0)
@@ -170,12 +164,42 @@ export async function migrateCommand(options) {
         totalSteps = 1;
     printSection(`${options.dryRun ? "[dry run] " : ""}Migrating workspace at ${root}`);
     const step = createStepRunner(totalSteps, options.dryRun);
-    // ── Step 1: Write tsconfig.base.json ──────────────────────────────────────
-    if (!status.hasTsConfigBase) {
-        await step("Write tsconfig.base.json", async () => {
+    // ── Step 1: Consolidate or Write tsconfig.json ────────────────────────────
+    if (status.hasLegacyRootTsConfig) {
+        await step("Consolidate tsconfig.base.json into tsconfig.json", async () => {
+            const { default: fs } = await import("fs-extra");
             const tsBasePath = path.join(root, "tsconfig.base.json");
+            const tsConfigPath = path.join(root, "tsconfig.json");
+            let baseContent = {};
+            try {
+                baseContent = await fs.readJson(tsBasePath);
+            }
+            catch {
+                // ignore
+            }
             await backupIfExists(tsBasePath, options.dryRun);
-            await writeJson(tsBasePath, rootTsConfigBase(scope));
+            await backupIfExists(tsConfigPath, options.dryRun);
+            const defaultBase = rootTsConfigBase(scope);
+            const merged = {
+                ...defaultBase,
+                compilerOptions: {
+                    ...defaultBase.compilerOptions,
+                    ...(baseContent.compilerOptions ?? {}),
+                    paths: {
+                        ...(defaultBase.compilerOptions?.paths ?? {}),
+                        ...(baseContent.compilerOptions?.paths ?? {}),
+                    },
+                },
+            };
+            await writeJson(tsConfigPath, merged);
+            await fs.remove(tsBasePath);
+        });
+    }
+    else if (!status.hasTsConfigBase) {
+        await step("Write root tsconfig.json", async () => {
+            const tsConfigPath = path.join(root, "tsconfig.json");
+            await backupIfExists(tsConfigPath, options.dryRun);
+            await writeJson(tsConfigPath, rootTsConfigBase(scope));
         });
     }
     // ── Step 1b: Migrate tooling/typescript package ─────────────────────────
@@ -230,14 +254,22 @@ export async function migrateCommand(options) {
                 if (uiVisibility === "internal") {
                     pkg.private = true;
                     delete pkg.publishConfig;
+                    delete pkg.exports;
+                    delete pkg.main;
+                    delete pkg.types;
+                    delete pkg.files;
+                    if (pkg.scripts) {
+                        const scripts = pkg.scripts;
+                        delete scripts.build;
+                        delete scripts["build:watch"];
+                    }
                 }
                 else {
                     delete pkg.private;
                     pkg.publishConfig = { access: "public" };
                     pkg.files = ["dist", "styles"];
-                }
-                // Ensure exports field is present
-                if (!pkg.exports) {
+                    pkg.main = "./dist/index.js";
+                    pkg.types = "./dist/index.d.ts";
                     pkg.exports = {
                         ".": { import: "./dist/index.js", types: "./dist/index.d.ts" },
                         "./styles": "./styles/globals.css",
@@ -246,6 +278,12 @@ export async function migrateCommand(options) {
                             types: "./dist/components/*.d.ts",
                         },
                     };
+                    if (!pkg.scripts)
+                        pkg.scripts = {};
+                    const scripts = pkg.scripts;
+                    scripts.build = "tsc -p tsconfig.json";
+                    scripts["build:watch"] = "tsc -p tsconfig.json --watch";
+                    scripts.typecheck = "tsc --noEmit";
                 }
                 await fs.writeJson(pkgPath, pkg, { spaces: 2 });
             }
@@ -316,29 +354,6 @@ export async function migrateCommand(options) {
             }
         });
     }
-    // ── Step 4b: Update/create root solution tsconfig.json ────────────────────
-    await step("Update root tsconfig.json solution file", async () => {
-        const { default: fs } = await import("fs-extra");
-        const pkgNames = [];
-        const appNames = [];
-        try {
-            const pkgDir = path.join(root, "packages");
-            if (await pathExists(pkgDir))
-                pkgNames.push(...(await fs.readdir(pkgDir)));
-        }
-        catch {
-            /* ok */
-        }
-        try {
-            const appsDir = path.join(root, "apps");
-            if (await pathExists(appsDir))
-                appNames.push(...(await fs.readdir(appsDir)));
-        }
-        catch {
-            /* ok */
-        }
-        await writeJson(path.join(root, "tsconfig.json"), rootTsConfigSolution(pkgNames, appNames));
-    });
     // ── Step 5: Update nx-factory.config.json ─────────────────────────────────
     if (!status.hasConfig || !status.hasUiPackageVisibility) {
         await step("Update nx-factory.config.json", async () => {
@@ -403,7 +418,20 @@ async function analyseWorkspace(root) {
     const { default: fs } = await import("fs-extra");
     const cfg = await loadConfig();
     const scope = resolveScope(cfg);
-    const hasTsConfigBase = await pathExists(path.join(root, "tsconfig.base.json"));
+    const hasLegacyRootTsConfig = await pathExists(path.join(root, "tsconfig.base.json"));
+    let hasTsConfigBase = false;
+    const rootTsConfigPath = path.join(root, "tsconfig.json");
+    if (await pathExists(rootTsConfigPath)) {
+        try {
+            const tsConfig = await fs.readJson(rootTsConfigPath);
+            if (tsConfig.compilerOptions && !tsConfig.references) {
+                hasTsConfigBase = true;
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
     const hasToolingTypescriptPackage = await pathExists(path.join(root, "tooling", "typescript", "tsconfig.internal.json"));
     const hasToolingTypescriptBaseExtendsRoot = await toolingTypescriptBaseExtendsRoot(root);
     const hasToolingTypescriptTsconfigExportAlias = await toolingTypescriptPackageJsonHasTsconfigAlias(root);
@@ -413,16 +441,24 @@ async function analyseWorkspace(root) {
     let uiPackageDir = null;
     const packagesDir = path.join(root, "packages");
     if (await pathExists(packagesDir)) {
-        const entries = await fs.readdir(packagesDir);
-        for (const e of entries) {
-            if (await pathExists(path.join(packagesDir, e, "components.json"))) {
-                uiPackageDir = path.join(packagesDir, e);
-                break;
+        if (cfg?.uiPackage) {
+            const candidate = path.join(packagesDir, cfg.uiPackage);
+            if (await pathExists(candidate)) {
+                uiPackageDir = candidate;
             }
         }
-        // Fallback to first package if no components.json found
-        if (!uiPackageDir && entries.length > 0) {
-            uiPackageDir = path.join(packagesDir, entries[0]);
+        if (!uiPackageDir) {
+            const entries = await fs.readdir(packagesDir);
+            for (const e of entries) {
+                if (await pathExists(path.join(packagesDir, e, "components.json"))) {
+                    uiPackageDir = path.join(packagesDir, e);
+                    break;
+                }
+            }
+            // Fallback to first package if no components.json found
+            if (!uiPackageDir && entries.length > 0) {
+                uiPackageDir = path.join(packagesDir, entries[0]);
+            }
         }
     }
     // Find packages with outdated tsconfigs (missing composite / still on bundler resolution)
@@ -450,11 +486,17 @@ async function analyseWorkspace(root) {
                     ? `@${scope}/typescript/tsconfig.internal.json`
                     : `@${scope}/typescript/tsconfig.package.json`;
                 const extendsValue = String(tsJson.extends ?? "");
-                // Outdated if package still extends workspace base directly or doesn't match
-                // the scoped tooling preset required by visibility.
+                const co = (tsJson.compilerOptions ?? {});
+                const paths = (co.paths ?? {});
+                const hasPaths = co.baseUrl === "." &&
+                    `@${scope}/${e}` in paths &&
+                    `@${scope}/${e}/*` in paths;
+                // Outdated if package still extends workspace base directly, doesn't match
+                // the scoped tooling preset required by visibility, or lacks custom self-referencing path aliases.
                 const isOutdated = !extendsValue ||
                     extendsValue.includes("tsconfig.base.json") ||
-                    extendsValue !== expectedExtends;
+                    extendsValue !== expectedExtends ||
+                    !hasPaths;
                 if (isOutdated)
                     packagesWithBadTsConfig.push(e);
             }
@@ -527,6 +569,7 @@ async function analyseWorkspace(root) {
     return {
         hasConfig: !!cfg,
         configVersion: cfg?.version ?? null,
+        hasLegacyRootTsConfig,
         hasTsConfigBase,
         hasToolingTypescriptPackage,
         hasToolingTypescriptBaseExtendsRoot,
@@ -546,6 +589,7 @@ async function analyseWorkspace(root) {
 }
 function isFullyMigrated(s) {
     return (s.hasConfig &&
+        !s.hasLegacyRootTsConfig &&
         s.hasTsConfigBase &&
         s.hasToolingTypescriptPackage &&
         s.hasToolingTypescriptBaseExtendsRoot &&
@@ -566,10 +610,16 @@ function printAnalysis(s) {
     const cross = c.yellow("✗");
     console.log();
     console.log(`  ${s.hasConfig ? tick : cross}  nx-factory.config.json ${s.hasConfig ? c.dim(`(v${s.configVersion ?? "unknown"})`) : c.yellow("missing")}`);
-    console.log(`  ${s.hasTsConfigBase ? tick : cross}  tsconfig.base.json ${s.hasTsConfigBase ? "" : c.yellow("missing — will create")}`);
+    if (s.hasLegacyRootTsConfig) {
+        console.log(`  ${cross}  legacy tsconfig.base.json detected ${c.yellow("will consolidate into tsconfig.json")}`);
+    }
+    else {
+        console.log(`  ${s.hasTsConfigBase ? tick : cross}  root tsconfig.json base configuration ${s.hasTsConfigBase ? "" : c.yellow("missing — will create")}`);
+    }
     console.log(`  ${s.hasToolingTypescriptPackage ? tick : cross}  tooling/typescript presets ${s.hasToolingTypescriptPackage ? "" : c.yellow("missing — will migrate")}`);
     if (s.hasToolingTypescriptPackage) {
-        console.log(`  ${s.hasToolingTypescriptBaseExtendsRoot ? tick : cross}  tooling/typescript/tsconfig.base.json extends ../../tsconfig.base.json ${s.hasToolingTypescriptBaseExtendsRoot ? "" : c.yellow("missing — will refresh presets")}`);
+        const expectedFile = s.hasLegacyRootTsConfig ? "tsconfig.base.json" : "tsconfig.json";
+        console.log(`  ${s.hasToolingTypescriptBaseExtendsRoot ? tick : cross}  tooling/typescript/tsconfig.base.json extends ../../${expectedFile} ${s.hasToolingTypescriptBaseExtendsRoot ? "" : c.yellow("missing — will refresh presets")}`);
         console.log(`  ${s.hasToolingTypescriptTsconfigExportAlias ? tick : cross}  tooling/typescript/package.json exports ./tsconfig.json ${s.hasToolingTypescriptTsconfigExportAlias ? "" : c.yellow("missing — will refresh package.json")}`);
     }
     if (s.hasLegacyTypescriptPackage) {
@@ -633,7 +683,9 @@ async function migrateTypescriptToolingPackage(root, scope) {
     }
     await fs.ensureDir(toolingDir);
     await writeJson(path.join(toolingDir, "package.json"), typescriptPackageJson(scope));
-    const presets = typescriptPresets();
+    const hasBase = await pathExists(path.join(root, "tsconfig.base.json"));
+    const rootTsConfigName = hasBase ? "tsconfig.base.json" : "tsconfig.json";
+    const presets = typescriptPresets(rootTsConfigName);
     for (const [filename, content] of Object.entries(presets)) {
         await writeJson(path.join(toolingDir, filename), content);
     }
@@ -664,7 +716,9 @@ async function toolingTypescriptBaseExtendsRoot(root) {
         return false;
     try {
         const tsBase = (await fs.readJson(tsBasePath));
-        return tsBase.extends === "../../tsconfig.base.json";
+        const hasBase = await pathExists(path.join(root, "tsconfig.base.json"));
+        const expectedExtends = hasBase ? "../../tsconfig.base.json" : "../../tsconfig.json";
+        return tsBase.extends === expectedExtends;
     }
     catch {
         return false;
@@ -831,6 +885,15 @@ async function makePackagesInternal(root, packageNames, dryRun) {
         const pkgJson = (await fs.readJson(pkgPath));
         pkgJson.private = true;
         delete pkgJson.publishConfig;
+        delete pkgJson.exports;
+        delete pkgJson.main;
+        delete pkgJson.types;
+        delete pkgJson.files;
+        if (pkgJson.scripts) {
+            const scripts = pkgJson.scripts;
+            delete scripts.build;
+            delete scripts["build:watch"];
+        }
         await fs.writeJson(pkgPath, pkgJson, { spaces: 2 });
     }
 }
@@ -842,9 +905,15 @@ async function removeExportsFromPackages(root, packageNames, dryRun) {
             continue;
         await backupIfExists(pkgPath, dryRun);
         const pkgJson = (await fs.readJson(pkgPath));
-        if (pkgJson.exports === undefined)
-            continue;
         delete pkgJson.exports;
+        delete pkgJson.main;
+        delete pkgJson.types;
+        delete pkgJson.files;
+        if (pkgJson.scripts) {
+            const scripts = pkgJson.scripts;
+            delete scripts.build;
+            delete scripts["build:watch"];
+        }
         await fs.writeJson(pkgPath, pkgJson, { spaces: 2 });
     }
 }
@@ -972,8 +1041,11 @@ async function countBackupFiles(root) {
     async function walk(dir) {
         const entries = await fs.readdir(dir, { withFileTypes: true });
         for (const entry of entries) {
-            if (entry.name === "node_modules" || entry.name === ".git")
+            if (entry.name === "node_modules" ||
+                entry.name === ".git" ||
+                entry.name === ".migration-backups") {
                 continue;
+            }
             const full = path.join(dir, entry.name);
             if (entry.isDirectory()) {
                 await walk(full);
@@ -984,6 +1056,11 @@ async function countBackupFiles(root) {
         }
     }
     await walk(root);
+    // Also count the .migration-backups directory if it exists
+    const migrationBackupsDir = path.join(root, ".migration-backups");
+    if (await pathExists(migrationBackupsDir)) {
+        count++;
+    }
     return count;
 }
 /**
@@ -997,8 +1074,11 @@ export async function cleanupMigrationBackups(root, dryRun) {
         try {
             const entries = await fs.readdir(dir, { withFileTypes: true });
             for (const entry of entries) {
-                if (entry.name === "node_modules" || entry.name === ".git")
+                if (entry.name === "node_modules" ||
+                    entry.name === ".git" ||
+                    entry.name === ".migration-backups") {
                     continue;
+                }
                 const full = path.join(dir, entry.name);
                 if (entry.isDirectory()) {
                     try {
@@ -1029,6 +1109,19 @@ export async function cleanupMigrationBackups(root, dryRun) {
         }
     }
     await walk(root);
+    // Also delete the .migration-backups directory itself
+    const migrationBackupsDir = path.join(root, ".migration-backups");
+    if (await pathExists(migrationBackupsDir)) {
+        deleted++;
+        if (!dryRun) {
+            try {
+                await fs.remove(migrationBackupsDir);
+            }
+            catch {
+                deleted--;
+            }
+        }
+    }
     return deleted;
 }
 //# sourceMappingURL=migrate.js.map