create-nx-workspace 16.3.0-beta.9 → 16.3.0

package/bin/create-nx-workspace.js

@@ -7,19 +7,17 @@ const yargs = require("yargs");
 const chalk = require("chalk");
 const create_workspace_1 = require("../src/create-workspace");
 const preset_1 = require("../src/utils/preset/preset");
-const preset_options_1 = require("../src/utils/preset/preset-options");
 const output_1 = require("../src/utils/output");
 const nx_version_1 = require("../src/utils/nx/nx-version");
 const point_to_tutorial_and_course_1 = require("../src/utils/preset/point-to-tutorial-and-course");
 const decorator_1 = require("./decorator");
 const get_third_party_preset_1 = require("../src/utils/preset/get-third-party-preset");
-const framework_list_1 = require("./types/framework-list");
-const bundler_list_1 = require("./types/bundler-list");
 const prompts_1 = require("../src/internal-utils/prompts");
 const yargs_options_1 = require("../src/internal-utils/yargs-options");
 const show_nx_warning_1 = require("../src/utils/nx/show-nx-warning");
 const nx_cloud_1 = require("../src/utils/nx/nx-cloud");
 const ab_testing_1 = require("../src/utils/nx/ab-testing");
+const fs_1 = require("fs");
 exports.commandsObject = yargs
     .wrap(yargs.terminalWidth())
     .parserConfiguration({
@@ -38,18 +36,23 @@ exports.commandsObject = yargs
         .map((p) => `"${p}"`)
         .join(', ')}]. To build your own see https://nx.dev/packages/nx-plugin#preset`,
     type: 'string',
-})
-    .option('appName', {
-    describe: chalk.dim `The name of the application when a preset with pregenerated app is selected`,
-    type: 'string',
 })
     .option('interactive', {
     describe: chalk.dim `Enable interactive mode with presets`,
     type: 'boolean',
     default: true,
+})
+    .option('workspaceType', {
+    describe: chalk.dim `The type of workspace to create`,
+    choices: ['integrated', 'package-based', 'standalone'],
+    type: 'string',
+})
+    .option('appName', {
+    describe: chalk.dim `The name of the app when using a monorepo with certain stacks`,
+    type: 'string',
 })
     .option('style', {
-    describe: chalk.dim `Style option to be used when a preset with pregenerated app is selected`,
+    describe: chalk.dim `Stylesheet type to be used with certain stacks`,
     type: 'string',
 })
     .option('standaloneApi', {
@@ -57,35 +60,35 @@ exports.commandsObject = yargs
     type: 'boolean',
 })
     .option('routing', {
-    describe: chalk.dim `Add a routing setup when a preset with pregenerated app is selected`,
+    describe: chalk.dim `Add a routing setup for an Angular app`,
     type: 'boolean',
 })
     .option('bundler', {
-    describe: chalk.dim `Bundler to be used to build the application`,
-    choices: bundler_list_1.bundlerList,
+    describe: chalk.dim `Bundler to be used to build the app`,
     type: 'string',
 })
     .option('framework', {
-    describe: chalk.dim `Framework option to be used when the node-standalone preset is selected`,
-    choices: framework_list_1.frameworkList,
+    describe: chalk.dim `Framework option to be used with certain stacks`,
     type: 'string',
 })
     .option('docker', {
-    describe: chalk.dim `Generate a Dockerfile with your node-standalone`,
+    describe: chalk.dim `Generate a Dockerfile for the Node API`,
     type: 'boolean',
 })
     .option('nextAppDir', {
     describe: chalk.dim `Enable the App Router for Next.js`,
     type: 'boolean',
-}), yargs_options_1.withNxCloud, yargs_options_1.withCI, yargs_options_1.withAllPrompts, yargs_options_1.withPackageManager, yargs_options_1.withGitOptions), (argv) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
-    yield main(argv).catch((error) => {
-        const { version } = require('../package.json');
-        output_1.output.error({
-            title: `Something went wrong! v${version}`,
+}), yargs_options_1.withNxCloud, yargs_options_1.withCI, yargs_options_1.withAllPrompts, yargs_options_1.withPackageManager, yargs_options_1.withGitOptions), function handler(argv) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        yield main(argv).catch((error) => {
+            const { version } = require('../package.json');
+            output_1.output.error({
+                title: `Something went wrong! v${version}`,
+            });
+            throw error;
         });
-        throw error;
     });
-}), [normalizeArgsMiddleware])
+}, [normalizeArgsMiddleware])
     .help('help', chalk.dim `Show help`)
     .updateLocale(decorator_1.yargsDecorator)
     .version('version', chalk.dim `Show version`, nx_version_1.nxVersion);
