express-genix 4.6.0 → 4.6.1

package/README.md

@@ -112,6 +112,7 @@ npm run dev
 
 ```bash
 cd my-express-app
+express-genix add infra       # Adds Production-Ready Infra (Docker, CI/CD, Nginx, Makefile)
 express-genix add docker      # Adds Dockerfile, docker-compose.yml, .dockerignore
 express-genix add cicd        # Adds GitHub Actions CI workflow
 express-genix add auth        # Adds JWT auth, controllers, routes, middleware
@@ -119,6 +120,23 @@ express-genix add websocket   # Adds Socket.io setup
 express-genix add prisma      # Adds Prisma schema, client config, migrations
 ```
 
+## Interactive Resource Scaffolding
+
+Generate a complete resource (Controller, Service, and Routes) inside an existing Express Genix project.
+
+```bash
+cd my-express-app
+express-genix generate product
+# or use the alias
+express-genix g product
+```
+
+This command automatically:
+1. Creates `src/controllers/productController.js` (with CRUD operations)
+2. Creates `src/services/productService.js` (with business logic structure)
+3. Creates `src/routes/productRoutes.js` (with Swagger annotations and auth middleware if enabled)
+4. **Auto-injects** the new route into `src/routes/index.js` (`router.use('/products', productRoutes);`)
+
 ### Generate from natural language (AI)
 
 Requires `OPENAI_API_KEY` or `ANTHROPIC_API_KEY` in your environment.

package/index.js

