@digitaldefiance/express-suite-starter 2.4.17 → 3.0.1

package/dist/src/core/programmatic-generator.js

@@ -0,0 +1,946 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateMonorepo = generateMonorepo;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const crypto = __importStar(require("crypto"));
+const step_executor_1 = require("./step-executor");
+const dry_run_executor_1 = require("./dry-run-executor");
+const config_validator_1 = require("./validators/config-validator");
+const project_generator_1 = require("./project-generator");
+const logger_1 = require("../cli/logger");
+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 addScriptsToPackageJson_1 = require("../../scripts/addScriptsToPackageJson");
+const templateUtils_1 = require("../../scripts/templateUtils");
+const i18n_lib_1 = require("@digitaldefiance/i18n-lib");
+const i18n_lib_2 = require("@digitaldefiance/i18n-lib");
+const i18n_1 = require("../i18n");
+const post_generation_validator_1 = require("./validators/post-generation-validator");
+/**
+ * Run the monorepo generator programmatically without interactive prompts.
+ * Accepts a fully-formed configuration and executes the same step pipeline
+ * as the interactive CLI.
+ *
+ * @param options - Programmatic generation options
+ * @throws Error if configuration validation fails or a step fails
+ */
+async function generateMonorepo(options) {
+    const { config, dryRun = false, hostname = `${config.workspace.name}.local`, language = i18n_lib_1.LanguageCodes.EN_US, siteTitle = 'Your Site Title', siteDescription = 'Your description here', siteTagline = 'Your tagline here', includeE2e = true, selectedGroups = [], devcontainer = { type: 'none' }, inMemoryDb = { enabled: false }, secrets = {}, createInitialCommit = false, pushToRemote = false, installPlaywright = false, skipSystemCheck: _skipSystemCheck = true, } = options;
+    (0, nodeSetup_1.checkAndUseNode)();
+    // Disable Yarn build scripts globally to avoid native module issues
+    process.env.YARN_ENABLE_SCRIPTS = 'false';
+    // Validate configuration
+    const validation = config_validator_1.ConfigValidator.validate(config);
+    if (!validation.valid) {
+        throw new Error(`Invalid configuration: ${validation.errors.join(', ')}`);
+    }
+    const { workspace, projects } = config;
+    const monorepoPath = path.join(workspace.parentDir, workspace.name);
+    // Generate secrets if not provided
+    const jwtSecret = secrets.jwtSecret ?? crypto.randomBytes(32).toString('hex');
+    const mnemonicEncryptionKey = secrets.mnemonicEncryptionKey ?? crypto.randomBytes(32).toString('hex');
+    const mnemonicHmacSecret = secrets.mnemonicHmacSecret ?? crypto.randomBytes(32).toString('hex');
+    const devcontainerChoice = devcontainer.type;
+    const mongoPassword = devcontainer.mongoPassword ?? '';
+    const useInMemoryDb = inMemoryDb.enabled;
+    const devDatabaseName = inMemoryDb.databaseName ?? 'test';
+    // Merge selected package groups
+    const packageGroupsPath = path.resolve(__dirname, '../../config/package-groups.json');
+    if (selectedGroups.length > 0 &&
+        fs.existsSync(packageGroupsPath)) {
+        const packageGroups = JSON.parse(fs.readFileSync(packageGroupsPath, 'utf-8')).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 || [],
+            };
+        }
+    }
+    // Build state entries (same as interactive flow)
+    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(workspace.parentDir, `.${workspace.name}.checkpoint`),
+        dryRun,
+    };
+    // Create executor
+    const executor = dryRun ? new dry_run_executor_1.DryRunExecutor() : new step_executor_1.StepExecutor();
+    if (dryRun) {
+        logger_1.Logger.warning((0, i18n_1.getStarterTranslation)(i18n_1.StarterStringKey.GENERATION_DRY_RUN_MODE));
+    }
+    // Build the same step pipeline as the interactive CLI
+    buildSteps(executor, {
+        config,
+        context,
+        monorepoPath,
+        projects,
+        workspace,
+        hostname,
+        language,
+        siteTitle,
+        siteDescription,
+        siteTagline,
+        includeE2e,
+        devcontainerChoice,
+        mongoPassword,
+        useInMemoryDb,
+        devDatabaseName,
+        jwtSecret,
+        mnemonicEncryptionKey,
+        mnemonicHmacSecret,
+        createInitialCommit,
+        pushToRemote,
+        installPlaywright,
+        dryRun,
+    });
+    // Execute
+    await executor.execute(context);
+}
+/**
+ * Builds the step pipeline — same steps as the interactive CLI
+ * but without any interactive prompts.
+ */
+function buildSteps(executor, params) {
+    const { config, context, monorepoPath, projects, workspace, hostname, language, siteTitle, siteDescription, siteTagline, includeE2e, devcontainerChoice, mongoPassword, useInMemoryDb, devDatabaseName, jwtSecret, mnemonicEncryptionKey, mnemonicHmacSecret, createInitialCommit, pushToRemote, installPlaywright, dryRun, } = params;
+    const workspaceName = workspace.name;
+    const projectPrefix = workspace.prefix;
+    const namespaceRoot = workspace.namespace;
+    const parentDir = workspace.parentDir;
+    const gitRepo = workspace.gitRepo ?? '';
+    executor.addStep({
+        name: 'checkTargetDir',
+        description: (0, i18n_1.getStarterTranslation)(i18n_1.StarterStringKey.STEP_CHECK_TARGET_DIR),
+        execute: () => {
+            if (fs.existsSync(monorepoPath) &&
+                fs.readdirSync(monorepoPath).length > 0) {
+                throw new i18n_lib_2.TranslatableGenericError(i18n_1.StarterComponentId, i18n_1.StarterStringKey.ERROR_DIRECTORY_NOT_EMPTY, { path: monorepoPath });
+            }
+        },
+    });
+    executor.addStep({
+        name: 'createMonorepo',
+        description: (0, i18n_1.getStarterTranslation)(i18n_1.StarterStringKey.STEP_CREATE_MONOREPO),
+        execute: (ctx) => {
+            (0, shell_utils_1.runCommand)(`npx create-nx-workspace@latest "${workspaceName}" --package-manager=yarn --preset=apps --ci=${config.nx?.ciProvider}`, { cwd: parentDir, dryRun: ctx.dryRun });
+        },
+    });
+    executor.addStep({
+        name: 'updateTsConfigBase',
+        description: (0, i18n_1.getStarterTranslation)(i18n_1.StarterStringKey.STEP_UPDATE_TSCONFIG_BASE),
+        execute: () => {
+            const tsconfigBasePath = path.join(monorepoPath, 'tsconfig.base.json');
+            if (fs.existsSync(tsconfigBasePath)) {
+                const tsconfigBase = JSON.parse(fs.readFileSync(tsconfigBasePath, 'utf-8'));
+                tsconfigBase.compilerOptions = tsconfigBase.compilerOptions || {};
+                tsconfigBase.compilerOptions.esModuleInterop = true;
+                tsconfigBase.compilerOptions.allowSyntheticDefaultImports = true;
+                tsconfigBase.compilerOptions.allowImportingTsExtensions = true;
+                tsconfigBase.compilerOptions.target = 'es2020';
+                tsconfigBase.compilerOptions.skipLibCheck = true;
+                tsconfigBase.compilerOptions.skipDefaultLibCheck = true;
+                tsconfigBase.compilerOptions.noImplicitOverride = false;
+                fs.writeFileSync(tsconfigBasePath, JSON.stringify(tsconfigBase, null, 2) + '\n');
+                logger_1.Logger.info((0, i18n_1.getStarterTranslation)(i18n_1.StarterStringKey.TSCONFIG_BASE_UPDATED));
+            }
+        },
+    });
+    executor.addStep({
+        name: 'setupGitOrigin',
+        description: (0, i18n_1.getStarterTranslation)(i18n_1.StarterStringKey.STEP_SETUP_GIT_ORIGIN),
+        skip: () => !gitRepo,
+        execute: () => {
+            if (!fs.existsSync(path.join(monorepoPath, '.git'))) {
+                (0, shell_utils_1.runCommand)('git init', { cwd: monorepoPath, dryRun: context.dryRun });
+            }
+            try {
+                (0, shell_utils_1.runCommand)(`git remote add origin ${gitRepo}`, {
+                    cwd: monorepoPath,
+                    dryRun: context.dryRun,
+                });
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                if (errorMsg.includes('remote origin already exists') ||
+                    (error !== null &&
+                        typeof error === 'object' &&
+                        'status' in error &&
+                        error.status === 3)) {
+                    logger_1.Logger.info('Remote origin already exists, updating URL...');
+                    (0, shell_utils_1.runCommand)(`git remote set-url origin ${gitRepo}`, {
+                        cwd: monorepoPath,
+                        dryRun: context.dryRun,
+                    });
+                }
+                else {
+                    throw error;
+                }
+            }
+        },
+    });
+    executor.addStep({
+        name: 'yarnBerrySetup',
+        description: (0, i18n_1.getStarterTranslation)(i18n_1.StarterStringKey.STEP_YARN_BERRY_SETUP),
+        execute: () => {
+            (0, shell_utils_1.runCommand)('yarn set version berry', {
+                cwd: monorepoPath,
+                dryRun: context.dryRun,
+            });
+            (0, shell_utils_1.runCommand)('yarn config set nodeLinker node-modules', {
+                cwd: monorepoPath,
+                dryRun: context.dryRun,
+            });
+            (0, shell_utils_1.runCommand)('yarn', { cwd: monorepoPath, dryRun: context.dryRun });
+        },
+    });
+    executor.addStep({
+        name: 'addPackageResolutions',
+        description: (0, i18n_1.getStarterTranslation)(i18n_1.StarterStringKey.STEP_ADD_PACKAGE_RESOLUTIONS),
+        execute: () => {
+            const packageJsonPath = path.join(monorepoPath, 'package.json');
+            if (fs.existsSync(packageJsonPath)) {
+                const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+                packageJson.resolutions = {
+                    '@noble/curves': '1.4.2',
+                    '@noble/hashes': '1.4.0',
+                    '@scure/bip32': '1.4.0',
+                    '@scure/bip39': '1.3.0',
+                };
+                fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n');
+                logger_1.Logger.info((0, i18n_1.getStarterTranslation)(i18n_1.StarterStringKey.PACKAGE_RESOLUTIONS_ADDED));
+            }
+        },
+    });
+    executor.addStep({
+        name: 'addNxPlugins',
+        description: (0, i18n_1.getStarterTranslation)(i18n_1.StarterStringKey.STEP_ADD_NX_PLUGINS),
+        execute: () => {
+            (0, shell_utils_1.runCommand)('yarn add -D @nx/react @nx/node', {
+                cwd: monorepoPath,
+                dryRun: context.dryRun,
+            });
+        },
+    });
+    executor.addStep({
+        name: 'resetNxDaemon',
+        description: 'Resetting Nx daemon',
+        execute: () => {
+            (0, shell_utils_1.runCommand)('npx nx reset', {
+                cwd: monorepoPath,
+                dryRun: context.dryRun,
+            });
+        },
+    });
+    executor.addStep({
+        name: 'addYarnPackages',
+        description: (0, i18n_1.getStarterTranslation)(i18n_1.StarterStringKey.STEP_ADD_YARN_PACKAGES),
+        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,
+                    dryRun: context.dryRun,
+                });
+            }
+            if (prodPkgs.length > 0) {
+                (0, shell_utils_1.runCommand)(`yarn add ${prodPkgs.join(' ')}`, {
+                    cwd: monorepoPath,
+                    dryRun: context.dryRun,
+                });
+            }
+        },
+    });
+    executor.addStep({
+        name: 'generateProjects',
+        description: (0, i18n_1.getStarterTranslation)(i18n_1.StarterStringKey.STEP_GENERATE_PROJECTS),
+        execute: () => {
+            projects.forEach((project) => {
+                if (!project.enabled)
+                    return;
+                logger_1.Logger.info((0, i18n_1.getStarterTranslation)(i18n_1.StarterStringKey.PROJECT_GENERATING, {
+                    type: project.type,
+                    name: project.name,
+                }));
+                switch (project.type) {
+                    case 'react':
+                        project_generator_1.ProjectGenerator.generateReact(project, monorepoPath, config.nx, context.dryRun);
+                        break;
+                    case 'react-lib':
+                        project_generator_1.ProjectGenerator.generateReactLib(project, monorepoPath, config.nx, context.dryRun);
+                        break;
+                    case 'api':
+                        project_generator_1.ProjectGenerator.generateApi(project, monorepoPath, config.nx, context.dryRun);
+                        break;
+                    case 'api-lib':
+                        project_generator_1.ProjectGenerator.generateApiLib(project, monorepoPath, config.nx, context.dryRun);
+                        break;
+                    case 'lib':
+                        project_generator_1.ProjectGenerator.generateLib(project, monorepoPath, config.nx, context.dryRun);
+                        break;
+                    case 'inituserdb':
+                        project_generator_1.ProjectGenerator.generateInitUserDb(project, monorepoPath, context.dryRun);
+                        break;
+                }
+            });
+            // Configure project.json targets for api and inituserdb
+            configureApiProjectJson(projects, monorepoPath);
+            configureInitUserDbProjectJson(projects, monorepoPath);
+            configureReactProjectJson(projects, monorepoPath);
+        },
+    });
+    executor.addStep({
+        name: 'updateTsConfigAppFiles',
+        description: 'Updating tsconfig.app.json files with skipLibCheck',
+        execute: () => {
+            const apiProject = projects.find((p) => p.type === 'api' && p.enabled);
+            const initUserDbProject = projects.find((p) => p.type === 'inituserdb' && p.enabled);
+            [apiProject, initUserDbProject].forEach((project) => {
+                if (project) {
+                    const tsconfigAppPath = path.join(monorepoPath, project.name, 'tsconfig.app.json');
+                    if (fs.existsSync(tsconfigAppPath)) {
+                        const tsconfigApp = JSON.parse(fs.readFileSync(tsconfigAppPath, 'utf-8'));
+                        tsconfigApp.compilerOptions = tsconfigApp.compilerOptions || {};
+                        tsconfigApp.compilerOptions.skipLibCheck = true;
+                        fs.writeFileSync(tsconfigAppPath, JSON.stringify(tsconfigApp, null, 2) + '\n');
+                        logger_1.Logger.info(`Updated ${project.name}/tsconfig.app.json with skipLibCheck`);
+                    }
+                }
+            });
+        },
+    });
+    executor.addStep({
+        name: 'installReactComponents',
+        description: (0, i18n_1.getStarterTranslation)(i18n_1.StarterStringKey.STEP_INSTALL_REACT_COMPONENTS),
+        execute: () => {
+            const reactLibProject = projects.find((p) => p.type === 'react-lib' && p.enabled);
+            if (reactLibProject) {
+                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,
+                    dryRun: context.dryRun,
+                });
+            }
+        },
+    });
+    executor.addStep({
+        name: 'renderTemplates',
+        description: (0, i18n_1.getStarterTranslation)(i18n_1.StarterStringKey.STEP_RENDER_TEMPLATES),
+        execute: () => {
+            const variables = {
+                WORKSPACE_NAME: workspaceName,
+                PROJECT_PREFIX: projectPrefix,
+                NAMESPACE_ROOT: namespaceRoot,
+                HOSTNAME: hostname,
+                SITE_TITLE: siteTitle,
+                SITE_DESCRIPTION: siteDescription,
+                SITE_TAGLINE: siteTagline,
+                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, context.dryRun);
+        },
+    });
+    executor.addStep({
+        name: 'copyScaffolding',
+        description: (0, i18n_1.getStarterTranslation)(i18n_1.StarterStringKey.STEP_COPY_SCAFFOLDING),
+        execute: () => {
+            const scaffoldingDir = context.state.get('scaffoldingDir');
+            const escapeForTypeScript = (str) => {
+                return str
+                    .replace(/\\/g, '\\\\')
+                    .replace(/'/g, "\\'")
+                    .replace(/"/g, '\\"')
+                    .replace(/\n/g, '\\n')
+                    .replace(/\r/g, '\\r')
+                    .replace(/\t/g, '\\t');
+            };
+            const scaffoldingVars = {
+                workspaceName,
+                WorkspaceName: workspaceName.charAt(0).toUpperCase() +
+                    workspaceName
+                        .slice(1)
+                        .replace(/-([a-z])/g, (_, c) => c.toUpperCase()),
+                prefix: projectPrefix,
+                namespace: namespaceRoot,
+                hostname,
+                selectedLanguage: language,
+                siteTitle: escapeForTypeScript(siteTitle),
+                siteDescription: escapeForTypeScript(siteDescription),
+                siteTagline: escapeForTypeScript(siteTagline),
+                isEnUs: language === i18n_lib_1.LanguageCodes.EN_US,
+                isEnGb: language === i18n_lib_1.LanguageCodes.EN_GB,
+                isFr: language === i18n_lib_1.LanguageCodes.FR,
+                isEs: language === i18n_lib_1.LanguageCodes.ES,
+                isDe: language === i18n_lib_1.LanguageCodes.DE,
+                isZhCn: language === i18n_lib_1.LanguageCodes.ZH_CN,
+                isJa: language === i18n_lib_1.LanguageCodes.JA,
+                isUk: language === i18n_lib_1.LanguageCodes.UK,
+            };
+            // Copy root scaffolding
+            const rootSrc = path.join(scaffoldingDir, 'root');
+            if (fs.existsSync(rootSrc)) {
+                (0, template_renderer_1.copyDir)(rootSrc, monorepoPath, scaffoldingVars, 'mustache', context.dryRun);
+            }
+            // 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, 'handlebars', context.dryRun);
+                }
+            }
+            // 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, 'mustache', context.dryRun);
+                }
+            });
+        },
+    });
+    executor.addStep({
+        name: 'fixPlaywrightPlugin',
+        description: 'Configuring Nx Playwright plugin to avoid daemon issues',
+        skip: () => !includeE2e,
+        execute: () => {
+            const nxJsonPath = path.join(monorepoPath, 'nx.json');
+            if (fs.existsSync(nxJsonPath)) {
+                const nxJson = JSON.parse(fs.readFileSync(nxJsonPath, 'utf-8'));
+                if (nxJson.plugins && Array.isArray(nxJson.plugins)) {
+                    const playwrightPluginIndex = nxJson.plugins.findIndex((plugin) => (typeof plugin === 'string' && plugin.includes('playwright')) ||
+                        (typeof plugin === 'object' &&
+                            plugin.plugin?.includes('playwright')));
+                    if (playwrightPluginIndex !== -1) {
+                        nxJson.plugins.splice(playwrightPluginIndex, 1);
+                        logger_1.Logger.info('Removed Playwright plugin from nx.json to avoid daemon worker issues');
+                    }
+                }
+                fs.writeFileSync(nxJsonPath, JSON.stringify(nxJson, null, 2) + '\n');
+            }
+        },
+    });
+    executor.addStep({
+        name: 'createTypesDirectory',
+        description: 'Creating types directory with global.d.ts',
+        execute: () => {
+            const typesDir = path.join(monorepoPath, 'types');
+            const globalDtsPath = path.join(typesDir, 'global.d.ts');
+            if (!fs.existsSync(typesDir)) {
+                fs.mkdirSync(typesDir, { recursive: true });
+            }
+            const globalDtsContent = buildGlobalDtsContent();
+            fs.writeFileSync(globalDtsPath, globalDtsContent);
+            logger_1.Logger.info('Created types/global.d.ts with Error extensions');
+            const nodeModulesTypesDir = path.join(monorepoPath, 'node_modules', 'types');
+            if (!fs.existsSync(nodeModulesTypesDir)) {
+                fs.mkdirSync(nodeModulesTypesDir, { recursive: true });
+            }
+            fs.writeFileSync(path.join(nodeModulesTypesDir, 'global.d.ts'), globalDtsContent);
+            logger_1.Logger.info('Created node_modules/types/global.d.ts for library references');
+        },
+    });
+    // Skip license prompt in programmatic mode (no interactive prompt)
+    executor.addStep({
+        name: 'generateLicense',
+        description: (0, i18n_1.getStarterTranslation)(i18n_1.StarterStringKey.STEP_GENERATE_LICENSE),
+        skip: () => true, // Skipped in programmatic mode — no interactive prompt
+        execute: () => {
+            // no-op
+        },
+    });
+    executor.addStep({
+        name: 'addScripts',
+        description: (0, i18n_1.getStarterTranslation)(i18n_1.StarterStringKey.STEP_ADD_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 initUserDbProject = projects.find((p) => p.type === 'inituserdb');
+            if (initUserDbProject) {
+                addScripts['inituserdb'] =
+                    `yarn build:dev && npx nx serve ${initUserDbProject.name} --output-style=stream`;
+                addScripts['inituserdb:drop'] =
+                    `yarn build:dev && npx nx serve ${initUserDbProject.name} --output-style=stream --args=--drop`;
+                addScripts['inituserdb:setenv'] =
+                    `yarn build:dev && npx nx serve ${initUserDbProject.name} --output-style=stream --args=--setEnv`;
+                addScripts['inituserdb:drop:setenv'] =
+                    `yarn build:dev && npx nx serve ${initUserDbProject.name} --output-style=stream --args="--drop --setEnv"`;
+            }
+            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: (0, i18n_1.getStarterTranslation)(i18n_1.StarterStringKey.STEP_GENERATE_DOCUMENTATION),
+        skip: () => true, // Disabled — README comes from scaffolding/root/
+        execute: async () => {
+            const { DocGenerator } = await Promise.resolve().then(() => __importStar(require('../utils/doc-generator')));
+            DocGenerator.generateProjectDocs(context);
+        },
+    });
+    executor.addStep({
+        name: 'setupEnvironment',
+        description: (0, i18n_1.getStarterTranslation)(i18n_1.StarterStringKey.STEP_SETUP_ENVIRONMENT),
+        execute: () => {
+            setupEnvironmentFiles({
+                projects,
+                monorepoPath,
+                workspaceName,
+                devcontainerChoice,
+                mongoPassword,
+                useInMemoryDb,
+                devDatabaseName,
+                jwtSecret,
+                mnemonicEncryptionKey,
+                mnemonicHmacSecret,
+            });
+        },
+    });
+    executor.addStep({
+        name: 'rebuildNativeModules',
+        description: (0, i18n_1.getStarterTranslation)(i18n_1.StarterStringKey.STEP_REBUILD_NATIVE_MODULES),
+        execute: () => {
+            logger_1.Logger.info((0, i18n_1.getStarterTranslation)(i18n_1.StarterStringKey.COMMAND_REBUILDING_NATIVE));
+            (0, shell_utils_1.runCommand)('yarn config set enableScripts true', {
+                cwd: monorepoPath,
+                dryRun: context.dryRun,
+            });
+            (0, shell_utils_1.runCommand)('yarn rebuild', {
+                cwd: monorepoPath,
+                dryRun: context.dryRun,
+            });
+        },
+    });
+    executor.addStep({
+        name: 'validateGeneration',
+        description: (0, i18n_1.getStarterTranslation)(i18n_1.StarterStringKey.STEP_VALIDATE_GENERATION),
+        skip: () => dryRun,
+        execute: async () => {
+            const report = await post_generation_validator_1.PostGenerationValidator.validate(context);
+            post_generation_validator_1.PostGenerationValidator.printReport(report);
+            if (!report.passed) {
+                logger_1.Logger.warning((0, i18n_1.getStarterTranslation)(i18n_1.StarterStringKey.WARNING_VALIDATION_ERRORS));
+            }
+        },
+    });
+    executor.addStep({
+        name: 'initialCommit',
+        description: (0, i18n_1.getStarterTranslation)(i18n_1.StarterStringKey.STEP_INITIAL_COMMIT),
+        skip: () => !createInitialCommit,
+        execute: () => {
+            if (!fs.existsSync(path.join(monorepoPath, '.git'))) {
+                (0, shell_utils_1.runCommand)('git init', { cwd: monorepoPath, dryRun: context.dryRun });
+            }
+            (0, shell_utils_1.runCommand)('git add -A', { cwd: monorepoPath, dryRun: context.dryRun });
+            (0, shell_utils_1.runCommand)('git commit -m "Initial commit"', {
+                cwd: monorepoPath,
+                dryRun: context.dryRun,
+            });
+            if (gitRepo && pushToRemote) {
+                (0, shell_utils_1.runCommand)('git push --set-upstream origin main', {
+                    cwd: monorepoPath,
+                    dryRun: context.dryRun,
+                });
+            }
+        },
+    });
+    executor.addStep({
+        name: 'installPlaywright',
+        description: (0, i18n_1.getStarterTranslation)(i18n_1.StarterStringKey.STEP_INSTALL_PLAYWRIGHT),
+        skip: () => !includeE2e || !installPlaywright,
+        execute: () => {
+            logger_1.Logger.info((0, i18n_1.getStarterTranslation)(i18n_1.StarterStringKey.COMMAND_INSTALLING_PLAYWRIGHT_BROWSERS));
+            (0, shell_utils_1.runCommand)('yarn playwright install --with-deps', {
+                cwd: monorepoPath,
+                dryRun: context.dryRun,
+            });
+        },
+    });
+}
+/** Configure api project.json targets */
+function configureApiProjectJson(projects, monorepoPath) {
+    const apiProject = projects.find((p) => p.type === 'api' && p.enabled);
+    if (!apiProject)
+        return;
+    const projectJsonPath = path.join(monorepoPath, apiProject.name, 'project.json');
+    if (!fs.existsSync(projectJsonPath))
+        return;
+    const projectJson = JSON.parse(fs.readFileSync(projectJsonPath, 'utf-8'));
+    if (projectJson.targets?.build?.options) {
+        projectJson.targets.build.options.skipTypeCheck = true;
+        projectJson.targets.build.options.bundle = true;
+        const existingAssets = projectJson.targets.build.options.assets || [];
+        const hasObjectAssets = existingAssets.some((asset) => typeof asset === 'object' && asset.input);
+        if (!hasObjectAssets) {
+            projectJson.targets.build.options.assets = [
+                {
+                    input: `${apiProject.name}/src/assets`,
+                    glob: '**/*',
+                    output: 'assets',
+                },
+                {
+                    input: `${apiProject.name}/src/views`,
+                    glob: '**/*',
+                    output: 'views',
+                },
+            ];
+        }
+    }
+    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`,
+        },
+    };
+    projectJson.targets.serve = {
+        continuous: true,
+        executor: 'nx:run-commands',
+        defaultConfiguration: 'development',
+        dependsOn: ['post-build'],
+        options: {
+            cwd: `dist/${apiProject.name}`,
+            command: 'node main.js',
+        },
+        configurations: {
+            development: {
+                cwd: `dist/${apiProject.name}`,
+                command: 'node main.js',
+            },
+            production: {
+                cwd: `dist/${apiProject.name}`,
+                command: 'node main.js',
+            },
+        },
+    };
+    fs.writeFileSync(projectJsonPath, JSON.stringify(projectJson, null, 2) + '\n');
+    logger_1.Logger.info((0, i18n_1.getStarterTranslation)(i18n_1.StarterStringKey.PROJECT_ADDED_TARGETS, {
+        name: apiProject.name,
+    }));
+}
+/** Configure inituserdb project.json targets */
+function configureInitUserDbProjectJson(projects, monorepoPath) {
+    const initUserDbProject = projects.find((p) => p.type === 'inituserdb' && p.enabled);
+    if (!initUserDbProject)
+        return;
+    const projectJsonPath = path.join(monorepoPath, initUserDbProject.name, 'project.json');
+    if (!fs.existsSync(projectJsonPath))
+        return;
+    const projectJson = JSON.parse(fs.readFileSync(projectJsonPath, 'utf-8'));
+    if (projectJson.targets?.build?.options) {
+        projectJson.targets.build.options.skipTypeCheck = true;
+        projectJson.targets.build.options.format = ['esm'];
+        delete projectJson.targets.build.options.platform;
+        projectJson.targets.build.options.bundle = true;
+        projectJson.targets.build.options.thirdParty = false;
+        projectJson.targets.build.options.generatePackageJson = false;
+        if (!projectJson.targets.build.options.esbuildOptions) {
+            projectJson.targets.build.options.esbuildOptions = {};
+        }
+        projectJson.targets.build.options.esbuildOptions.external = [
+            '@digitaldefiance/*',
+        ];
+        if (projectJson.targets.build.configurations?.production) {
+            if (!projectJson.targets.build.configurations.production.esbuildOptions) {
+                projectJson.targets.build.configurations.production.esbuildOptions =
+                    {};
+            }
+            projectJson.targets.build.configurations.production.esbuildOptions.external =
+                ['@digitaldefiance/*'];
+        }
+    }
+    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: {
+            command: `cp ${initUserDbProject.name}/.env dist/${initUserDbProject.name}/.env`,
+        },
+    };
+    projectJson.targets.serve = {
+        executor: 'nx:run-commands',
+        defaultConfiguration: 'development',
+        dependsOn: ['post-build'],
+        options: {
+            command: `node dist/${initUserDbProject.name}/main.js`,
+            cwd: '{workspaceRoot}',
+        },
+        configurations: {
+            development: {
+                command: `node dist/${initUserDbProject.name}/main.js`,
+            },
+            production: {
+                command: `node dist/${initUserDbProject.name}/main.js`,
+            },
+        },
+    };
+    fs.writeFileSync(projectJsonPath, JSON.stringify(projectJson, null, 2) + '\n');
+    logger_1.Logger.info((0, i18n_1.getStarterTranslation)(i18n_1.StarterStringKey.PROJECT_ADDED_TARGETS, {
+        name: initUserDbProject.name,
+    }));
+}
+/** Configure react project.json targets */
+function configureReactProjectJson(projects, monorepoPath) {
+    const reactProject = projects.find((p) => p.type === 'react' && p.enabled);
+    if (!reactProject)
+        return;
+    const projectJsonPath = path.join(monorepoPath, reactProject.name, 'project.json');
+    if (!fs.existsSync(projectJsonPath))
+        return;
+    const projectJson = JSON.parse(fs.readFileSync(projectJsonPath, 'utf-8'));
+    if (!projectJson.targets) {
+        projectJson.targets = {};
+    }
+    projectJson.targets['build'] = {
+        executor: 'nx:run-commands',
+        dependsOn: ['^build'],
+        cache: true,
+        outputs: [`{workspaceRoot}/dist/${reactProject.name}`],
+        options: {
+            cwd: reactProject.name,
+            command: 'vite build --mode development',
+        },
+        configurations: {
+            development: { command: 'vite build --mode development' },
+            production: { command: 'vite build --mode production' },
+        },
+    };
+    fs.writeFileSync(projectJsonPath, JSON.stringify(projectJson, null, 2) + '\n');
+    logger_1.Logger.info((0, i18n_1.getStarterTranslation)(i18n_1.StarterStringKey.PROJECT_ADDED_TARGETS, {
+        name: reactProject.name,
+    }));
+    // Update vite.config.ts to handle mode properly
+    const viteConfigPath = path.join(monorepoPath, reactProject.name, 'vite.config.ts');
+    if (fs.existsSync(viteConfigPath)) {
+        let viteConfig = fs.readFileSync(viteConfigPath, 'utf-8');
+        viteConfig = viteConfig.replace(/export default defineConfig\(\(\) => \(\{/, 'export default defineConfig(({ mode }) => ({');
+        if (!viteConfig.includes('mode:')) {
+            viteConfig = viteConfig.replace(/cacheDir: '[^']*',/, `cacheDir: '../node_modules/.vite/${reactProject.name}',\n  mode: mode || process.env.NODE_ENV || 'production',`);
+        }
+        if (!viteConfig.includes('minify:')) {
+            viteConfig = viteConfig.replace(/commonjsOptions: \{[^}]*\},/, `commonjsOptions: {\n      transformMixedEsModules: true,\n    },\n    minify: mode === 'production' ? ('esbuild' as const) : false,`);
+        }
+        viteConfig = viteConfig.replace(/\}\);(\s*)$/, '}));$1');
+        fs.writeFileSync(viteConfigPath, viteConfig);
+    }
+}
+/** Setup .env files for api, inituserdb, and devcontainer */
+function setupEnvironmentFiles(params) {
+    const { projects, monorepoPath, workspaceName, devcontainerChoice, mongoPassword, useInMemoryDb, devDatabaseName, jwtSecret, mnemonicEncryptionKey, mnemonicHmacSecret, } = params;
+    const apiProject = projects.find((p) => p.type === 'api');
+    const initUserDbProject = projects.find((p) => p.type === 'inituserdb');
+    const escapeEnvValue = (value) => {
+        const escaped = value.replace(/'/g, "'\\''");
+        return `'${escaped}'`;
+    };
+    const buildMongoUri = (dbName) => {
+        const auth = mongoPassword
+            ? `admin:${encodeURIComponent(mongoPassword)}@`
+            : '';
+        const mongoParams = devcontainerChoice === 'mongodb-replicaset'
+            ? '?authSource=admin&replicaSet=rs0&directConnection=true'
+            : '?authSource=admin&directConnection=true';
+        return `mongodb://${auth}db:27017/${dbName}${mongoParams}`;
+    };
+    // 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)) {
+            let envContent = fs.readFileSync(envExamplePath, 'utf-8');
+            if (useInMemoryDb) {
+                envContent = envContent.replace(/DEV_DATABASE=.*/g, `DEV_DATABASE=${devDatabaseName}`);
+            }
+            else {
+                envContent = envContent.replace(/DEV_DATABASE=.*/g, 'DEV_DATABASE=');
+            }
+            envContent = envContent.replace(/JWT_SECRET=.*/g, `JWT_SECRET=${jwtSecret}`);
+            envContent = envContent.replace(/MNEMONIC_ENCRYPTION_KEY=.*/g, `MNEMONIC_ENCRYPTION_KEY=${mnemonicEncryptionKey}`);
+            envContent = envContent.replace(/MNEMONIC_HMAC_SECRET=.*/g, `MNEMONIC_HMAC_SECRET=${mnemonicHmacSecret}`);
+            if (devcontainerChoice === 'mongodb' ||
+                devcontainerChoice === 'mongodb-replicaset') {
+                const mongoUri = buildMongoUri(workspaceName);
+                envContent = envContent.replace(/MONGO_URI=.*/g, `MONGO_URI=${mongoUri}`);
+            }
+            if (devcontainerChoice === 'mongodb-replicaset') {
+                envContent = envContent.replace(/MONGO_USE_TRANSACTIONS=.*/g, 'MONGO_USE_TRANSACTIONS=true');
+            }
+            else {
+                envContent = envContent.replace(/MONGO_USE_TRANSACTIONS=.*/g, 'MONGO_USE_TRANSACTIONS=false');
+            }
+            fs.writeFileSync(envPath, envContent);
+            logger_1.Logger.info(`Created ${apiProject.name}/.env with secrets`);
+        }
+    }
+    // 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.copyFileSync(apiEnvPath, initEnvPath);
+            logger_1.Logger.info(`Created ${initUserDbProject.name}/.env from ${apiProject.name}/.env`);
+        }
+    }
+    // Setup devcontainer .env
+    if (devcontainerChoice === 'mongodb' ||
+        devcontainerChoice === 'mongodb-replicaset') {
+        const devcontainerEnvExamplePath = path.join(monorepoPath, '.devcontainer', '.env.example');
+        const devcontainerEnvPath = path.join(monorepoPath, '.devcontainer', '.env');
+        if (fs.existsSync(devcontainerEnvExamplePath)) {
+            let envContent = fs.readFileSync(devcontainerEnvExamplePath, 'utf-8');
+            envContent = envContent.replace(/MONGO_INITDB_ROOT_PASSWORD=.*/g, `MONGO_INITDB_ROOT_PASSWORD=${escapeEnvValue(mongoPassword)}`);
+            envContent = envContent.replace(/MONGO_INITDB_DATABASE=.*/g, `MONGO_INITDB_DATABASE=${workspaceName}`);
+            envContent = envContent.replace(/COMPOSE_PROJECT_NAME=.*/g, `COMPOSE_PROJECT_NAME=${workspaceName}_devcontainer`);
+            fs.writeFileSync(devcontainerEnvPath, envContent);
+        }
+        else {
+            const envContent = `MONGO_INITDB_ROOT_PASSWORD=${escapeEnvValue(mongoPassword)}\nMONGO_INITDB_DATABASE=${workspaceName}\nCOMPOSE_PROJECT_NAME=${workspaceName}_devcontainer\n`;
+            fs.writeFileSync(devcontainerEnvPath, envContent);
+        }
+    }
+    else if (devcontainerChoice === 'simple') {
+        const devcontainerEnvExamplePath = path.join(monorepoPath, '.devcontainer', '.env.example');
+        const devcontainerEnvPath = path.join(monorepoPath, '.devcontainer', '.env');
+        if (fs.existsSync(devcontainerEnvExamplePath)) {
+            fs.copyFileSync(devcontainerEnvExamplePath, devcontainerEnvPath);
+        }
+    }
+}
+/** Build the global.d.ts content for the generated project */
+function buildGlobalDtsContent() {
+    return `/**
+ * Global ambient type declarations for Error and globalThis extensions
+ */
+declare global {
+  interface ErrorConstructor {
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+  }
+  interface Error {
+    disposedAt?: string;
+    type?: string;
+    componentId?: string;
+    reasonMap?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+  }
+  var GlobalActiveContext: any;
+}
+export {};
+`;
+}
+//# sourceMappingURL=programmatic-generator.js.map