@ohos-ports/nx 17.3.2-beta.0

package/src/command-line/list/list.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listHandler = void 0;
+const workspace_root_1 = require("../../utils/workspace-root");
+const output_1 = require("../../utils/output");
+const plugins_1 = require("../../utils/plugins");
+const local_plugins_1 = require("../../utils/plugins/local-plugins");
+const project_graph_1 = require("../../project-graph/project-graph");
+const nx_json_1 = require("../../config/nx-json");
+/**
+ * List available plugins or capabilities within a specific plugin
+ *
+ * @remarks
+ *
+ * Must be run within an Nx workspace
+ *
+ */
+async function listHandler(args) {
+    const nxJson = (0, nx_json_1.readNxJson)();
+    const projectGraph = await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true });
+    const projects = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
+    if (args.plugin) {
+        await (0, plugins_1.listPluginCapabilities)(args.plugin, projects.projects);
+    }
+    else {
+        const corePlugins = (0, plugins_1.fetchCorePlugins)();
+        const localPlugins = await (0, local_plugins_1.getLocalWorkspacePlugins)(projects, nxJson);
+        const installedPlugins = await (0, plugins_1.getInstalledPluginsAndCapabilities)(workspace_root_1.workspaceRoot, projects.projects);
+        if (localPlugins.size) {
+            (0, local_plugins_1.listLocalWorkspacePlugins)(localPlugins);
+        }
+        (0, plugins_1.listInstalledPlugins)(installedPlugins);
+        (0, plugins_1.listCorePlugins)(installedPlugins, corePlugins);
+        output_1.output.note({
+            title: 'Community Plugins',
+            bodyLines: [
+                'Looking for a technology / framework not listed above?',
+                'There are many excellent plugins maintained by the Nx community.',
+                'Search for the one you need here: https://nx.dev/plugins/registry.',
+            ],
+        });
+        output_1.output.note({
+            title: `Use "nx list [plugin]" to find out more`,
+        });
+    }
+}
+exports.listHandler = listHandler;

package/src/command-line/migrate/command-object.d.ts

@@ -0,0 +1,3 @@
+import { CommandModule } from 'yargs';
+export declare const yargsMigrateCommand: CommandModule;
+export declare const yargsInternalMigrateCommand: CommandModule;

