@nx/next 0.0.0-pr-22179-271588f

package/plugins/with-nx.js

@@ -0,0 +1,297 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withNx = exports.forNextVersion = exports.getAliasForProject = exports.getNextConfig = void 0;
+function regexEqual(x, y) {
+    return (x instanceof RegExp &&
+        y instanceof RegExp &&
+        x.source === y.source &&
+        x.global === y.global &&
+        x.ignoreCase === y.ignoreCase &&
+        x.multiline === y.multiline);
+}
+/**
+ * Do not remove or rename this function. Production builds inline `with-nx.js` file with a replacement
+ * To this function that hard-codes the libsDir.
+ */
+function getWithNxContext() {
+    const { workspaceRoot, workspaceLayout } = require('@nx/devkit');
+    return {
+        workspaceRoot,
+        libsDir: workspaceLayout().libsDir,
+    };
+}
+function getNxContext(graph, target) {
+    const { parseTargetString, workspaceRoot } = require('@nx/devkit');
+    const projectNode = graph.nodes[target.project];
+    const targetConfig = projectNode.data.targets[target.target];
+    const targetOptions = targetConfig.options;
+    if (target.configuration) {
+        Object.assign(targetOptions, targetConfig.configurations[target.configuration]);
+    }
+    const partialExecutorContext = {
+        projectName: target.project,
+        targetName: target.target,
+        projectGraph: graph,
+        configurationName: target.configuration,
+        root: workspaceRoot,
+    };
+    if (targetOptions.devServerTarget) {
+        // Executors such as @nx/cypress:cypress define the devServerTarget option.
+        return getNxContext(graph, parseTargetString(targetOptions.devServerTarget, partialExecutorContext));
+    }
+    else if (targetOptions.buildTarget) {
+        // Executors such as @nx/next:server or @nx/next:export define the buildTarget option.
+        return getNxContext(graph, parseTargetString(targetOptions.buildTarget, partialExecutorContext));
+    }
+    // Default case, return info for current target.
+    // This could be a build using @nx/next:build or run-commands without using our executors.
+    return {
+        node: graph.nodes[target.project],
+        options: targetOptions,
+        projectName: target.project,
+        targetName: target.target,
+        configurationName: target.configuration,
+    };
+}
+/**
+ * Try to read output dir from project, and default to '.next' if executing outside of Nx (e.g. dist is added to a docker image).
+ */
+function withNx(_nextConfig = {}, context = getWithNxContext()) {
+    return async (phase) => {
+        const { PHASE_PRODUCTION_SERVER, PHASE_DEVELOPMENT_SERVER } = await Promise.resolve().then(() => require('next/constants'));
+        // Two scenarios where we want to skip graph creation:
+        // 1. Running production server means the build is already done so we just need to start the Next.js server.
+        // 2. During graph creation (i.e. create nodes), we won't have a graph to read, and it is not needed anyway since it's a build-time concern.
+        //
+        // NOTE: Avoid any `require(...)` or `import(...)` statements here. Development dependencies are not available at production runtime.
+        if (PHASE_PRODUCTION_SERVER === phase || global.NX_GRAPH_CREATION) {
+            const { nx, ...validNextConfig } = _nextConfig;
+            return {
+                distDir: '.next',
+                ...validNextConfig,
+            };
+        }
+        else {
+            const { createProjectGraphAsync, joinPathFragments, offsetFromRoot, workspaceRoot, } = require('@nx/devkit');
+            let graph;
+            try {
+                graph = await createProjectGraphAsync();
+            }
+            catch (e) {
+                throw new Error('Could not create project graph. Please ensure that your workspace is valid.', { cause: e });
+            }
+            const originalTarget = {
+                project: process.env.NX_TASK_TARGET_PROJECT,
+                target: process.env.NX_TASK_TARGET_TARGET,
+                configuration: process.env.NX_TASK_TARGET_CONFIGURATION,
+            };
+            const { node: projectNode, options, projectName: project, } = getNxContext(graph, originalTarget);
+            const projectDirectory = projectNode.data.root;
+            // Get next config
+            const nextConfig = getNextConfig(_nextConfig, context);
+            // For Next.js 13.1 and greater, make sure workspace libs are transpiled.
+            forNextVersion('>=13.1.0', () => {
+                if (!graph.dependencies[project])
+                    return;
+                const { readTsConfigPaths } = require('@nx/js');
+                const { findAllProjectNodeDependencies, } = require('nx/src/utils/project-graph-utils');
+                const paths = readTsConfigPaths();
+                const deps = findAllProjectNodeDependencies(project);
+                nextConfig.transpilePackages ??= [];
+                for (const dep of deps) {
+                    const alias = getAliasForProject(graph.nodes[dep], paths);
+                    if (alias) {
+                        nextConfig.transpilePackages.push(alias);
+                    }
+                }
+            });
+            // process.env.NX_NEXT_OUTPUT_PATH is set when running @nx/next:build
+            options.outputPath =
+                process.env.NX_NEXT_OUTPUT_PATH || options.outputPath;
+            // outputPath may be undefined if using run-commands or other executors other than @nx/next:build.
+            // In this case, the user should set distDir in their next.config.js.
+            if (options.outputPath && phase !== PHASE_DEVELOPMENT_SERVER) {
+                const outputDir = `${offsetFromRoot(projectDirectory)}${options.outputPath}`;
+                // If running dev-server, we should keep `.next` inside project directory since Turbopack expects this.
+                // See: https://github.com/nrwl/nx/issues/19365
+                nextConfig.distDir =
+                    nextConfig.distDir && nextConfig.distDir !== '.next'
+                        ? joinPathFragments(outputDir, nextConfig.distDir)
+                        : joinPathFragments(outputDir, '.next');
+            }
+            // If we are running a static serve of the Next.js app, we need to change the output to 'export' and the distDir to 'out'.
+            if (process.env.NX_SERVE_STATIC_BUILD_RUNNING === 'true') {
+                nextConfig.output = 'export';
+                nextConfig.distDir = 'out';
+            }
+            const userWebpackConfig = nextConfig.webpack;
+            const { createWebpackConfig } = require('@nx/next/src/utils/config');
+            nextConfig.webpack = (a, b) => createWebpackConfig(workspaceRoot, projectDirectory, options.fileReplacements, options.assets)(userWebpackConfig ? userWebpackConfig(a, b) : a, b);
+            return nextConfig;
+        }
+    };
+}
+exports.withNx = withNx;
+function getNextConfig(nextConfig = {}, context = getWithNxContext()) {
+    // If `next-compose-plugins` is used, the context argument is invalid.
+    if (!context.libsDir || !context.workspaceRoot) {
+        context = getWithNxContext();
+    }
+    const userWebpack = nextConfig.webpack || ((x) => x);
+    const { nx, ...validNextConfig } = nextConfig;
+    return {
+        eslint: {
+            ignoreDuringBuilds: true,
+            ...(validNextConfig.eslint ?? {}),
+        },
+        ...validNextConfig,
+        webpack: (config, options) => {
+            /*
+             * Update babel to support our monorepo setup.
+             * The 'upward' mode allows the root babel.config.json and per-project .babelrc files to be picked up.
+             */
+            if (nx?.babelUpwardRootMode) {
+                options.defaultLoaders.babel.options.babelrc = true;
+                options.defaultLoaders.babel.options.rootMode = 'upward';
+            }
+            /*
+             * Modify the Next.js webpack config to allow workspace libs to use css modules.
+             * Note: This would be easier if Next.js exposes css-loader and sass-loader on `defaultLoaders`.
+             */
+            // Include workspace libs in css/sass loaders
+            const includes = [
+                require('path').join(context.workspaceRoot, context.libsDir),
+            ];
+            const nextCssLoaders = config.module.rules.find((rule) => typeof rule.oneOf === 'object');
+            // webpack config is not as expected
+            if (!nextCssLoaders)
+                return config;
+            /*
+             *  1. Modify css loader to enable module support for workspace libs
+             */
+            const nextCssLoader = nextCssLoaders.oneOf.find((rule) => rule.sideEffects === false && regexEqual(rule.test, /\.module\.css$/));
+            // Might not be found if Next.js webpack config changes in the future
+            if (nextCssLoader && nextCssLoader.issuer) {
+                nextCssLoader.issuer.or = nextCssLoader.issuer.and
+                    ? nextCssLoader.issuer.and.concat(includes)
+                    : includes;
+                delete nextCssLoader.issuer.and;
+            }
+            /*
+             *  2. Modify sass loader to enable module support for workspace libs
+             */
+            const nextSassLoader = nextCssLoaders.oneOf.find((rule) => rule.sideEffects === false &&
+                regexEqual(rule.test, /\.module\.(scss|sass)$/));
+            // Might not be found if Next.js webpack config changes in the future
+            if (nextSassLoader && nextSassLoader.issuer) {
+                nextSassLoader.issuer.or = nextSassLoader.issuer.and
+                    ? nextSassLoader.issuer.and.concat(includes)
+                    : includes;
+                delete nextSassLoader.issuer.and;
+            }
+            /*
+             *  3. Modify error loader to ignore css modules used by workspace libs
+             */
+            const nextErrorCssModuleLoader = nextCssLoaders.oneOf.find((rule) => rule.use &&
+                rule.use.loader === 'error-loader' &&
+                rule.use.options &&
+                (rule.use.options.reason ===
+                    'CSS Modules \u001b[1mcannot\u001b[22m be imported from within \u001b[1mnode_modules\u001b[22m.\n' +
+                        'Read more: https://err.sh/next.js/css-modules-npm' ||
+                    rule.use.options.reason ===
+                        'CSS Modules cannot be imported from within node_modules.\nRead more: https://err.sh/next.js/css-modules-npm'));
+            // Might not be found if Next.js webpack config changes in the future
+            if (nextErrorCssModuleLoader) {
+                nextErrorCssModuleLoader.exclude = includes;
+            }
+            /**
+             * 4. Modify css loader to allow global css from node_modules to be imported from workspace libs
+             */
+            const nextGlobalCssLoader = nextCssLoaders.oneOf.find((rule) => rule.include?.and?.find((include) => regexEqual(include, /node_modules/)));
+            // Might not be found if Next.js webpack config changes in the future
+            if (nextGlobalCssLoader && nextGlobalCssLoader.issuer) {
+                nextGlobalCssLoader.issuer.or = nextGlobalCssLoader.issuer.and
+                    ? nextGlobalCssLoader.issuer.and.concat(includes)
+                    : includes;
+                delete nextGlobalCssLoader.issuer.and;
+            }
+            /**
+             * 5. Add env variables prefixed with NX_
+             */
+            addNxEnvVariables(config);
+            /**
+             * 6. Add SVGR support if option is on.
+             */
+            // Default SVGR support to be on for projects.
+            if (nx?.svgr !== false) {
+                config.module.rules.push(
+                // Apply rule for svg imports ending in ?url
+                {
+                    test: /\.svg$/i,
+                    type: 'asset',
+                    resourceQuery: /url/, // apply to *.svg?url
+                }, 
+                // Convert all other svg imports to React components
+                {
+                    test: /\.svg$/i,
+                    issuer: /\.[jt]sx?$/,
+                    resourceQuery: { not: [/url/] },
+                    use: ['@svgr/webpack'],
+                });
+            }
+            return userWebpack(config, options);
+        },
+    };
+}
+exports.getNextConfig = getNextConfig;
+function getNxEnvironmentVariables() {
+    return Object.keys(process.env)
+        .filter((env) => /^NX_/i.test(env))
+        .reduce((env, key) => {
+        env[key] = process.env[key];
+        return env;
+    }, {});
+}
+/**
+ * TODO(v19)
+ * @deprecated Use Next.js 9.4+ built-in support for environment variables. Reference https://nextjs.org/docs/pages/api-reference/next-config-js/env
+ */
+function addNxEnvVariables(config) {
+    const maybeDefinePlugin = config.plugins?.find((plugin) => {
+        return plugin.definitions?.['process.env.NODE_ENV'];
+    });
+    if (maybeDefinePlugin) {
+        const env = getNxEnvironmentVariables();
+        Object.entries(env)
+            .map(([name, value]) => [`process.env.${name}`, `"${value}"`])
+            .filter(([name]) => !maybeDefinePlugin.definitions[name])
+            .forEach(([name, value]) => (maybeDefinePlugin.definitions[name] = value));
+    }
+}
+function getAliasForProject(node, paths) {
+    // Match workspace libs to their alias in tsconfig paths.
+    for (const [alias, lookup] of Object.entries(paths ?? {})) {
+        const lookupContainsDepNode = lookup.some((lookupPath) => lookupPath.startsWith(node?.data?.root) ||
+            lookupPath.startsWith('./' + node?.data?.root));
+        if (lookupContainsDepNode) {
+            return alias;
+        }
+    }
+    return null;
+}
+exports.getAliasForProject = getAliasForProject;
+// Runs a function if the Next.js version satisfies the range.
+function forNextVersion(range, fn) {
+    const semver = require('semver');
+    const nextJsVersion = require('next/package.json').version;
+    if (semver.satisfies(nextJsVersion, range)) {
+        fn();
+    }
+}
+exports.forNextVersion = forNextVersion;
+// Support for older generated code: `const withNx = require('@nx/next/plugins/with-nx');`
+module.exports = withNx;
+// Support for newer generated code: `const { withNx } = require(...);`
+module.exports.withNx = withNx;
+module.exports.getNextConfig = getNextConfig;
+module.exports.getAliasForProject = getAliasForProject;