@@ -126,14 +129,14 @@ function main(parsedArgs) {
  * @param argv user arguments
  */
 function normalizeArgsMiddleware(argv) {
-    var _a, _b, _c, _d, _e, _f, _g;
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        output_1.output.log({
+            title: "Let's create a new workspace [https://nx.dev/getting-started/intro]",
+        });
         try {
-            let name, appName, style, preset, framework, bundler, docker, nextAppDir, routing, standaloneApi;
-            output_1.output.log({
-                title: "Let's create a new workspace [https://nx.dev/getting-started/intro]",
-            });
             let thirdPartyPreset;
+            // Node options
+            let docker;
             try {
                 thirdPartyPreset = yield (0, get_third_party_preset_1.getThirdPartyPreset)(argv.preset);
             }
@@ -143,101 +146,28 @@ function normalizeArgsMiddleware(argv) {
                 });
                 process.exit(1);
             }
+            argv.name = yield determineFolder(argv);
             if (thirdPartyPreset) {
-                preset = thirdPartyPreset;
-                name = yield determineRepoName(argv);
-                appName = '';
-                style = null;
+                Object.assign(argv, {
+                    preset: thirdPartyPreset,
+                    appName: '',
+                    style: '',
+                });
             }
             else {
-                if (!argv.preset) {
-                    const monorepoStyle = yield determineMonorepoStyle();
-                    if (monorepoStyle === 'package-based') {
-                        preset = 'npm';
-                    }
-                    else if (monorepoStyle === 'react') {
-                        preset = yield determineReactFramework(argv);
-                    }
-                    else if (monorepoStyle === 'angular') {
-                        preset = preset_1.Preset.AngularStandalone;
-                    }
-                    else if (monorepoStyle === 'node-standalone') {
-                        preset = preset_1.Preset.NodeStandalone;
-                    }
-                    else {
-                        // when choose integrated monorepo, further prompt for preset
-                        preset = yield determinePreset(argv);
-                    }
-                }
-                else if (argv.preset === 'react') {
-                    preset = yield monorepoOrStandalone('react');
-                }
-                else if (argv.preset === 'angular') {
-                    preset = yield monorepoOrStandalone('angular');
-                }
-                else {
-                    preset = argv.preset;
-                }
-                if (preset === preset_1.Preset.ReactStandalone ||
-                    preset === preset_1.Preset.AngularStandalone ||
-                    preset === preset_1.Preset.NodeStandalone ||
-                    preset === preset_1.Preset.NextJsStandalone) {
-                    appName =
-                        (_b = (_a = argv.appName) !== null && _a !== void 0 ? _a : argv.name) !== null && _b !== void 0 ? _b : (yield determineAppName(preset, argv));
-                    name = (_c = argv.name) !== null && _c !== void 0 ? _c : appName;
-                    if (preset === preset_1.Preset.NodeStandalone) {
-                        framework = yield determineFramework(argv);
-                        if (framework !== 'none') {
-                            docker = yield determineDockerfile(argv);
-                        }
-                    }
-                    if (preset === preset_1.Preset.NextJsStandalone) {
-                        nextAppDir = yield isNextAppDir(argv);
-                    }
-                    if (preset === preset_1.Preset.ReactStandalone) {
-                        bundler = yield determineBundler(argv);
-                    }
-                    if (preset === preset_1.Preset.AngularStandalone) {
-                        standaloneApi =
-                            (_d = argv.standaloneApi) !== null && _d !== void 0 ? _d : (argv.interactive ? yield determineStandaloneApi(argv) : false);
-                        routing =
-                            (_e = argv.routing) !== null && _e !== void 0 ? _e : (argv.interactive ? yield determineRouting(argv) : true);
-                    }
-                }
-                else {
-                    name = yield determineRepoName(argv);
-                    appName = yield determineAppName(preset, argv);
-                    if (preset === preset_1.Preset.ReactMonorepo) {
-                        bundler = yield determineBundler(argv);
-                    }
-                    if (preset === preset_1.Preset.AngularMonorepo) {
-                        standaloneApi =
-                            (_f = argv.standaloneApi) !== null && _f !== void 0 ? _f : (argv.interactive ? yield determineStandaloneApi(argv) : false);
-                        routing =
-                            (_g = argv.routing) !== null && _g !== void 0 ? _g : (argv.interactive ? yield determineRouting(argv) : true);
-                    }
-                }
-                style = yield determineStyle(preset, argv);
+                argv.stack = yield determineStack(argv);
+                const presetOptions = yield determinePresetOptions(argv);
+                Object.assign(argv, presetOptions);
             }
             const packageManager = yield (0, prompts_1.determinePackageManager)(argv);
             const defaultBase = yield (0, prompts_1.determineDefaultBase)(argv);
             const nxCloud = yield (0, prompts_1.determineNxCloud)(argv);
             const ci = yield (0, prompts_1.determineCI)(argv, nxCloud);
             Object.assign(argv, {
-                name,
-                preset,
-                appName,
-                style,
-                standaloneApi,
-                routing,
-                framework,
                 nxCloud,
                 packageManager,
                 defaultBase,
                 ci,
-                bundler,
-                docker,
-                nextAppDir,
             });
         }
         catch (e) {
@@ -246,224 +176,338 @@ function normalizeArgsMiddleware(argv) {
         }
     });
 }
