khushikumarigupta14-express-generator-cli 1.0.0

package/bin/cli.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { initProject } from '../lib/commands/init.js';
+import { generateModule } from '../lib/commands/generate.js';
+
+const program = new Command();
+
+program
+    .name('my-express-gen')
+    .description('CLI to scaffold Express apps and modules')
+    .version('1.0.0');
+
+program.command('init')
+    .description('Initialize a new project')
+    .argument('<project-name>', 'project name')
+    .action(initProject);
+
+const generate = program.command('generate')
+    .alias('g')
+    .description('Generate components');
+
+generate.command('module')
+    .argument('<module-name>', 'name of the module')
+    .action(generateModule);
+
+program.parse();

package/lib/commands/generate.js

@@ -0,0 +1,456 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+
+const toCamelCase = (s) => s.replace(/-./g, (x) => x[1].toUpperCase());
+const toPascalCase = (s) => s.charAt(0).toUpperCase() + toCamelCase(s.slice(1));
+
+export const generateModule = (moduleName) => {
+    if (!moduleName) {
+        console.error(chalk.red('Please provide a module name'));
+        process.exit(1);
+    }
+
+    const ModuleName = toPascalCase(moduleName);
+    const moduleNameCamel = toCamelCase(moduleName);
+
+    // Assume we are in the project root
+    const srcPath = path.join(process.cwd(), 'src');
+    const modulesPath = path.join(srcPath, 'modules');
+    const modulePath = path.join(modulesPath, moduleName);
+
+    if (!fs.existsSync(srcPath)) {
+        console.error(chalk.red('Error: src directory not found. Are you in the project root?'));
+        process.exit(1);
+    }
+
+    if (fs.existsSync(modulePath)) {
+        console.error(chalk.red(`Module ${moduleName} already exists`));
+        process.exit(1);
+    }
+
+    // Create module directory
+    fs.mkdirSync(modulePath, { recursive: true });
+
+    const templates = {
+        docs: `import { create${ModuleName}Schema, update${ModuleName}Schema } from './${moduleName}.validation';
+
+export const ${moduleNameCamel}Docs = {
+    getAll: {
+        summary: 'Get all ${moduleName}s',
+        description: 'Retrieve a list of all ${moduleName}s with optional filtering, sorting, and pagination',
+        tags: ['${ModuleName}'],
+        responses: { 
+            200: { description: '${ModuleName}s retrieved successfully' } 
+        }
+    },
+    getById: {
+        summary: 'Get ${moduleName} by ID',
+        description: 'Retrieve a specific ${moduleName} by its ID',
+        tags: ['${ModuleName}'],
+        responses: { 
+            200: { description: '${ModuleName} retrieved successfully' },
+            404: { description: '${ModuleName} not found' }
+        }
+    },
+    create: {
+        summary: 'Create a new ${moduleName}',
+        description: 'Create a new ${moduleName} with the provided data',
+        tags: ['${ModuleName}'],
+        request: { body: { schema: create${ModuleName}Schema.shape.body } },
+        responses: { 
+            201: { description: '${ModuleName} created successfully' },
+            400: { description: 'Invalid request data' }
+        }
+    },
+    update: {
+        summary: 'Update ${moduleName}',
+        description: 'Update an existing ${moduleName} by ID',
+        tags: ['${ModuleName}'],
+        request: { body: { schema: update${ModuleName}Schema.shape.body } },
+        responses: { 
+            200: { description: '${ModuleName} updated successfully' },
+            404: { description: '${ModuleName} not found' }
+        }
+    },
+    softDelete: {
+        summary: 'Soft delete ${moduleName}',
+        description: 'Soft delete a ${moduleName} (marks as deleted but keeps in database)',
+        tags: ['${ModuleName}'],
+        responses: { 
+            200: { description: '${ModuleName} soft-deleted successfully' },
+            404: { description: '${ModuleName} not found' }
+        }
+    },
+    restore: {
+        summary: 'Restore ${moduleName}',
+        description: 'Restore a previously soft-deleted ${moduleName}',
+        tags: ['${ModuleName}'],
+        responses: { 
+            200: { description: '${ModuleName} restored successfully' },
+            404: { description: '${ModuleName} not found' }
+        }
+    },
+    toggleActive: {
+        summary: 'Toggle ${moduleName} active status',
+        description: 'Toggle the active/inactive status of a ${moduleName}',
+        tags: ['${ModuleName}'],
+        responses: { 
+            200: { description: '${ModuleName} status toggled successfully' },
+            404: { description: '${ModuleName} not found' }
+        }
+    },
+    hardDelete: {
+        summary: 'Permanently delete ${moduleName}',
+        description: 'Permanently delete a ${moduleName} from the database (cannot be undone)',
+        tags: ['${ModuleName}'],
+        responses: { 
+            200: { description: '${ModuleName} permanently deleted' },
+            404: { description: '${ModuleName} not found' }
+        }
+    }
+};
+`,
+        interface: `export interface I${ModuleName} {
+    name: string;
+    slug: string;
+    description?: string;
+    image?: string;
+    isActive: boolean;
+    isDeleted: boolean;
+    deletedAt?: Date | null;
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+`,
+        model: `import mongoose, { Schema, Document } from 'mongoose';
+import slugify from 'slugify';
+import { I${ModuleName} } from './${moduleName}.interface';
+
+export interface I${ModuleName}Doc extends I${ModuleName}, Document {
+    _id: mongoose.Types.ObjectId;
+}
+
+const ${ModuleName}Schema = new Schema<I${ModuleName}Doc>(
+    {
+        name: {
+            type: String,
+            required: [true, '${ModuleName} name is required'],
+            unique: true,
+            trim: true,
+        },
+        slug: {
+            type: String,
+            lowercase: true,
+            index: true,
+        },
+        description: {
+            type: String,
+            trim: true,
+        },
+        image: {
+            type: String,
+        },
+        isActive: {
+            type: Boolean,
+            default: true,
+        },
+        isDeleted: {
+            type: Boolean,
+            default: false,
+            index: true,
+        },
+        deletedAt: {
+            type: Date,
+            default: null,
+        },
+    },
+    {
+        timestamps: true,
+        toJSON: { virtuals: true },
+        toObject: { virtuals: true },
+    }
+);
+
+// Slugify before saving
+${ModuleName}Schema.pre('save', function (next) {
+    if (!this.isModified('name')) return next();
+    this.slug = slugify(this.name, { lower: true, strict: true });
+    next();
+});
+
+// Query middleware to filter out deleted documents by default
+${ModuleName}Schema.pre(/^find/, function (next) {
+    (this as any).find({ isDeleted: { $ne: true } });
+    next();
+});
+
+export const ${ModuleName}Model = mongoose.model<I${ModuleName}Doc>('${ModuleName}', ${ModuleName}Schema);
+`,
+        repository: `import { BaseRepository } from '../../database/base.repository';
+import { I${ModuleName} } from './${moduleName}.interface';
+import { ${ModuleName}Model } from './${moduleName}.model';
+
+export class ${ModuleName}Repository extends BaseRepository<I${ModuleName}> {
+    constructor() {
+        super(${ModuleName}Model as any);
+    }
+}
+`,
+        events: `import { eventBus } from '../../common/eventBus';
+import { I${ModuleName} } from './${moduleName}.interface';
+import { logger } from '../../common/logger';
+
+export const emit${ModuleName}Created = (data: I${ModuleName}) => {
+    eventBus.emit('${moduleName}.created', data);
+};
+
+export const register${ModuleName}Handlers = () => {
+    eventBus.on('${moduleName}.created', (data: I${ModuleName}) => {
+        logger.info(\`[Event] ${ModuleName} Created: \${data.name}\`);
+    });
+};
+`,
+        service: `import { ${ModuleName}Repository } from './${moduleName}.repository';
+import { I${ModuleName} } from './${moduleName}.interface';
+import { APIError } from '../../common/APIError';
+import { APIFeatures } from '../../common/APIFeatures';
+import { ${ModuleName}Model } from './${moduleName}.model';
+import { emit${ModuleName}Created } from './${moduleName}.events';
+
+class ${ModuleName}Service {
+    private repository: ${ModuleName}Repository;
+
+    constructor() {
+        this.repository = new ${ModuleName}Repository();
+    }
+
+    async create(data: Partial<I${ModuleName}>) {
+        const doc = await this.repository.create(data);
+        emit${ModuleName}Created(doc as I${ModuleName});
+        return doc;
+    }
+
+    async findAll(queryParams: any) {
+        const features = new APIFeatures(${ModuleName}Model.find(), queryParams)
+            .filter()
+            .search(['name', 'description'])
+            .sort()
+            .limitFields()
+            .paginate();
+
+        const docs = await features.query.lean();
+        const total = await this.repository.count(features.query.getFilter());
+
+        return {
+            results: docs.length,
+            total,
+            data: docs,
+        };
+    }
+
+    async findOne(id: string) {
+        const doc = await this.repository.findById(id);
+        if (!doc) throw new APIError('${ModuleName} not found', 404);
+        return doc;
+    }
+
+    async update(id: string, data: Partial<I${ModuleName}>) {
+        const doc = await this.repository.update(id, data);
+        if (!doc) throw new APIError('${ModuleName} not found', 404);
+        return doc;
+    }
+
+    async softDelete(id: string) {
+        const success = await this.repository.softDelete(id);
+        if (!success) throw new APIError('${ModuleName} not found', 404);
+        return success;
+    }
+
+    async restore(id: string) {
+        const success = await this.repository.restore(id);
+        if (!success) throw new APIError('${ModuleName} not found', 404);
+        return success;
+    }
+
+    async hardDelete(id: string) {
+        const success = await this.repository.delete(id);
+        if (!success) throw new APIError('${ModuleName} not found', 404);
+        return success;
+    }
+
+    async toggleActive(id: string) {
+        const doc = await this.findOne(id);
+        return await this.update(id, { isActive: !doc.isActive });
+    }
+}
+
+export const ${moduleNameCamel}Service = new ${ModuleName}Service();
+`,
+        controller: `import { Request, Response } from 'express';
+import { ${moduleNameCamel}Service } from './${moduleName}.service';
+import { asyncHandler } from '../../common/asyncHandler';
+import { sendResponse } from '../../common/responseHandler';
+
+export const create${ModuleName} = asyncHandler(async (req: Request, res: Response) => {
+    const result = await ${moduleNameCamel}Service.create(req.body);
+    sendResponse(res, 201, result, '${ModuleName} created successfully');
+});
+
+export const get${ModuleName}s = asyncHandler(async (req: Request, res: Response) => {
+    const result = await ${moduleNameCamel}Service.findAll(req.query);
+    sendResponse(res, 200, result, '${ModuleName}s retrieved successfully');
+});
+
+export const get${ModuleName}ById = asyncHandler(async (req: Request, res: Response) => {
+    const result = await ${moduleNameCamel}Service.findOne(req.params.id);
+    sendResponse(res, 200, result, '${ModuleName} retrieved successfully');
+});
+
+export const update${ModuleName} = asyncHandler(async (req: Request, res: Response) => {
+    const result = await ${moduleNameCamel}Service.update(req.params.id, req.body);
+    sendResponse(res, 200, result, '${ModuleName} updated successfully');
+});
+
+export const delete${ModuleName} = asyncHandler(async (req: Request, res: Response) => {
+    await ${moduleNameCamel}Service.softDelete(req.params.id);
+    sendResponse(res, 200, null, '${ModuleName} soft-deleted successfully');
+});
+
+export const restore${ModuleName} = asyncHandler(async (req: Request, res: Response) => {
+    await ${moduleNameCamel}Service.restore(req.params.id);
+    sendResponse(res, 200, null, '${ModuleName} restored successfully');
+});
+
+export const hardDelete${ModuleName} = asyncHandler(async (req: Request, res: Response) => {
+    await ${moduleNameCamel}Service.hardDelete(req.params.id);
+    sendResponse(res, 200, null, '${ModuleName} permanently deleted');
+});
+
+export const toggle${ModuleName}Active = asyncHandler(async (req: Request, res: Response) => {
+    const result = await ${moduleNameCamel}Service.toggleActive(req.params.id);
+    sendResponse(res, 200, result, '${ModuleName} status toggled');
+});
+`,
+        validation: `import { z } from 'zod';
+
+export const create${ModuleName}Schema = z.object({
+    body: z.object({
+        name: z.string().min(2, 'Name is too short'),
+        description: z.string().optional(),
+        image: z.string().optional(),
+    }),
+});
+
+export const update${ModuleName}Schema = z.object({
+    body: z.object({
+        name: z.string().min(2).optional(),
+        description: z.string().optional(),
+        image: z.string().optional(),
+        isActive: z.boolean().optional(),
+    }),
+});
+`,
+        routes: `import { createDocRouter } from '../../common/docRouter';
+import * as ${moduleNameCamel}Controller from './${moduleName}.controller';
+import { validateRequest } from '../../common/validateRequest';
+import { create${ModuleName}Schema, update${ModuleName}Schema } from './${moduleName}.validation';
+import { protect, hasPermission } from '../auth/auth.middleware';
+import { PERMISSIONS } from '../../config/roles';
+import { ${moduleNameCamel}Docs } from './${moduleName}.docs';
+
+const { router, get, post, put, patch, delete: del } = createDocRouter('/${moduleName}s');
+
+// Public routes
+get('/', 
+    ${moduleNameCamel}Docs.getAll,
+    ${moduleNameCamel}Controller.get${ModuleName}s
+);
+
+get('/:id', 
+    ${moduleNameCamel}Docs.getById,
+    ${moduleNameCamel}Controller.get${ModuleName}ById
+);
+
+// Protected routes
+router.use(protect);
+
+post('/', 
+    ${moduleNameCamel}Docs.create,
+    hasPermission(PERMISSIONS.${ModuleName.toUpperCase()}S_WRITE), 
+    validateRequest(create${ModuleName}Schema), 
+    ${moduleNameCamel}Controller.create${ModuleName}
+);
+
+put('/:id', 
+    ${moduleNameCamel}Docs.update,
+    hasPermission(PERMISSIONS.${ModuleName.toUpperCase()}S_WRITE), 
+    validateRequest(update${ModuleName}Schema), 
+    ${moduleNameCamel}Controller.update${ModuleName}
+);
+
+patch('/:id/restore', 
+    ${moduleNameCamel}Docs.restore,
+    hasPermission(PERMISSIONS.${ModuleName.toUpperCase()}S_WRITE), 
+    ${moduleNameCamel}Controller.restore${ModuleName}
+);
+
+patch('/:id/toggle-active', 
+    ${moduleNameCamel}Docs.toggleActive,
+    hasPermission(PERMISSIONS.${ModuleName.toUpperCase()}S_WRITE), 
+    ${moduleNameCamel}Controller.toggle${ModuleName}Active
+);
+
+del('/:id', 
+    ${moduleNameCamel}Docs.softDelete,
+    hasPermission(PERMISSIONS.${ModuleName.toUpperCase()}S_WRITE), 
+    ${moduleNameCamel}Controller.delete${ModuleName}
+);
+
+// Admin-only (Dangerous) actions
+del('/:id/hard', 
+    ${moduleNameCamel}Docs.hardDelete,
+    hasPermission(PERMISSIONS.${ModuleName.toUpperCase()}S_DELETE), 
+    ${moduleNameCamel}Controller.hardDelete${ModuleName}
+);
+
+export const ${moduleNameCamel}Routes = router;
+`,
+
+
+        index: `export * from './${moduleName}.controller';
+export * from './${moduleName}.docs';
+export * from './${moduleName}.interface';
+export * from './${moduleName}.model';
+export * from './${moduleName}.repository';
+export * from './${moduleName}.routes';
+export * from './${moduleName}.service';
+export * from './${moduleName}.validation';
+export * from './${moduleName}.events';
+
+import { register${ModuleName}Handlers } from './${moduleName}.events';
+
+// Initialize Module Events
+register${ModuleName}Handlers();
+`
+    };
+
+
+    // Write files
+    fs.writeFileSync(path.join(modulePath, `${moduleName}.interface.ts`), templates.interface);
+    fs.writeFileSync(path.join(modulePath, `${moduleName}.model.ts`), templates.model);
+    fs.writeFileSync(path.join(modulePath, `${moduleName}.repository.ts`), templates.repository);
+    fs.writeFileSync(path.join(modulePath, `${moduleName}.events.ts`), templates.events);
+    fs.writeFileSync(path.join(modulePath, `${moduleName}.service.ts`), templates.service);
+    fs.writeFileSync(path.join(modulePath, `${moduleName}.controller.ts`), templates.controller);
+    fs.writeFileSync(path.join(modulePath, `${moduleName}.validation.ts`), templates.validation);
+    fs.writeFileSync(path.join(modulePath, `${moduleName}.docs.ts`), templates.docs);
+    fs.writeFileSync(path.join(modulePath, `${moduleName}.routes.ts`), templates.routes);
+    fs.writeFileSync(path.join(modulePath, `index.ts`), templates.index);
+
+    console.log(chalk.green(`Module ${moduleName} created successfully at ${modulePath}`));
+    console.log(chalk.blue(`Next steps:`));
+    console.log(`1. Open src/app.ts`);
+    console.log(`2. Import ${moduleNameCamel}Routes`);
+    console.log(`3. Register the route: app.use('/api/v1/${moduleName}s', ${moduleNameCamel}Routes);`);
+}

