speedrun-cli 2.6.1

package/bin/cli.js

@@ -0,0 +1,224 @@
+#!/usr/bin/env node
+/**
+ * create-nestjs-auth CLI
+ * Scaffold production-ready NestJS authentication projects
+ * 
+ * @author Sabin Shrestha <sabin.shrestha.er@gmail.com>
+ * @license MIT
+ */
+
+const { program } = require('commander');
+const fs = require('fs-extra');
+const path = require('path');
+const { execSync } = require('child_process');
+const chalk = require('chalk');
+
+// Resolve paths relative to the package root
+const packageRoot = path.join(__dirname, '..');
+
+const {
+  CLI_VERSION,
+  ORM_OPTIONS,
+  DATABASE_OPTIONS,
+  validateAppName,
+  checkNodeVersion,
+  getInstallCommand,
+  promptForProjectDetails,
+  generateProject,
+  handlePostSetup,
+  printManualInstructions,
+  generateModule,
+} = require(path.join(packageRoot, 'src'));
+
+program
+  .name('speedrun-cli')
+  .version(CLI_VERSION)
+  .description('Create a production-ready NestJS authentication system with your choice of ORM and database');
+
+// ==================== GENERATE COMMAND ====================
+program
+  .command('generate [module-name]')
+  .alias('g')
+  .description('Generate a new CRUD module')
+  .action(async (moduleName) => {
+    try {
+      console.log(chalk.cyan(`\n⚡️ create-nestjs-auth v${CLI_VERSION} Module Generator\n`));
+      await generateModule(moduleName, process.cwd());
+    } catch (error) {
+      console.error(chalk.red('\n❌ Module generation failed:'));
+      console.error(error);
+    }
+  });
+
+// ==================== MAIN SCAFFOLD COMMAND (DEFAULT) ====================
+program
+  .command('create [app-name]', { isDefault: true })
+  .description('Create a new NestJS Auth project')
+  .option('--skip-install', 'Skip automatic dependency installation')
+  .option('--package-manager <pm>', 'Package manager to use (npm|pnpm|yarn|bun)')
+  .option('--skip-git', 'Skip git repository initialization')
+  .option('--orm <orm>', 'ORM to use (prisma|typeorm|drizzle|mongoose)')
+  .option('--database <db>', 'Database to use (postgres|mysql|sqlite|mongodb)')
+  .option('--swagger', 'Add Swagger API documentation')
+  .option('--base-crud', 'Generate Base CRUD Architecture (BaseService, BaseController & Swagger helpers in src/common/base)')
+  .option('--yes', 'Skip all prompts and use defaults')
+  .action(async (appName, options) => {
+    try {
+      console.log(chalk.cyan(`\n⚡️ create-nestjs-auth v${CLI_VERSION}\n`));
+      console.log(chalk.gray('Production-ready NestJS authentication - Now with ORM & Database choices!\n'));
+
+      // Check Node.js version
+      checkNodeVersion();
+
+      // Interactive mode - prompt for missing information
+      const projectOptions = await promptForProjectDetails(appName, options);
+      appName = projectOptions.appName;
+
+      // Validate app name
+      validateAppName(appName);
+
+      const targetDir = path.join(process.cwd(), appName);
+      
+      // Check if directory exists
+      if (await fs.pathExists(targetDir)) {
+        console.error(chalk.red(`❌ Directory "${appName}" already exists`));
+        console.error(chalk.yellow('   Please choose a different name or remove the existing directory'));
+        process.exit(1);
+      }
+
+      console.log(chalk.blue(`\n🚀 Creating ${chalk.bold(appName)}...`));
+      console.log(chalk.gray(`   ORM: ${ORM_OPTIONS[projectOptions.orm]?.name || projectOptions.orm}`));
+      console.log(chalk.gray(`   Database: ${DATABASE_OPTIONS[projectOptions.database]?.name || projectOptions.database}`));
+      if (projectOptions.swagger) {
+        console.log(chalk.gray(`   Swagger: ${chalk.green('Enabled')}`));
+      }
+      if (projectOptions.baseCrud) {
+        console.log(chalk.gray(`   Base CRUD: ${chalk.green('Enabled')}`));
+      }
+      console.log('');
+
+      // Generate the project
+      await generateProject(targetDir, projectOptions);
+
+      // Update package.json
+      console.log(chalk.gray('   Updating package.json...'));
+      const packageJsonPath = path.join(targetDir, 'package.json');
+      
+      if (await fs.pathExists(packageJsonPath)) {
+        const packageJson = await fs.readJSON(packageJsonPath);
+        packageJson.name = appName;
+        packageJson.version = '0.0.1';
+        delete packageJson.private;
+        await fs.writeJSON(packageJsonPath, packageJson, { spaces: 2 });
+      }
+
+      // Create .env from .env.example
+      console.log(chalk.gray('   Setting up environment variables...'));
+      const envExamplePath = path.join(targetDir, '.env.example');
+      const envPath = path.join(targetDir, '.env');
+      
+      if (await fs.pathExists(envExamplePath)) {
+        const envExample = await fs.readFile(envExamplePath, 'utf8');
+        await fs.writeFile(envPath, envExample);
+      }
+
+      // Install dependencies
+      if (projectOptions.installDependencies) {
+        const pm = projectOptions.packageManager;
+        const installCmd = getInstallCommand(pm);
+        
+        console.log(chalk.yellow(`\n📦 Installing dependencies with ${chalk.bold(pm)}...`));
+        console.log(chalk.gray(`   Running: ${installCmd}\n`));
+        
+        try {
+          execSync(installCmd, { 
+            cwd: targetDir, 
+            stdio: 'inherit',
+            timeout: 300000,
+          });
+        } catch (error) {
+          console.error(chalk.red('\n❌ Dependency installation failed'));
+          console.error(chalk.yellow('   You can try installing manually:'));
+          console.error(chalk.cyan(`     cd ${appName}`));
+          console.error(chalk.cyan(`     ${installCmd}`));
+          process.exit(1);
+        }
+      } else {
+        console.log(chalk.gray('\n   Skipping dependency installation (--skip-install)'));
+      }
+
+      // Initialize git repository
+      if (projectOptions.initializeGit) {
+        console.log(chalk.yellow('\n🔧 Initializing git repository...'));
+        try {
+          execSync('git init', { cwd: targetDir, stdio: 'ignore' });
+          execSync('git add -A', { cwd: targetDir, stdio: 'ignore' });
+          execSync('git commit -m "Initial commit from create-nestjs-auth"', { 
+            cwd: targetDir, 
+            stdio: 'ignore',
+          });
+          console.log(chalk.gray('   Git repository initialized with initial commit'));
+        } catch {
+          console.warn(chalk.yellow('   ⚠️  Git initialization failed (git may not be installed)'));
+        }
+      } else {
+        console.log(chalk.gray('\n   Skipping git initialization (--skip-git)'));
+      }
+
+      // Post-setup interactive prompts
+      const completedInteractiveSetup = await handlePostSetup(
+        targetDir, 
+        appName, 
+        {
+          ...projectOptions,
+          skipInstall: !projectOptions.installDependencies,
+          yes: options.yes,
+        }
+      );
+
+      // Show manual instructions if interactive setup was skipped
+      if (!completedInteractiveSetup) {
+        printManualInstructions(appName, projectOptions);
+      } else {
+        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'));
+        if (projectOptions.swagger) {
+          console.log(chalk.cyan('📄 Swagger docs: http://localhost:8080/api/docs'));
+        }
+        if (projectOptions.baseCrud) {
+          console.log(chalk.cyan('🏗️  Base CRUD: src/common/base/ — see CRUD_README.md'));
+        }
+        console.log(chalk.magenta('\nHappy coding! 🎉\n'));
+
+        // Post-setup module generation hook
+        if (projectOptions.baseCrud) {
+          const inquirer = require('inquirer');
+          const { generateNow } = await inquirer.prompt([{
+            type: 'confirm',
+            name: 'generateNow',
+            message: 'Do you want to generate your first CRUD module now?',
+            default: true
+          }]);
+          
+          if (generateNow) {
+            await generateModule(undefined, targetDir, projectOptions.orm);
+          }
+        }
+      }
+
+    } catch (error) {
+      console.error(chalk.red('\n❌ An unexpected error occurred:'));
+      console.error(chalk.red(`   ${error.message}`));
+      
+      if (error.stack && process.env.DEBUG) {
+        console.error(chalk.gray('\n   Stack trace:'));
+        console.error(chalk.gray(error.stack));
+      }
+      
+      console.error(chalk.yellow('\n   If this persists, please report it:'));
+      console.error(chalk.cyan('   https://github.com/masabinhok/create-nestjs-auth/issues\n'));
+      process.exit(1);
+    }
+  });
+
+program.parse(process.argv);