-function determineRepoName(parsedArgs) {
+function invariant(predicate, message) {
+    if (!predicate) {
+        output_1.output.error(message);
+        process.exit(1);
+    }
+}
+function determineFolder(parsedArgs) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const repoName = parsedArgs._[0]
+        const folderName = parsedArgs._[0]
             ? parsedArgs._[0].toString()
             : parsedArgs.name;
-        if (repoName) {
-            return Promise.resolve(repoName);
-        }
-        const a = yield enquirer.prompt([
+        if (folderName)
+            return folderName;
+        const reply = yield enquirer.prompt([
             {
-                name: 'RepoName',
-                message: `Repository name                      `,
+                name: 'folderName',
+                message: `Where would you like to create your workspace?`,
+                initial: 'org',
                 type: 'input',
             },
         ]);
-        if (!a.RepoName) {
-            output_1.output.error({
-                title: 'Invalid repository name',
-                bodyLines: [`Repository name cannot be empty`],
-            });
-            process.exit(1);
-        }
-        return a.RepoName;
+        invariant(reply.folderName, {
+            title: 'Invalid folder name',
+            bodyLines: [`Folder name cannot be empty`],
+        });
+        invariant(!(0, fs_1.existsSync)(reply.folderName), {
+            title: 'That folder is already taken',
+        });
+        return reply.folderName;
     });
 }
-function monorepoOrStandalone(preset) {
+function determineStack(parsedArgs) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const a = yield enquirer.prompt([
+        if (parsedArgs.preset) {
+            switch (parsedArgs.preset) {
+                case preset_1.Preset.Angular:
+                case preset_1.Preset.AngularStandalone:
+                case preset_1.Preset.AngularMonorepo:
+                    return 'angular';
+                case preset_1.Preset.React:
+                case preset_1.Preset.ReactStandalone:
+                case preset_1.Preset.ReactMonorepo:
+                case preset_1.Preset.NextJs:
+                case preset_1.Preset.NextJsStandalone:
+                    return 'react';
+                case preset_1.Preset.Nest:
+                case preset_1.Preset.NodeStandalone:
+                case preset_1.Preset.Express:
+                    return 'node';
+                case preset_1.Preset.Core:
+                case preset_1.Preset.Empty:
+                case preset_1.Preset.Apps:
+                case preset_1.Preset.NPM:
+                    return 'none';
+                case preset_1.Preset.TS:
+                case preset_1.Preset.WebComponents:
+                case preset_1.Preset.ReactNative:
+                case preset_1.Preset.Expo:
+                default:
+                    return 'unknown';
+            }
+        }
+        const { stack } = yield enquirer.prompt([
             {
-                name: 'MonorepoOrStandalone',
-                message: `--preset=${preset} has been replaced with the following:`,
+                name: 'stack',
+                message: `Which stack do you want to use?`,
                 type: 'autocomplete',
                 choices: [
                     {
-                        name: preset + '-standalone',
-                        message: `${preset}-standalone: a standalone ${preset} application.`,
+                        name: `none`,
+                        message: `None:          Configures a minimal structure without specific frameworks or technologies.`,
                     },
                     {
-                        name: preset + '-monorepo',
-                        message: `${preset}-monorepo:   a monorepo with the apps and libs folders.`,
+                        name: `react`,
+                        message: `React:         Configures a React app with your framework of choice.`,
+                    },
+                    {
+                        name: `angular`,
+                        message: `Angular:       Configures a Angular app with modern tooling.`,
+                    },
+                    {
+                        name: `node`,
+                        message: `Node:          Configures a Node API with your framework of choice.`,
                     },
                 ],
             },
         ]);
-        if (!a.MonorepoOrStandalone) {
-            output_1.output.error({
-                title: 'Invalid selection',
-            });
-            process.exit(1);
+        return stack;
+    });
+}
+function determinePresetOptions(parsedArgs) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        switch (parsedArgs.stack) {
+            case 'none':
+                return determineNoneptions(parsedArgs);
+            case 'react':
+                return determineReactOptions(parsedArgs);
+            case 'angular':
+                return determineAngularOptions(parsedArgs);
+            case 'node':
+                return determineNodeOptions(parsedArgs);
+            default:
+                return parsedArgs;
         }
-        return a.MonorepoOrStandalone;
     });
 }
