@digitaldefiance/express-suite-starter 2.1.41

package/dist/src/generate-monorepo.js

@@ -0,0 +1,668 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+const input_1 = __importDefault(require("@inquirer/input"));
+const select_1 = __importDefault(require("@inquirer/select"));
+const confirm_1 = __importDefault(require("@inquirer/confirm"));
+const checkbox_1 = __importDefault(require("@inquirer/checkbox"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const albatross_1 = require("../scripts/albatross");
+const logger_1 = require("./cli/logger");
+const config_schema_1 = require("./core/config-schema");
+const system_check_1 = require("./utils/system-check");
+const step_executor_1 = require("./core/step-executor");
+const project_config_builder_1 = require("./core/project-config-builder");
+const project_generator_1 = require("./core/project-generator");
+const shell_utils_1 = require("./utils/shell-utils");
+const template_renderer_1 = require("./utils/template-renderer");
+const passwordObfuscator_1 = require("../scripts/passwordObfuscator");
+const nodeSetup_1 = require("../scripts/nodeSetup");
+const licensePrompt_1 = require("../scripts/licensePrompt");
+const addScriptsToPackageJson_1 = require("../scripts/addScriptsToPackageJson");
+const templateUtils_1 = require("../scripts/templateUtils");
+async function main() {
+    (0, albatross_1.printBanner)();
+    (0, nodeSetup_1.checkAndUseNode)();
+    // Disable Yarn build scripts globally to avoid native module issues
+    process.env.YARN_ENABLE_SCRIPTS = 'false';
+    // System check
+    logger_1.Logger.header('System Check');
+    const systemCheck = system_check_1.SystemCheck.check();
+    system_check_1.SystemCheck.printReport(systemCheck);
+    if (!systemCheck.passed) {
+        const proceed = await (0, confirm_1.default)({
+            message: 'Continue anyway? (Installation may fail)',
+            default: false,
+        });
+        if (!proceed) {
+            logger_1.Logger.info('Cancelled. Please install required tools and try again.');
+            process.exit(0);
+        }
+    }
+    // Load preset
+    const presetPath = path.resolve(__dirname, '../../config/presets/standard.json');
+    const preset = JSON.parse(fs.readFileSync(presetPath, 'utf-8'));
+    // Prompt for workspace configuration
+    logger_1.Logger.header('Workspace Configuration');
+    const workspaceName = await (0, input_1.default)({
+        message: 'Enter the workspace name:',
+        default: 'example-project',
+        validate: (val) => config_schema_1.ConfigValidator.validateWorkspaceName(val) || 'Invalid workspace name (letters, numbers, dashes only)',
+    });
+    const projectPrefix = await (0, input_1.default)({
+        message: 'Enter the project prefix:',
+        default: workspaceName,
+        validate: (val) => config_schema_1.ConfigValidator.validatePrefix(val) || 'Invalid prefix (lowercase letters, numbers, dashes only)',
+    });
+    const namespaceRoot = await (0, input_1.default)({
+        message: 'Enter the npm namespace:',
+        default: `@${projectPrefix}`,
+        validate: (val) => config_schema_1.ConfigValidator.validateNamespace(val) || 'Invalid namespace (must start with @)',
+    });
+    const parentDir = path.resolve(await (0, input_1.default)({
+        message: 'Enter the parent directory:',
+        default: process.cwd(),
+    }));
+    const gitRepo = await (0, input_1.default)({
+        message: 'Enter the git repository URL (optional):',
+        validate: (val) => config_schema_1.ConfigValidator.validateGitRepo(val) || 'Invalid git repository URL',
+    });
+    const hostname = await (0, input_1.default)({
+        message: 'Enter the hostname for development (e.g., example-project.local):',
+        default: `${workspaceName}.local`,
+        validate: (val) => /^[a-z0-9-]+(\.[a-z0-9-]+)*$/.test(val) || 'Invalid hostname format',
+    });
+    const dryRun = await (0, confirm_1.default)({
+        message: 'Run in dry-run mode (preview without creating files)?',
+        default: false,
+    });
+    logger_1.Logger.section('Optional Projects');
+    const includeE2e = await (0, confirm_1.default)({
+        message: 'Include E2E tests?',
+        default: true,
+    });
+    logger_1.Logger.section('Package Groups');
+    const packageGroupsPath = path.resolve(__dirname, '../../config/package-groups.json');
+    const packageGroups = JSON.parse(fs.readFileSync(packageGroupsPath, 'utf-8')).groups;
+    const selectedGroups = await (0, checkbox_1.default)({
+        message: 'Select optional package groups:',
+        choices: packageGroups
+            .filter((g) => !g.enabled)
+            .map((g) => ({
+            name: `${g.name} - ${g.description}`,
+            value: g.name,
+            checked: true,
+        })),
+    });
+    const enableDocGeneration = await (0, confirm_1.default)({
+        message: 'Generate documentation (README, ARCHITECTURE, API docs)?',
+        default: true,
+    });
+    logger_1.Logger.section('DevContainer Configuration');
+    const setupDevcontainer = await (0, confirm_1.default)({
+        message: 'Set up DevContainer configuration?',
+        default: true,
+    });
+    let devcontainerChoice = 'none';
+    if (setupDevcontainer) {
+        devcontainerChoice = await (0, select_1.default)({
+            message: 'DevContainer configuration:',
+            choices: [
+                { name: 'Simple (Node.js only)', value: 'simple' },
+                { name: 'With MongoDB', value: 'mongodb' },
+                { name: 'With MongoDB Replica Set', value: 'mongodb-replicaset' },
+            ],
+            default: 'mongodb-replicaset',
+        });
+    }
+    logger_1.Logger.section('Express Suite Packages');
+    const monorepoPath = path.join(parentDir, workspaceName);
+    // Build project configurations
+    const projects = project_config_builder_1.ProjectConfigBuilder.build(projectPrefix, namespaceRoot, {
+        includeReactLib: true,
+        includeApiLib: true,
+        includeE2e,
+        includeInitUserDb: true,
+        includeTestUtils: false,
+    });
+    // Build configuration
+    const config = {
+        workspace: {
+            name: workspaceName,
+            prefix: projectPrefix,
+            namespace: namespaceRoot,
+            parentDir,
+            gitRepo,
+            hostname,
+        },
+        projects,
+        ...preset,
+    };
+    // Validate configuration
+    const validation = config_schema_1.ConfigValidator.validate(config);
+    if (!validation.valid) {
+        validation.errors.forEach(err => logger_1.Logger.error(err));
+        process.exit(1);
+    }
+    // Setup context with all project names
+    const stateEntries = [
+        ['monorepoPath', monorepoPath],
+        ['templatesDir', path.resolve(__dirname, '../../templates')],
+        ['scaffoldingDir', path.resolve(__dirname, '../../scaffolding')],
+    ];
+    projects.forEach(project => {
+        stateEntries.push([project.type === 'lib' ? 'libName' : `${project.type}Name`, project.name]);
+    });
+    const context = {
+        config,
+        state: new Map(stateEntries),
+        checkpointPath: path.join(parentDir, `.${workspaceName}.checkpoint`),
+    };
+    // Merge selected package groups
+    const additionalPackages = [];
+    selectedGroups.forEach((groupName) => {
+        const group = packageGroups.find((g) => g.name === groupName);
+        if (group) {
+            additionalPackages.push(...group.packages);
+        }
+    });
+    if (additionalPackages.length > 0 && config.packages) {
+        config.packages = {
+            ...config.packages,
+            dev: [...(config.packages.dev || []), ...additionalPackages],
+            prod: config.packages.prod || [],
+        };
+    }
+    // Note: @digitaldefiance/express-suite-test-utils is always included in dev dependencies
+    // react-components will be added to react-lib or react project directly
+    // Setup steps
+    const executor = dryRun
+        ? new (await Promise.resolve().then(() => __importStar(require('./core/dry-run-executor')))).DryRunExecutor()
+        : new step_executor_1.StepExecutor();
+    if (dryRun) {
+        logger_1.Logger.warning('DRY RUN MODE - No files will be created');
+    }
+    executor.addStep({
+        name: 'checkTargetDir',
+        description: 'Checking target directory',
+        execute: () => {
+            if (fs.existsSync(monorepoPath) && fs.readdirSync(monorepoPath).length > 0) {
+                throw new Error(`Directory ${logger_1.Logger.path(monorepoPath)} already exists and is not empty`);
+            }
+        },
+    });
+    executor.addStep({
+        name: 'createMonorepo',
+        description: 'Creating Nx monorepo',
+        execute: () => {
+            (0, shell_utils_1.runCommand)(`npx create-nx-workspace@latest "${workspaceName}" --package-manager=yarn --preset=apps --ci=${config.nx?.ciProvider}`, { cwd: parentDir });
+        },
+    });
+    executor.addStep({
+        name: 'setupGitOrigin',
+        description: 'Setting up git remote',
+        skip: () => !gitRepo,
+        execute: () => {
+            (0, shell_utils_1.runCommand)(`git remote add origin ${gitRepo}`, { cwd: monorepoPath });
+        },
+    });
+    executor.addStep({
+        name: 'yarnBerrySetup',
+        description: 'Configuring Yarn Berry',
+        execute: () => {
+            (0, shell_utils_1.runCommand)('yarn set version berry', { cwd: monorepoPath });
+            (0, shell_utils_1.runCommand)('yarn config set nodeLinker node-modules', { cwd: monorepoPath });
+            (0, shell_utils_1.runCommand)('yarn', { cwd: monorepoPath });
+        },
+    });
+    executor.addStep({
+        name: 'addNxPlugins',
+        description: 'Installing Nx plugins',
+        execute: () => {
+            try {
+                (0, shell_utils_1.runCommand)('yarn add -D @nx/react @nx/node', { cwd: monorepoPath });
+            }
+            catch (error) {
+                if (error.status === 1) {
+                    logger_1.Logger.error('\nPackage installation failed.');
+                    logger_1.Logger.section('If you see "exit code 127" above, install build tools:');
+                    logger_1.Logger.dim('  Ubuntu/Debian: sudo apt-get install build-essential python3');
+                    logger_1.Logger.dim('  Fedora/RHEL:   sudo dnf install gcc-c++ make python3');
+                    logger_1.Logger.dim('  macOS:         xcode-select --install');
+                    logger_1.Logger.section('\nThen retry or skip: yarn start --start-at=addYarnPackages');
+                }
+                throw error;
+            }
+        },
+    });
+    executor.addStep({
+        name: 'addYarnPackages',
+        description: 'Installing dependencies',
+        execute: () => {
+            const devPkgs = config.packages?.dev || [];
+            const prodPkgs = config.packages?.prod || [];
+            if (devPkgs.length > 0) {
+                (0, shell_utils_1.runCommand)(`yarn add -D ${devPkgs.join(' ')}`, { cwd: monorepoPath });
+            }
+            if (prodPkgs.length > 0) {
+                (0, shell_utils_1.runCommand)(`yarn add ${prodPkgs.join(' ')}`, { cwd: monorepoPath });
+            }
+        },
+    });
+    executor.addStep({
+        name: 'generateProjects',
+        description: 'Generating project structure',
+        execute: () => {
+            projects.forEach(project => {
+                if (!project.enabled)
+                    return;
+                logger_1.Logger.info(`Generating ${project.type}: ${project.name}`);
+                switch (project.type) {
+                    case 'react':
+                        project_generator_1.ProjectGenerator.generateReact(project, monorepoPath, config.nx);
+                        break;
+                    case 'react-lib':
+                        project_generator_1.ProjectGenerator.generateReactLib(project, monorepoPath, config.nx);
+                        break;
+                    case 'api':
+                        project_generator_1.ProjectGenerator.generateApi(project, monorepoPath, config.nx);
+                        break;
+                    case 'api-lib':
+                        project_generator_1.ProjectGenerator.generateApiLib(project, monorepoPath, config.nx);
+                        break;
+                    case 'lib':
+                        project_generator_1.ProjectGenerator.generateLib(project, monorepoPath, config.nx);
+                        break;
+                    case 'inituserdb':
+                        project_generator_1.ProjectGenerator.generateInitUserDb(project, monorepoPath);
+                        break;
+                }
+            });
+            // Add copy-env and post-build targets to api and inituserdb project.json
+            const apiProject = projects.find(p => p.type === 'api' && p.enabled);
+            const initUserDbProject = projects.find(p => p.type === 'inituserdb' && p.enabled);
+            if (apiProject) {
+                const projectJsonPath = path.join(monorepoPath, apiProject.name, 'project.json');
+                if (fs.existsSync(projectJsonPath)) {
+                    const projectJson = JSON.parse(fs.readFileSync(projectJsonPath, 'utf-8'));
+                    projectJson.targets['copy-env'] = {
+                        executor: 'nx:run-commands',
+                        options: {
+                            command: `cp ${apiProject.name}/.env dist/${apiProject.name}/.env`
+                        }
+                    };
+                    projectJson.targets['post-build'] = {
+                        executor: 'nx:run-commands',
+                        dependsOn: ['build'],
+                        options: {
+                            command: `cp ${apiProject.name}/.env dist/${apiProject.name}/.env`
+                        }
+                    };
+                    // Update serve to depend on post-build instead of build
+                    if (projectJson.targets.serve) {
+                        projectJson.targets.serve.dependsOn = ['post-build'];
+                        projectJson.targets.serve.options.buildTarget = `${apiProject.name}:post-build`;
+                        if (projectJson.targets.serve.configurations) {
+                            Object.keys(projectJson.targets.serve.configurations).forEach(config => {
+                                projectJson.targets.serve.configurations[config].buildTarget = `${apiProject.name}:post-build`;
+                            });
+                        }
+                    }
+                    fs.writeFileSync(projectJsonPath, JSON.stringify(projectJson, null, 2) + '\n');
+                    logger_1.Logger.info(`Added copy-env and post-build targets to ${apiProject.name}/project.json`);
+                }
+            }
+            if (initUserDbProject) {
+                const projectJsonPath = path.join(monorepoPath, initUserDbProject.name, 'project.json');
+                if (fs.existsSync(projectJsonPath)) {
+                    const projectJson = JSON.parse(fs.readFileSync(projectJsonPath, 'utf-8'));
+                    projectJson.targets['copy-env'] = {
+                        executor: 'nx:run-commands',
+                        options: {
+                            command: `cp ${initUserDbProject.name}/.env dist/${initUserDbProject.name}/.env`
+                        }
+                    };
+                    projectJson.targets['post-build'] = {
+                        executor: 'nx:run-commands',
+                        dependsOn: ['build'],
+                        options: {
+                            commands: [
+                                `cp ${initUserDbProject.name}/.env dist/${initUserDbProject.name}/.env`,
+                                `cd dist/${initUserDbProject.name} && yarn install`
+                            ],
+                            parallel: false
+                        }
+                    };
+                    // Update serve to depend on post-build instead of build
+                    if (projectJson.targets.serve) {
+                        projectJson.targets.serve.dependsOn = ['post-build'];
+                        projectJson.targets.serve.options.buildTarget = `${initUserDbProject.name}:post-build`;
+                        if (projectJson.targets.serve.configurations) {
+                            Object.keys(projectJson.targets.serve.configurations).forEach(config => {
+                                projectJson.targets.serve.configurations[config].buildTarget = `${initUserDbProject.name}:post-build`;
+                            });
+                        }
+                    }
+                    fs.writeFileSync(projectJsonPath, JSON.stringify(projectJson, null, 2) + '\n');
+                    logger_1.Logger.info(`Added copy-env and post-build targets to ${initUserDbProject.name}/project.json`);
+                }
+            }
+        },
+    });
+    executor.addStep({
+        name: 'installReactComponents',
+        description: 'Installing React components package',
+        execute: () => {
+            const reactLibProject = projects.find(p => p.type === 'react-lib' && p.enabled);
+            if (reactLibProject) {
+                logger_1.Logger.info(`Installing @digitaldefiance/express-suite-react-components in ${reactLibProject.name}`);
+                const projectPackageJsonPath = path.join(monorepoPath, reactLibProject.name, 'package.json');
+                const projectPackageJson = JSON.parse(fs.readFileSync(projectPackageJsonPath, 'utf-8'));
+                projectPackageJson.dependencies = projectPackageJson.dependencies || {};
+                projectPackageJson.dependencies['@digitaldefiance/express-suite-react-components'] = 'latest';
+                fs.writeFileSync(projectPackageJsonPath, JSON.stringify(projectPackageJson, null, 2) + '\n');
+                (0, shell_utils_1.runCommand)('yarn install', { cwd: monorepoPath });
+            }
+        },
+    });
+    executor.addStep({
+        name: 'renderTemplates',
+        description: 'Rendering configuration templates',
+        execute: () => {
+            const variables = {
+                WORKSPACE_NAME: workspaceName,
+                PROJECT_PREFIX: projectPrefix,
+                NAMESPACE_ROOT: namespaceRoot,
+                HOSTNAME: hostname,
+                EXAMPLE_PASSWORD: (0, passwordObfuscator_1.obfuscatePassword)(projectPrefix),
+                EXAMPLE_JWT_SECRET: (0, passwordObfuscator_1.obfuscatePassword)(`${workspaceName}Secret`),
+                GIT_REPO: gitRepo,
+                NVM_USE_VERSION: config.node?.version,
+                YARN_VERSION: config.node?.yarnVersion,
+            };
+            projects.forEach(project => {
+                const key = project.type === 'lib' ? 'LIB_NAME' : `${project.type.toUpperCase().replace(/-/g, '_')}_NAME`;
+                variables[key] = project.name;
+            });
+            (0, template_renderer_1.renderTemplates)(context.state.get('templatesDir'), monorepoPath, variables, config.templates?.engine);
+        },
+    });
+    executor.addStep({
+        name: 'copyScaffolding',
+        description: 'Copying scaffolding files',
+        execute: () => {
+            const scaffoldingDir = context.state.get('scaffoldingDir');
+            // Template variables for scaffolding
+            const scaffoldingVars = {
+                workspaceName,
+                WorkspaceName: workspaceName.charAt(0).toUpperCase() + workspaceName.slice(1).replace(/-([a-z])/g, (_, c) => c.toUpperCase()),
+                prefix: projectPrefix,
+                namespace: namespaceRoot,
+                hostname,
+            };
+            // Copy root scaffolding
+            const rootSrc = path.join(scaffoldingDir, 'root');
+            if (fs.existsSync(rootSrc)) {
+                (0, template_renderer_1.copyDir)(rootSrc, monorepoPath, scaffoldingVars);
+            }
+            // Copy devcontainer configuration
+            if (devcontainerChoice !== 'none') {
+                const devcontainerSrc = path.join(scaffoldingDir, `devcontainer-${devcontainerChoice}`);
+                if (fs.existsSync(devcontainerSrc)) {
+                    logger_1.Logger.info(`Copying devcontainer configuration: ${devcontainerChoice}`);
+                    (0, template_renderer_1.copyDir)(devcontainerSrc, monorepoPath, scaffoldingVars);
+                }
+            }
+            // Copy project-specific scaffolding
+            projects.forEach(project => {
+                const projectSrc = path.join(scaffoldingDir, project.type);
+                if (fs.existsSync(projectSrc)) {
+                    (0, template_renderer_1.copyDir)(projectSrc, path.join(monorepoPath, project.name), scaffoldingVars);
+                }
+            });
+        },
+    });
+    executor.addStep({
+        name: 'generateLicense',
+        description: 'Generating LICENSE file',
+        execute: async () => {
+            await (0, licensePrompt_1.promptAndGenerateLicense)(monorepoPath);
+        },
+    });
+    executor.addStep({
+        name: 'addScripts',
+        description: 'Adding package.json scripts',
+        execute: () => {
+            const packageJsonPath = path.join(monorepoPath, 'package.json');
+            const scriptContext = {
+                workspaceName,
+                projectPrefix,
+                namespaceRoot,
+                gitRepo,
+            };
+            projects.forEach(project => {
+                scriptContext[`${project.type}Name`] = project.name;
+            });
+            const addScripts = {
+                'build': 'NODE_ENV=production npx nx run-many --target=build --all --configuration=production',
+                'build:dev': 'NODE_ENV=development npx nx run-many --target=build --all --configuration=development',
+                'test:all': 'yarn test:jest && yarn test:e2e',
+                'test:jest': 'NODE_ENV=development npx nx run-many --target=test --all --configuration=development',
+                'lint:all': 'npx nx run-many --target=lint --all',
+                'prettier:check': "prettier --check '**/*.{ts,tsx}'",
+                'prettier:fix': "prettier --write '**/*.{ts,tsx}'",
+            };
+            const apiProject = projects.find(p => p.type === 'api');
+            if (apiProject) {
+                addScripts['serve'] = `npx nx serve ${apiProject.name} --configuration production`;
+                addScripts['serve:stream'] = `npx nx serve ${apiProject.name} --configuration production --output-style=stream`;
+                addScripts['serve:dev'] = `npx nx serve ${apiProject.name} --configuration development`;
+                addScripts['serve:dev:stream'] = `npx nx serve ${apiProject.name} --configuration development --output-style=stream`;
+                addScripts['build:api'] = `npx nx build ${apiProject.name}`;
+            }
+            const reactProject = projects.find(p => p.type === 'react');
+            if (reactProject) {
+                addScripts['build:react'] = `npx nx build ${reactProject.name}`;
+            }
+            const interpolatedScripts = {};
+            for (const [k, v] of Object.entries(addScripts)) {
+                interpolatedScripts[k] = (0, templateUtils_1.interpolateTemplateStrings)(v, scriptContext);
+            }
+            (0, addScriptsToPackageJson_1.addScriptsToPackageJson)(packageJsonPath, interpolatedScripts);
+        },
+    });
+    executor.addStep({
+        name: 'generateDocumentation',
+        description: 'Generating documentation',
+        skip: () => !enableDocGeneration || dryRun,
+        execute: async () => {
+            const { DocGenerator } = await Promise.resolve().then(() => __importStar(require('./utils/doc-generator')));
+            DocGenerator.generateProjectDocs(context);
+        },
+    });
+    executor.addStep({
+        name: 'setupEnvironment',
+        description: 'Setting up environment files',
+        execute: () => {
+            const apiProject = projects.find(p => p.type === 'api');
+            const initUserDbProject = projects.find(p => p.type === 'inituserdb');
+            // Setup API .env
+            if (apiProject) {
+                const envExamplePath = path.join(monorepoPath, apiProject.name, '.env.example');
+                const envPath = path.join(monorepoPath, apiProject.name, '.env');
+                if (fs.existsSync(envExamplePath) && !fs.existsSync(envPath)) {
+                    fs.copyFileSync(envExamplePath, envPath);
+                    logger_1.Logger.info(`Created ${apiProject.name}/.env from .env.example`);
+                }
+            }
+            // Setup inituserdb .env
+            if (initUserDbProject && apiProject) {
+                const apiEnvPath = path.join(monorepoPath, apiProject.name, '.env');
+                const initEnvPath = path.join(monorepoPath, initUserDbProject.name, '.env');
+                if (fs.existsSync(apiEnvPath) && !fs.existsSync(initEnvPath)) {
+                    fs.copyFileSync(apiEnvPath, initEnvPath);
+                    logger_1.Logger.info(`Created ${initUserDbProject.name}/.env from ${apiProject.name}/.env`);
+                }
+            }
+            // Setup devcontainer .env if devcontainer with MongoDB
+            if (devcontainerChoice === 'mongodb' || devcontainerChoice === 'mongodb-replicaset') {
+                const devcontainerEnvPath = path.join(monorepoPath, '.devcontainer', '.env');
+                if (!fs.existsSync(devcontainerEnvPath)) {
+                    const mongoUri = devcontainerChoice === 'mongodb-replicaset'
+                        ? 'mongodb://localhost:27017/example-project?replicaSet=rs0&directConnection=true'
+                        : 'mongodb://localhost:27017/example-project?directConnection=true';
+                    const envContent = `MONGO_URI=${mongoUri}\n`;
+                    fs.writeFileSync(devcontainerEnvPath, envContent);
+                    logger_1.Logger.info('Created .devcontainer/.env with MongoDB configuration');
+                }
+            }
+        },
+    });
+    executor.addStep({
+        name: 'rebuildNativeModules',
+        description: 'Building native modules',
+        execute: () => {
+            logger_1.Logger.info('Re-enabling build scripts and building native modules...');
+            (0, shell_utils_1.runCommand)('yarn config set enableScripts true', { cwd: monorepoPath });
+            (0, shell_utils_1.runCommand)('yarn rebuild', { cwd: monorepoPath });
+        },
+    });
+    executor.addStep({
+        name: 'validateGeneration',
+        description: 'Validating generated project',
+        skip: () => dryRun,
+        execute: async () => {
+            const { PostGenerationValidator } = await Promise.resolve().then(() => __importStar(require('./core/validators/post-generation-validator')));
+            const report = await PostGenerationValidator.validate(context);
+            PostGenerationValidator.printReport(report);
+            if (!report.passed) {
+                logger_1.Logger.warning('Validation found errors, but continuing...');
+            }
+        },
+    });
+    executor.addStep({
+        name: 'initialCommit',
+        description: 'Creating initial commit',
+        execute: async () => {
+            // Ensure git is initialized
+            if (!fs.existsSync(path.join(monorepoPath, '.git'))) {
+                (0, shell_utils_1.runCommand)('git init', { cwd: monorepoPath });
+            }
+            const doCommit = await (0, confirm_1.default)({
+                message: 'Create initial git commit?',
+                default: true,
+            });
+            if (doCommit) {
+                (0, shell_utils_1.runCommand)('git add -A', { cwd: monorepoPath });
+                (0, shell_utils_1.runCommand)('git commit -m "Initial commit"', { cwd: monorepoPath });
+                if (gitRepo) {
+                    const doPush = await (0, confirm_1.default)({
+                        message: 'Push to remote repository?',
+                        default: true,
+                    });
+                    if (doPush) {
+                        (0, shell_utils_1.runCommand)('git push --set-upstream origin main', { cwd: monorepoPath });
+                    }
+                }
+            }
+        },
+    });
+    executor.addStep({
+        name: 'installPlaywright',
+        description: 'Installing Playwright browsers',
+        skip: () => !includeE2e,
+        execute: async () => {
+            const installPlaywright = await (0, confirm_1.default)({
+                message: 'Install Playwright browsers? (Required for E2E tests)',
+                default: true,
+            });
+            if (installPlaywright) {
+                logger_1.Logger.info('Installing Playwright browsers (this may take a few minutes)...');
+                (0, shell_utils_1.runCommand)('yarn playwright install --with-deps', { cwd: monorepoPath });
+            }
+            else {
+                logger_1.Logger.warning('Skipped. Run manually later: yarn playwright install --with-deps');
+            }
+        },
+    });
+    // Execute
+    try {
+        await executor.execute(context);
+        if (dryRun) {
+            logger_1.Logger.warning('Dry-run complete. Re-run without dry-run to generate.');
+            process.exit(0);
+        }
+        logger_1.Logger.header('Generation Complete!');
+        logger_1.Logger.success(`Monorepo created at: ${logger_1.Logger.path(monorepoPath)}`);
+        const apiProject = projects.find(p => p.type === 'api');
+        if (apiProject) {
+            logger_1.Logger.warning(`\nIMPORTANT: Update ${apiProject.name}/.env with your configuration`);
+        }
+        if (devcontainerChoice === 'mongodb' || devcontainerChoice === 'mongodb-replicaset') {
+            logger_1.Logger.warning(`IMPORTANT: Update .devcontainer/.env with your MongoDB configuration`);
+        }
+        logger_1.Logger.section('Next steps:');
+        logger_1.Logger.dim(`  cd ${workspaceName}`);
+        if (apiProject) {
+            logger_1.Logger.dim(`  # Update ${apiProject.name}/.env with your settings`);
+        }
+        logger_1.Logger.dim(`  yarn build:dev`);
+        logger_1.Logger.dim(`  yarn serve:dev`);
+        logger_1.Logger.section('Generated projects:');
+        projects.forEach(p => {
+            if (p.enabled) {
+                logger_1.Logger.dim(`  ${p.type.padEnd(12)} ${p.name}`);
+            }
+        });
+    }
+    catch (error) {
+        logger_1.Logger.error('Generation failed');
+        console.error(error);
+        process.exit(1);
+    }
+}
+if (require.main === module) {
+    main().catch((err) => {
+        logger_1.Logger.error('Fatal error');
+        console.error(err);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=generate-monorepo.js.map