speedrun-cli 2.6.1

package/src/postSetup.js

@@ -0,0 +1,365 @@
+/**
+ * Post-Setup Interactive Handlers
+ * @module postSetup
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const { execSync } = require('child_process');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const { ORM_OPTIONS, DATABASE_OPTIONS } = require('./constants');
+const { generateJWTSecret, getRunPrefix } = require('./utils');
+
+/**
+ * Handles interactive post-setup configuration
+ * @param {string} targetDir - Project directory
+ * @param {string} appName - Application name
+ * @param {object} options - Configuration options
+ * @returns {Promise<boolean>} Whether interactive setup completed
+ */
+async function handlePostSetup(targetDir, appName, options) {
+  const { packageManager, orm, database, swagger, baseCrud, yes: isYesMode, skipInstall } = options;
+
+  if (isYesMode || skipInstall) {
+    return false;
+  }
+
+  printSuccessHeader(appName, orm, database, swagger, baseCrud);
+
+  const { continueSetup } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'continueSetup',
+    message: 'Would you like to complete the setup now? (JWT secrets, database, etc.)',
+    default: true,
+  }]);
+
+  if (!continueSetup) {
+    return false;
+  }
+
+  // Configure JWT secrets and database URL
+  await configureEnvironment(targetDir, database);
+
+  // ORM-specific database setup
+  await setupDatabase(targetDir, orm, packageManager);
+
+  // Optionally start dev server
+  await promptDevServer(targetDir, packageManager);
+
+  return true;
+}
+
+/**
+ * Prints the success header
+ */
+function printSuccessHeader(appName, orm, database, swagger, baseCrud) {
+  console.log(chalk.green('\n✅ Success! Created ' + chalk.bold(appName)));
+  console.log(chalk.gray(`   ORM: ${ORM_OPTIONS[orm]?.name || orm}`));
+  console.log(chalk.gray(`   Database: ${DATABASE_OPTIONS[database]?.name || database}`));
+  if (swagger) {
+    console.log(chalk.gray(`   Swagger: ${chalk.green('Enabled')}`));
+  }
+  if (baseCrud) {
+    console.log(chalk.gray(`   Base CRUD Architecture: ${chalk.green('Enabled')} — src/common/base/`));
+  }
+  console.log(chalk.white('\n🎉 Your project is ready!\n'));
+}
+
+/**
+ * Configures environment variables
+ */
+async function configureEnvironment(targetDir, database) {
+  console.log(chalk.yellow('\n🔑 Generating JWT secrets...\n'));
+  const accessSecret = generateJWTSecret();
+  const refreshSecret = generateJWTSecret();
+  
+  console.log(chalk.gray('   Generated JWT_ACCESS_SECRET'));
+  console.log(chalk.gray('   Generated JWT_REFRESH_SECRET\n'));
+
+  const dbInfo = DATABASE_OPTIONS[database];
+  const { databaseUrl } = await inquirer.prompt([{
+    type: 'input',
+    name: 'databaseUrl',
+    message: `Enter your ${dbInfo.name} database URL:`,
+    default: dbInfo.urlTemplate,
+    validate: (input) => {
+      if (!input || input.trim() === '') {
+        return 'Database URL is required';
+      }
+      const validPrefix = dbInfo.urlPrefix.some((prefix) => input.startsWith(prefix));
+      if (!validPrefix) {
+        return `Database URL must start with ${dbInfo.urlPrefix.join(' or ')}`;
+      }
+      return true;
+    },
+  }]);
+
+  // Update .env file
+  console.log(chalk.gray('\n   Updating .env file...'));
+  const envPath = path.join(targetDir, '.env');
+  
+  try {
+    let envContent = await fs.readFile(envPath, 'utf8');
+    envContent = envContent.replace(/DATABASE_URL=.*/, `DATABASE_URL="${databaseUrl}"`);
+    envContent = envContent.replace(/JWT_ACCESS_SECRET=.*/, `JWT_ACCESS_SECRET="${accessSecret}"`);
+    envContent = envContent.replace(/JWT_REFRESH_SECRET=.*/, `JWT_REFRESH_SECRET="${refreshSecret}"`);
+    await fs.writeFile(envPath, envContent);
+    console.log(chalk.green('   ✓ Environment variables configured\n'));
+  } catch {
+    console.error(chalk.red('   ✗ Failed to update .env file'));
+  }
+}
+
+/**
+ * Sets up the database based on selected ORM
+ */
+async function setupDatabase(targetDir, orm, packageManager) {
+  const setupHandlers = {
+    prisma: setupPrisma,
+    typeorm: setupTypeOrm,
+    mongoose: setupMongoose,
+    drizzle: setupDrizzle,
+  };
+
+  const handler = setupHandlers[orm];
+  if (handler) {
+    await handler(targetDir, packageManager);
+  }
+}
+
+async function setupPrisma(targetDir, packageManager) {
+  const { setupDatabase } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'setupDatabase',
+    message: 'Set up the database now? (generate Prisma client, run migrations, seed)',
+    default: true,
+  }]);
+
+  if (!setupDatabase) return;
+
+  // Prompt for migration name before running prisma commands
+  const { migrationName } = await inquirer.prompt([{
+    type: 'input',
+    name: 'migrationName',
+    message: 'Enter migration name:',
+    default: 'init',
+    validate: (input) => {
+      if (!input || input.trim() === '') {
+        return 'Migration name is required';
+      }
+      if (!/^[a-zA-Z0-9_-]+$/.test(input)) {
+        return 'Migration name can only contain letters, numbers, underscores, and hyphens';
+      }
+      return true;
+    },
+  }]);
+
+  console.log(chalk.yellow('\n📦 Setting up database...\n'));
+  const pmPrefix = getRunPrefix(packageManager);
+
+  try {
+    console.log(chalk.gray('   Generating Prisma client...'));
+    execSync(`${pmPrefix} prisma:generate`, { cwd: targetDir, stdio: 'inherit' });
+    
+    console.log(chalk.gray('\n   Running database migrations...'));
+    // Run prisma directly with --name to avoid double prompt
+    execSync(`npx prisma migrate dev --name ${migrationName}`, { cwd: targetDir, stdio: 'inherit' });
+    
+    console.log(chalk.gray('\n   Seeding database...'));
+    execSync(`${pmPrefix} prisma:seed`, { cwd: targetDir, stdio: 'inherit' });
+    
+    printCredentials();
+  } catch {
+    console.error(chalk.red('\n   ✗ Database setup failed'));
+    console.error(chalk.yellow('   Run these commands manually:'));
+    console.error(chalk.gray(`     ${pmPrefix} prisma:generate`));
+    console.error(chalk.gray(`     ${pmPrefix} prisma:migrate`));
+    console.error(chalk.gray(`     ${pmPrefix} prisma:seed\n`));
+  }
+}
+
+async function setupTypeOrm(targetDir, packageManager) {
+  const { setupDatabase } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'setupDatabase',
+    message: 'Set up the database now? (sync schema, seed)',
+    default: true,
+  }]);
+
+  if (!setupDatabase) return;
+
+  console.log(chalk.yellow('\n📦 Setting up database...\n'));
+  const pmPrefix = getRunPrefix(packageManager);
+
+  try {
+    console.log(chalk.gray('   Synchronizing database schema...'));
+    execSync(`${pmPrefix} schema:sync`, { cwd: targetDir, stdio: 'inherit' });
+    
+    console.log(chalk.gray('\n   Seeding database...'));
+    execSync(`${pmPrefix} seed`, { cwd: targetDir, stdio: 'inherit' });
+    
+    printCredentials();
+  } catch {
+    console.error(chalk.red('\n   ✗ Database setup failed'));
+    console.error(chalk.yellow('   Run these commands manually:'));
+    console.error(chalk.gray(`     ${pmPrefix} schema:sync`));
+    console.error(chalk.gray(`     ${pmPrefix} seed\n`));
+  }
+}
+
+async function setupMongoose(targetDir, packageManager) {
+  const { setupDatabase } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'setupDatabase',
+    message: 'Seed the database now? (create default admin user)',
+    default: true,
+  }]);
+
+  if (!setupDatabase) return;
+
+  console.log(chalk.yellow('\n📦 Setting up database...\n'));
+  const pmPrefix = getRunPrefix(packageManager);
+
+  try {
+    console.log(chalk.gray('   Seeding database...'));
+    execSync(`${pmPrefix} db:seed`, { cwd: targetDir, stdio: 'inherit' });
+    
+    printCredentials();
+  } catch {
+    console.error(chalk.red('\n   ✗ Database setup failed'));
+    console.error(chalk.yellow('   Run this command manually:'));
+    console.error(chalk.gray(`     ${pmPrefix} db:seed\n`));
+  }
+}
+
+async function setupDrizzle(targetDir, packageManager) {
+  const { setupDatabase } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'setupDatabase',
+    message: 'Set up the database now? (push schema, seed)',
+    default: true,
+  }]);
+
+  if (!setupDatabase) return;
+
+  console.log(chalk.yellow('\n📦 Setting up database...\n'));
+  const pmPrefix = getRunPrefix(packageManager);
+
+  try {
+    console.log(chalk.gray('   Pushing schema to database...'));
+    execSync(`${pmPrefix} db:push`, { cwd: targetDir, stdio: 'inherit' });
+    
+    console.log(chalk.gray('\n   Seeding database...'));
+    execSync(`${pmPrefix} db:seed`, { cwd: targetDir, stdio: 'inherit' });
+    
+    printCredentials();
+  } catch {
+    console.error(chalk.red('\n   ✗ Database setup failed'));
+    console.error(chalk.yellow('   Run these commands manually:'));
+    console.error(chalk.gray(`     ${pmPrefix} db:push`));
+    console.error(chalk.gray(`     ${pmPrefix} db:seed\n`));
+  }
+}
+
+/**
+ * Prints default admin credentials
+ */
+function printCredentials() {
+  console.log(chalk.green('\n   ✓ Database setup complete!\n'));
+  console.log(chalk.cyan('   📝 Default admin credentials:'));
+  console.log(chalk.white('      Email:    admin@example.com'));
+  console.log(chalk.white('      Password: Admin@123\n'));
+}
+
+/**
+ * Prompts user to start dev server
+ */
+async function promptDevServer(targetDir, packageManager) {
+  const { startServer } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'startServer',
+    message: 'Start the development server now?',
+    default: false,
+  }]);
+
+  if (!startServer) return;
+
+  console.log(chalk.yellow('\n🚀 Starting development server...\n'));
+  console.log(chalk.gray(`   Your API will be available at: ${chalk.cyan('http://localhost:8080/api/v1')}`));
+  console.log(chalk.gray(`   Press ${chalk.bold('Ctrl+C')} to stop the server\n`));
+
+  const pmPrefix = getRunPrefix(packageManager);
+  
+  try {
+    execSync(`${pmPrefix} start:dev`, { cwd: targetDir, stdio: 'inherit' });
+  } catch {
+    console.log(chalk.yellow('\n   Server stopped.'));
+  }
+}
+
+/**
+ * Prints manual setup instructions when interactive setup is skipped
+ */
+function printManualInstructions(appName, options) {
+  const { orm, database, packageManager, installDependencies, swagger, baseCrud } = options;
+  
+  console.log(chalk.green('\n✅ Success! Created ' + chalk.bold(appName)));
+  console.log(chalk.gray(`   ORM: ${ORM_OPTIONS[orm]?.name || orm}`));
+  console.log(chalk.gray(`   Database: ${DATABASE_OPTIONS[database]?.name || database}`));
+  if (swagger) {
+    console.log(chalk.gray(`   Swagger: ${chalk.green('Enabled')}`));
+  }
+  if (baseCrud) {
+    console.log(chalk.gray(`   Base CRUD Architecture: ${chalk.green('Enabled')} — see CRUD_README.md`));
+  }
+  console.log(chalk.white('\n📚 Next steps:\n'));
+  console.log(chalk.cyan(`   cd ${appName}`));
+  
+  if (!installDependencies) {
+    const installCmd = require('./utils').getInstallCommand(packageManager);
+    console.log(chalk.cyan(`   ${installCmd}`));
+  }
+  
+  console.log(chalk.cyan('\n   # Generate secure JWT secrets (save these!):'));
+  console.log(chalk.gray('   openssl rand -base64 32  # For JWT_ACCESS_SECRET'));
+  console.log(chalk.gray('   openssl rand -base64 32  # For JWT_REFRESH_SECRET'));
+  console.log(chalk.cyan('\n   # Edit .env with your database URL and JWT secrets'));
+  
+  const ormCommands = {
+    prisma: ['prisma:generate', 'prisma:migrate', 'prisma:seed'],
+    typeorm: ['schema:sync', 'seed'],
+    mongoose: ['db:seed'],
+    drizzle: ['db:push', 'db:seed'],
+  };
+  
+  const commands = ormCommands[orm];
+  if (commands) {
+    console.log(chalk.cyan('\n   # Then setup the database:'));
+    commands.forEach((cmd) => console.log(chalk.gray(`   npm run ${cmd}`)));
+  }
+  
+  console.log(chalk.cyan('\n   # Start development server:'));
+  console.log(chalk.gray('   npm run start:dev'));
+  
+  if (swagger) {
+    console.log(chalk.cyan('\n   # Swagger API documentation:'));
+    console.log(chalk.gray('   http://localhost:8080/api/docs'));
+  }
+  
+  if (baseCrud) {
+    console.log(chalk.cyan('\n   # Base CRUD Architecture:'));
+    console.log(chalk.gray('   src/common/base/   — BaseService & BaseController'));
+    console.log(chalk.gray('   src/modules/products/  — Concrete example (ProductModule)'));
+    console.log(chalk.gray('   CRUD_README.md         — Full guide & cheatsheet'));
+  }
+  
+  console.log(chalk.white('\n📖 Documentation: https://github.com/masabinhok/create-nestjs-auth'));
+  console.log(chalk.white('🐛 Issues: https://github.com/masabinhok/create-nestjs-auth/issues\n'));
+  console.log(chalk.magenta('Happy coding! 🎉\n'));
+}
+
+module.exports = {
+  handlePostSetup,
+  printManualInstructions,
+};