-function determineMonorepoStyle() {
+function determineNoneptions(parsedArgs) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const a = yield enquirer.prompt([
+        if (parsedArgs.preset)
+            return parsedArgs;
+        const { workspaceType } = yield enquirer.prompt([
             {
-                name: 'MonorepoStyle',
-                message: `Choose what to create                `,
                 type: 'autocomplete',
+                name: 'workspaceType',
+                message: `Package-based or integrated?`,
+                initial: 'package-based',
                 choices: [
                     {
                         name: 'package-based',
-                        message: 'Package-based monorepo:      Nx makes it fast, but lets you run things your way.',
+                        message: 'Package-based:           Nx makes it fast, but lets you run things your way.',
                     },
                     {
                         name: 'integrated',
-                        message: 'Integrated monorepo:         Nx configures your favorite frameworks and lets you focus on shipping features.',
-                    },
-                    {
-                        name: 'react',
-                        message: 'Standalone React app:        Nx configures a React app with an optional framework (e.g. Next.js).',
-                    },
-                    {
-                        name: 'angular',
-                        message: 'Standalone Angular app:      Nx configures Jest, ESLint and Cypress.',
-                    },
-                    {
-                        name: 'node-standalone',
-                        message: 'Standalone Node app:         Nx configures a framework (e.g. Express), esbuild, ESlint and Jest.',
+                        message: 'Integrated:              Nx creates a workspace structure most suitable for building apps.',
                     },
                 ],
             },
         ]);
-        if (!a.MonorepoStyle) {
-            output_1.output.error({
-                title: 'Invalid monorepo style',
-            });
-            process.exit(1);
+        if (workspaceType === 'integrated') {
+            return {
+                preset: preset_1.Preset.Apps,
+            };
+        }
+        else {
+            return {
+                preset: preset_1.Preset.NPM,
+            };
         }
-        return a.MonorepoStyle;
     });
 }
-function determinePreset(parsedArgs) {
+function determineReactOptions(parsedArgs) {
+    var _a;
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        let preset;
+        let style = undefined;
+        let appName;
+        let bundler = undefined;
+        let nextAppDir = false;
         if (parsedArgs.preset) {
-            if (Object.values(preset_1.Preset).indexOf(parsedArgs.preset) === -1) {
-                output_1.output.error({
-                    title: 'Invalid preset',
-                    bodyLines: [
-                        `It must be one of the following:`,
-                        '',
-                        ...Object.values(preset_1.Preset),
-                    ],
-                });
-                process.exit(1);
+            preset = parsedArgs.preset;
+            if (preset === preset_1.Preset.ReactStandalone ||
+                preset === preset_1.Preset.NextJsStandalone) {
+                appName = (_a = parsedArgs.appName) !== null && _a !== void 0 ? _a : parsedArgs.name;
             }
             else {
-                return Promise.resolve(parsedArgs.preset);
+                appName = yield determineAppName(parsedArgs);
             }
         }
-        return enquirer
-            .prompt([
-            {
-                name: 'preset',
-                message: `What to create in the new workspace  `,
-                initial: 'empty',
-                type: 'autocomplete',
-                choices: preset_options_1.presetOptions,
-            },
-        ])
-            .then((a) => a.preset);
-    });
-}
-function determineAppName(preset, parsedArgs) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        if (preset === preset_1.Preset.Apps ||
-            preset === preset_1.Preset.Core ||
-            preset === preset_1.Preset.TS ||
-            preset === preset_1.Preset.Empty ||
-            preset === preset_1.Preset.NPM) {
-            return Promise.resolve('');
+        else {
+            const framework = yield determineReactFramework(parsedArgs);
+            // React Native and Expo only support integrated monorepos for now.
+            // TODO(jack): Add standalone support for React Native and Expo.
+            const workspaceType = framework === 'react-native' || framework === 'expo'
+                ? 'integrated'
+                : yield determineStandAloneOrMonorepo();
+            if (workspaceType === 'standalone') {
+                appName = parsedArgs.name;
+            }
+            else {
+                appName = yield determineAppName(parsedArgs);
+            }
+            if (framework === 'nextjs') {
+                if (workspaceType === 'standalone') {
+                    preset = preset_1.Preset.NextJsStandalone;
+                }
+                else {
+                    preset = preset_1.Preset.NextJs;
+                }
+            }
+            else if (framework === 'react-native') {
+                preset = preset_1.Preset.ReactNative;
+            }
+            else if (framework === 'expo') {
+                preset = preset_1.Preset.Expo;
+            }
+            else {
+                if (workspaceType === 'standalone') {
+                    preset = preset_1.Preset.ReactStandalone;
+                }
+                else {
+                    preset = preset_1.Preset.ReactMonorepo;
+                }
+            }
         }
-        if (parsedArgs.appName) {
-            return Promise.resolve(parsedArgs.appName);
+        if (preset === preset_1.Preset.ReactStandalone || preset === preset_1.Preset.ReactMonorepo) {
+            bundler = yield determineReactBundler(parsedArgs);
         }
-        return enquirer
-            .prompt([
-            {
-                name: 'AppName',
-                message: `Application name                     `,
-                type: 'input',
-            },
-        ])
-            .then((a) => {
-            if (!a.AppName) {
-                output_1.output.error({
-                    title: 'Invalid name',
-                    bodyLines: [`Name cannot be empty`],
-                });
-                process.exit(1);
-            }
-            return a.AppName;
-        });
+        else if (preset === preset_1.Preset.NextJs || preset === preset_1.Preset.NextJsStandalone) {
+            nextAppDir = yield determineNextAppDir(parsedArgs);
+        }
+        if (parsedArgs.style) {
+            style = parsedArgs.style;
+        }
+        else if (preset === preset_1.Preset.ReactStandalone ||
+            preset === preset_1.Preset.ReactMonorepo ||
+            preset === preset_1.Preset.NextJs ||
+            preset === preset_1.Preset.NextJsStandalone) {
+            const reply = yield enquirer.prompt([
+                {
+                    name: 'style',
+                    message: `Default stylesheet format`,
+                    initial: 'css',
+                    type: 'autocomplete',
+                    choices: [
+                        {
+                            name: 'css',
+                            message: 'CSS',
+                        },
+                        {
+                            name: 'scss',
+                            message: 'SASS(.scss)       [ http://sass-lang.com   ]',
+                        },
+                        {
+                            name: 'less',
+                            message: 'LESS              [ http://lesscss.org     ]',
+                        },
+                        {
+                            name: 'styled-components',
+                            message: 'styled-components [ https://styled-components.com            ]',
+                        },
+                        {
+                            name: '@emotion/styled',
+                            message: 'emotion           [ https://emotion.sh                       ]',
+                        },
+                        {
+                            name: 'styled-jsx',
+                            message: 'styled-jsx        [ https://www.npmjs.com/package/styled-jsx ]',
+                        },
+                    ],
+                },
+            ]);
+            style = reply.style;
+        }
+        return { preset, style, appName, bundler, nextAppDir };
     });
 }
