create-backlist 2.0.1 → 4.0.0

package/bin/index.js

@@ -34,15 +34,32 @@ async function main() {
       ],
     },
     {
-        type: 'input',
-        name: 'srcPath',
-        message: 'Enter the path to your frontend `src` directory:',
-        default: 'src',
+      type: 'input',
+      name: 'srcPath',
+      message: 'Enter the path to your frontend `src` directory:',
+      default: 'src',
+    },
+    {
+      type: 'confirm',
+      name: 'addAuth',
+      message: 'Do you want to add basic JWT authentication? (generates a User model, login/register routes)',
+      default: true,
+      when: (answers) => answers.stack === 'node-ts-express'
+    },
+    // --- NEW QUESTION FOR V4.0 ---
+    {
+      type: 'confirm',
+      name: 'addSeeder',
+      message: 'Do you want to add a database seeder with sample user data?',
+      default: true,
+      // Only ask this if Node.js is selected AND authentication is being added
+      when: (answers) => answers.stack === 'node-ts-express' && answers.addAuth
     }
   ]);
 
+  // Pass all answers to the options object
   const options = {
-    ...answers,
+    ...answers, 
     projectDir: path.resolve(process.cwd(), answers.projectName),
     frontendSrcDir: path.resolve(process.cwd(), answers.srcPath),
   };