package/src/prompts.js

@@ -0,0 +1,189 @@
+/**
+ * Interactive Prompt Handlers
+ * @module prompts
+ */
+
+const inquirer = require('inquirer');
+const { ORM_OPTIONS, DATABASE_OPTIONS, RESERVED_NAMES } = require('./constants');
+const { detectPackageManager } = require('./utils');
+
+/**
+ * Prompts for project configuration interactively
+ * @param {string|undefined} providedAppName - App name from CLI args
+ * @param {object} options - CLI options
+ * @returns {Promise<object>} Project configuration
+ */
+async function promptForProjectDetails(providedAppName, options) {
+  const questions = [];
+
+  // App name prompt
+  if (!providedAppName) {
+    questions.push({
+      type: 'input',
+      name: 'appName',
+      message: 'What is your project name?',
+      default: 'my-nestjs-app',
+      validate: validateAppNameInput,
+    });
+  }
+
+  // ORM selection
+  if (!options.yes) {
+    questions.push({
+      type: 'list',
+      name: 'orm',
+      message: 'Which ORM would you like to use?',
+      choices: Object.entries(ORM_OPTIONS).map(([key, value]) => ({
+        name: `${value.name} - ${value.description}`,
+        value: key,
+      })),
+      default: 'prisma',
+    });
+  }
+
+  // Database selection
+  if (!options.yes) {
+    questions.push({
+      type: 'list',
+      name: 'database',
+      message: 'Which database would you like to use?',
+      choices: (answers) => getDatabaseChoices(answers, options),
+      default: 'postgres',
+      when: (answers) => shouldShowDatabasePrompt(answers, options),
+    });
+  }
+
+  // Package manager selection
+  if (!options.packageManager && !options.yes) {
+    const detected = detectPackageManager();
+    questions.push({
+      type: 'list',
+      name: 'packageManager',
+      message: 'Which package manager would you like to use?',
+      choices: [
+        { name: `npm${detected === 'npm' ? ' (detected)' : ''}`, value: 'npm' },
+        { name: `pnpm${detected === 'pnpm' ? ' (detected)' : ''}`, value: 'pnpm' },
+        { name: `yarn${detected === 'yarn' ? ' (detected)' : ''}`, value: 'yarn' },
+        { name: `bun${detected === 'bun' ? ' (detected)' : ''}`, value: 'bun' },
+      ],
+      default: detected,
+    });
+  }
+
+  // Install dependencies prompt
+  if (!options.skipInstall && !options.yes) {
+    questions.push({
+      type: 'confirm',
+      name: 'installDependencies',
+      message: 'Install dependencies?',
+      default: true,
+    });
+  }
+
+  // Git initialization prompt
+  if (!options.skipGit && !options.yes) {
+    questions.push({
+      type: 'confirm',
+      name: 'initializeGit',
+      message: 'Initialize git repository?',
+      default: true,
+    });
+  }
+
+  // Swagger documentation prompt
+  if (!options.swagger && !options.yes) {
+    questions.push({
+      type: 'confirm',
+      name: 'swagger',
+      message: 'Add Swagger (OpenAPI) documentation?',
+      default: false,
+    });
+  }
+
+  // Base CRUD Architecture prompt
+  if (!options.baseCrud && !options.yes) {
+    questions.push({
+      type: 'confirm',
+      name: 'baseCrud',
+      message:
+        'Enable Base CRUD Architecture? (generates abstract BaseService, BaseController & Swagger helpers in src/common/base)',
+      default: false,
+    });
+  }
+
+  const answers = await inquirer.prompt(questions);
+
+  // Determine ORM and database
+  const selectedOrm = options.orm || answers.orm || 'prisma';
+  const selectedDatabase = ORM_OPTIONS[selectedOrm]?.fixedDatabase
+    ? ORM_OPTIONS[selectedOrm].databases[0]
+    : options.database || answers.database || 'postgres';
+
+  return {
+    appName: providedAppName || answers.appName,
+    orm: selectedOrm,
+    database: selectedDatabase,
+    packageManager: options.packageManager || answers.packageManager || detectPackageManager(),
+    installDependencies: options.skipInstall ? false : answers.installDependencies !== false,
+    initializeGit: options.skipGit ? false : answers.initializeGit !== false,
+    swagger: options.swagger || answers.swagger || false,
+    baseCrud: options.baseCrud || answers.baseCrud || false,
+  };
+}
+
+/**
+ * Validates app name input from inquirer
+ * @param {string} input - User input
+ * @returns {boolean|string} True if valid, error message if invalid
+ */
+function validateAppNameInput(input) {
+  if (!input || input.trim() === '') {
+    return 'Project name is required';
+  }
+  if (!/^[a-z0-9-_@/]+$/i.test(input)) {
+    return 'Project name must contain only letters, numbers, hyphens, underscores, @ and /';
+  }
+  if (input.length > 214) {
+    return 'Project name must be less than 214 characters';
+  }
+  if (RESERVED_NAMES.includes(input.toLowerCase())) {
+    return `"${input}" is a reserved name and cannot be used`;
+  }
+  return true;
+}
+
+/**
+ * Gets database choices based on selected ORM
+ * @param {object} answers - Previous answers
+ * @param {object} options - CLI options
+ * @returns {Array} Database choices for inquirer
+ */
+function getDatabaseChoices(answers, options) {
+  const selectedOrm = answers.orm || options.orm || 'prisma';
+  const supportedDatabases = ORM_OPTIONS[selectedOrm]?.databases || ['postgres'];
+
+  return supportedDatabases.map((db) => {
+    const dbInfo = DATABASE_OPTIONS[db];
+    const suffix = dbInfo.devOnly ? ' (Development only)' : '';
+    const recommended = db === 'postgres' ? ' (Recommended)' : '';
+    return {
+      name: `${dbInfo.name}${recommended}${suffix}`,
+      value: db,
+    };
+  });
+}
+
+/**
+ * Determines if database prompt should be shown
+ * @param {object} answers - Previous answers
+ * @param {object} options - CLI options
+ * @returns {boolean} Whether to show database prompt
+ */
+function shouldShowDatabasePrompt(answers, options) {
+  const selectedOrm = answers.orm || options.orm || 'prisma';
+  return !ORM_OPTIONS[selectedOrm]?.fixedDatabase;
+}
+
+module.exports = {
+  promptForProjectDetails,
+};