-function determineFramework(parsedArgs) {
+function determineAngularOptions(parsedArgs) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const frameworkChoices = [
-            {
-                name: 'express',
-                message: 'Express [https://expressjs.com/]',
-            },
-            {
-                name: 'fastify',
-                message: 'Fastify [https://www.fastify.io/]',
-            },
-            {
-                name: 'koa',
-                message: 'Koa     [https://koajs.com/]',
-            },
-            {
-                name: 'nest',
-                message: 'NestJs  [https://nestjs.com/]',
-            },
-            {
-                name: 'none',
-                message: 'None',
-            },
-        ];
-        if (!parsedArgs.framework) {
-            return enquirer
-                .prompt([
+        let preset;
+        let style;
+        let appName;
+        let standaloneApi;
+        let routing;
+        if (parsedArgs.preset) {
+            preset = parsedArgs.preset;
+            if (preset === preset_1.Preset.AngularStandalone) {
+                appName = parsedArgs.name;
+            }
+            else {
+                appName = yield determineAppName(parsedArgs);
+            }
+        }
+        else {
+            const workspaceType = yield determineStandAloneOrMonorepo();
+            if (workspaceType === 'standalone') {
+                preset = preset_1.Preset.AngularStandalone;
+                appName = parsedArgs.name;
+            }
+            else {
+                preset = preset_1.Preset.AngularMonorepo;
+                appName = yield determineAppName(parsedArgs);
+            }
+        }
+        if (parsedArgs.style) {
+            style = parsedArgs.style;
+        }
+        else {
+            const reply = yield enquirer.prompt([
                 {
-                    message: 'What framework should be used?',
+                    name: 'style',
+                    message: `Default stylesheet format`,
+                    initial: 'css',
                     type: 'autocomplete',
-                    name: 'framework',
-                    choices: frameworkChoices,
+                    choices: [
+                        {
+                            name: 'css',
+                            message: 'CSS',
+                        },
+                        {
+                            name: 'scss',
+                            message: 'SASS(.scss)       [ http://sass-lang.com   ]',
+                        },
+                        {
+                            name: 'less',
+                            message: 'LESS              [ http://lesscss.org     ]',
+                        },
+                    ],
                 },
-            ])
-                .then((a) => a.framework);
+            ]);
+            style = reply.style;
         }
-        const foundFramework = frameworkChoices
-            .map(({ name }) => name)
-            .indexOf(parsedArgs.framework);
-        if (foundFramework < 0) {
-            output_1.output.error({
-                title: 'Invalid framework',
-                bodyLines: [
-                    `It must be one of the following:`,
-                    '',
-                    ...frameworkChoices.map(({ name }) => name),
-                ],
-            });
-            process.exit(1);
+        if (parsedArgs.standaloneApi !== undefined) {
+            standaloneApi = parsedArgs.standaloneApi;
         }
-        return Promise.resolve(parsedArgs.framework);
-    });
-}
-function determineStandaloneApi(parsedArgs) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        if (parsedArgs.standaloneApi === undefined) {
-            return enquirer
-                .prompt([
+        else {
+            const reply = yield enquirer.prompt([
                 {
                     name: 'standaloneApi',
                     message: 'Would you like to use Standalone Components in your application?',
                     type: 'autocomplete',
+                    choices: [
+                        {
+                            name: 'No',
+                        },
+                        {
+                            name: 'Yes',
+                        },
+                    ],
+                    initial: 'No',
+                },
+            ]);
+            standaloneApi = reply.standaloneApi === 'Yes';
+        }
+        if (parsedArgs.routing !== undefined) {
+            routing = parsedArgs.routing;
+        }
+        else {
+            const reply = yield enquirer.prompt([
+                {
+                    name: 'routing',
+                    message: 'Would you like to add routing?',
+                    type: 'autocomplete',
                     choices: [
                         {
                             name: 'Yes',
@@ -472,19 +516,54 @@ function determineStandaloneApi(parsedArgs) {
                             name: 'No',
                         },
                     ],
-                    initial: 'No',
+                    initial: 'Yes',
                 },
-            ])
-                .then((a) => a.standaloneApi === 'Yes');
+            ]);
+            routing = reply.routing === 'Yes';
         }
-        return parsedArgs.standaloneApi;
+        return { preset, style, appName, standaloneApi, routing };
     });
 }