package/plugins/with-stylus.d.ts

@@ -0,0 +1,3 @@
+import { NextConfigFn } from '../src/utils/config';
+import { WithNxOptions } from './with-nx';
+export declare function withStylus(configOrFn: WithNxOptions | NextConfigFn): NextConfigFn;

package/plugins/with-stylus.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withStylus = void 0;
+// TODO(v19): Remove file, it is here until users migrate over to SASS manually.
+function withStylus(configOrFn) {
+    return async (phase) => {
+        throw new Error(`Stylus support has been removed and you should use the built-in SASS support. Remove the "withStylus" plugin from your Next.js config, and rename your files from .styl to .scss.`);
+    };
+}
+exports.withStylus = withStylus;
+module.exports = withStylus;
+module.exports.withStylus = withStylus;

package/src/executors/build/build.impl.d.ts

@@ -0,0 +1,5 @@
+import { ExecutorContext } from '@nx/devkit';
+import { NextBuildBuilderOptions } from '../../utils/types';
+export default function buildExecutor(options: NextBuildBuilderOptions, context: ExecutorContext): Promise<{
+    success: boolean;
+}>;

package/src/executors/build/build.impl.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const js_1 = require("@nx/js");
+const path_1 = require("path");
+const fs_extra_1 = require("fs-extra");
+const semver_1 = require("semver");
+const fileutils_1 = require("@nx/workspace/src/utilities/fileutils");
+const semver_2 = require("@nx/devkit/src/utils/semver");
+const update_package_json_1 = require("./lib/update-package-json");
+const create_next_config_file_1 = require("./lib/create-next-config-file");
+const check_project_1 = require("./lib/check-project");
+const child_process_1 = require("child_process");
+const create_cli_options_1 = require("../../utils/create-cli-options");
+let childProcess;
+async function buildExecutor(options, context) {
+    // Cast to any to overwrite NODE_ENV
+    process.env.NODE_ENV ||= 'production';
+    const projectRoot = context.projectGraph.nodes[context.projectName].data.root;
+    (0, check_project_1.checkPublicDirectory)(projectRoot);
+    // Set `__NEXT_REACT_ROOT` based on installed ReactDOM version
+    const packageJsonPath = (0, path_1.join)(projectRoot, 'package.json');
+    const packageJson = (0, fs_extra_1.existsSync)(packageJsonPath)
+        ? (0, devkit_1.readJsonFile)(packageJsonPath)
+        : undefined;
+    const rootPackageJson = (0, devkit_1.readJsonFile)((0, path_1.join)(context.root, 'package.json'));
+    const reactDomVersion = packageJson?.dependencies?.['react-dom'] ??
+        rootPackageJson.dependencies?.['react-dom'];
+    const hasReact18 = reactDomVersion &&
+        (0, semver_1.gte)((0, semver_2.checkAndCleanWithSemver)('react-dom', reactDomVersion), '18.0.0');
+    if (hasReact18) {
+        process.env['__NEXT_REACT_ROOT'] ||= 'true';
+    }
+    try {
+        await runCliBuild(devkit_1.workspaceRoot, projectRoot, options);
+    }
+    catch (error) {
+        devkit_1.logger.error(`Error occurred while trying to run the build command`);
+        devkit_1.logger.error(error);
+        return { success: false };
+    }
+    finally {
+        if (childProcess) {
+            childProcess.kill();
+        }
+    }
+    if (!(0, fileutils_1.directoryExists)(options.outputPath)) {
+        (0, fs_extra_1.mkdir)(options.outputPath);
+    }
+    const builtPackageJson = (0, js_1.createPackageJson)(context.projectName, context.projectGraph, {
+        target: context.targetName,
+        root: context.root,
+        isProduction: !options.includeDevDependenciesInPackageJson, // By default we remove devDependencies since this is a production build.
+    });
+    // Update `package.json` to reflect how users should run the build artifacts
+    builtPackageJson.scripts = {
+        start: 'next start',
+    };
+    (0, update_package_json_1.updatePackageJson)(builtPackageJson, context);
+    (0, devkit_1.writeJsonFile)(`${options.outputPath}/package.json`, builtPackageJson);
+    if (options.generateLockfile) {
+        const packageManager = (0, devkit_1.detectPackageManager)(context.root);
+        const lockFile = (0, js_1.createLockFile)(builtPackageJson, context.projectGraph, packageManager);
+        (0, fs_extra_1.writeFileSync)(`${options.outputPath}/${(0, js_1.getLockFileName)(packageManager)}`, lockFile, {
+            encoding: 'utf-8',
+        });
+    }
+    // If output path is different from source path, then copy over the config and public files.
+    // This is the default behavior when running `nx build <app>`.
+    if (options.outputPath.replace(/\/$/, '') !== projectRoot) {
+        (0, create_next_config_file_1.createNextConfigFile)(options, context);
+        (0, fs_extra_1.copySync)((0, path_1.join)(projectRoot, 'public'), (0, path_1.join)(options.outputPath, 'public'), {
+            dereference: true,
+        });
+    }
+    return { success: true };
+}
+exports.default = buildExecutor;
+function runCliBuild(workspaceRoot, projectRoot, options) {
+    const { experimentalAppOnly, profile, debug, outputPath } = options;
+    // Set output path here since it can also be set via CLI
+    // We can retrieve it inside plugins/with-nx
+    process.env.NX_NEXT_OUTPUT_PATH ??= outputPath;
+    const args = (0, create_cli_options_1.createCliOptions)({ experimentalAppOnly, profile, debug });
+    return new Promise((resolve, reject) => {
+        childProcess = (0, child_process_1.fork)(require.resolve('next/dist/bin/next'), ['build', ...args], {
+            cwd: (0, path_1.resolve)(workspaceRoot, projectRoot),
+            stdio: 'inherit',
+            env: process.env,
+        });
+        // Ensure the child process is killed when the parent exits
+        process.on('exit', () => childProcess.kill());
+        process.on('SIGTERM', () => childProcess.kill());
+        childProcess.on('error', (err) => {
+            reject(err);
+        });
+        childProcess.on('exit', (code) => {
+            if (code === 0) {
+                resolve(code);
+            }
+            else {
+                reject(code);
+            }
+        });
+    });
+}