package/index.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+/**
+ * create-nestjs-auth CLI
+ * 
+ * Entry point for npx/npm execution.
+ * All logic has been modularized into src/ directory.
+ * 
+ * @see ./bin/cli.js for the main CLI implementation
+ * @see ./src/ for modular source code
+ */
+
+require('./bin/cli');

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "speedrun-cli",
+  "version": "2.6.1",
+  "description": "CLI tool to scaffold a production-ready NestJS authentication system with JWT, refresh tokens, and RBAC",
+  "keywords": [
+    "nestjs",
+    "authentication",
+    "jwt",
+    "auth",
+    "boilerplate",
+    "starter",
+    "template",
+    "rbac",
+    "refresh-token",
+    "prisma",
+    "drizzle",
+    "typeorm",
+    "mongoose",
+    "postgresql",
+    "mysql",
+    "mongodb",
+    "sqlite",
+    "cli",
+    "scaffold",
+    "generator"
+  ],
+  "author": {
+    "name": "Sabin Shrestha",
+    "email": "sabin.shrestha.er@gmail.com",
+    "url": "https://sabinshrestha69.com.np"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/masabinhok/create-nestjs-auth#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/masabinhok/create-nestjs-auth.git"
+  },
+  "bugs": {
+    "url": "https://github.com/masabinhok/create-nestjs-auth/issues"
+  },
+  "bin": {
+    "create-nestjs-auth": "./index.js"
+  },
+  "main": "./index.js",
+  "type": "commonjs",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "scripts": {
+    "test": "node index.js test-output --skip-install --skip-git --yes",
+    "test:full": "node index.js test-output",
+    "test:prisma": "node index.js test-prisma --orm prisma --database postgres --skip-install --skip-git --yes",
+    "test:drizzle": "node index.js test-drizzle --orm drizzle --database postgres --skip-install --skip-git --yes",
+    "test:typeorm": "node index.js test-typeorm --orm typeorm --database postgres --skip-install --skip-git --yes",
+    "test:mongoose": "node index.js test-mongoose --orm mongoose --skip-install --skip-git --yes",
+    "clean": "node -e \"require('fs-extra').removeSync('test-output'); require('fs-extra').removeSync('test-prisma'); require('fs-extra').removeSync('test-drizzle'); require('fs-extra').removeSync('test-typeorm'); require('fs-extra').removeSync('test-mongoose');\"",
+    "prepublishOnly": "npm run clean && echo 'Ready to publish create-nestjs-auth'"
+  },
+  "files": [
+    "index.js",
+    "bin/",
+    "src/",
+    "templates/",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^14.0.0",
+    "fs-extra": "^11.2.0",
+    "inquirer": "^8.2.6"
+  }
+}