-function determineDockerfile(parsedArgs) {
+function determineNodeOptions(parsedArgs) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        if (parsedArgs.docker === undefined) {
-            return enquirer
-                .prompt([
+        let preset;
+        let appName;
+        let framework;
+        let docker;
+        if (parsedArgs.preset) {
+            preset = parsedArgs.preset;
+            if (preset === preset_1.Preset.Nest ||
+                preset === preset_1.Preset.Express ||
+                preset === preset_1.Preset.NodeMonorepo) {
+                appName = yield determineAppName(parsedArgs);
+            }
+            else {
+                appName = parsedArgs.name;
+            }
+            if (preset === preset_1.Preset.NodeStandalone || preset === preset_1.Preset.NodeMonorepo) {
+                framework = yield determineNodeFramework(parsedArgs);
+            }
+            else {
+                framework = 'none';
+            }
+        }
+        else {
+            framework = yield determineNodeFramework(parsedArgs);
+            const workspaceType = yield determineStandAloneOrMonorepo();
+            if (workspaceType === 'standalone') {
+                preset = preset_1.Preset.NodeStandalone;
+                appName = parsedArgs.name;
+            }
+            else {
+                preset = preset_1.Preset.NodeMonorepo;
+                appName = yield determineAppName(parsedArgs);
+            }
+        }
+        if (parsedArgs.docker !== undefined) {
+            docker = parsedArgs.docker;
+        }
+        else {
+            const reply = yield enquirer.prompt([
                 {
                     name: 'docker',
                     message: 'Would you like to generate a Dockerfile? [https://docs.docker.com/]',
@@ -500,23 +579,68 @@ function determineDockerfile(parsedArgs) {
                     ],
                     initial: 'No',
                 },
-            ])
-                .then((a) => a.docker === 'Yes');
-        }
-        else {
-            return Promise.resolve(parsedArgs.docker);
+            ]);
+            docker = reply.docker === 'Yes';
         }
+        return {
+            preset,
+            appName,
+            framework,
+            docker,
+        };
+    });
+}
+function determineStandAloneOrMonorepo() {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const { workspaceType } = yield enquirer.prompt([
+            {
+                type: 'autocomplete',
+                name: 'workspaceType',
+                message: `Standalone project or integrated monorepo?`,
+                initial: 'standalone',
+                choices: [
+                    {
+                        name: 'standalone',
+                        message: 'Standalone:           Nx creates a single project and makes it fast.',
+                    },
+                    {
+                        name: 'integrated',
+                        message: 'Integrated Monorepo:  Nx creates a monorepo that contains multiple projects.',
+                    },
+                ],
+            },
+        ]);
+        invariant(workspaceType, {
+            title: 'Invalid workspace type',
+            bodyLines: [
+                `It must be one of the following: standalone, integrated. Got ${workspaceType}`,
+            ],
+        });
+        return workspaceType;
+    });
+}
+function determineAppName(parsedArgs) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        if (parsedArgs.appName)
+            return parsedArgs.appName;
+        const { appName } = yield enquirer.prompt([
+            {
+                name: 'appName',
+                message: `Application name`,
+                type: 'input',
+                initial: parsedArgs.name,
+            },
+        ]);
+        invariant(appName, {
+            title: 'Invalid name',
+            bodyLines: [`Name cannot be empty`],
+        });
+        return appName;
     });
 }
 function determineReactFramework(parsedArgs) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        if (parsedArgs.framework) {
-            return parsedArgs.framework === 'next.js'
-                ? preset_1.Preset.NextJsStandalone
-                : preset_1.Preset.ReactStandalone;
-        }
-        return enquirer
-            .prompt([
+        const reply = yield enquirer.prompt([
             {
                 name: 'framework',
                 message: 'What framework would you like to use?',
@@ -525,188 +649,112 @@ function determineReactFramework(parsedArgs) {
                     {
                         name: 'none',
                         message: 'None',
-                        hint: 'I only want React',
+                        hint: '         I only want react and react-dom',
+                    },
+                    {
+                        name: 'nextjs',
+                        message: 'Next.js       [ https://nextjs.org/      ]',
                     },
                     {
-                        name: 'next.js',
-                        message: 'Next.js [https://nextjs.org/]',
+                        name: 'expo',
+                        message: 'Expo          [ https://expo.io/         ]',
+                    },
+                    {
+                        name: 'react-native',
+                        message: 'React Native  [ https://reactnative.dev/ ]',
                     },
                 ],
                 initial: 'none',
             },
-        ])
-            .then((choice) => choice.framework === 'next.js'
-            ? preset_1.Preset.NextJsStandalone
-            : preset_1.Preset.ReactStandalone);
-    });
-}
-function isNextAppDir(parsedArgs) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        if (parsedArgs.nextAppDir === undefined) {
-            return enquirer
-                .prompt([
-                {
-                    name: 'appDir',
-                    message: 'Would you like to use the App Router (recommended)?',
-                    type: 'autocomplete',
-                    choices: [
-                        {
-                            name: 'No',
-                        },
-                        {
-                            name: 'Yes',
-                        },
-                    ],
-                    initial: 'Yes',
-                },
-            ])
-                .then((choice) => choice.appDir === 'Yes');
-        }
-        else {
-            return Promise.resolve(parsedArgs.nextAppDir);
-        }
+        ]);
+        return reply.framework;
     });
 }
