@nx/rspack/src/generators/convert-to-inferred/convert-to-inferred.js

The Nx Plugin for Rspack contains executors and generators that support building applications using Rspack.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.convertToInferred = convertToInferred;
exports.createCollectingLogger = createCollectingLogger;
const devkit_1 = require("@nx/devkit");
const aggregate_log_util_1 = require("@nx/devkit/src/generators/plugin-migrations/aggregate-log-util");
const executor_to_plugin_migrator_1 = require("@nx/devkit/src/generators/plugin-migrations/executor-to-plugin-migrator");
const tsquery_1 = require("@phenomnomnominal/tsquery");
const plugin_1 = require("../../plugins/plugin");
const versions_1 = require("../../utils/versions");
const utils_1 = require("./utils");
const devkit_exports_1 = require("nx/src/devkit-exports");
async function convertToInferred(tree, options) {
    const projectGraph = await (0, devkit_1.createProjectGraphAsync)();
    const migrationContext = {
        logger: new aggregate_log_util_1.AggregatedLog(),
        projectGraph,
        workspaceRoot: tree.root,
    };
    const logger = createCollectingLogger();
    const migratedProjects = await (0, executor_to_plugin_migrator_1.migrateProjectExecutorsToPlugin)(tree, projectGraph, '@nx/rspack/plugin', plugin_1.createNodesV2, {
        buildTargetName: 'build',
        previewTargetName: 'preview',
        serveStaticTargetName: 'serve-static',
        serveTargetName: 'serve',
    }, [
        {
            executors: ['@nx/rspack:rspack', '@nrwl/rspack:rspack'],
            postTargetTransformer: (0, utils_1.buildPostTargetTransformerFactory)(migrationContext),
            targetPluginOptionMapper: (target) => ({ buildTargetName: target }),
            skipProjectFilter: skipProjectFilterFactory(tree),
        },
        {
            executors: ['@nx/rspack:dev-server', '@nrwl/rspack:dev-server'],
            postTargetTransformer: (0, utils_1.servePostTargetTransformerFactory)(migrationContext),
            targetPluginOptionMapper: (target) => ({ serveTargetName: target }),
            skipProjectFilter: skipProjectFilterFactory(tree),
        },
    ], options.project, logger);
    if (migratedProjects.size === 0) {
        const convertMessage = [...logger.loggedMessages.values()]
            .flat()
            .find((v) => v.includes('@nx/rspack:convert-config-to-rspack-plugin'));
        if (convertMessage.length > 0) {
            logger.flushLogs((message) => !convertMessage.includes(message));
            throw new Error(convertMessage);
        }
        else {
            logger.flushLogs();
            throw new executor_to_plugin_migrator_1.NoTargetsToMigrateError();
        }
    }
    else {
        logger.flushLogs();
    }
    const installCallback = (0, devkit_1.addDependenciesToPackageJson)(tree, {}, { '@rspack/core': versions_1.rspackCoreVersion }, undefined, true);
    if (!options.skipFormat) {
        await (0, devkit_1.formatFiles)(tree);
    }
    return (0, devkit_1.runTasksInSerial)(installCallback, () => {
        migrationContext.logger.flushLogs();
    });
}
function skipProjectFilterFactory(tree) {
    return function skipProjectFilter(projectConfiguration) {
        const buildTarget = Object.values(projectConfiguration.targets).find((target) => target.executor === '@nx/rspack:rspack' ||
            target.executor === '@nrwl/rspack:rspack');
        // the projects for which this is called are guaranteed to have a build target
        const rspackConfigPath = buildTarget.options.rspackConfig;
        if (!rspackConfigPath) {
            return `The rspack config path is missing in the project configuration (${projectConfiguration.root}).`;
        }
        const sourceFile = (0, tsquery_1.ast)(tree.read(rspackConfigPath, 'utf-8'));
        const composePluginsSelector = 'CallExpression:has(Identifier[name=composePlugins])';
        const composePlugins = (0, tsquery_1.query)(sourceFile, composePluginsSelector)[0];
        if (composePlugins) {
            return `The rspack config (${rspackConfigPath}) can only work with the  "@nx/rspack:rspack" executor. Run the "@nx/rspack:convert-config-to-rspack-plugin" generator first.`;
        }
        const nxAppRspackPluginSelector = 'PropertyAssignment:has(Identifier[name=plugins]) NewExpression:has(Identifier[name=NxAppRspackPlugin])';
        const nxAppRspackPlugin = (0, tsquery_1.query)(sourceFile, nxAppRspackPluginSelector)[0];
        if (!nxAppRspackPlugin) {
            return `No "NxAppRspackPlugin" found in the rspack config (${rspackConfigPath}). Its usage is required for the migration to work.`;
        }
        return false;
    };
}
function createCollectingLogger() {
    const loggedMessages = new Map();
    const flushLogs = (filter) => {
        loggedMessages.forEach((messages, method) => {
            messages.forEach((message) => {
                if (!filter || filter(message)) {
                    devkit_exports_1.logger[method](message);
                }
            });
        });
    };
    return new Proxy({ ...devkit_exports_1.logger, loggedMessages, flushLogs }, {
        get(target, property) {
            const originalMethod = target[property];
            if (typeof originalMethod === 'function') {
                return (...args) => {
                    const message = args.join(' ');
                    const propertyString = String(property);
                    if (!loggedMessages.has(message)) {
                        loggedMessages.set(propertyString, []);
                    }
                    loggedMessages.get(propertyString).push(message);
                };
            }
            return originalMethod;
        },
    });
}