package/src/command-line/migrate/command-object.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsInternalMigrateCommand = exports.yargsMigrateCommand = void 0;
+const path = require("path");
+const child_process_1 = require("../../utils/child-process");
+const documentation_1 = require("../yargs-utils/documentation");
+const child_process_2 = require("child_process");
+const package_manager_1 = require("../../utils/package-manager");
+const fileutils_1 = require("../../utils/fileutils");
+const workspace_root_1 = require("../../utils/workspace-root");
+exports.yargsMigrateCommand = {
+    command: 'migrate [packageAndVersion]',
+    describe: `Creates a migrations file or runs migrations from the migrations file.
+  - Migrate packages and create migrations.json (e.g., nx migrate @nx/workspace@latest)
+  - Run migrations (e.g., nx migrate --run-migrations=migrations.json). Use flag --if-exists to run migrations only if the migrations file exists.`,
+    builder: (yargs) => (0, documentation_1.linkToNxDevAndExamples)(withMigrationOptions(yargs), 'migrate'),
+    handler: () => {
+        runMigration();
+        process.exit(0);
+    },
+};
+exports.yargsInternalMigrateCommand = {
+    command: '_migrate [packageAndVersion]',
+    describe: false,
+    builder: (yargs) => withMigrationOptions(yargs),
+    handler: async (args) => process.exit(await (await Promise.resolve().then(() => require('./migrate'))).migrate(process.cwd(), args, process.argv.slice(3))),
+};
+function withMigrationOptions(yargs) {
+    const defaultCommitPrefix = 'chore: [nx migration] ';
+    return yargs
+        .positional('packageAndVersion', {
+        describe: `The target package and version (e.g, @nx/workspace@16.0.0)`,
+        type: 'string',
+    })
+        .option('runMigrations', {
+        describe: `Execute migrations from a file (when the file isn't provided, execute migrations from migrations.json)`,
+        type: 'string',
+    })
+        .option('ifExists', {
+        describe: `Run migrations only if the migrations file exists, if not continues successfully`,
+        type: 'boolean',
+        default: false,
+    })
+        .option('from', {
+        describe: 'Use the provided versions for packages instead of the ones installed in node_modules (e.g., --from="@nx/react@16.0.0,@nx/js@16.0.0")',
+        type: 'string',
+    })
+        .option('to', {
+        describe: 'Use the provided versions for packages instead of the ones calculated by the migrator (e.g., --to="@nx/react@16.0.0,@nx/js@16.0.0")',
+        type: 'string',
+    })
+        .option('createCommits', {
+        describe: 'Automatically create a git commit after each migration runs',
+        type: 'boolean',
+        alias: ['C'],
+        default: false,
+    })
+        .option('commitPrefix', {
+        describe: 'Commit prefix to apply to the commit for each migration, when --create-commits is enabled',
+        type: 'string',
+        default: defaultCommitPrefix,
+    })
+        .option('interactive', {
+        describe: 'Enable prompts to confirm whether to collect optional package updates and migrations',
+        type: 'boolean',
+        default: false,
+    })
+        .option('excludeAppliedMigrations', {
+        describe: 'Exclude migrations that should have been applied on previous updates. To be used with --from',
+        type: 'boolean',
+        default: false,
+    })
+        .check(({ createCommits, commitPrefix, from, excludeAppliedMigrations }) => {
+        if (!createCommits && commitPrefix !== defaultCommitPrefix) {
+            throw new Error('Error: Providing a custom commit prefix requires --create-commits to be enabled');
+        }
+        if (excludeAppliedMigrations && !from) {
+            throw new Error('Error: Excluding migrations that should have been previously applied requires --from to be set');
+        }
+        return true;
+    });
+}
+function runMigration() {
+    const runLocalMigrate = () => {
+        (0, child_process_1.runNxSync)(`_migrate ${process.argv.slice(3).join(' ')}`, {
+            stdio: ['inherit', 'inherit', 'inherit'],
+        });
+    };
+    if (process.env.NX_MIGRATE_USE_LOCAL === undefined) {
+        const p = nxCliPath();
+        if (p === null) {
+            runLocalMigrate();
+        }
+        else {
+            // ensure local registry from process is not interfering with the install
+            // when we start the process from temp folder the local registry would override the custom registry
+            if (process.env.npm_config_registry &&
+                process.env.npm_config_registry.match(/^https:\/\/registry\.(npmjs\.org|yarnpkg\.com)/)) {
+                delete process.env.npm_config_registry;
+            }
+            (0, child_process_2.execSync)(`${p} _migrate ${process.argv.slice(3).join(' ')}`, {
+                stdio: ['inherit', 'inherit', 'inherit'],
+            });
+        }
+    }
+    else {
+        runLocalMigrate();
+    }
+}
+function nxCliPath() {
+    try {
+        const packageManager = (0, package_manager_1.getPackageManagerCommand)();
+        const { dirSync } = require('tmp');
+        const tmpDir = dirSync().name;
+        const version = process.env.NX_MIGRATE_USE_NEXT === 'true' ? 'next' : 'latest';
+        (0, fileutils_1.writeJsonFile)(path.join(tmpDir, 'package.json'), {
+            dependencies: {
+                nx: version,
+            },
+            license: 'MIT',
+        });
+        (0, child_process_2.execSync)(packageManager.install, {
+            cwd: tmpDir,
+            stdio: ['ignore', 'ignore', 'ignore'],
+        });
+        // Set NODE_PATH so that these modules can be used for module resolution
+        addToNodePath(path.join(tmpDir, 'node_modules'));
+        addToNodePath(path.join(workspace_root_1.workspaceRoot, 'node_modules'));
+        return path.join(tmpDir, `node_modules`, '.bin', 'nx');
+    }
+    catch (e) {
+        console.error('Failed to install the latest version of the migration script. Using the current version.');
+        if (process.env.NX_VERBOSE_LOGGING) {
+            console.error(e);
+        }
+        return null;
+    }
+}
+function addToNodePath(dir) {
+    // NODE_PATH is a delimited list of paths.
+    // The delimiter is different for windows.
+    const delimiter = require('os').platform() === 'win32' ? ';' : ':';
+    const paths = process.env.NODE_PATH
+        ? process.env.NODE_PATH.split(delimiter)
+        : [];
+    // Add the tmp path
+    paths.push(dir);
+    // Update the env variable.
+    process.env.NODE_PATH = paths.join(delimiter);
+}