-function determineStyle(preset, parsedArgs) {
+function determineReactBundler(parsedArgs) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        if (preset === preset_1.Preset.Apps ||
-            preset === preset_1.Preset.Core ||
-            preset === preset_1.Preset.TS ||
-            preset === preset_1.Preset.Empty ||
-            preset === preset_1.Preset.NPM ||
-            preset === preset_1.Preset.Nest ||
-            preset === preset_1.Preset.Express ||
-            preset === preset_1.Preset.ReactNative ||
-            preset === preset_1.Preset.Expo ||
-            preset === preset_1.Preset.NodeStandalone) {
-            return Promise.resolve(null);
-        }
-        const choices = [
+        if (parsedArgs.bundler)
+            return parsedArgs.bundler;
+        const reply = yield enquirer.prompt([
             {
-                name: 'css',
-                message: 'CSS',
-            },
-            {
-                name: 'scss',
-                message: 'SASS(.scss)       [ http://sass-lang.com   ]',
-            },
-            {
-                name: 'less',
-                message: 'LESS              [ http://lesscss.org     ]',
-            },
-        ];
-        if ([
-            preset_1.Preset.ReactMonorepo,
-            preset_1.Preset.ReactStandalone,
-            preset_1.Preset.NextJs,
-            preset_1.Preset.NextJsStandalone,
-        ].includes(preset)) {
-            choices.push({
-                name: 'styled-components',
-                message: 'styled-components [ https://styled-components.com            ]',
-            }, {
-                name: '@emotion/styled',
-                message: 'emotion           [ https://emotion.sh                       ]',
-            }, {
-                name: 'styled-jsx',
-                message: 'styled-jsx        [ https://www.npmjs.com/package/styled-jsx ]',
-            });
-        }
-        if (!parsedArgs.style) {
-            return enquirer
-                .prompt([
-                {
-                    name: 'style',
-                    message: `Default stylesheet format            `,
-                    initial: 'css',
-                    type: 'autocomplete',
-                    choices: choices,
-                },
-            ])
-                .then((a) => a.style);
-        }
-        const foundStyle = choices.find((choice) => choice.name === parsedArgs.style);
-        if (foundStyle === undefined) {
-            output_1.output.error({
-                title: 'Invalid style',
-                bodyLines: [
-                    `It must be one of the following:`,
-                    '',
-                    ...choices.map((choice) => choice.name),
+                name: 'bundler',
+                message: `Which bundler would you like to use?`,
+                type: 'autocomplete',
+                choices: [
+                    {
+                        name: 'vite',
+                        message: 'Vite    [ https://vitejs.dev/     ]',
+                    },
+                    {
+                        name: 'webpack',
+                        message: 'Webpack [ https://webpack.js.org/ ]',
+                    },
+                    {
+                        name: 'rspack',
+                        message: 'Rspack  [ https://www.rspack.dev/ ]',
+                    },
                 ],
-            });
-            process.exit(1);
-        }
-        return Promise.resolve(parsedArgs.style);
+            },
+        ]);
+        return reply.bundler;
     });
 }