package/src/constants.js

@@ -0,0 +1,65 @@
+/**
+ * CLI Constants and Configuration
+ * @module constants
+ */
+
+const ORM_OPTIONS = {
+  prisma: {
+    name: 'Prisma',
+    description: 'Next-generation ORM with type safety',
+    databases: ['postgres', 'mysql', 'sqlite'],
+  },
+  typeorm: {
+    name: 'TypeORM',
+    description: 'Traditional ORM with decorators',
+    databases: ['postgres', 'mysql', 'sqlite'],
+  },
+  drizzle: {
+    name: 'Drizzle',
+    description: 'Lightweight TypeScript ORM',
+    databases: ['postgres', 'mysql', 'sqlite'],
+  },
+  mongoose: {
+    name: 'Mongoose',
+    description: 'MongoDB ODM (MongoDB only)',
+    databases: ['mongodb'],
+    fixedDatabase: true,
+  },
+};
+
+const DATABASE_OPTIONS = {
+  postgres: {
+    name: 'PostgreSQL',
+    urlTemplate: 'postgresql://user:password@localhost:5432/database_name',
+    urlPrefix: ['postgresql://', 'postgres://'],
+  },
+  mysql: {
+    name: 'MySQL',
+    urlTemplate: 'mysql://user:password@localhost:3306/database_name',
+    urlPrefix: ['mysql://'],
+  },
+  sqlite: {
+    name: 'SQLite',
+    urlTemplate: 'file:./dev.db',
+    urlPrefix: ['file:'],
+    devOnly: true,
+  },
+  mongodb: {
+    name: 'MongoDB',
+    urlTemplate: 'mongodb://user:password@localhost:27017/database_name',
+    urlPrefix: ['mongodb://', 'mongodb+srv://'],
+  },
+};
+
+const RESERVED_NAMES = ['node_modules', 'favicon.ico'];
+
+const path = require('path');
+const packageJson = require(path.join(__dirname, '..', 'package.json'));
+const CLI_VERSION = packageJson.version;
+
+module.exports = {
+  ORM_OPTIONS,
+  DATABASE_OPTIONS,
+  RESERVED_NAMES,
+  CLI_VERSION,
+};