package/src/command-line/migrate/migrate.d.ts

@@ -0,0 +1,114 @@
+import { MigrationsJson, PackageJsonUpdateForPackage as PackageUpdate } from '../../config/misc-interfaces';
+import { NxJsonConfiguration } from '../../config/nx-json';
+import { ArrayPackageGroup, PackageJson } from '../../utils/package-json';
+export interface ResolvedMigrationConfiguration extends MigrationsJson {
+    packageGroup?: ArrayPackageGroup;
+}
+export declare function normalizeVersion(version: string): string;
+export interface MigratorOptions {
+    packageJson?: PackageJson;
+    nxInstallation?: NxJsonConfiguration['installation'];
+    getInstalledPackageVersion: (pkg: string, overrides?: Record<string, string>) => string;
+    fetch: (pkg: string, version: string) => Promise<ResolvedMigrationConfiguration>;
+    from: {
+        [pkg: string]: string;
+    };
+    to: {
+        [pkg: string]: string;
+    };
+    interactive?: boolean;
+    excludeAppliedMigrations?: boolean;
+}
+export declare class Migrator {
+    private readonly packageJson?;
+    private readonly getInstalledPackageVersion;
+    private readonly fetch;
+    private readonly installedPkgVersionOverrides;
+    private readonly to;
+    private readonly interactive;
+    private readonly excludeAppliedMigrations;
+    private readonly packageUpdates;
+    private readonly collectedVersions;
+    private readonly promptAnswers;
+    private readonly nxInstallation;
+    private minVersionWithSkippedUpdates;
+    constructor(opts: MigratorOptions);
+    migrate(targetPackage: string, targetVersion: string): Promise<{
+        packageUpdates: Record<string, PackageUpdate>;
+        migrations: {
+            package: string;
+            name: string;
+            version: string;
+            description?: string;
+            cli?: string;
+            implementation?: string;
+            factory?: string;
+            requires?: Record<string, string>;
+        }[];
+        minVersionWithSkippedUpdates: string;
+    }>;
+    private createMigrateJson;
+    private buildPackageJsonUpdates;
+    private populatePackageJsonUpdatesAndGetPackagesToCheck;
+    private getPackageJsonUpdatesFromMigrationConfig;
+    /**
+     * Mutates migrationConfig, adding package group updates into packageJsonUpdates section
+     *
+     * @param packageName Package which is being migrated
+     * @param targetVersion Version which is being migrated to
+     * @param migrationConfig Configuration which is mutated to contain package json updates
+     * @returns Order of package groups
+     */
+    private getPackageJsonUpdatesFromPackageGroup;
+    private filterPackageJsonUpdates;
+    private shouldApplyPackageUpdate;
+    private addPackageUpdate;
+    private areRequirementsMet;
+    private areMigrationRequirementsMet;
+    private isMigrationForHigherVersionThanWhatIsInstalled;
+    private wasMigrationSkipped;
+    private runPackageJsonUpdatesConfirmationPrompt;
+    private getPackageUpdatePromptKey;
+    private getPkgVersion;
+    private gt;
+    private lt;
+    private lte;
+}
+type GenerateMigrations = {
+    type: 'generateMigrations';
+    targetPackage: string;
+    targetVersion: string;
+    from: {
+        [k: string]: string;
+    };
+    to: {
+        [k: string]: string;
+    };
+    interactive?: boolean;
+    excludeAppliedMigrations?: boolean;
+};
+type RunMigrations = {
+    type: 'runMigrations';
+    runMigrations: string;
+    ifExists: boolean;
+};
+export declare function parseMigrationsOptions(options: {
+    [k: string]: any;
+}): Promise<GenerateMigrations | RunMigrations>;
+export declare function executeMigrations(root: string, migrations: {
+    package: string;
+    name: string;
+    description?: string;
+    version: string;
+    cli?: 'nx' | 'angular';
+}[], isVerbose: boolean, shouldCreateCommits: boolean, commitPrefix: string): Promise<{
+    package: string;
+    name: string;
+    description?: string;
+    version: string;
+    cli?: 'nx' | 'angular';
+}[]>;
+export declare function migrate(root: string, args: {
+    [k: string]: any;
+}, rawArgs: string[]): Promise<any>;
+export {};