-function determineRouting(parsedArgs) {
+function determineNextAppDir(parsedArgs) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        if (!parsedArgs.routing) {
-            return enquirer
-                .prompt([
-                {
-                    name: 'routing',
-                    message: 'Would you like to add routing?',
-                    type: 'autocomplete',
-                    choices: [
-                        {
-                            name: 'Yes',
-                        },
-                        {
-                            name: 'No',
-                        },
-                    ],
-                    initial: 'Yes',
-                },
-            ])
-                .then((a) => a.routing === 'Yes');
-        }
-        return parsedArgs.routing;
+        if (parsedArgs.nextAppDir !== undefined)
+            return parsedArgs.nextAppDir;
+        const reply = yield enquirer.prompt([
+            {
+                name: 'nextAppDir',
+                message: 'Would you like to use the App Router (recommended)?',
+                type: 'autocomplete',
+                choices: [
+                    {
+                        name: 'Yes',
+                    },
+                    {
+                        name: 'No',
+                    },
+                ],
+                initial: 'Yes',
+            },
+        ]);
+        return reply.nextAppDir === 'Yes';
     });
 }
-function determineBundler(parsedArgs) {
+function determineNodeFramework(parsedArgs) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const choices = [
-            {
-                name: 'vite',
-                message: 'Vite    [ https://vitejs.dev/ ]',
-            },
-            {
-                name: 'webpack',
-                message: 'Webpack [ https://webpack.js.org/ ]',
-            },
+        if (parsedArgs.framework)
+            return parsedArgs.framework;
+        const reply = yield enquirer.prompt([
             {
-                name: 'rspack',
-                message: 'Rspack  [ https://www.rspack.dev/ ]',
-            },
-        ];
-        if (!parsedArgs.bundler) {
-            return enquirer
-                .prompt([
-                {
-                    name: 'bundler',
-                    message: `Bundler to be used to build the application`,
-                    initial: 'vite',
-                    type: 'autocomplete',
-                    choices: choices,
-                },
-            ])
-                .then((a) => a.bundler);
-        }
-        const foundBundler = choices.find((choice) => choice.name === parsedArgs.bundler);
-        if (foundBundler === undefined) {
-            output_1.output.error({
-                title: 'Invalid bundler',
-                bodyLines: [
-                    `It must be one of the following:`,
-                    '',
-                    ...choices.map((choice) => choice.name),
+                message: 'What framework should be used?',
+                type: 'autocomplete',
+                name: 'framework',
+                choices: [
+                    {
+                        name: 'none',
+                        message: 'None',
+                    },
+                    {
+                        name: 'express',
+                        message: 'Express [ https://expressjs.com/ ]',
+                    },
+                    {
+                        name: 'fastify',
+                        message: 'Fastify [ https://www.fastify.io/ ]',
+                    },
+                    {
+                        name: 'koa',
+                        message: 'Koa     [ https://koajs.com/      ]',
+                    },
+                    {
+                        name: 'nest',
+                        message: 'NestJs  [ https://nestjs.com/     ]',
+                    },
                 ],
-            });
-            process.exit(1);
-        }
-        return parsedArgs.bundler;
+            },
+        ]);
+        return reply.framework;
     });
 }
 //# sourceMappingURL=create-nx-workspace.js.map