package/src/generator.js

@@ -0,0 +1,271 @@
+/**
+ * Project Generation Logic
+ * @module generator
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const { ORM_OPTIONS } = require('./constants');
+
+/**
+ * Generates the project by merging base, ORM, and database templates
+ * @param {string} targetDir - Target directory for the project
+ * @param {object} options - Generation options
+ */
+async function generateProject(targetDir, options) {
+  const { orm, database, swagger, baseCrud } = options;
+  const templatesDir = path.join(__dirname, '..', 'templates');
+
+  const baseDir = path.join(templatesDir, 'base');
+  const ormDir = path.join(templatesDir, 'orm', orm);
+  const dbDir = path.join(templatesDir, 'database', database);
+  const swaggerDir = path.join(templatesDir, 'swagger');
+  const swaggerMongooseDir = path.join(templatesDir, 'swagger-mongoose');
+
+  const useNewStructure = await fs.pathExists(baseDir);
+
+  if (useNewStructure) {
+    await generateFromModularTemplates(targetDir, { baseDir, ormDir, dbDir, orm, swagger, swaggerDir, swaggerMongooseDir, baseCrud });
+  } else {
+    await generateFromLegacyTemplate(targetDir);
+  }
+}
+
+/**
+ * Generates project from modular template structure
+ * @param {string} targetDir - Target directory
+ * @param {object} dirs - Directory paths
+ */
+async function generateFromModularTemplates(targetDir, { baseDir, ormDir, dbDir, orm, swagger, swaggerDir, swaggerMongooseDir, baseCrud }) {
+  console.log(chalk.gray('   Using modular template structure...'));
+
+  // Ensure target directory exists
+  await fs.ensureDir(targetDir);
+
+  // Step 1: Copy base template
+  console.log(chalk.gray('   Copying base template...'));
+  await fs.copy(baseDir, targetDir, {
+    filter: createCopyFilter(baseDir),
+  });
+
+  // Step 2: Rename gitignore to .gitignore (npm excludes .gitignore files from packages)
+  const gitignoreSrc = path.join(targetDir, 'gitignore');
+  const gitignoreDest = path.join(targetDir, '.gitignore');
+  if (await fs.pathExists(gitignoreSrc)) {
+    await fs.rename(gitignoreSrc, gitignoreDest);
+  }
+
+  // Step 3: Apply ORM adapter
+  if (await fs.pathExists(ormDir)) {
+    console.log(chalk.gray(`   Applying ${ORM_OPTIONS[orm]?.name || orm} adapter...`));
+    await fs.copy(ormDir, targetDir, {
+      overwrite: true,
+      filter: createCopyFilter(ormDir, ['package.json']),
+    });
+
+    await mergePackageJson(ormDir, targetDir);
+  }
+
+  // Step 4: Apply database configuration
+  if (await fs.pathExists(dbDir)) {
+    console.log(chalk.gray(`   Configuring database...`));
+    await fs.copy(dbDir, targetDir, {
+      overwrite: true,
+      filter: createOrmSpecificFilter(orm, dbDir),
+    });
+
+    await mergePackageJson(dbDir, targetDir, true);
+  }
+
+  // Step 5: Apply Swagger documentation overlay
+  if (swagger) {
+    console.log(chalk.gray('   Adding Swagger documentation...'));
+    if (await fs.pathExists(swaggerDir)) {
+      await fs.copy(swaggerDir, targetDir, {
+        overwrite: true,
+        filter: createCopyFilter(swaggerDir),
+      });
+    }
+
+    // Apply ORM-specific Swagger overrides (e.g., Mongoose DTOs)
+    if (orm === 'mongoose' && await fs.pathExists(swaggerMongooseDir)) {
+      await fs.copy(swaggerMongooseDir, targetDir, {
+        overwrite: true,
+        filter: createCopyFilter(swaggerMongooseDir),
+      });
+    }
+
+    // Add Swagger dependencies to package.json
+    await addSwaggerDependencies(targetDir);
+  }
+
+  // Step 6: Apply Base CRUD Architecture overlay
+  if (baseCrud) {
+    // 6a. Shared layer: abstract base + shared DTOs + shared controller
+    const baseCrudDir = path.join(__dirname, '..', 'templates', 'base-crud');
+    if (await fs.pathExists(baseCrudDir)) {
+      console.log(chalk.gray('   Adding Base CRUD Architecture (abstract layer + shared DTOs)...'));
+      await fs.copy(baseCrudDir, targetDir, {
+        overwrite: true,
+        filter: createCopyFilter(baseCrudDir),
+      });
+    }
+
+    // 6b. ORM-specific ProductModule example (overrides products.service.ts + module)
+    const baseCrudOrmDir = path.join(__dirname, '..', 'templates', `base-crud-${orm}`);
+    if (await fs.pathExists(baseCrudOrmDir)) {
+      console.log(chalk.gray(`   Adding ${ORM_OPTIONS[orm]?.name || orm} ProductModule example...`));
+      await fs.copy(baseCrudOrmDir, targetDir, {
+        overwrite: true,
+        filter: createCopyFilter(baseCrudOrmDir),
+      });
+    }
+  }
+}
+
+/**
+ * Generates project from legacy single-template structure
+ * @param {string} targetDir - Target directory
+ */
+async function generateFromLegacyTemplate(targetDir) {
+  console.log(chalk.gray('   Using legacy template structure...'));
+  const templateDir = path.join(__dirname, '..', 'template');
+
+  if (!(await fs.pathExists(templateDir))) {
+    console.error(chalk.red('❌ Template directory not found'));
+    console.error(chalk.yellow('   Please reinstall create-nestjs-auth: npm install -g create-nestjs-auth'));
+    process.exit(1);
+  }
+
+  await fs.copy(templateDir, targetDir, {
+    filter: (src) => {
+      const relativePath = path.relative(templateDir, src);
+      const basename = path.basename(src);
+      if (basename === '.gitignore') return true;
+      return !relativePath.startsWith('.git' + path.sep) &&
+        relativePath !== '.git' &&
+        !relativePath.includes('node_modules') &&
+        !relativePath.includes('dist');
+    },
+  });
+}
+
+/**
+ * Creates a copy filter function
+ * @param {string} baseDir - The base directory being copied from
+ * @param {Array<string>} excludeFiles - Additional files to exclude
+ * @returns {function} Filter function
+ */
+function createCopyFilter(baseDir, excludeFiles = []) {
+  return (src) => {
+    const basename = path.basename(src);
+    const relativePath = path.relative(baseDir, src);
+
+    // Allow gitignore (renamed from .gitignore for npm compatibility)
+    if (basename === 'gitignore' || basename === '.gitignore') return true;
+    if (excludeFiles.includes(basename)) return false;
+
+    // Check for node_modules and .git only within the template directory
+    return !relativePath.includes('node_modules') &&
+      !relativePath.includes(path.sep + '.git') &&
+      basename !== '.git';
+  };
+}
+
+/**
+ * Creates ORM-specific filter for database templates
+ * @param {string} orm - Selected ORM
+ * @param {string} dbDir - Database directory path
+ * @returns {function} Filter function
+ */
+function createOrmSpecificFilter(orm, dbDir) {
+  const drizzleFiles = ['drizzle.config.ts', 'drizzle'];
+  const prismaFiles = ['prisma'];
+
+  return (src) => {
+    const basename = path.basename(src);
+    const relativePath = path.relative(dbDir, src);
+
+    // Allow gitignore (renamed from .gitignore for npm compatibility)
+    if (basename === 'gitignore' || basename === '.gitignore') return true;
+    // Check for node_modules only within the template directory (not in the CLI install path)
+    if (relativePath.includes('node_modules') || basename === 'package.json') return false;
+
+    // Filter based on ORM
+    if (orm === 'prisma') {
+      if (drizzleFiles.some((f) => relativePath.startsWith(f) || basename === f)) return false;
+      if (relativePath.includes('src' + path.sep + 'database')) return false;
+    } else if (orm === 'drizzle') {
+      if (prismaFiles.some((f) => relativePath.startsWith(f) || basename === f)) return false;
+    } else if (orm === 'typeorm' || orm === 'mongoose') {
+      if (drizzleFiles.some((f) => relativePath.startsWith(f) || basename === f)) return false;
+      if (prismaFiles.some((f) => relativePath.startsWith(f) || basename === f)) return false;
+      if (relativePath.includes('src' + path.sep + 'database')) return false;
+    }
+
+    return true;
+  };
+}
+
+/**
+ * Merges package.json files
+ * @param {string} sourceDir - Source directory
+ * @param {string} targetDir - Target directory
+ * @param {boolean} dependenciesOnly - Only merge dependencies
+ */
+async function mergePackageJson(sourceDir, targetDir, dependenciesOnly = false) {
+  const sourcePackageJsonPath = path.join(sourceDir, 'package.json');
+  const targetPackageJsonPath = path.join(targetDir, 'package.json');
+
+  if (!(await fs.pathExists(sourcePackageJsonPath))) return;
+
+  const sourcePackageJson = await fs.readJSON(sourcePackageJsonPath);
+  let targetPackageJson = {};
+
+  // Ensure target directory exists before writing
+  await fs.ensureDir(targetDir);
+
+  if (await fs.pathExists(targetPackageJsonPath)) {
+    targetPackageJson = await fs.readJSON(targetPackageJsonPath);
+  }
+
+  if (dependenciesOnly) {
+    targetPackageJson = {
+      ...targetPackageJson,
+      dependencies: { ...targetPackageJson.dependencies, ...sourcePackageJson.dependencies },
+      devDependencies: { ...targetPackageJson.devDependencies, ...sourcePackageJson.devDependencies },
+    };
+  } else {
+    targetPackageJson = {
+      ...targetPackageJson,
+      ...sourcePackageJson,
+      dependencies: { ...targetPackageJson.dependencies, ...sourcePackageJson.dependencies },
+      devDependencies: { ...targetPackageJson.devDependencies, ...sourcePackageJson.devDependencies },
+      scripts: { ...targetPackageJson.scripts, ...sourcePackageJson.scripts },
+    };
+  }
+
+  await fs.writeJSON(targetPackageJsonPath, targetPackageJson, { spaces: 2 });
+}
+
+/**
+ * Adds Swagger dependencies to the project's package.json
+ * @param {string} targetDir - Target directory
+ */
+async function addSwaggerDependencies(targetDir) {
+  const packageJsonPath = path.join(targetDir, 'package.json');
+  if (!(await fs.pathExists(packageJsonPath))) return;
+
+  const packageJson = await fs.readJSON(packageJsonPath);
+  packageJson.dependencies = {
+    ...packageJson.dependencies,
+    '@nestjs/swagger': '^11.0.0',
+    'swagger-ui-express': '^5.0.1',
+  };
+  await fs.writeJSON(packageJsonPath, packageJson, { spaces: 2 });
+}
+
+module.exports = {
+  generateProject,
+};

package/src/index.js

@@ -0,0 +1,13 @@
+/**
+ * Module exports for CLI source files
+ * @module src
+ */
+
+module.exports = {
+  ...require('./constants'),
+  ...require('./utils'),
+  ...require('./prompts'),
+  ...require('./generator'),
+  ...require('./postSetup'),
+  ...require('./moduleGenerator'),
+};