@unisphere/nx 2.2.1 → 3.2.3

package/dist/migrations/3-0-0/reorganize-applications-by-distribution-channel.js

@@ -0,0 +1,563 @@
+"use strict";
+/**
+* Migration: Reorganize Applications by Distribution Channel
+*
+* This migration reorganizes applications based on their `distributionChannel` property in `.unisphere`:
+*
+* Directory structure:
+* - none (local-dev-playground) -> applications/local/
+* - unisphere (server) -> applications/server/
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = update;
+const devkit_1 = require("@nx/devkit");
+const child_process_1 = require("child_process");
+/**
+ * Manually move all files from source to destination directory.
+ * This avoids using moveGenerator which relies on the Nx project graph cache.
+ * The project graph is read from disk, but during migrations the Tree (virtual FS)
+ * may have changes that aren't flushed to disk yet, causing stale data issues.
+ * Using manual move with Tree APIs ensures we always work with the correct state.
+ */
+function moveProjectFiles(tree, sourcePath, destPath) {
+    const filesToMove = [];
+    // Collect all files to move
+    (0, devkit_1.visitNotIgnoredFiles)(tree, sourcePath, (filePath) => {
+        const relativePath = filePath.substring(sourcePath.length);
+        const newPath = `${destPath}${relativePath}`;
+        filesToMove.push({ source: filePath, dest: newPath });
+    });
+    // Move files (create at dest, delete at source)
+    for (const { source, dest } of filesToMove) {
+        const content = tree.read(source);
+        if (content !== null) {
+            tree.write(dest, content);
+            tree.delete(source);
+        }
+    }
+    devkit_1.logger.info(`  Moved ${filesToMove.length} files from ${sourcePath} to ${destPath}`);
+}
+/**
+ * Update project.json after moving to new location
+ */
+function updateProjectJsonAfterMove(tree, newPath, newProjectName) {
+    const projectJsonPath = `${newPath}/project.json`;
+    if (!tree.exists(projectJsonPath)) {
+        return;
+    }
+    const projectJson = (0, devkit_1.readJson)(tree, projectJsonPath);
+    // Update name if different
+    if (projectJson.name !== newProjectName) {
+        projectJson.name = newProjectName;
+    }
+    // Update sourceRoot to match new location
+    projectJson.sourceRoot = `${newPath}/src`;
+    (0, devkit_1.writeJson)(tree, projectJsonPath, projectJson);
+}
+/**
+ * Reset Nx cache to ensure fresh project graph
+ * This is important before moving projects, as Nx caches project locations
+ */
+function resetNxCache() {
+    try {
+        devkit_1.logger.info('Resetting Nx cache to ensure fresh project graph...');
+        (0, child_process_1.execSync)('npx nx reset', {
+            stdio: 'pipe',
+        });
+        devkit_1.logger.info('Nx cache reset successfully');
+    }
+    catch (error) {
+        // Log but don't fail - cache reset is best effort
+        devkit_1.logger.warn('Could not reset Nx cache (continuing anyway): ' + error);
+    }
+}
+/**
+ * Get the subdirectory based on distribution channel
+ */
+function getSubdirectory(distributionChannel) {
+    switch (distributionChannel) {
+        case 'none':
+            return 'local';
+        case 'unisphere':
+            return 'server';
+        default:
+            // Default to local for unknown channels
+            return 'local';
+    }
+}
+/**
+ * Get the actual Nx project name from project.json
+ */
+function getProjectNameFromProjectJson(tree, projectPath) {
+    const projectJsonPath = `${projectPath}/project.json`;
+    if (!tree.exists(projectJsonPath)) {
+        return null;
+    }
+    try {
+        const projectJson = (0, devkit_1.readJson)(tree, projectJsonPath);
+        return projectJson.name || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check if an application has already been migrated to the new subdirectory structure
+ */
+function isAlreadyMigrated(tree, name, distributionChannel) {
+    const subdirectory = getSubdirectory(distributionChannel);
+    const newPath = `unisphere/applications/${subdirectory}/${name}`;
+    // Check if the new path exists and has a project.json
+    return tree.exists(`${newPath}/project.json`);
+}
+/**
+ * Discover all applications in the workspace
+ */
+function discoverApplications(tree) {
+    if (!tree.exists('.unisphere')) {
+        devkit_1.logger.warn('No .unisphere file found, skipping migration');
+        return [];
+    }
+    const unisphereConfig = (0, devkit_1.readJson)(tree, '.unisphere');
+    const applications = [];
+    const applicationsConfig = unisphereConfig.elements?.applications || {};
+    for (const [name, config] of Object.entries(applicationsConfig)) {
+        const normalizedName = (0, devkit_1.names)(name).fileName;
+        const distributionChannel = config.distributionChannel || 'none';
+        // Get sourceRoot from .unisphere config, or fall back to default path
+        const sourceRoot = config.sourceRoot;
+        const currentPath = sourceRoot || `unisphere/applications/${normalizedName}`;
+        // Calculate target path
+        const subdirectory = getSubdirectory(distributionChannel);
+        const targetPath = `unisphere/applications/${subdirectory}/${normalizedName}`;
+        // Check if application is already at the target location (sourceRoot == targetPath)
+        if (currentPath === targetPath) {
+            devkit_1.logger.info(`  Application ${name} is already at target location (${targetPath}), skipping`);
+            continue;
+        }
+        // Check if already migrated to new location (project.json exists at new location)
+        if (isAlreadyMigrated(tree, normalizedName, distributionChannel)) {
+            devkit_1.logger.info(`  Application ${name} already migrated to new location, skipping`);
+            continue;
+        }
+        // Check if target path already exists with actual content (project.json)
+        // If target exists but is empty (no project.json), clean it up and proceed
+        if (tree.exists(targetPath)) {
+            if (tree.exists(`${targetPath}/project.json`)) {
+                devkit_1.logger.info(`  Application ${name} target path already exists with project.json (${targetPath}), skipping`);
+                continue;
+            }
+            else {
+                // Empty directory - clean it up so migration can proceed
+                devkit_1.logger.info(`  Application ${name} target path exists but is empty, cleaning up: ${targetPath}`);
+                tree.delete(targetPath);
+            }
+        }
+        if (!tree.exists(currentPath)) {
+            devkit_1.logger.warn(`Application ${name} not found at ${currentPath}, skipping`);
+            continue;
+        }
+        // Read actual project name from project.json instead of assuming it
+        const actualProjectName = getProjectNameFromProjectJson(tree, currentPath);
+        if (!actualProjectName) {
+            devkit_1.logger.warn(`Application ${name} has no project.json or missing name at ${currentPath}, skipping`);
+            continue;
+        }
+        devkit_1.logger.info(`  Found application: ${normalizedName} (Nx project: ${actualProjectName})`);
+        applications.push({
+            name: normalizedName,
+            distributionChannel: distributionChannel,
+            currentPath,
+            currentNxProjectName: actualProjectName,
+        });
+    }
+    return applications;
+}
+/**
+ * Calculate migration target for an application
+ */
+function calculateMigrationTarget(app) {
+    const subdirectory = getSubdirectory(app.distributionChannel);
+    const newPath = `unisphere/applications/${subdirectory}/${app.name}`;
+    return {
+        application: app,
+        newPath,
+        newNxProjectName: app.currentNxProjectName,
+        subdirectory,
+    };
+}
+/**
+ * Validate migration preconditions
+ */
+function validateMigrationPreconditions(tree, targets) {
+    // Check destination directories don't conflict
+    const destinations = new Set();
+    for (const target of targets) {
+        if (destinations.has(target.newPath)) {
+            throw new Error(`Duplicate destination path: ${target.newPath}`);
+        }
+        destinations.add(target.newPath);
+        // Check destination doesn't already exist
+        if (tree.exists(target.newPath)) {
+            throw new Error(`Destination already exists: ${target.newPath}`);
+        }
+    }
+    // Check all source applications exist
+    for (const target of targets) {
+        if (!tree.exists(target.application.currentPath)) {
+            throw new Error(`Source application not found: ${target.application.currentPath}`);
+        }
+    }
+}
+/**
+ * Update .unisphere configuration sourceRoot
+ */
+function updateUnisphereSourceRoot(tree, name, newPath) {
+    const unisphereConfig = (0, devkit_1.readJson)(tree, '.unisphere');
+    if (unisphereConfig.elements?.applications?.[name]) {
+        const applicationConfig = unisphereConfig.elements.applications[name];
+        applicationConfig.sourceRoot = newPath;
+        (0, devkit_1.writeJson)(tree, '.unisphere', unisphereConfig);
+    }
+}
+/**
+ * Update package-lock.json paths
+ */
+function updatePackageLockPaths(tree, oldPath, newPath) {
+    if (!tree.exists('package-lock.json')) {
+        return;
+    }
+    const packageLock = (0, devkit_1.readJson)(tree, 'package-lock.json');
+    let updated = false;
+    if (packageLock.packages) {
+        const newPackages = {};
+        for (const [key, value] of Object.entries(packageLock.packages)) {
+            if (key === oldPath) {
+                newPackages[newPath] = value;
+                updated = true;
+            }
+            else if (key.startsWith(oldPath + '/')) {
+                // Handle nested node_modules paths if any
+                newPackages[key.replace(oldPath, newPath)] = value;
+                updated = true;
+            }
+            else {
+                newPackages[key] = value;
+            }
+        }
+        if (updated) {
+            packageLock.packages = newPackages;
+        }
+    }
+    // Update resolved paths if they exist
+    if (packageLock.packages) {
+        for (const value of Object.values(packageLock.packages)) {
+            if (value && typeof value === 'object' && 'resolved' in value) {
+                const pkg = value;
+                if (pkg.resolved === oldPath) {
+                    pkg.resolved = newPath;
+                    updated = true;
+                }
+            }
+        }
+    }
+    if (updated) {
+        (0, devkit_1.writeJson)(tree, 'package-lock.json', packageLock);
+        devkit_1.logger.info(`  Updated package-lock.json paths`);
+    }
+}
+/**
+ * Fix .eslintrc.json extends path after moving to subdirectory
+ * Path changes from ../../../.eslintrc.json to ../../../../.eslintrc.json
+ */
+function fixEslintConfigPath(tree, applicationPath) {
+    const eslintConfigPath = `${applicationPath}/.eslintrc.json`;
+    if (!tree.exists(eslintConfigPath)) {
+        return;
+    }
+    const eslintConfig = (0, devkit_1.readJson)(tree, eslintConfigPath);
+    if (eslintConfig.extends && Array.isArray(eslintConfig.extends)) {
+        const updatedExtends = eslintConfig.extends.map((ext) => {
+            // Update the relative path to root .eslintrc.json
+            if (ext === '../../../.eslintrc.json') {
+                return '../../../../.eslintrc.json';
+            }
+            return ext;
+        });
+        eslintConfig.extends = updatedExtends;
+        (0, devkit_1.writeJson)(tree, eslintConfigPath, eslintConfig);
+        devkit_1.logger.info(`  Fixed .eslintrc.json extends path`);
+    }
+}
+/**
+ * Fix tsconfig.json extends path after moving to subdirectory
+ * Path changes from ../../../tsconfig.base.json to ../../../../tsconfig.base.json
+ */
+function fixTsconfigJsonPath(tree, applicationPath) {
+    const tsconfigPath = `${applicationPath}/tsconfig.json`;
+    if (!tree.exists(tsconfigPath)) {
+        return;
+    }
+    const tsconfig = (0, devkit_1.readJson)(tree, tsconfigPath);
+    if (tsconfig.extends === '../../../tsconfig.base.json') {
+        tsconfig.extends = '../../../../tsconfig.base.json';
+        (0, devkit_1.writeJson)(tree, tsconfigPath, tsconfig);
+        devkit_1.logger.info(`  Fixed tsconfig.json extends path`);
+    }
+}
+/**
+ * Fix jest.config.ts paths after moving to subdirectory
+ * - preset path changes from ../../../jest.preset.js to ../../../../jest.preset.js
+ * - coverageDirectory path needs extra level
+ */
+function fixJestConfigPath(tree, applicationPath, newPath) {
+    const jestConfigPath = `${applicationPath}/jest.config.ts`;
+    if (!tree.exists(jestConfigPath)) {
+        return;
+    }
+    let content = tree.read(jestConfigPath, 'utf-8');
+    if (!content) {
+        return;
+    }
+    let updated = false;
+    // Fix preset path
+    if (content.includes("preset: '../../../jest.preset.js'")) {
+        content = content.replace("preset: '../../../jest.preset.js'", "preset: '../../../../jest.preset.js'");
+        updated = true;
+    }
+    // Fix coverageDirectory path - update to use the new path
+    const coverageDirRegex = /coverageDirectory:\s*['"]\.\.\/\.\.\/\.\.\/coverage\/[^'"]+['"]/;
+    if (coverageDirRegex.test(content)) {
+        content = content.replace(coverageDirRegex, `coverageDirectory: '../../../../coverage/${newPath}'`);
+        updated = true;
+    }
+    if (updated) {
+        tree.write(jestConfigPath, content);
+        devkit_1.logger.info(`  Fixed jest.config.ts paths`);
+    }
+}
+/**
+ * Fix project.json $schema path after moving to subdirectory
+ * Path changes from ../../../node_modules/... to ../../../../node_modules/...
+ */
+function fixProjectJsonPath(tree, applicationPath, newPath) {
+    const projectJsonPath = `${applicationPath}/project.json`;
+    if (!tree.exists(projectJsonPath)) {
+        return;
+    }
+    const projectJson = (0, devkit_1.readJson)(tree, projectJsonPath);
+    let updated = false;
+    // Fix $schema path
+    if (projectJson['$schema'] === '../../../node_modules/nx/schemas/project-schema.json') {
+        projectJson['$schema'] = '../../../../node_modules/nx/schemas/project-schema.json';
+        updated = true;
+    }
+    // Update sourceRoot to use the new path
+    if (projectJson.sourceRoot && !projectJson.sourceRoot.includes(newPath)) {
+        projectJson.sourceRoot = `${newPath}/src`;
+        updated = true;
+    }
+    if (updated) {
+        (0, devkit_1.writeJson)(tree, projectJsonPath, projectJson);
+        devkit_1.logger.info(`  Fixed project.json paths`);
+    }
+}
+/**
+ * Fix webpack.config.js output path after moving to subdirectory
+ * Path changes from ../../../dist/unisphere/applications/... to ../../../../dist/...
+ */
+function fixWebpackConfigPath(tree, applicationPath, newPath) {
+    const webpackConfigPath = `${applicationPath}/webpack.config.js`;
+    if (!tree.exists(webpackConfigPath)) {
+        return;
+    }
+    let content = tree.read(webpackConfigPath, 'utf-8');
+    if (!content) {
+        return;
+    }
+    let updated = false;
+    // Fix output path - look for various patterns
+    const outputPathRegex = /path:\s*join\(__dirname,\s*['"]\.\.\/\.\.\/\.\.\/dist\/unisphere\/applications\/[^'"]+['"]\)/;
+    if (outputPathRegex.test(content)) {
+        content = content.replace(outputPathRegex, `path: join(__dirname, '../../../../dist/${newPath}')`);
+        updated = true;
+    }
+    if (updated) {
+        tree.write(webpackConfigPath, content);
+        devkit_1.logger.info(`  Fixed webpack.config.js output path`);
+    }
+}
+/**
+ * Update tsconfig.base.json paths for the application
+ */
+function updateTsConfigBasePaths(tree, oldPath, newPath) {
+    if (!tree.exists('tsconfig.base.json')) {
+        return;
+    }
+    const tsconfigBase = (0, devkit_1.readJson)(tree, 'tsconfig.base.json');
+    if (!tsconfigBase.compilerOptions?.paths) {
+        return;
+    }
+    let updated = false;
+    for (const [key, paths] of Object.entries(tsconfigBase.compilerOptions.paths)) {
+        if (Array.isArray(paths)) {
+            const newPaths = paths.map((p) => {
+                if (p.startsWith(oldPath + '/') || p === oldPath) {
+                    updated = true;
+                    return p.replace(oldPath, newPath);
+                }
+                return p;
+            });
+            tsconfigBase.compilerOptions.paths[key] = newPaths;
+        }
+    }
+    if (updated) {
+        (0, devkit_1.writeJson)(tree, 'tsconfig.base.json', tsconfigBase);
+        devkit_1.logger.info(`  Updated tsconfig.base.json paths`);
+    }
+}
+/**
+ * Update root package.json scripts that reference the application
+ */
+function updateRootPackageJsonScripts(tree, oldPath, newPath) {
+    if (!tree.exists('package.json')) {
+        return;
+    }
+    const packageJson = (0, devkit_1.readJson)(tree, 'package.json');
+    if (!packageJson.scripts) {
+        return;
+    }
+    let updated = false;
+    for (const [scriptName, scriptValue] of Object.entries(packageJson.scripts)) {
+        if (typeof scriptValue === 'string' && scriptValue.includes(oldPath)) {
+            packageJson.scripts[scriptName] = scriptValue.replace(new RegExp(oldPath.replace(/[/\\]/g, '[\\\\/]'), 'g'), newPath);
+            updated = true;
+        }
+    }
+    if (updated) {
+        (0, devkit_1.writeJson)(tree, 'package.json', packageJson);
+        devkit_1.logger.info(`  Updated root package.json scripts`);
+    }
+}
+/**
+ * Migrate a single application
+ */
+async function migrateApplication(tree, target) {
+    const { application: app, newPath, newNxProjectName } = target;
+    devkit_1.logger.info(`Moving ${app.name} to ${target.subdirectory}/`);
+    devkit_1.logger.info(`  From: ${app.currentPath}`);
+    devkit_1.logger.info(`  To: ${newPath}`);
+    devkit_1.logger.info(`  Nx project: ${app.currentNxProjectName}`);
+    // Verify source exists before attempting move (safety check)
+    const sourceProjectJson = `${app.currentPath}/project.json`;
+    if (!tree.exists(sourceProjectJson)) {
+        devkit_1.logger.warn(`  Source project.json not found at ${sourceProjectJson}, skipping`);
+        return;
+    }
+    // Step 1: Manually move files using Tree APIs
+    // We avoid moveGenerator because it relies on the Nx project graph cache,
+    // which reads from disk. During migrations, the packages migration may have
+    // already moved packages in the Tree but those changes aren't flushed to disk
+    // yet, causing moveGenerator to use stale project locations.
+    // Since applications don't need import path updates (they're entry points),
+    // manual move is safe and reliable.
+    try {
+        moveProjectFiles(tree, app.currentPath, newPath);
+        updateProjectJsonAfterMove(tree, newPath, newNxProjectName);
+        devkit_1.logger.info(`  Project moved successfully`);
+        // Reset Nx cache after move to ensure fresh project graph for next operations
+        resetNxCache();
+    }
+    catch (error) {
+        devkit_1.logger.error(`  Failed to move project: ${error}`);
+        devkit_1.logger.error(`  Source path: ${app.currentPath}`);
+        devkit_1.logger.error(`  Destination path: ${newPath}`);
+        devkit_1.logger.error(`  Project name: ${app.currentNxProjectName}`);
+        throw error;
+    }
+    // Step 2: Update .unisphere configuration
+    updateUnisphereSourceRoot(tree, app.name, newPath);
+    devkit_1.logger.info(`  Updated .unisphere sourceRoot`);
+    // Step 3: Update package-lock.json
+    updatePackageLockPaths(tree, app.currentPath, newPath);
+    // Step 4: Fix .eslintrc.json extends path
+    fixEslintConfigPath(tree, newPath);
+    // Step 5: Fix tsconfig.json extends path
+    fixTsconfigJsonPath(tree, newPath);
+    // Step 6: Fix jest.config.ts paths
+    fixJestConfigPath(tree, newPath, newPath);
+    // Step 7: Fix project.json paths
+    fixProjectJsonPath(tree, newPath, newPath);
+    // Step 8: Fix webpack.config.js output path
+    fixWebpackConfigPath(tree, newPath, newPath);
+    // Step 9: Update tsconfig.base.json paths
+    updateTsConfigBasePaths(tree, app.currentPath, newPath);
+    // Step 10: Update root package.json scripts
+    updateRootPackageJsonScripts(tree, app.currentPath, newPath);
+}
+/**
+ * Main migration function
+ */
+async function update(tree) {
+    devkit_1.logger.info('');
+    devkit_1.logger.info('========================================');
+    devkit_1.logger.info('Reorganizing applications by distribution channel');
+    devkit_1.logger.info('========================================');
+    devkit_1.logger.info('');
+    // Phase 0: Reset Nx cache to ensure fresh project graph
+    resetNxCache();
+    devkit_1.logger.info('');
+    // Phase 1: Discover applications
+    const applications = discoverApplications(tree);
+    if (applications.length === 0) {
+        devkit_1.logger.info('No applications found to migrate');
+        return;
+    }
+    devkit_1.logger.info(`Found ${applications.length} application(s) to reorganize`);
+    // Phase 2: Calculate migration targets
+    const targets = applications.map(calculateMigrationTarget);
+    // Group by subdirectory for logging
+    const byChannel = {
+        local: targets.filter((t) => t.subdirectory === 'local'),
+        server: targets.filter((t) => t.subdirectory === 'server'),
+    };
+    devkit_1.logger.info('');
+    devkit_1.logger.info('Migration plan:');
+    devkit_1.logger.info(`  - local/ (distributionChannel: none): ${byChannel['local'].length} application(s)`);
+    devkit_1.logger.info(`  - server/ (distributionChannel: unisphere): ${byChannel['server'].length} application(s)`);
+    devkit_1.logger.info('');
+    // Phase 3: Validate preconditions
+    try {
+        validateMigrationPreconditions(tree, targets);
+    }
+    catch (error) {
+        devkit_1.logger.error(`Migration precondition failed: ${error}`);
+        throw error;
+    }
+    // Phase 4: Execute migrations SEQUENTIALLY
+    let migrated = 0;
+    for (const target of targets) {
+        try {
+            await migrateApplication(tree, target);
+            migrated++;
+            devkit_1.logger.info(`  [${migrated}/${targets.length}] Migrated ${target.application.name}`);
+            devkit_1.logger.info('');
+        }
+        catch (error) {
+            devkit_1.logger.error(`Failed to migrate ${target.application.name}: ${error}`);
+            throw error;
+        }
+    }
+    // Format all files at the end
+    await (0, devkit_1.formatFiles)(tree);
+    devkit_1.logger.info('');
+    devkit_1.logger.info('========================================');
+    devkit_1.logger.info(`Successfully reorganized ${migrated} application(s)`);
+    devkit_1.logger.info('========================================');
+    devkit_1.logger.info('');
+    devkit_1.logger.info('Next steps:');
+    devkit_1.logger.info('  1. Run: npm install');
+    devkit_1.logger.info('  2. Run: npm run build');
+    devkit_1.logger.info('  3. Verify all imports are updated');
+    devkit_1.logger.info('');
+}

package/dist/migrations/3-0-0/reorganize-packages-by-distribution-channel.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Migration: Reorganize Packages by Distribution Channel
+ *
+ * This migration reorganizes packages based on their `distributionChannel` property in `.unisphere`:
+ *
+ * Directory structure:
+ * - none -> packages/local/
+ * - github -> packages/kaltura-corp/
+ * - npm -> packages/unisphere/
+ * - kaltura-ai -> packages/kaltura-ai/
+ *
+ * Package scope changes:
+ * - none -> @local/{pkg}
+ * - github -> @kaltura-corp/unisphere-{pkg} (replaces @kaltura/unisphere-{pkg})
+ * - npm -> @unisphere/{pkg} (unchanged)
+ * - kaltura-ai -> @kaltura-ai/{pkg}
+ */
+import { Tree } from '@nx/devkit';
+/**
+ * Main migration function
+ */
+export default function update(tree: Tree): Promise<void>;
+//# sourceMappingURL=reorganize-packages-by-distribution-channel.d.ts.map

package/dist/migrations/3-0-0/reorganize-packages-by-distribution-channel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reorganize-packages-by-distribution-channel.d.ts","sourceRoot":"","sources":["../../../src/migrations/3-0-0/reorganize-packages-by-distribution-channel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EACL,IAAI,EAML,MAAM,YAAY,CAAC;AA8qBpB;;GAEG;AACH,wBAA8B,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CA6E9D"}