@@ -267,7 +267,7 @@ Configuration:
     .command('add <feature>')
     .description('Add a feature to an existing express-genix project')
     .action(async (feature) => {
-      const supportedFeatures = ['auth', 'websocket', 'docker', 'cicd', 'prisma'];
+      const supportedFeatures = ['auth', 'websocket', 'docker', 'cicd', 'prisma', 'infra'];
       if (!supportedFeatures.includes(feature)) {
         console.error(`❌ Unknown feature: "${feature}"`);
         console.log(`Supported features: ${supportedFeatures.join(', ')}`);
@@ -296,6 +296,21 @@ Configuration:
 
 
 
+  program
+    .command('generate <resource>')
+    .alias('g')
+    .description('Generate a new resource (controller, service, routes)')
+    .action(async (resource) => {
+      try {
+        const { generateResource } = require('./lib/scaffold');
+        await generateResource(resource, process.cwd());
+        console.log(`\n🎉 Resource "${resource}" generated successfully!`);
+      } catch (error) {
+        console.error(`\n❌ Failed to generate resource: ${error.message}`);
+        process.exit(1);
+      }
+    });
+
   await program.parseAsync(process.argv);
 }
 

package/lib/features.js

@@ -11,6 +11,7 @@ const addFeature = async (feature, projectDir) => {
   const handlers = {
     docker: () => addDocker(projectDir, templatesDir, pkg),
     cicd: () => addCicd(projectDir, templatesDir, pkg),
+    infra: () => addInfra(projectDir, templatesDir, pkg),
     auth: () => addAuth(projectDir, templatesDir, pkg),
     websocket: () => addWebsocket(projectDir, templatesDir, pkg),
     prisma: () => addPrisma(projectDir, templatesDir, pkg),
@@ -62,6 +63,47 @@ const addCicd = (projectDir, templatesDir, pkg) => {
   console.log('  Created .github/workflows/ci.yml');
 };
 
+const addInfra = (projectDir, templatesDir, pkg) => {
+  const config = inferConfig(projectDir, pkg);
+  config.hasNginx = true; // Enable Nginx in docker-compose
+
+  // 1. Add Docker files
+  const dockerFiles = [
+    { template: 'core/Dockerfile.ejs', output: 'Dockerfile' },
+    { template: 'core/docker-compose.yml.ejs', output: 'docker-compose.yml' },
+    { template: 'core/dockerignore.ejs', output: '.dockerignore' },
+  ];
+
+  for (const file of dockerFiles) {
+    const content = renderTemplate(templatesDir, file.template, config);
+    fs.writeFileSync(path.join(projectDir, file.output), content);
+  }
+
+  // 2. Add CI/CD files
+  const workflowDir = path.join(projectDir, '.github', 'workflows');
+  fs.mkdirSync(workflowDir, { recursive: true });
+  const ciContent = renderTemplate(templatesDir, 'cicd/github-actions.yml.ejs', config);
+  fs.writeFileSync(path.join(workflowDir, 'ci.yml'), ciContent);
+
+  // 3. Add Infra specific files (Makefile, Nginx)
+  const infraFiles = [
+    { template: 'infra/Makefile.ejs', output: 'Makefile' },
+    { template: 'infra/nginx.conf.ejs', output: 'nginx/nginx.conf' },
+  ];
+
+  for (const file of infraFiles) {
+    const outputPath = path.join(projectDir, file.output);
+    fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+    const content = renderTemplate(templatesDir, file.template, config);
+    fs.writeFileSync(outputPath, content);
+  }
+
+  console.log('  ✅ Production-Ready Infrastructure added!');
+  console.log('  Created Dockerfile, docker-compose.yml, .dockerignore');
+  console.log('  Created .github/workflows/ci.yml');
+  console.log('  Created Makefile and nginx/nginx.conf');
+};
+
 const addAuth = (projectDir, templatesDir, pkg) => {
   const config = inferConfig(projectDir, pkg);
 

package/lib/scaffold.js

@@ -0,0 +1,165 @@
+const fs = require('fs');
+const path = require('path');
+const ejs = require('ejs');
+
+/**
+ * Capitalize first letter
+ */
+const capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+/**
+ * Convert to camelCase
+ */
+const toCamelCase = (str) => {
+  return str.replace(/[-_](.)/g, (_, c) => c.toUpperCase());
+};
+
+/**
+ * Convert to PascalCase
+ */
+const toPascalCase = (str) => {
+  const camel = toCamelCase(str);
+  return capitalize(camel);
+};
+
+/**
+ * Simple pluralize (adds 's' if not ending in 's')
+ */
+const pluralize = (str) => {
+  if (str.endsWith('s')) return str;
+  if (str.endsWith('y')) return str.slice(0, -1) + 'ies';
+  return str + 's';
+};
+
+/**
+ * Generate a resource (controller, service, route)
+ */
+const generateResource = async (resourceName, projectDir) => {
+  const packageJsonPath = path.join(projectDir, 'package.json');
+  
+  if (!fs.existsSync(packageJsonPath)) {
+    throw new Error('No package.json found. Run this command from your express-genix project root.');
+  }
+
+  const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+  
+  // Check if it's an express-genix project (or at least has the structure)
+  const srcDir = path.join(projectDir, 'src');
+  if (!fs.existsSync(srcDir)) {
+    throw new Error('No "src" directory found. Are you in an express-genix project?');
+  }
+
+  // Determine features from package.json dependencies
+  const hasAuth = !!pkg.dependencies['jsonwebtoken'];
+  
+  const nameCamel = toCamelCase(resourceName);
+  const namePascal = toPascalCase(resourceName);
+  const namePlural = pluralize(nameCamel);
+
+  const templateData = {
+    resourceName: resourceName.toLowerCase(),
+    resourceNameCamel: nameCamel,
+    resourceNamePascal: namePascal,
+    resourceNamePlural: namePlural,
+    hasAuth,
+  };
+
+  const templatesDir = path.join(__dirname, '..', 'templates', 'scaffold');
+  
+  const filesToGenerate = [
+    {
+      template: 'controller.js.ejs',
+      dest: path.join(srcDir, 'controllers', `${nameCamel}Controller.js`),
+    },
+    {
+      template: 'service.js.ejs',
+      dest: path.join(srcDir, 'services', `${nameCamel}Service.js`),
+    },
+    {
+      template: 'route.js.ejs',
+      dest: path.join(srcDir, 'routes', `${nameCamel}Routes.js`),
+    },
+  ];
+
+  console.log(`\nGenerating resource: ${namePascal}...`);
+
+  for (const file of filesToGenerate) {
+    if (fs.existsSync(file.dest)) {
+      console.log(`⚠️  Skipping ${path.basename(file.dest)} (already exists)`);
+      continue;
+    }
+
+    const templatePath = path.join(templatesDir, file.template);
+    const templateContent = fs.readFileSync(templatePath, 'utf8');
+    const rendered = ejs.render(templateContent, templateData);
+    
+    // Ensure directory exists
+    fs.mkdirSync(path.dirname(file.dest), { recursive: true });
+    
+    fs.writeFileSync(file.dest, rendered);
+    console.log(`✅ Created ${path.relative(projectDir, file.dest)}`);
+  }
+
+  // Inject route into src/routes/index.js
+  injectRoute(srcDir, nameCamel, namePlural);
+};
+
+/**
+ * Inject the new route into src/routes/index.js
+ */
+const injectRoute = (srcDir, nameCamel, namePlural) => {
+  const routesIndexPath = path.join(srcDir, 'routes', 'index.js');
+  
+  if (!fs.existsSync(routesIndexPath)) {
+    console.log(`⚠️  Could not find src/routes/index.js to inject the route.`);
+    return;
+  }
+
+  let content = fs.readFileSync(routesIndexPath, 'utf8');
+  
+  const requireStatement = `const ${nameCamel}Routes = require('./${nameCamel}Routes');`;
+  const useStatement = `router.use('/${namePlural}', ${nameCamel}Routes);`;
+
+  if (content.includes(requireStatement) || content.includes(useStatement)) {
+    console.log(`⚠️  Route already injected in src/routes/index.js`);
+    return;
+  }
+
+  // Find the last require statement
+  const requireRegex = /const .* = require\('.*'\);/g;
+  let lastRequireMatch;
+  let match;
+  while ((match = requireRegex.exec(content)) !== null) {
+    lastRequireMatch = match;
+  }
+
+  if (lastRequireMatch) {
+    const insertPos = lastRequireMatch.index + lastRequireMatch[0].length;
+    content = content.slice(0, insertPos) + '\n' + requireStatement + content.slice(insertPos);
+  } else {
+    // Fallback: put it after express require
+    content = content.replace(/const express = require\('express'\);/, `const express = require('express');\n${requireStatement}`);
+  }
+
+  // Find the last router.use statement
+  const useRegex = /router\.use\('.*', .*\);/g;
+  let lastUseMatch;
+  while ((match = useRegex.exec(content)) !== null) {
+    lastUseMatch = match;
+  }
+
+  if (lastUseMatch) {
+    const insertPos = lastUseMatch.index + lastUseMatch[0].length;
+    content = content.slice(0, insertPos) + '\n' + useStatement + content.slice(insertPos);
+  } else {
+    // Fallback: put it before router.get('/', ...)
+    content = content.replace(/router\.get\('\/'/, `${useStatement}\n\nrouter.get('/'`);
+  }
+
+  fs.writeFileSync(routesIndexPath, content);
+  console.log(`✅ Injected /${namePlural} route into src/routes/index.js`);
+};
+
+module.exports = {
+  generateResource,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "express-genix",
-    "version": "4.6.0",
+    "version": "4.6.1",
     "description": "Production-grade CLI to generate Express apps with JWT, RBAC, GraphQL, TypeScript, Prisma, MongoDB, PostgreSQL, file uploads, email, background jobs, and more",
     "main": "index.js",
     "bin": {

package/templates/core/docker-compose.yml.ejs

@@ -1,11 +1,24 @@
 # templates/core/docker-compose.yml.ejs
 version: '3.8'
 
-services:
+services:<% if (typeof hasNginx !== 'undefined' && hasNginx) { %>
+  nginx:
+    image: nginx:alpine
+    ports:
+      - "80:80"
+    volumes:
+      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
+    depends_on:
+      - app
+    restart: unless-stopped
+    networks:
+      - app-network
+<% } %>
   app:
     build: .
-    ports:
-      - "3000:3000"
+    ports:<% if (typeof hasNginx !== 'undefined' && hasNginx) { %>
+      - "3000" # Exposed to Nginx, not host directly<% } else { %>
+      - "3000:3000"<% } %>
     environment:
       - NODE_ENV=production
     env_file:

package/templates/infra/Makefile.ejs

@@ -0,0 +1,30 @@
+.PHONY: build up down logs test lint clean
+
+# Build the Docker image
+build:
+	docker-compose build
+
+# Start the application in detached mode
+up:
+	docker-compose up -d
+
+# Stop the application
+down:
+	docker-compose down
+
+# View logs
+logs:
+	docker-compose logs -f app
+
+# Run tests
+test:
+	npm test
+
+# Run linter
+lint:
+	npm run lint
+
+# Clean up Docker resources
+clean:
+	docker-compose down -v --remove-orphans
+	docker system prune -f

package/templates/infra/nginx.conf.ejs

@@ -0,0 +1,25 @@
+events {
+    worker_connections 1024;
+}
+
+http {
+    upstream app_servers {
+        server app:3000;
+    }
+
+    server {
+        listen 80;
+        server_name localhost;
+
+        location / {
+            proxy_pass http://app_servers;
+            proxy_http_version 1.1;
+            proxy_set_header Upgrade $http_upgrade;
+            proxy_set_header Connection 'upgrade';
+            proxy_set_header Host $host;
+            proxy_cache_bypass $http_upgrade;
+            proxy_set_header X-Real-IP $remote_addr;
+            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        }
+    }
+}

package/templates/scaffold/controller.js.ejs

@@ -0,0 +1,94 @@
+const <%= resourceNameCamel %>Service = require('../services/<%= resourceNameCamel %>Service');
+const { AppError } = require('../utils/errors');
+const { success, created, paginated } = require('../utils/response');
+const { createLogger } = require('../utils/logger');
+
+const logger = createLogger('<%= resourceNamePascal %>Controller');
+
+const getAll<%= resourceNamePascal %>s = async (req, res, next) => {
+  try {
+    const page = Math.max(1, parseInt(req.query.page, 10) || 1);
+    const limit = Math.min(100, Math.max(1, parseInt(req.query.limit, 10) || 10));
+
+    logger.info('Fetching <%= resourceNamePlural %>', { page, limit });
+    const result = await <%= resourceNameCamel %>Service.getAll<%= resourceNamePascal %>s(page, limit);
+
+    return paginated(res, result.<%= resourceNamePlural %>, {
+      page,
+      limit,
+      total: result.total,
+      totalPages: result.totalPages,
+    });
+  } catch (error) {
+    logger.error('Error fetching <%= resourceNamePlural %>', { error: error.message });
+    next(error);
+  }
+};
+
+const get<%= resourceNamePascal %>ById = async (req, res, next) => {
+  try {
+    const { id } = req.params;
+    const <%= resourceNameCamel %> = await <%= resourceNameCamel %>Service.get<%= resourceNamePascal %>ById(id);
+
+    if (!<%= resourceNameCamel %>) {
+      throw new AppError('<%= resourceNamePascal %> not found', 404);
+    }
+
+    return success(res, <%= resourceNameCamel %>);
+  } catch (error) {
+    next(error);
+  }
+};
+
+const create<%= resourceNamePascal %> = async (req, res, next) => {
+  try {
+    const data = req.body;
+
+    logger.info('Creating <%= resourceNameCamel %>', { data });
+    const <%= resourceNameCamel %> = await <%= resourceNameCamel %>Service.create<%= resourceNamePascal %>(data);
+
+    return created(res, <%= resourceNameCamel %>);
+  } catch (error) {
+    next(error);
+  }
+};
+
+const update<%= resourceNamePascal %> = async (req, res, next) => {
+  try {
+    const { id } = req.params;
+    const data = req.body;
+
+    const <%= resourceNameCamel %> = await <%= resourceNameCamel %>Service.update<%= resourceNamePascal %>(id, data);
+
+    if (!<%= resourceNameCamel %>) {
+      throw new AppError('<%= resourceNamePascal %> not found', 404);
+    }
+
+    return success(res, <%= resourceNameCamel %>);
+  } catch (error) {
+    next(error);
+  }
+};
+
+const delete<%= resourceNamePascal %> = async (req, res, next) => {
+  try {
+    const { id } = req.params;
+    const deleted = await <%= resourceNameCamel %>Service.delete<%= resourceNamePascal %>(id);
+
+    if (!deleted) {
+      throw new AppError('<%= resourceNamePascal %> not found', 404);
+    }
+
+    return success(res, { message: '<%= resourceNamePascal %> deleted successfully' });
+  } catch (error) {
+    next(error);
+  }
+};
+
+module.exports = {
+  getAll<%= resourceNamePascal %>s,
+  get<%= resourceNamePascal %>ById,
+  create<%= resourceNamePascal %>,
+  update<%= resourceNamePascal %>,
+  delete<%= resourceNamePascal %>
+};

package/templates/scaffold/route.js.ejs

@@ -0,0 +1,88 @@
+const express = require('express');
+const <%= resourceNameCamel %>Controller = require('../controllers/<%= resourceNameCamel %>Controller');
+<% if (hasAuth) { %>const { authenticate } = require('../middleware/auth');<% } %>
+
+const router = express.Router();
+
+<% if (hasAuth) { %>// Apply authentication middleware to all routes
+router.use(authenticate);
+<% } %>
+/**
+ * @swagger
+ * /<%= resourceNamePlural %>:
+ *   get:
+ *     summary: Get all <%= resourceNamePlural %>
+ *     tags: [<%= resourceNamePascal %>]
+ *     responses:
+ *       200:
+ *         description: List of <%= resourceNamePlural %>
+ */
+router.get('/', <%= resourceNameCamel %>Controller.getAll<%= resourceNamePascal %>s);
+
+/**
+ * @swagger
+ * /<%= resourceNamePlural %>/{id}:
+ *   get:
+ *     summary: Get a <%= resourceNameCamel %> by ID
+ *     tags: [<%= resourceNamePascal %>]
+ *     parameters:
+ *       - in: path
+ *         name: id
+ *         required: true
+ *         schema:
+ *           type: string
+ *     responses:
+ *       200:
+ *         description: <%= resourceNamePascal %> details
+ */
+router.get('/:id', <%= resourceNameCamel %>Controller.get<%= resourceNamePascal %>ById);
+
+/**
+ * @swagger
+ * /<%= resourceNamePlural %>:
+ *   post:
+ *     summary: Create a new <%= resourceNameCamel %>
+ *     tags: [<%= resourceNamePascal %>]
+ *     responses:
+ *       201:
+ *         description: Created <%= resourceNameCamel %>
+ */
+router.post('/', <%= resourceNameCamel %>Controller.create<%= resourceNamePascal %>);
+
+/**
+ * @swagger
+ * /<%= resourceNamePlural %>/{id}:
+ *   put:
+ *     summary: Update a <%= resourceNameCamel %>
+ *     tags: [<%= resourceNamePascal %>]
+ *     parameters:
+ *       - in: path
+ *         name: id
+ *         required: true
+ *         schema:
+ *           type: string
+ *     responses:
+ *       200:
+ *         description: Updated <%= resourceNameCamel %>
+ */
+router.put('/:id', <%= resourceNameCamel %>Controller.update<%= resourceNamePascal %>);
+
+/**
+ * @swagger
+ * /<%= resourceNamePlural %>/{id}:
+ *   delete:
+ *     summary: Delete a <%= resourceNameCamel %>
+ *     tags: [<%= resourceNamePascal %>]
+ *     parameters:
+ *       - in: path
+ *         name: id
+ *         required: true
+ *         schema:
+ *           type: string
+ *     responses:
+ *       200:
+ *         description: <%= resourceNamePascal %> deleted successfully
+ */
+router.delete('/:id', <%= resourceNameCamel %>Controller.delete<%= resourceNamePascal %>);
+
+module.exports = router;

package/templates/scaffold/service.js.ejs

@@ -0,0 +1,77 @@
+const { createLogger } = require('../utils/logger');
+
+const logger = createLogger('<%= resourceNamePascal %>Service');
+
+/**
+ * Get all <%= resourceNamePlural %> with pagination
+ */
+const getAll<%= resourceNamePascal %>s = async (page = 1, limit = 10) => {
+  logger.info('Fetching all <%= resourceNamePlural %>', { page, limit });
+  
+  // TODO: Implement database logic here
+  // Example (Prisma): return prisma.<%= resourceNameCamel %>.findMany({ skip: (page - 1) * limit, take: limit });
+  // Example (Mongoose): return <%= resourceNamePascal %>.find().skip((page - 1) * limit).limit(limit);
+  
+  return {
+    <%= resourceNamePlural %>: [],
+    total: 0,
+    totalPages: 0,
+    currentPage: page,
+  };
+};
+
+/**
+ * Get <%= resourceNameCamel %> by ID
+ */
+const get<%= resourceNamePascal %>ById = async (id) => {
+  logger.info('Fetching <%= resourceNameCamel %> by ID', { id });
+  
+  // TODO: Implement database logic here
+  // Example (Prisma): return prisma.<%= resourceNameCamel %>.findUnique({ where: { id } });
+  
+  return null;
+};
+
+/**
+ * Create new <%= resourceNameCamel %>
+ */
+const create<%= resourceNamePascal %> = async (data) => {
+  logger.info('Creating new <%= resourceNameCamel %>');
+  
+  // TODO: Implement database logic here
+  // Example (Prisma): return prisma.<%= resourceNameCamel %>.create({ data });
+  
+  return { id: 'new-id', ...data };
+};
+
+/**
+ * Update <%= resourceNameCamel %> by ID
+ */
+const update<%= resourceNamePascal %> = async (id, data) => {
+  logger.info('Updating <%= resourceNameCamel %>', { id });
+  
+  // TODO: Implement database logic here
+  // Example (Prisma): return prisma.<%= resourceNameCamel %>.update({ where: { id }, data });
+  
+  return { id, ...data };
+};
+
+/**
+ * Delete <%= resourceNameCamel %> by ID
+ */
+const delete<%= resourceNamePascal %> = async (id) => {
+  logger.info('Deleting <%= resourceNameCamel %>', { id });
+  
+  // TODO: Implement database logic here
+  // Example (Prisma): await prisma.<%= resourceNameCamel %>.delete({ where: { id } });
+  
+  return true;
+};
+
+module.exports = {
+  getAll<%= resourceNamePascal %>s,
+  get<%= resourceNamePascal %>ById,
+  create<%= resourceNamePascal %>,
+  update<%= resourceNamePascal %>,
+  delete<%= resourceNamePascal %>,
+};