create-backlist 2.0.1 → 3.0.0

package/bin/index.js

@@ -38,11 +38,21 @@ async function main() {
         name: 'srcPath',
         message: 'Enter the path to your frontend `src` directory:',
         default: 'src',
+    },
+    // --- NEW QUESTION FOR V3.0 ---
+    {
+      type: 'confirm',
+      name: 'addAuth',
+      message: 'Do you want to add basic JWT authentication? (generates a User model, login/register routes)',
+      default: true,
+      // This question will only be asked if the user selects the Node.js stack
+      when: (answers) => answers.stack === 'node-ts-express'
     }
   ]);
 
+  // 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 +63,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':
@@ -61,6 +71,7 @@ async function main() {
           throw new Error('.NET SDK is not installed. Please install it from https://dotnet.microsoft.com/download');
         }
         await generateDotnetProject(options);
+
         break;
       
       default:

package/package.json

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

package/src/generators/node.js

@@ -6,7 +6,7 @@ const { analyzeFrontend } = require('../analyzer');
 const { renderAndWrite, getTemplatePath } = require('./template');
 
 async function generateNodeProject(options) {
-  const { projectDir, projectName, frontendSrcDir } = options;
+  const { projectDir, projectName, frontendSrcDir, addAuth } = options;
 
   try {
     // --- Step 1: Analyze Frontend to get Endpoints and Schema Info ---
@@ -21,53 +21,55 @@ 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 auth is enabled, we MUST have a 'User' model.
+    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 ---
     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';
     }
-
-    // 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: Generate Models and Controllers ---
     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'));
 
-      for (const [modelName, schema] of modelsToGenerate.entries()) {
-        // Generate Model File (e.g., models/User.model.ts)
+      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 }
         );
-        // 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`),
@@ -75,25 +77,53 @@ async function generateNodeProject(options) {
         );
       }
     }
+    
+    // --- Step 6 (v3.0): Generate Authentication Boilerplate ---
+    if (addAuth) {
+        console.log(chalk.blue('  -> Generating authentication boilerplate...'));
+        await fs.ensureDir(path.join(destSrcDir, 'routes'));
+        await fs.ensureDir(path.join(destSrcDir, 'middleware'));
 
-    // --- 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
-    );
+        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'), {});
+
+        // Modify the User model to add password hashing
+        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 = `
+// Hash password before saving
+UserSchema.pre('save', async function(next) {
+  if (!this.isModified('password')) {
+    return next();
+  }
+  const salt = await bcrypt.genSalt(10);
+  this.password = await bcrypt.hash(this.password, salt);
+  next();
+});
+`;
+                userModelContent = userModelContent.replace(`// Create and export the Model`, `${preSaveHook}\n// Create and export the Model`);
+                await fs.writeFile(userModelPath, userModelContent);
+            }
+        }
+    }
+
+    // --- Step 7: 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 6: Inject Routes into the Main Server File ---
-    const serverDestPath = path.join(destSrcDir, 'server.ts');
-    let serverFileContent = await fs.readFile(serverDestPath, 'utf-8');
+    // --- Step 8: Inject Logic into Main Server File ---
+    let serverFileContent = await fs.readFile(path.join(destSrcDir, 'server.ts'), 'utf-8');
     
     let dbConnectionCode = '';
-    if (modelsToGenerate.size > 0) {
+    if (modelsToGenerate.size > 0 || addAuth) {
       dbConnectionCode = `
 // --- Database Connection ---
 import mongoose from 'mongoose';
-const MONGO_URI = process.env.MONGO_URI || 'mongodb://localhost:27017/${projectName}';
+const MONGO_URI = process.env.MONGO_URI || 'mongodb://127.0.0.1:27017/${projectName}';
 mongoose.connect(MONGO_URI)
   .then(() => console.log('MongoDB Connected...'))
   .catch(err => console.error('MongoDB Connection Error:', err));
@@ -101,27 +131,35 @@ mongoose.connect(MONGO_URI)
 `;
     }
 
-    // Inject DB connection code after dotenv.config() and route loader
+    let authRoutesInjector = '';
+    if (addAuth) {
+        authRoutesInjector = `import authRoutes from './routes/Auth.routes';\napp.use('/api/auth', authRoutes);\n\n`;
+    }
+
     serverFileContent = serverFileContent
       .replace("dotenv.config();", `dotenv.config();\n${dbConnectionCode}`)
-      .replace('// INJECT:ROUTES', `import apiRoutes from './routes';\napp.use(apiRoutes);`);
+      .replace('// INJECT:ROUTES', `${authRoutesInjector}import apiRoutes from './routes';\napp.use('/api', apiRoutes);`); // Changed to /api
       
-    await fs.writeFile(serverDestPath, serverFileContent);
+    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 9: 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 ---
+    // --- Step 10: 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/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 %>);
 
 <% }); %>