create-nx-workspace 17.3.0-beta.5 → 17.3.0-beta.6

package/bin/create-nx-workspace.d.ts

@@ -18,6 +18,7 @@ interface ReactArguments extends BaseArguments {
     style: string;
     bundler: 'webpack' | 'vite' | 'rspack';
     nextAppDir: boolean;
+    nextSrcDir: boolean;
     e2eTestRunner: 'none' | 'cypress' | 'playwright';
 }
 interface AngularArguments extends BaseArguments {

package/bin/create-nx-workspace.js

@@ -79,6 +79,10 @@ exports.commandsObject = yargs
     .option('nextAppDir', {
     describe: chalk.dim `Enable the App Router for Next.js`,
     type: 'boolean',
+})
+    .option('nextSrcDir', {
+    describe: chalk.dim `Generate a 'src/' directory for Next.js`,
+    type: 'boolean',
 })
     .option('e2eTestRunner', {
     describe: chalk.dim `Test runner to use for end to end (E2E) tests.`,
@@ -88,7 +92,7 @@ exports.commandsObject = yargs
     .option('ssr', {
     describe: chalk.dim `Enable Server-Side Rendering (SSR) and Static Site Generation (SSG/Prerendering) for the Angular application`,
     type: 'boolean',
-}), yargs_options_1.withNxCloud, yargs_options_1.withCI, yargs_options_1.withAllPrompts, yargs_options_1.withPackageManager, yargs_options_1.withGitOptions), async function handler(argv) {
+}), yargs_options_1.withNxCloud, yargs_options_1.withAllPrompts, yargs_options_1.withPackageManager, yargs_options_1.withGitOptions), async function handler(argv) {
     await main(argv).catch((error) => {
         const { version } = require('../package.json');
         output_1.output.error({
@@ -120,8 +124,11 @@ async function main(parsedArgs) {
     await (0, ab_testing_1.recordStat)({
         nxVersion: nx_version_1.nxVersion,
         command: 'create-nx-workspace',
-        useCloud: parsedArgs.nxCloud,
-        meta: ab_testing_1.messages.codeOfSelectedPromptMessage('nxCloudCreation'),
+        useCloud: parsedArgs.nxCloud !== 'skip',
+        meta: [
+            ab_testing_1.messages.codeOfSelectedPromptMessage('setupCI'),
+            ab_testing_1.messages.codeOfSelectedPromptMessage('setupNxCloud'),
+        ],
     });
     if (parsedArgs.nxCloud && workspaceInfo.nxCloudInfo) {
         (0, nx_cloud_1.printNxCloudSuccessMessage)(workspaceInfo.nxCloudInfo);
@@ -190,12 +197,10 @@ async function normalizeArgsMiddleware(argv) {
         const packageManager = await (0, prompts_1.determinePackageManager)(argv);
         const defaultBase = await (0, prompts_1.determineDefaultBase)(argv);
         const nxCloud = await (0, prompts_1.determineNxCloud)(argv);
-        const ci = await (0, prompts_1.determineCI)(argv, nxCloud);
         Object.assign(argv, {
             nxCloud,
             packageManager,
             defaultBase,
-            ci,
         });
     }
     catch (e) {
@@ -366,6 +371,7 @@ async function determineReactOptions(parsedArgs) {
     let bundler = undefined;
     let e2eTestRunner = undefined;
     let nextAppDir = false;
+    let nextSrcDir = false;
     if (parsedArgs.preset && parsedArgs.preset !== preset_1.Preset.React) {
         preset = parsedArgs.preset;
         if (preset === preset_1.Preset.ReactStandalone ||
@@ -418,6 +424,7 @@ async function determineReactOptions(parsedArgs) {
     }
     else if (preset === preset_1.Preset.NextJs || preset === preset_1.Preset.NextJsStandalone) {
         nextAppDir = await determineNextAppDir(parsedArgs);
+        nextSrcDir = await determineNextSrcDir(parsedArgs);
         e2eTestRunner = await determineE2eTestRunner(parsedArgs);
     }
     if (parsedArgs.style) {
@@ -463,7 +470,15 @@ async function determineReactOptions(parsedArgs) {
         ]);
         style = reply.style;
     }
-    return { preset, style, appName, bundler, nextAppDir, e2eTestRunner };
+    return {
+        preset,
+        style,
+        appName,
+        bundler,
+        nextAppDir,
+        nextSrcDir,
+        e2eTestRunner,
+    };
 }
 async function determineVueOptions(parsedArgs) {
     let preset;
@@ -864,6 +879,27 @@ async function determineNextAppDir(parsedArgs) {
     ]);
     return reply.nextAppDir === 'Yes';
 }
+async function determineNextSrcDir(parsedArgs) {
+    if (parsedArgs.nextSrcDir !== undefined)
+        return parsedArgs.nextSrcDir;
+    const reply = await enquirer.prompt([
+        {
+            name: 'nextSrcDir',
+            message: 'Would you like to use the src/ directory?',
+            type: 'autocomplete',
+            choices: [
+                {
+                    name: 'Yes',
+                },
+                {
+                    name: 'No',
+                },
+            ],
+            initial: 'Yes',
+        },
+    ]);
+    return reply.nextSrcDir === 'Yes';
+}
 async function determineVueFramework(parsedArgs) {
     if (!!parsedArgs.framework)
         return parsedArgs.framework;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-nx-workspace",
-  "version": "17.3.0-beta.5",
+  "version": "17.3.0-beta.6",
   "private": false,
   "description": "Smart Monorepos · Fast CI",
   "repository": {

package/src/create-preset.js

@@ -6,7 +6,7 @@ const package_manager_1 = require("./utils/package-manager");
 const child_process_utils_1 = require("./utils/child-process-utils");
 const unparse_1 = require("./utils/unparse");
 async function createPreset(preset, parsedArgs, packageManager, directory) {
-    const { skipGit, ci, commit, nxCloud, ...restArgs } = parsedArgs;
+    const { skipGit, commit, nxCloud, ...restArgs } = parsedArgs;
     let args = (0, unparse_1.unparse)({
         interactive: true,
         ...restArgs,

package/src/create-workspace-options.d.ts

@@ -1,19 +1,14 @@
+import { NxCloud } from './utils/nx/nx-cloud';
 import { PackageManager } from './utils/package-manager';
-import { CI } from './utils/ci/ci-list';
 export interface CreateWorkspaceOptions {
     name: string;
     packageManager: PackageManager;
-    nxCloud: boolean;
+    nxCloud: NxCloud;
     /**
      * @description Enable interactive mode with presets
      * @default true
      */
     interactive?: boolean;
-    /**
-     * @description Generate a CI workflow file
-     * @default ''
-     */
-    ci?: CI;
     /**
      * @description Default base to use for new projects. e.g. main, master
      * @default 'main'

package/src/create-workspace.js

@@ -11,7 +11,7 @@ const git_1 = require("./utils/git/git");
 const get_third_party_preset_1 = require("./utils/preset/get-third-party-preset");
 const error_utils_1 = require("./utils/error-utils");
 async function createWorkspace(preset, options) {
-    const { packageManager, name, nxCloud, ci = '', skipGit = false, defaultBase = 'main', commit, cliName, } = options;
+    const { packageManager, name, nxCloud, skipGit = false, defaultBase = 'main', commit, cliName, } = options;
     if (cliName) {
         output_1.output.setCliName(cliName ?? 'NX');
     }
@@ -26,11 +26,11 @@ async function createWorkspace(preset, options) {
         await (0, create_preset_1.createPreset)(thirdPartyPreset, options, packageManager, directory);
     }
     let nxCloudInstallRes;
-    if (nxCloud) {
+    if (nxCloud !== 'skip') {
         nxCloudInstallRes = await (0, nx_cloud_1.setupNxCloud)(directory, packageManager);
-    }
-    if (ci) {
-        await (0, setup_ci_1.setupCI)(directory, ci, packageManager, nxCloud && nxCloudInstallRes?.code === 0);
+        if (nxCloud !== 'yes') {
+            await (0, setup_ci_1.setupCI)(directory, nxCloud, packageManager, nxCloudInstallRes?.code === 0);
+        }
     }
     if (!skipGit && commit) {
         try {

package/src/internal-utils/prompts.d.ts

@@ -1,13 +1,9 @@
 import * as yargs from 'yargs';
-import { CI } from '../utils/ci/ci-list';
 import { PackageManager } from '../utils/package-manager';
+import { NxCloud } from '../utils/nx/nx-cloud';
 export declare function determineNxCloud(parsedArgs: yargs.Arguments<{
-    nxCloud: boolean;
-}>): Promise<boolean>;
-export declare function determineCI(parsedArgs: yargs.Arguments<{
-    ci?: CI;
-    allPrompts?: boolean;
-}>, nxCloud: boolean): Promise<string>;
+    nxCloud: NxCloud;
+}>): Promise<NxCloud>;
 export declare function determineDefaultBase(parsedArgs: yargs.Arguments<{
     defaultBase?: string;
 }>): Promise<string>;

package/src/internal-utils/prompts.js

@@ -1,79 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.determinePackageManager = exports.determineDefaultBase = exports.determineCI = exports.determineNxCloud = void 0;
+exports.determinePackageManager = exports.determineDefaultBase = exports.determineNxCloud = void 0;
 const ab_testing_1 = require("../utils/nx/ab-testing");
 const output_1 = require("../utils/output");
 const default_base_1 = require("../utils/git/default-base");
 const package_manager_1 = require("../utils/package-manager");
 const string_utils_1 = require("../utils/string-utils");
 const enquirer = require("enquirer");
+const chalk = require("chalk");
 async function determineNxCloud(parsedArgs) {
     if (parsedArgs.nxCloud === undefined) {
-        return enquirer
-            .prompt([
-            {
-                name: 'NxCloud',
-                message: ab_testing_1.messages.getPromptMessage('nxCloudCreation'),
-                type: 'autocomplete',
-                choices: [
-                    {
-                        name: 'Yes',
-                        hint: 'I want faster builds',
-                    },
-                    {
-                        name: 'No',
-                    },
-                ],
-                initial: 'Yes',
-            },
-        ])
-            .then((a) => a.NxCloud === 'Yes');
+        return nxCloudPrompt('setupCI');
     }
     else {
         return parsedArgs.nxCloud;
     }
 }
 exports.determineNxCloud = determineNxCloud;
-async function determineCI(parsedArgs, nxCloud) {
-    if (!nxCloud) {
-        if (parsedArgs.ci) {
-            output_1.output.warn({
-                title: 'Invalid CI value',
-                bodyLines: [
-                    `CI option only works when Nx Cloud is enabled.`,
-                    `The value provided will be ignored.`,
-                ],
-            });
-        }
-        return '';
+async function nxCloudPrompt(key) {
+    const { message, choices, initial, fallback, footer, hint } = ab_testing_1.messages.getPrompt(key);
+    const promptConfig = {
+        name: 'NxCloud',
+        message,
+        type: 'autocomplete',
+        choices,
+        initial,
+    }; // meeroslav: types in enquirer are not up to date
+    if (footer) {
+        promptConfig.footer = () => chalk.dim(footer);
     }
-    if (parsedArgs.ci) {
-        return parsedArgs.ci;
+    if (hint) {
+        promptConfig.hint = () => chalk.dim(hint);
     }
-    if (parsedArgs.allPrompts) {
-        return (enquirer
-            .prompt([
-            {
-                name: 'CI',
-                message: `CI workflow file to generate?      `,
-                type: 'autocomplete',
-                initial: '',
-                choices: [
-                    { message: 'none', name: '' },
-                    { message: 'GitHub Actions', name: 'github' },
-                    { message: 'Circle CI', name: 'circleci' },
-                    { message: 'Azure DevOps', name: 'azure' },
-                ],
-            },
-        ])
-            // enquirer ignores name and value if they are falsy and takes
-            // first field that has a truthy value, so wee need to explicitly
-            // check for none
-            .then((a) => (a.CI !== 'none' ? a.CI : '')));
-    }
-    return '';
+    return enquirer.prompt([promptConfig]).then((a) => {
+        if (fallback && a.NxCloud === fallback.value) {
+            return nxCloudPrompt(fallback.key);
+        }
+        return a.NxCloud;
+    });
 }
-exports.determineCI = determineCI;
 async function determineDefaultBase(parsedArgs) {
     if (parsedArgs.defaultBase) {
         return Promise.resolve(parsedArgs.defaultBase);

package/src/internal-utils/yargs-options.d.ts

@@ -1,9 +1,6 @@
 import yargs = require('yargs');
 export declare function withNxCloud<T = unknown>(argv: yargs.Argv<T>): yargs.Argv<T & {
-    nxCloud: boolean | undefined;
-}>;
-export declare function withCI<T = unknown>(argv: yargs.Argv<T>): yargs.Argv<T & {
-    ci: string | undefined;
+    nxCloud: string | undefined;
 }>;
 export declare function withAllPrompts<T = unknown>(argv: yargs.Argv<T>): yargs.Argv<T & {
     allPrompts: boolean;

package/src/internal-utils/yargs-options.js

@@ -1,27 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.withOptions = exports.withGitOptions = exports.withPackageManager = exports.withAllPrompts = exports.withCI = exports.withNxCloud = void 0;
+exports.withOptions = exports.withGitOptions = exports.withPackageManager = exports.withAllPrompts = exports.withNxCloud = void 0;
 const chalk = require("chalk");
-const ci_list_1 = require("../utils/ci/ci-list");
 const ab_testing_1 = require("../utils/nx/ab-testing");
 const package_manager_1 = require("../utils/package-manager");
 function withNxCloud(argv) {
+    const { message } = ab_testing_1.messages.getPrompt('setupCI');
     const result = argv.option('nxCloud', {
-        describe: chalk.dim(ab_testing_1.messages.getPromptMessage('nxCloudCreation')),
-        type: 'boolean',
+        alias: 'ci',
+        describe: chalk.dim(message),
+        choices: ab_testing_1.NxCloudChoices,
+        type: 'string',
     });
     return result;
 }
 exports.withNxCloud = withNxCloud;
-function withCI(argv) {
-    return argv.option('ci', {
-        describe: chalk.dim `Generate a CI workflow file`,
-        choices: ci_list_1.ciList,
-        defaultDescription: '',
-        type: 'string',
-    });
-}
-exports.withCI = withCI;
 function withAllPrompts(argv) {
     return argv.option('allPrompts', {
         alias: 'a',

package/src/utils/nx/ab-testing.d.ts

@@ -1,17 +1,67 @@
+export declare const NxCloudChoices: string[];
 declare const messageOptions: {
-    readonly nxCloudCreation: readonly [{
-        readonly code: "set-up-distributed-caching-ci";
-        readonly message: "Enable remote caching to make your CI faster";
+    readonly setupCI: readonly [{
+        readonly code: "enable-nx-cloud";
+        readonly message: "Do you want Nx Cloud to make your CI fast?";
+        readonly initial: "github";
+        readonly choices: readonly [{
+            readonly value: "yes";
+            readonly name: "Yes, enable Nx Cloud";
+        }, {
+            readonly value: "github";
+            readonly name: "Yes, configure Nx Cloud for GitHub Actions";
+        }, {
+            readonly value: "circleci";
+            readonly name: "Yes, configure Nx Cloud for Circle CI";
+        }, {
+            readonly value: "skip";
+            readonly name: "Skip for now";
+        }];
+        readonly footer: "\nRead more about remote cache at https://nx.dev/ci/features/remote-cache";
+        readonly hint: "\n(it's free and can be disabled any time)";
+        readonly fallback: undefined;
+    }, {
+        readonly code: "set-up-ci";
+        readonly message: "Set up CI with caching, distribution and test deflaking";
+        readonly initial: "github";
+        readonly choices: readonly [{
+            readonly value: "github";
+            readonly name: "Yes, for GitHub Actions with Nx Cloud";
+        }, {
+            readonly value: "circleci";
+            readonly name: "Yes, for CircleCI with Nx Cloud";
+        }, {
+            readonly value: "skip";
+            readonly name: "Skip for now";
+        }];
+        readonly footer: "\nRead more about CI benefits with Nx at https://nx.dev/ci/intro/ci-with-nx";
+        readonly hint: "\n(it's free and can be disabled any time)";
+        readonly fallback: {
+            readonly value: "skip";
+            readonly key: "setupNxCloud";
+        };
     }];
-    readonly nxCloudMigration: readonly [{
-        readonly code: "make-ci-faster";
-        readonly message: "Enable remote caching to make your CI faster?";
+    readonly setupNxCloud: readonly [{
+        readonly code: "enable-caching";
+        readonly message: "Would you like remote caching to make your build faster?";
+        readonly initial: "yes";
+        readonly choices: readonly [{
+            readonly value: "yes";
+            readonly name: "Yes";
+        }, {
+            readonly value: "skip";
+            readonly name: "Skip for now";
+        }];
+        readonly footer: "\nRead more about remote caching at https://nx.dev/ci/features/remote-cache";
+        readonly hint: "\n(it's free and can be disabled any time)";
+        readonly fallback: undefined;
     }];
 };
-type MessageKey = keyof typeof messageOptions;
+export type MessageKey = keyof typeof messageOptions;
+type MessageData = typeof messageOptions[MessageKey][number];
 export declare class PromptMessages {
     private selectedMessages;
-    getPromptMessage(key: MessageKey): string;
+    getPrompt(key: MessageKey): MessageData;
     codeOfSelectedPromptMessage(key: MessageKey): string;
 }
 export declare const messages: PromptMessages;
@@ -23,6 +73,6 @@ export declare function recordStat(opts: {
     command: string;
     nxVersion: string;
     useCloud: boolean;
-    meta: string;
+    meta: string[];
 }): Promise<void>;
 export {};

package/src/utils/nx/ab-testing.js

@@ -1,18 +1,50 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.recordStat = exports.messages = exports.PromptMessages = void 0;
+exports.recordStat = exports.messages = exports.PromptMessages = exports.NxCloudChoices = void 0;
 const is_ci_1 = require("../ci/is-ci");
+exports.NxCloudChoices = ['yes', 'github', 'circleci', 'skip'];
 const messageOptions = {
-    nxCloudCreation: [
+    setupCI: [
         {
-            code: 'set-up-distributed-caching-ci',
-            message: `Enable remote caching to make your CI faster`,
+            code: 'enable-nx-cloud',
+            message: `Do you want Nx Cloud to make your CI fast?`,
+            initial: 'github',
+            choices: [
+                { value: 'yes', name: 'Yes, enable Nx Cloud' },
+                { value: 'github', name: 'Yes, configure Nx Cloud for GitHub Actions' },
+                { value: 'circleci', name: 'Yes, configure Nx Cloud for Circle CI' },
+                { value: 'skip', name: 'Skip for now' },
+            ],
+            footer: '\nRead more about remote cache at https://nx.dev/ci/features/remote-cache',
+            hint: `\n(it's free and can be disabled any time)`,
+            fallback: undefined,
+        },
+        {
+            code: 'set-up-ci',
+            message: `Set up CI with caching, distribution and test deflaking`,
+            initial: 'github',
+            choices: [
+                { value: 'github', name: 'Yes, for GitHub Actions with Nx Cloud' },
+                { value: 'circleci', name: 'Yes, for CircleCI with Nx Cloud' },
+                { value: 'skip', name: 'Skip for now' },
+            ],
+            footer: '\nRead more about CI benefits with Nx at https://nx.dev/ci/intro/ci-with-nx',
+            hint: `\n(it's free and can be disabled any time)`,
+            fallback: { value: 'skip', key: 'setupNxCloud' },
         },
     ],
-    nxCloudMigration: [
+    setupNxCloud: [
         {
-            code: 'make-ci-faster',
-            message: `Enable remote caching to make your CI faster?`,
+            code: 'enable-caching',
+            message: `Would you like remote caching to make your build faster?`,
+            initial: 'yes',
+            choices: [
+                { value: 'yes', name: 'Yes' },
+                { value: 'skip', name: 'Skip for now' },
+            ],
+            footer: '\nRead more about remote caching at https://nx.dev/ci/features/remote-cache',
+            hint: `\n(it's free and can be disabled any time)`,
+            fallback: undefined,
         },
     ],
 };
@@ -20,7 +52,7 @@ class PromptMessages {
     constructor() {
         this.selectedMessages = {};
     }
-    getPromptMessage(key) {
+    getPrompt(key) {
         if (this.selectedMessages[key] === undefined) {
             if (process.env.NX_GENERATE_DOCS_PROCESS === 'true') {
                 this.selectedMessages[key] = 0;
@@ -29,12 +61,12 @@ class PromptMessages {
                 this.selectedMessages[key] = Math.floor(Math.random() * messageOptions[key].length);
             }
         }
-        return messageOptions[key][this.selectedMessages[key]].message;
+        return messageOptions[key][this.selectedMessages[key]];
     }
     codeOfSelectedPromptMessage(key) {
         const selected = this.selectedMessages[key];
         if (selected === undefined) {
-            return messageOptions[key][0].code;
+            return '';
         }
         else {
             return messageOptions[key][selected].code;
@@ -65,7 +97,7 @@ async function recordStat(opts) {
             command: opts.command,
             isCI: (0, is_ci_1.isCI)(),
             useCloud: opts.useCloud,
-            meta: opts.meta,
+            meta: opts.meta.filter((v) => !!v).join(','),
         });
     }
     catch (e) {

package/src/utils/nx/nx-cloud.d.ts

@@ -1,4 +1,5 @@
 import { PackageManager } from '../package-manager';
+export type NxCloud = 'yes' | 'github' | 'circleci' | 'skip';
 export declare function setupNxCloud(directory: string, packageManager: PackageManager): Promise<{
     code: number;
     stdout: string;

package/src/utils/ci/ci-list.d.ts

@@ -1,2 +0,0 @@
-export declare const ciList: string[];
-export type CI = typeof ciList[number];

package/src/utils/ci/ci-list.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ciList = void 0;
-exports.ciList = [
-    'github',
-    'circleci',
-    'azure',
-    'bitbucket-pipelines',
-    'gitlab',
-];