package/src/executors/build/lib/check-project.d.ts

@@ -0,0 +1 @@
+export declare function checkPublicDirectory(root: string): void;

package/src/executors/build/lib/check-project.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkPublicDirectory = void 0;
+const devkit_1 = require("@nx/devkit");
+const fs_extra_1 = require("fs-extra");
+const path_1 = require("path");
+function checkPublicDirectory(root) {
+    if ((0, fs_extra_1.readdirSync)((0, path_1.join)(root, 'public')).length === 0) {
+        devkit_1.logger.warn('public directory cannot be empty. This may result in errors during the deployment. Consider adding a public/.gitkeep file');
+    }
+}
+exports.checkPublicDirectory = checkPublicDirectory;

package/src/executors/build/lib/create-next-config-file.d.ts

@@ -0,0 +1,14 @@
+import type { ExecutorContext } from '@nx/devkit';
+import type { NextBuildBuilderOptions } from '../../../utils/types';
+export declare function createNextConfigFile(options: NextBuildBuilderOptions, context: ExecutorContext): void;
+export declare function getWithNxContent({ file, content }?: {
+    file: string;
+    content: string;
+}): string;
+export declare function findNextConfigPath(dirname: string, userDefinedConfigPath?: string): string;
+export declare function getRelativeFilesToCopy(fileName: string, cwd: string): string[];
+export declare function getRelativeImports({ file, content, }: {
+    file: string;
+    content: string;
+}): string[];
+export declare function ensureFileExtensions(files: string[], absoluteDir: string): string[];