@@ -53,7 +70,7 @@ async function main() {
     // --- Dispatcher Logic ---
     switch (options.stack) {
       case 'node-ts-express':
-        await generateNodeProject(options);
+        await generateNodeProject(options); // Pass the entire options object
         break;
 
       case 'dotnet-webapi':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-backlist",
-  "version": "2.0.1",
+  "version": "4.0.0",
   "description": "An advanced, multi-language backend generator based on frontend analysis.",
   "type": "commonjs",
   "bin": {

package/src/generators/node.js

@@ -6,7 +6,8 @@ const { analyzeFrontend } = require('../analyzer');
 const { renderAndWrite, getTemplatePath } = require('./template');
 
 async function generateNodeProject(options) {
-  const { projectDir, projectName, frontendSrcDir } = options;
+  // v4.0: Destructure the new 'addSeeder' option
+  const { projectDir, projectName, frontendSrcDir, addAuth, addSeeder } = options;
 
   try {
     // --- Step 1: Analyze Frontend to get Endpoints and Schema Info ---
@@ -21,107 +22,122 @@ async function generateNodeProject(options) {
     // --- Step 2: Identify which Database Models to Generate ---
     const modelsToGenerate = new Map();
     endpoints.forEach(ep => {
-      // If an endpoint has schemaFields and a valid controllerName, add it to our map.
       if (ep.schemaFields && ep.controllerName !== 'Default' && !modelsToGenerate.has(ep.controllerName)) {
         modelsToGenerate.set(ep.controllerName, ep.schemaFields);
       }
     });
 
+    if (addAuth && !modelsToGenerate.has('User')) {
+      console.log(chalk.yellow('  -> Authentication requires a "User" model. Creating a default one.'));
+      modelsToGenerate.set('User', { name: 'String', email: 'String', password: 'String' });
+    }
+
     // --- Step 3: Scaffold Base Project Structure & Files ---
     console.log(chalk.blue('  -> Scaffolding Node.js (Express + TS) project...'));
-    
-    // Create the main source directory
     const destSrcDir = path.join(projectDir, 'src');
     await fs.ensureDir(destSrcDir);
-
-    // Copy static base files
     await fs.copy(getTemplatePath('node-ts-express/base/server.ts'), path.join(destSrcDir, 'server.ts'));
     await fs.copy(getTemplatePath('node-ts-express/base/tsconfig.json'), path.join(projectDir, 'tsconfig.json'));
     
-    // --- Step 4: Generate Dynamic Files (package.json, Models, Controllers) ---
-
-    // Prepare package.json content (in memory)
+    // --- Step 4: Prepare and Write package.json with all conditional dependencies ---
     const packageJsonContent = JSON.parse(
       await ejs.renderFile(getTemplatePath('node-ts-express/partials/package.json.ejs'), { projectName })
     );
 
-    // Conditionally add Mongoose if we are generating models
-    if (modelsToGenerate.size > 0) {
-      console.log(chalk.gray('    -> Preparing to add Mongoose to dependencies...'));
-      packageJsonContent.dependencies['mongoose'] = '^7.5.0'; // Use a recent, stable version
+    if (modelsToGenerate.size > 0 || addAuth) {
+      packageJsonContent.dependencies['mongoose'] = '^7.5.0';
+    }
+    if (addAuth) {
+      packageJsonContent.dependencies['jsonwebtoken'] = '^9.0.2';
+      packageJsonContent.dependencies['bcryptjs'] = '^2.4.3';
+      packageJsonContent.devDependencies['@types/jsonwebtoken'] = '^9.0.2';
+      packageJsonContent.devDependencies['@types/bcryptjs'] = '^2.4.2';
+    }
+    // v4.0: Add seeder dependencies and scripts
+    if (addSeeder) {
+      packageJsonContent.devDependencies['@faker-js/faker'] = '^8.2.0';
+      // We also need chalk for the seeder script's console logs
+      packageJsonContent.dependencies['chalk'] = '^4.1.2';
+      packageJsonContent.scripts['seed'] = 'ts-node scripts/seeder.ts';
+      packageJsonContent.scripts['destroy'] = 'ts-node scripts/seeder.ts -d';
     }
-
-    // Write the final package.json to the disk
     await fs.writeJson(path.join(projectDir, 'package.json'), packageJsonContent, { spaces: 2 });
     
-    // Generate Model and Controller files if any were found
+    // --- Step 5 & 6: Generate Models, Controllers, and Auth boilerplate ---
     if (modelsToGenerate.size > 0) {
-      console.log(chalk.blue('  -> Generating database models and controllers...'));
-      await fs.ensureDir(path.join(destSrcDir, 'models'));
-      await fs.ensureDir(path.join(destSrcDir, 'controllers'));
+        console.log(chalk.blue('  -> Generating database models and controllers...'));
+        await fs.ensureDir(path.join(destSrcDir, 'models'));
+        await fs.ensureDir(path.join(destSrcDir, 'controllers'));
+        for (let [modelName, schema] of modelsToGenerate.entries()) {
+            if (addAuth && modelName === 'User') {
+                schema = { name: 'String', email: 'String', password: 'String', ...schema };
+            }
+            await renderAndWrite(getTemplatePath('node-ts-express/partials/Model.ts.ejs'), path.join(destSrcDir, 'models', `${modelName}.model.ts`), { modelName, schema });
+            await renderAndWrite(getTemplatePath('node-ts-express/partials/Controller.ts.ejs'), path.join(destSrcDir, 'controllers', `${modelName}.controller.ts`), { modelName });
+        }
+    }
+    if (addAuth) {
+        console.log(chalk.blue('  -> Generating authentication boilerplate...'));
+        await fs.ensureDir(path.join(destSrcDir, 'routes'));
+        await fs.ensureDir(path.join(destSrcDir, 'middleware'));
+        await renderAndWrite(getTemplatePath('node-ts-express/partials/Auth.controller.ts.ejs'), path.join(destSrcDir, 'controllers', 'Auth.controller.ts'), {});
+        await renderAndWrite(getTemplatePath('node-ts-express/partials/Auth.routes.ts.ejs'), path.join(destSrcDir, 'routes', 'Auth.routes.ts'), {});
+        await renderAndWrite(getTemplatePath('node-ts-express/partials/Auth.middleware.ts.ejs'), path.join(destSrcDir, 'middleware', 'Auth.middleware.ts'), {});
 
-      for (const [modelName, schema] of modelsToGenerate.entries()) {
-        // Generate Model File (e.g., models/User.model.ts)
-        await renderAndWrite(
-          getTemplatePath('node-ts-express/partials/Model.ts.ejs'),
-          path.join(destSrcDir, 'models', `${modelName}.model.ts`),
-          { modelName, schema }
-        );
-        // Generate Controller File (e.g., controllers/User.controller.ts)
-        await renderAndWrite(
-          getTemplatePath('node-ts-express/partials/Controller.ts.ejs'),
-          path.join(destSrcDir, 'controllers', `${modelName}.controller.ts`),
-          { modelName }
-        );
-      }
+        const userModelPath = path.join(destSrcDir, 'models', 'User.model.ts');
+        if (await fs.pathExists(userModelPath)) {
+            let userModelContent = await fs.readFile(userModelPath, 'utf-8');
+            if (!userModelContent.includes('bcryptjs')) {
+                userModelContent = userModelContent.replace(`import mongoose, { Schema, Document } from 'mongoose';`, `import mongoose, { Schema, Document } from 'mongoose';\nimport bcrypt from 'bcryptjs';`);
+                const preSaveHook = `\n// Hash password before saving\nUserSchema.pre('save', async function(next) {\n  if (!this.isModified('password')) {\n    return next();\n  }\n  const salt = await bcrypt.genSalt(10);\n  this.password = await bcrypt.hash(this.password, salt);\n  next();\n});\n`;
+                userModelContent = userModelContent.replace(`// Create and export the Model`, `${preSaveHook}\n// Create and export the Model`);
+                await fs.writeFile(userModelPath, userModelContent);
+            }
+        }
     }
 
-    // --- Step 5: Generate the Smart Route File ---
-    console.log(chalk.gray('    -> Generating dynamic routes...'));
-    await renderAndWrite(
-      getTemplatePath('node-ts-express/partials/routes.ts.ejs'),
-      path.join(destSrcDir, 'routes.ts'),
-      { endpoints } // Pass all endpoints to the template
-    );
-    
-    // --- Step 6: Inject Routes into the Main Server File ---
-    const serverDestPath = path.join(destSrcDir, 'server.ts');
-    let serverFileContent = await fs.readFile(serverDestPath, 'utf-8');
+    // --- Step 7 (v4.0): Generate Seeder Script ---
+    if (addSeeder) {
+      console.log(chalk.blue('  -> Generating database seeder script...'));
+      await fs.ensureDir(path.join(projectDir, 'scripts'));
+      await renderAndWrite(
+        getTemplatePath('node-ts-express/partials/Seeder.ts.ejs'),
+        path.join(projectDir, 'scripts', 'seeder.ts'),
+        { projectName }
+      );
+    }
+
+    // --- Step 8: Generate the Main Route File ---
+    console.log(chalk.gray('    -> Generating dynamic API routes...'));
+    await renderAndWrite(getTemplatePath('node-ts-express/partials/routes.ts.ejs'), path.join(destSrcDir, 'routes.ts'), { endpoints, addAuth });
     
+    // --- Step 9: Inject Logic into Main Server File ---
+    let serverFileContent = await fs.readFile(path.join(destSrcDir, 'server.ts'), 'utf-8');
     let dbConnectionCode = '';
-    if (modelsToGenerate.size > 0) {
-      dbConnectionCode = `
-// --- Database Connection ---
-import mongoose from 'mongoose';
-const MONGO_URI = process.env.MONGO_URI || 'mongodb://localhost:27017/${projectName}';
-mongoose.connect(MONGO_URI)
-  .then(() => console.log('MongoDB Connected...'))
-  .catch(err => console.error('MongoDB Connection Error:', err));
-// -------------------------
-`;
+    if (modelsToGenerate.size > 0 || addAuth) {
+      dbConnectionCode = `\n// --- Database Connection ---\nimport mongoose from 'mongoose';\nconst MONGO_URI = process.env.MONGO_URI || 'mongodb://127.0.0.1:27017/${projectName}';\nmongoose.connect(MONGO_URI)\n  .then(() => console.log('MongoDB Connected...'))\n  .catch(err => console.error('MongoDB Connection Error:', err));\n// -------------------------\n`;
+    }
+    let authRoutesInjector = '';
+    if (addAuth) {
+      authRoutesInjector = `import authRoutes from './routes/Auth.routes';\napp.use('/api/auth', authRoutes);\n\n`;
     }
-
-    // Inject DB connection code after dotenv.config() and route loader
     serverFileContent = serverFileContent
-      .replace("dotenv.config();", `dotenv.config();\n${dbConnectionCode}`)
-      .replace('// INJECT:ROUTES', `import apiRoutes from './routes';\napp.use(apiRoutes);`);
-      
-    await fs.writeFile(serverDestPath, serverFileContent);
+      .replace("dotenv.config();", `dotenv.config();${dbConnectionCode}`)
+      .replace('// INJECT:ROUTES', `${authRoutesInjector}import apiRoutes from './routes';\napp.use('/api', apiRoutes);`);
+    await fs.writeFile(path.join(destSrcDir, 'server.ts'), serverFileContent);
 
-    // --- Step 7: Install All Dependencies at Once ---
-    console.log(chalk.magenta('  -> Installing dependencies (npm install)... This might take a moment.'));
+    // --- Step 10: Install All Dependencies ---
+    console.log(chalk.magenta('  -> Installing all dependencies... This might take a moment.'));
     await execa('npm', ['install'], { cwd: projectDir });
 
-    // --- Step 8: Generate README ---
-    await renderAndWrite(
-      getTemplatePath('node-ts-express/partials/README.md.ejs'),
-      path.join(projectDir, 'README.md'),
-      { projectName }
-    );
+    // --- Step 11: Generate Final Files (README, .env.example) ---
+    await renderAndWrite(getTemplatePath('node-ts-express/partials/README.md.ejs'), path.join(projectDir, 'README.md'), { projectName });
+    if (addAuth) {
+      const envExampleContent = `PORT=8000\nMONGO_URI=mongodb://127.0.0.1:27017/${projectName}\nJWT_SECRET=your_super_secret_jwt_key_123`;
+      await fs.writeFile(path.join(projectDir, '.env.example'), envExampleContent);
+    }
 
   } catch (error) {
-    // Re-throw the error so it can be caught by the main CLI handler in index.js
-    // This allows for centralized error message display and cleanup.
     throw error;
   }
 }

package/src/templates/node-ts-express/partials/Auth.controller.ts.ejs

@@ -0,0 +1,89 @@
+// Auto-generated by create-backlist v3.0 on <%= new Date().toISOString() %>
+import { Request, Response } from 'express';
+import bcrypt from 'bcryptjs';
+import jwt from 'jsonwebtoken';
+import User, { IUser } from '../models/User.model'; // We assume the model is named 'User'
+
+// @desc    Register a new user
+export const registerUser = async (req: Request, res: Response) => {
+  const { name, email, password } = req.body;
+
+  try {
+    // Check if user already exists
+    let user = await User.findOne({ email });
+    if (user) {
+      return res.status(400).json({ message: 'User already exists' });
+    }
+
+    // Create a new user instance
+    user = new User({
+      name,
+      email,
+      password, // Password will be hashed by the pre-save hook in the model
+    });
+
+    // Save the user to the database
+    await user.save();
+
+    // Create JWT Payload
+    const payload = {
+      user: {
+        id: user.id,
+      },
+    };
+
+    // Sign the token
+    jwt.sign(
+      payload,
+      process.env.JWT_SECRET as string,
+      { expiresIn: '5h' }, // Token expires in 5 hours
+      (err, token) => {
+        if (err) throw err;
+        res.status(201).json({ token });
+      }
+    );
+  } catch (error) {
+    console.error(error);
+    res.status(500).send('Server Error');
+  }
+};
+
+// @desc    Authenticate user & get token (Login)
+export const loginUser = async (req: Request, res: Response) => {
+  const { email, password } = req.body;
+
+  try {
+    // Check if user exists
+    const user = await User.findOne({ email });
+    if (!user) {
+      return res.status(400).json({ message: 'Invalid Credentials' });
+    }
+
+    // Compare entered password with stored hashed password
+    const isMatch = await bcrypt.compare(password, user.password);
+    if (!isMatch) {
+      return res.status(400).json({ message: 'Invalid Credentials' });
+    }
+
+    // Create JWT Payload
+    const payload = {
+      user: {
+        id: user.id,
+      },
+    };
+
+    // Sign the token
+    jwt.sign(
+      payload,
+      process.env.JWT_SECRET as string,
+      { expiresIn: '5h' },
+      (err, token) => {
+        if (err) throw err;
+        res.json({ token });
+      }
+    );
+  } catch (error) {
+    console.error(error);
+    res.status(500).send('Server Error');
+  }
+};

package/src/templates/node-ts-express/partials/Auth.middleware.ts.ejs

@@ -0,0 +1,27 @@
+// Auto-generated by create-backlist v3.0 on <%= new Date().toISOString() %>
+import { Request, Response, NextFunction } from 'express';
+import jwt from 'jsonwebtoken';
+
+// Extend the default Request interface to include our 'user' property
+interface AuthRequest extends Request {
+  user?: any;
+}
+
+export const protect = (req: AuthRequest, res: Response, next: NextFunction) => {
+  // Get token from header
+  const token = req.header('x-auth-token');
+
+  // Check if not token
+  if (!token) {
+    return res.status(401).json({ message: 'No token, authorization denied' });
+  }
+
+  // Verify token
+  try {
+    const decoded = jwt.verify(token, process.env.JWT_SECRET as string);
+    req.user = decoded.user;
+    next();
+  } catch (err) {
+    res.status(401).json({ message: 'Token is not valid' });
+  }
+};

package/src/templates/node-ts-express/partials/Auth.routes.ts.ejs

@@ -0,0 +1,15 @@
+// Auto-generated by create-backlist v3.0 on <%= new Date().toISOString() %>
+import { Router } from 'express';
+import { registerUser, loginUser } from '../controllers/Auth.controller';
+
+const router = Router();
+
+// @route   POST /api/auth/register
+// @desc    Register a new user
+router.post('/register', registerUser);
+
+// @route   POST /api/auth/login
+// @desc    Authenticate user and get token
+router.post('/login', loginUser);
+
+export default router;

package/src/templates/node-ts-express/partials/Controller.ts.ejs

@@ -9,6 +9,9 @@ export const create<%= modelName %> = async (req: Request, res: Response) => {
     await newDoc.save();
     res.status(201).json(newDoc);
   } catch (error) {
+    if (error.name === 'ValidationError') {
+        return res.status(400).json({ message: 'Validation Error', errors: error.errors });
+    }
     res.status(500).json({ message: 'Error creating document', error });
   }
 };
@@ -41,6 +44,9 @@ export const update<%= modelName %>ById = async (req: Request, res: Response) =>
     if (!doc) return res.status(404).json({ message: 'Document not found' });
     res.status(200).json(doc);
   } catch (error) {
+    if (error.name === 'ValidationError') {
+        return res.status(400).json({ message: 'Validation Error', errors: error.errors });
+    }
     res.status(500).json({ message: 'Error updating document', error });
   }
 };
@@ -50,6 +56,7 @@ export const delete<%= modelName %>ById = async (req: Request, res: Response) =>
   try {
     const doc = await <%= modelName %>.findByIdAndDelete(req.params.id);
     if (!doc) return res.status(404).json({ message: 'Document not found' });
+    // For DELETE, it's common to return a success message or just a 204 No Content status.
     res.status(200).json({ message: 'Document deleted successfully' });
   } catch (error) {
     res.status(500).json({ message: 'Error deleting document', error });

package/src/templates/node-ts-express/partials/Seeder.ts.ejs

@@ -0,0 +1,83 @@
+// Auto-generated by create-backlist v4.0 on <%= new Date().toISOString() %>
+import mongoose from 'mongoose';
+import dotenv from 'dotenv';
+import { faker } from '@faker-js/faker';
+import chalk from 'chalk'; // For colorful console logs
+
+// Load env vars
+dotenv.config();
+
+// We assume a User model exists for seeding.
+// The path is relative to the generated 'backend' project root.
+import User from '../src/models/User.model';
+
+// --- Connect to DB ---
+const connectDB = async () => {
+  try {
+    const MONGO_URI = process.env.MONGO_URI || 'mongodb://127.0.0.1:27017/<%= projectName %>';
+    if (!MONGO_URI) {
+        throw new Error('MONGO_URI is not defined in your .env file');
+    }
+    await mongoose.connect(MONGO_URI);
+    console.log(chalk.green('MongoDB Connected for Seeder...'));
+  } catch (err) {
+    console.error(chalk.red(`Seeder DB Connection Error: ${err.message}`));
+    process.exit(1);
+  }
+};
+
+// --- Import Data ---
+const importData = async () => {
+  try {
+    // Clear existing data
+    await User.deleteMany();
+
+    const sampleUsers = [];
+    const userCount = 10; // Number of sample users to create
+
+    for (let i = 0; i < userCount; i++) {
+      sampleUsers.push({
+        name: faker.person.fullName(),
+        email: faker.internet.email().toLowerCase(),
+        password: 'password123', // All sample users will have the same password for easy testing
+      });
+    }
+
+    await User.insertMany(sampleUsers);
+
+    console.log(chalk.green.bold('✅ Data Imported Successfully!'));
+    process.exit();
+  } catch (error) {
+    console.error(chalk.red(`Error with data import: ${error.message}`));
+    process.exit(1);
+  }
+};
+
+// --- Destroy Data ---
+const destroyData = async () => {
+  try {
+    await User.deleteMany();
+    // If you have other models, you can add them here for destruction
+    // e.g., await Product.deleteMany();
+
+    console.log(chalk.red.bold('🔥 Data Destroyed Successfully!'));
+    process.exit();
+  } catch (error) {
+    console.error(chalk.red(`Error with data destruction: ${error.message}`));
+    process.exit(1);
+  }
+};
+
+// --- CLI Logic to run the seeder ---
+const runSeeder = async () => {
+  await connectDB();
+
+  // process.argv[2] will be '-d' if the script is run with `npm run destroy`
+  if (process.argv[2] === '-d') {
+    await destroyData();
+  } else {
+    await importData();
+  }
+};
+
+runSeeder();

package/src/templates/node-ts-express/partials/routes.ts.ejs

@@ -1,4 +1,4 @@
-// Auto-generated by create-backlist on <%= new Date().toISOString() %>
+// Auto-generated by create-backlist v3.0 on <%= new Date().toISOString() %>
 import { Router, Request, Response } from 'express';
 <%# Create a unique set of controller names from the endpoints array %>
 <% const controllersToImport = new Set(endpoints.map(ep => ep.controllerName).filter(name => name !== 'Default')); %>
@@ -8,6 +8,11 @@ import { Router, Request, Response } from 'express';
 import * as <%= controller %>Controller from '../controllers/<%= controller %>.controller';
 <% } %>
 
+<%# Import the protect middleware only if authentication is enabled %>
+<% if (addAuth) { %>
+import { protect } from '../middleware/Auth.middleware';
+<% } %>
+
 const router = Router();
 
 <%# Loop through each endpoint found by the analyzer %>
@@ -19,41 +24,40 @@ const router = Router();
   let handlerFunction;
 
   // --- LOGIC TO MAP ENDPOINT TO A CRUD CONTROLLER FUNCTION ---
-  // This logic assumes a standard RESTful API structure.
-  
   if (controllerName !== 'Default') {
     if (endpoint.method === 'POST' && !expressPath.includes(':')) {
-      // e.g., POST /users -> create a new user
       handlerFunction = `${controllerName}Controller.create${controllerName}`;
     } else if (endpoint.method === 'GET' && !expressPath.includes(':')) {
-      // e.g., GET /users -> get all users
       handlerFunction = `${controllerName}Controller.getAll${controllerName}s`;
     } else if (endpoint.method === 'GET' && expressPath.includes(':')) {
-      // e.g., GET /users/:id -> get a single user by ID
       handlerFunction = `${controllerName}Controller.get${controllerName}ById`;
     } else if (endpoint.method === 'PUT' && expressPath.includes(':')) {
-      // e.g., PUT /users/:id -> update a user by ID
       handlerFunction = `${controllerName}Controller.update${controllerName}ById`;
     } else if (endpoint.method === 'DELETE' && expressPath.includes(':')) {
-      // e.g., DELETE /users/:id -> delete a user by ID
       handlerFunction = `${controllerName}Controller.delete${controllerName}ById`;
     }
   }
 
-  // If no specific CRUD function matches, or if it's a default/unhandled route,
-  // create a simple placeholder function.
+  // If no specific CRUD function matches, create a placeholder handler.
   if (!handlerFunction) {
     handlerFunction = `(req: Request, res: Response) => {
-      // TODO: Implement logic for this custom endpoint
       res.status(501).json({ message: 'Handler not implemented for <%= endpoint.method %> <%= expressPath %>' });
     }`;
   }
+
+  // --- V3.0 AUTH LOGIC: Decide if the route should be protected ---
+  // We protect all routes that modify data (POST, PUT, DELETE) if auth is enabled.
+  // We leave GET routes public by default. This is a common pattern.
+  const middleware = (addAuth && (endpoint.method === 'POST' || endpoint.method === 'PUT' || endpoint.method === 'DELETE')) 
+    ? 'protect, ' 
+    : '';
 %>
 /**
  * Route for <%= endpoint.method.toUpperCase() %> <%= endpoint.path %>
  * Mapped to: <%- handlerFunction.includes('=>') ? 'Inline Handler' : handlerFunction %>
+ * Protected: <%= middleware ? 'Yes' : 'No' %>
  */
-router.<%= endpoint.method.toLowerCase() %>('<%- expressPath %>', <%- handlerFunction %>);
+router.<%= endpoint.method.toLowerCase() %>('<%- expressPath %>', <%- middleware %><%- handlerFunction %>);
 
 <% }); %>