package/src/utils.js

@@ -0,0 +1,112 @@
+/**
+ * Utility and Validation Functions
+ * @module utils
+ */
+
+const { execSync } = require('child_process');
+const crypto = require('crypto');
+const chalk = require('chalk');
+const { RESERVED_NAMES } = require('./constants');
+
+/**
+ * Validates the application name against npm naming conventions
+ * @param {string} name - The app name to validate
+ * @throws {Error} If validation fails
+ */
+function validateAppName(name) {
+  if (!/^[a-z0-9-_@/]+$/i.test(name)) {
+    console.error(chalk.red('❌ App name must contain only letters, numbers, hyphens, underscores, @ and /'));
+    console.error(chalk.yellow('   Valid examples: my-app, @myorg/app, my_app_123'));
+    process.exit(1);
+  }
+  
+  if (name.length > 214) {
+    console.error(chalk.red('❌ App name must be less than 214 characters (npm restriction)'));
+    process.exit(1);
+  }
+
+  if (RESERVED_NAMES.includes(name.toLowerCase())) {
+    console.error(chalk.red(`❌ "${name}" is a reserved name and cannot be used`));
+    process.exit(1);
+  }
+}
+
+/**
+ * Checks if the Node.js version meets minimum requirements
+ * @throws {Error} If Node.js version is below 20.x
+ */
+function checkNodeVersion() {
+  const currentVersion = process.version;
+  const major = parseInt(currentVersion.split('.')[0].slice(1));
+  
+  if (major < 20) {
+    console.error(chalk.red(`❌ Node.js ${currentVersion} is not supported`));
+    console.error(chalk.yellow('   This template requires Node.js >= 20.x'));
+    console.error(chalk.cyan('   Please upgrade: https://nodejs.org/'));
+    process.exit(1);
+  }
+}
+
+/**
+ * Detects the available package manager in order of preference
+ * @returns {string} The detected package manager (bun, pnpm, yarn, or npm)
+ */
+function detectPackageManager() {
+  const managers = [
+    { name: 'bun', cmd: 'bun --version' },
+    { name: 'pnpm', cmd: 'pnpm --version' },
+    { name: 'yarn', cmd: 'yarn --version' },
+  ];
+
+  for (const { name, cmd } of managers) {
+    try {
+      execSync(cmd, { stdio: 'ignore' });
+      return name;
+    } catch {
+      // Continue to next package manager
+    }
+  }
+
+  return 'npm';
+}
+
+/**
+ * Returns the install command for the given package manager
+ * @param {string} packageManager - The package manager name
+ * @returns {string} The install command
+ */
+function getInstallCommand(packageManager) {
+  const commands = {
+    npm: 'npm install',
+    yarn: 'yarn install',
+    pnpm: 'pnpm install',
+    bun: 'bun install',
+  };
+  return commands[packageManager] || 'npm install';
+}
+
+/**
+ * Generates a cryptographically secure JWT secret
+ * @returns {string} A base64-encoded random string
+ */
+function generateJWTSecret() {
+  return crypto.randomBytes(32).toString('base64');
+}
+
+/**
+ * Returns the command prefix for running scripts
+ * @param {string} packageManager - The package manager name
+ * @returns {string} The command prefix (e.g., 'npm run' or 'pnpm')
+ */
+function getRunPrefix(packageManager) {
+  return packageManager === 'npm' ? 'npm run' : packageManager;
+}
+
+module.exports = {
+  validateAppName,
+  checkNodeVersion,
+  detectPackageManager,
+  getInstallCommand,
+  generateJWTSecret,
+  getRunPrefix,
+};