package/src/executors/build/lib/create-next-config-file.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureFileExtensions = exports.getRelativeImports = exports.getRelativeFilesToCopy = exports.findNextConfigPath = exports.getWithNxContent = exports.createNextConfigFile = void 0;
+const devkit_1 = require("@nx/devkit");
+const ts = require("typescript");
+const fs_extra_1 = require("fs-extra");
+const path_1 = require("path");
+const typescript_1 = require("nx/src/utils/typescript");
+function createNextConfigFile(options, context) {
+    // Don't overwrite the next.config.js file if output path is the same as the source path.
+    if (options.outputPath.replace(/\/$/, '') ===
+        context.projectGraph.nodes[context.projectName].data.root) {
+        return;
+    }
+    const projectRoot = context.projectGraph.nodes[context.projectName].data.root;
+    const configRelativeToProjectRoot = findNextConfigPath(projectRoot, 
+    // If user passed a config then it is relative to the workspace root, need to normalize it to be relative to the project root.
+    options.nextConfig ? (0, path_1.relative)(projectRoot, options.nextConfig) : undefined);
+    const configAbsolutePath = (0, path_1.join)(projectRoot, configRelativeToProjectRoot);
+    if (!(0, fs_extra_1.existsSync)(configAbsolutePath)) {
+        throw new Error('next.config.js not found');
+    }
+    // Copy config file and our `.nx-helpers` folder to remove dependency on @nrwl/next for production build.
+    const helpersPath = (0, path_1.join)(options.outputPath, '.nx-helpers');
+    (0, fs_extra_1.mkdirSync)(helpersPath, { recursive: true });
+    (0, fs_extra_1.copyFileSync)((0, path_1.join)(__dirname, '../../../utils/compose-plugins.js'), (0, path_1.join)(helpersPath, 'compose-plugins.js'));
+    (0, fs_extra_1.writeFileSync)((0, path_1.join)(helpersPath, 'with-nx.js'), getWithNxContent());
+    (0, fs_extra_1.writeFileSync)((0, path_1.join)(helpersPath, 'compiled.js'), `
+        const withNx = require('./with-nx');
+        module.exports = withNx;
+        module.exports.withNx = withNx;
+        module.exports.composePlugins = require('./compose-plugins').composePlugins;
+      `);
+    (0, fs_extra_1.writeFileSync)((0, path_1.join)(options.outputPath, configRelativeToProjectRoot), (0, fs_extra_1.readFileSync)(configAbsolutePath)
+        .toString()
+        .replace(/["']@nx\/next["']/, `'./.nx-helpers/compiled.js'`)
+        // TODO(v17): Remove this once users have all migrated to new @nx scope and import from '@nx/next' not the deep import paths.
+        .replace('@nx/next/plugins/with-nx', './.nx-helpers/compiled.js')
+        .replace('@nrwl/next/plugins/with-nx', './.nx-helpers/compiled.js'));
+    // Find all relative imports needed by next.config.js and copy them to the dist folder.
+    const moduleFilesToCopy = getRelativeFilesToCopy(configRelativeToProjectRoot, projectRoot);
+    for (const moduleFile of moduleFilesToCopy) {
+        (0, fs_extra_1.ensureDirSync)((0, path_1.dirname)((0, path_1.join)(context.root, options.outputPath, moduleFile)));
+        // We already generate a build version of package.json in the dist folder.
+        if (moduleFile !== 'package.json') {
+            (0, fs_extra_1.copyFileSync)((0, path_1.join)(context.root, projectRoot, moduleFile), (0, path_1.join)(context.root, options.outputPath, moduleFile));
+        }
+    }
+}
+exports.createNextConfigFile = createNextConfigFile;
+function readSource(getFile) {
+    return {
+        file: getFile(),
+        content: (0, fs_extra_1.readFileSync)(getFile()).toString(),
+    };
+}
+// Exported for testing
+function getWithNxContent({ file, content } = readSource(() => (0, path_1.join)(__dirname, '../../../../plugins/with-nx.js'))) {
+    const withNxSource = ts.createSourceFile(file, content, ts.ScriptTarget.Latest, true);
+    const getWithNxContextDeclaration = (0, typescript_1.findNodes)(withNxSource, ts.SyntaxKind.FunctionDeclaration)?.find((node) => node.name?.text === 'getWithNxContext');
+    if (getWithNxContextDeclaration) {
+        content = (0, devkit_1.applyChangesToString)(content, [
+            {
+                type: devkit_1.ChangeType.Delete,
+                start: getWithNxContextDeclaration.getStart(withNxSource),
+                length: getWithNxContextDeclaration.getWidth(withNxSource),
+            },
+            {
+                type: devkit_1.ChangeType.Insert,
+                index: getWithNxContextDeclaration.getStart(withNxSource),
+                text: (0, devkit_1.stripIndents) `function getWithNxContext() {
+          return {
+            workspaceRoot: '${devkit_1.workspaceRoot}',
+            libsDir: '${(0, devkit_1.workspaceLayout)().libsDir}'
+          }
+        }`,
+            },
+        ]);
+    }
+    return content;
+}
+exports.getWithNxContent = getWithNxContent;
+function findNextConfigPath(dirname, userDefinedConfigPath) {
+    if (userDefinedConfigPath) {
+        const file = userDefinedConfigPath;
+        if ((0, fs_extra_1.existsSync)((0, path_1.join)(dirname, file)))
+            return file;
+        throw new Error(`Cannot find the Next.js config file: ${userDefinedConfigPath}. Is the path correct in project.json?`);
+    }
+    const candidates = ['next.config.js', 'next.config.cjs', 'next.config.mjs'];
+    for (const candidate of candidates) {
+        if ((0, fs_extra_1.existsSync)((0, path_1.join)(dirname, candidate)))
+            return candidate;
+    }
+    throw new Error(`Cannot find any of the following files in your project: ${candidates.join(', ')}. Is this a Next.js project?`);
+}
+exports.findNextConfigPath = findNextConfigPath;
+// Exported for testing
+function getRelativeFilesToCopy(fileName, cwd) {
+    const seen = new Set();
+    const collected = new Set();
+    function doCollect(currFile) {
+        // Prevent circular dependencies from causing infinite loop
+        if (seen.has(currFile))
+            return;
+        seen.add(currFile);
+        const absoluteFilePath = (0, path_1.join)(cwd, currFile);
+        const content = (0, fs_extra_1.readFileSync)(absoluteFilePath).toString();
+        const files = getRelativeImports({ file: currFile, content });
+        const modules = ensureFileExtensions(files, (0, path_1.dirname)(absoluteFilePath));
+        const relativeDirPath = (0, path_1.dirname)(currFile);
+        for (const moduleName of modules) {
+            const relativeModulePath = (0, path_1.join)(relativeDirPath, moduleName);
+            collected.add(relativeModulePath);
+            doCollect(relativeModulePath);
+        }
+    }
+    doCollect(fileName);
+    return Array.from(collected);
+}
+exports.getRelativeFilesToCopy = getRelativeFilesToCopy;
+// Exported for testing
+function getRelativeImports({ file, content, }) {
+    const source = ts.createSourceFile(file, content, ts.ScriptTarget.Latest, true);
+    const callExpressionsOrImportDeclarations = (0, typescript_1.findNodes)(source, [
+        ts.SyntaxKind.CallExpression,
+        ts.SyntaxKind.ImportDeclaration,
+    ]);
+    const modulePaths = [];
+    for (const node of callExpressionsOrImportDeclarations) {
+        if (node.kind === ts.SyntaxKind.ImportDeclaration) {
+            modulePaths.push(stripOuterQuotes(node.moduleSpecifier.getText(source)));
+        }
+        else {
+            if (node.expression.getText(source) === 'require') {
+                modulePaths.push(stripOuterQuotes(node.arguments[0].getText(source)));
+            }
+        }
+    }
+    return modulePaths.filter((path) => path.startsWith('.'));
+}
+exports.getRelativeImports = getRelativeImports;
+function stripOuterQuotes(str) {
+    return str.match(/^["'](.*)["']/)?.[1] ?? str;
+}
+// Exported for testing
+function ensureFileExtensions(files, absoluteDir) {
+    const extensions = ['.js', '.cjs', '.mjs', '.json'];
+    return files.map((file) => {
+        const providedExt = (0, path_1.extname)(file);
+        if (providedExt && extensions.includes(providedExt))
+            return file;
+        const ext = extensions.find((ext) => (0, fs_extra_1.existsSync)((0, path_1.join)(absoluteDir, file + ext)));
+        if (ext) {
+            return file + ext;
+        }
+        else {
+            throw new Error(`Cannot find file "${file}" with any of the following extensions: ${extensions.join(', ')}`);
+        }
+    });
+}
+exports.ensureFileExtensions = ensureFileExtensions;

package/src/executors/build/lib/test-fixtures/ensure-exts/baz.json

@@ -0,0 +1 @@
+{}

package/src/executors/build/lib/update-package-json.d.ts

@@ -0,0 +1,3 @@
+import type { ExecutorContext } from '@nx/devkit';
+import type { PackageJson } from 'nx/src/utils/package-json';
+export declare function updatePackageJson(packageJson: PackageJson, context: ExecutorContext): void;

package/src/executors/build/lib/update-package-json.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updatePackageJson = void 0;
+function updatePackageJson(packageJson, context) {
+    if (!packageJson.scripts) {
+        packageJson.scripts = {};
+    }
+    if (!packageJson.scripts.start) {
+        packageJson.scripts.start = 'next start';
+    }
+    packageJson.dependencies ??= {};
+    // These are always required for a production Next.js app to run.
+    // sharp is for next/image https://nextjs.org/docs/messages/sharp-missing-in-production
+    // critters is required for experimental optimizing CSS
+    const requiredPackages = [
+        'react',
+        'react-dom',
+        'next',
+        'typescript',
+        'sharp',
+        'critters',
+    ];
+    for (const pkg of requiredPackages) {
+        const externalNode = context.projectGraph.externalNodes[`npm:${pkg}`];
+        if (externalNode) {
+            packageJson.dependencies[pkg] ??= externalNode.data.version;
+        }
+    }
+}
+exports.updatePackageJson = updatePackageJson;