package/lib/commands/init.js

@@ -0,0 +1,46 @@
+import shell from 'shelljs';
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+
+// TODO: Replace with your actual boilerplate repository URL
+const BOILERPLATE_REPO = 'https://github.com/khushikumarigupta14/repo-pattern-boiler';
+
+export const initProject = (projectName) => {
+    if (!projectName) {
+        console.error(chalk.red('Please provide a project name'));
+        process.exit(1);
+    }
+
+    if (fs.existsSync(projectName)) {
+        console.error(chalk.red(`Directory ${projectName} already exists`));
+        process.exit(1);
+    }
+
+    console.log(chalk.blue(`Initializing project ${projectName}...`));
+    console.log(chalk.gray(`Cloning from ${BOILERPLATE_REPO}...`));
+
+    // Check if git is installed
+    if (!shell.which('git')) {
+        console.error(chalk.red('Sorry, this script requires git'));
+        process.exit(1);
+    }
+
+    if (shell.exec(`git clone ${BOILERPLATE_REPO} ${projectName}`).code !== 0) {
+        console.error(chalk.red('Error: Git clone failed'));
+        process.exit(1);
+    }
+
+    // Remove .git folder to detach from boilerplate history
+    fs.removeSync(path.join(projectName, '.git'));
+
+    // Initialize new git repo
+    shell.cd(projectName);
+    shell.exec('git init');
+
+    console.log(chalk.green(`\nProject ${projectName} initialized successfully!`));
+    console.log(chalk.blue(`\nNext steps:`));
+    console.log(`  cd ${projectName}`);
+    console.log(`  npm install`);
+    console.log(`  npm run dev`);
+};

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "khushikumarigupta14-express-generator-cli",
+  "version": "1.0.0",
+  "description": "",
+  "type": "module",
+  "bin": {
+    "my-express-gen": "./bin/cli.js"
+  },
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "commander": "^14.0.2",
+    "fs-extra": "^11.3.3",
+    "inquirer": "^13.1.0",
+    "shelljs": "^0.10.0"
+  }
+}