create-backlist 1.3.3 → 2.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [2025] [W.A.H.ISHAN]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,97 @@
+# 🚀 Create Backlist
+
+[![NPM Version](https://img.shields.io/npm/v/create-backlist.svg)](https://www.npmjs.com/package/create-backlist)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Tired of manually creating backend boilerplate every time you build a frontend? **`create-backlist`** is an intelligent CLI tool that analyzes your frontend project and automatically generates a backend with all the necessary routes and controllers, saving you hours of repetitive work.
+
+It's not just another scaffolder; it's a **context-aware, dynamic code generator** that builds a backend tailor-made for your frontend's specific API needs.
+
+![Demo GIF (Optional: Add a GIF of your tool in action here)](link-to-your-demo-gif.gif)
+
+## ✨ Key Features
+
+-   **🤖 Intelligent Code Analysis:** Scans your frontend codebase (React, Vue, etc.) using Abstract Syntax Trees (ASTs) to detect API calls (`fetch` requests).
+-   **🌐 Multi-Language Support:** Generate a backend in your preferred stack.
+    -   ✅ **Currently Supports:**
+        -   Node.js (with TypeScript & Express)
+        -   C# (with ASP.NET Core Web API)
+    -   ⏳ **Coming Soon:**
+        -   Python (with FastAPI)
+        -   Java (with Spring Boot)
+-   **⚡️ Fully Automated:** A single command handles everything from project scaffolding to dependency installation.
+-   **🔧 Zero-Configuration:** No complex config files needed. Just run the command and answer a few simple questions.
+-   **🧼 Clean Code Generation:** Creates a well-structured backend, ready for you to implement your business logic.
+
+## 📦 Installation & Usage
+
+No global installation needed! Just run this command inside your existing frontend project's root directory:
+
+```bash
+npm create backlist@latest
+```
+
+The tool will then guide you through an interactive setup process:
+
+1.  **Enter a name for your backend directory:** (default: `backend`)
+2.  **Select the backend stack:** (e.g., `Node.js (TypeScript, Express)`)
+3.  **Enter the path to your frontend `src` directory:** (default: `src`)
+
+That's it! The tool will analyze your code, generate the backend in a new directory, and install all the necessary dependencies.
+
+### Example
+
+Let's say your frontend has this API call:
+
+```javascript
+// in your React component
+fetch('/api/products/123', { method: 'PUT' });
+```
+
+`create-backlist` will automatically generate a backend with a `products` controller and a `PUT` route for `products/:id`.
+
+## 💡 How It's Different from Other Tools
+
+| Tool                  | Approach                               | Use Case                                                    |
+| --------------------- | -------------------------------------- | ----------------------------------------------------------- |
+| **Express Generator** | Static Scaffolding                     | Quickly start a *new, empty* Express project.               |
+| **NestJS CLI**        | Static Scaffolding & Code Generation | Start a *new, structured* NestJS project and add parts manually. |
+| **`create-backlist`** | **Dynamic & Context-Aware Scaffolding** | Generate a backend that is **tailor-made** for an *existing* frontend. |
+
+While traditional generators give you a blank canvas, `create-backlist` looks at your finished painting (the frontend) and builds the perfect frame (the backend) for it.
+
+## 🗺️ Roadmap
+
+`create-backlist` is actively being developed. Here are some of the features planned for future releases:
+
+-   [ ] **Python Support:** Generate a backend using FastAPI.
+-   [ ] **Java Support:** Generate a backend using Spring Boot.
+-   [ ] **Database Model Generation:** Automatically create basic database models (e.g., Mongoose, Prisma) based on `POST`/`PUT` request bodies.
+-   [ ] **Authentication Boilerplate:** Add an option to generate basic JWT-based authentication routes (`/login`, `/register`).
+
+Have an idea for a new feature? Feel free to [open an issue](https://github.com/WAH-ISHAN/create-backlist/issues) on GitHub!
+
+## 🛠️ Contributing
+
+Contributions are what make the open-source community such an amazing place to learn, inspire, and create. Any contributions you make are **greatly appreciated**.
+
+1.  Fork the Project
+2.  Create your Feature Branch (`git checkout -b feature/AmazingFeature`)
+3.  Commit your Changes (`git commit -m 'Add some AmazingFeature'`)
+4.  Push to the Branch (`git push origin feature/AmazingFeature`)
+5.  Open a Pull Request
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 🙏 Acknowledgements
+
+-   **Babel** for the amazing AST parser.
+-   **Inquirer.js** for the interactive CLI prompts.
+-   **fs-extra** for making file system operations a breeze.
+-   **Google's Gemini** for assistance with brainstorming and debugging.
+
+---
+
+_Built with ❤️ by [W.A.H. ISHAN](https://github.com/WAH-ISHAN)._

package/package.json

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

package/src/analyzer.js

@@ -3,12 +3,24 @@ const { glob } = require('glob');
 const parser = require('@babel/parser');
 const traverse = require('@babel/traverse').default;
 
+/**
+ * Converts a string to TitleCase, which is suitable for model and controller names.
+ * e.g., 'user-orders' -> 'UserOrders'
+ * @param {string} str The input string.
+ * @returns {string} The TitleCased string.
+ */
 function toTitleCase(str) {
     if (!str) return 'Default';
-    return str.replace(/\w\S*/g, txt => txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase())
+    return str.replace(/-_(\w)/g, g => g[1].toUpperCase()) // handle snake_case and kebab-case
+              .replace(/\w\S*/g, txt => txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase())
               .replace(/[^a-zA-Z0-9]/g, '');
 }
 
+/**
+ * Analyzes frontend source files to find API endpoints and their details.
+ * @param {string} srcPath The path to the frontend source directory.
+ * @returns {Promise<Array<object>>} A promise that resolves to an array of endpoint objects.
+ */
 async function analyzeFrontend(srcPath) {
   if (!fs.existsSync(srcPath)) {
     throw new Error(`The source directory '${srcPath}' does not exist.`);
@@ -21,39 +33,92 @@ async function analyzeFrontend(srcPath) {
     const code = await fs.readFile(file, 'utf-8');
     try {
       const ast = parser.parse(code, { sourceType: 'module', plugins: ['jsx', 'typescript'] });
+      
       traverse(ast, {
         CallExpression(path) {
+          // We are only interested in 'fetch' calls
           if (path.node.callee.name !== 'fetch') return;
+
           const urlNode = path.node.arguments[0];
           
           let urlValue;
           if (urlNode.type === 'StringLiteral') {
             urlValue = urlNode.value;
           } else if (urlNode.type === 'TemplateLiteral' && urlNode.quasis.length > 0) {
-            urlValue = urlNode.quasis.map(q => q.value.raw).join('{id}');
+            // Reconstruct path for dynamic URLs like `/api/users/${id}` -> `/api/users/{id}`
+            urlValue = urlNode.quasis.map((q, i) => {
+              return q.value.raw + (urlNode.expressions[i] ? `{${urlNode.expressions[i].name || 'id'}}` : '');
+            }).join('');
           }
           
+          // Only process API calls that start with '/api/'
           if (!urlValue || !urlValue.startsWith('/api/')) return;
           
           let method = 'GET';
+          let schemaFields = null;
 
           const optionsNode = path.node.arguments[1];
           if (optionsNode && optionsNode.type === 'ObjectExpression') {
+            // Find the HTTP method
             const methodProp = optionsNode.properties.find(p => p.key.name === 'method');
             if (methodProp && methodProp.value.type === 'StringLiteral') {
               method = methodProp.value.value.toUpperCase();
             }
+
+            // --- NEW LOGIC: Analyze the 'body' for POST/PUT requests ---
+            if (method === 'POST' || method === 'PUT') {
+              const bodyProp = optionsNode.properties.find(p => p.key.name === 'body');
+              
+              // Check if body is wrapped in JSON.stringify
+              if (bodyProp && bodyProp.value.callee && bodyProp.value.callee.name === 'JSON.stringify') {
+                const dataObjectNode = bodyProp.value.arguments[0];
+
+                // This is a simplified analysis assuming the object is defined inline.
+                // A more robust solution would trace variables back to their definition.
+                if (dataObjectNode.type === 'ObjectExpression') {
+                  schemaFields = {};
+                  dataObjectNode.properties.forEach(prop => {
+                    const key = prop.key.name;
+                    const valueNode = prop.value;
+                    
+                    // Infer Mongoose schema type based on the value's literal type
+                    if (valueNode.type === 'StringLiteral') {
+                      schemaFields[key] = 'String';
+                    } else if (valueNode.type === 'NumericLiteral') {
+                      schemaFields[key] = 'Number';
+                    } else if (valueNode.type === 'BooleanLiteral') {
+                      schemaFields[key] = 'Boolean';
+                    } else {
+                      // Default to String if the type is complex or a variable
+                      schemaFields[key] = 'String'; 
+                    }
+                  });
+                }
+              }
+            }
           }
 
+          // Generate a clean controller name (e.g., /api/user-orders -> UserOrders)
           const controllerName = toTitleCase(urlValue.split('/')[2]);
           const key = `${method}:${urlValue}`;
+
+          // Avoid adding duplicate endpoints
           if (!endpoints.has(key)) {
-            endpoints.set(key, { path: urlValue, method, controllerName });
+            endpoints.set(key, { 
+              path: urlValue, 
+              method, 
+              controllerName, 
+              schemaFields // This will be null for GET/DELETE, and an object for POST/PUT
+            });
           }
         },
       });
-    } catch (e) { /* Ignore parsing errors */ }
+    } catch (e) { 
+      // Ignore files that babel can't parse (e.g., CSS-in-JS files)
+    }
   }
+
+  // Return all found endpoints as an array
   return Array.from(endpoints.values());
 }
 

package/src/generators/node.js

@@ -9,7 +9,7 @@ async function generateNodeProject(options) {
   const { projectDir, projectName, frontendSrcDir } = options;
 
   try {
-    // --- Step 1: Analyze Frontend ---
+    // --- Step 1: Analyze Frontend to get Endpoints and Schema Info ---
     console.log(chalk.blue('  -> Analyzing frontend for API endpoints...'));
     const endpoints = await analyzeFrontend(frontendSrcDir);
     if (endpoints.length > 0) {
@@ -18,58 +18,101 @@ async function generateNodeProject(options) {
       console.log(chalk.yellow('  -> No API endpoints found. A basic project will be created.'));
     }
 
-    // --- Step 2: Scaffold Base Project ---
+    // --- 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);
+      }
+    });
+
+    // --- Step 3: Scaffold Base Project Structure & Files ---
     console.log(chalk.blue('  -> Scaffolding Node.js (Express + TS) project...'));
     
-    // Define paths clearly
-    const baseDir = getTemplatePath('node-ts-express/base');
-    const serverTemplatePath = path.join(baseDir, 'server.ts');
-    const tsconfigTemplatePath = path.join(baseDir, 'tsconfig.json');
-    
+    // Create the main source directory
     const destSrcDir = path.join(projectDir, 'src');
-    const serverDestPath = path.join(destSrcDir, 'server.ts');
-    const tsconfigDestPath = path.join(projectDir, 'tsconfig.json');
-
-    // Ensure destination directory exists
     await fs.ensureDir(destSrcDir);
 
-    // Copy base files individually for clarity
-    await fs.copy(serverTemplatePath, serverDestPath);
-    await fs.copy(tsconfigTemplatePath, tsconfigDestPath);
-    
-    console.log(chalk.gray('    -> Base server.ts copied.'));
+    // 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 3: Generate Dynamic Files ---
-    await renderAndWrite(
-      getTemplatePath('node-ts-express/partials/package.json.ejs'),
-      path.join(projectDir, 'package.json'),
-      { projectName }
+    // --- Step 4: Generate Dynamic Files (package.json, Models, Controllers) ---
+
+    // Prepare package.json content (in memory)
+    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
+    }
+
+    // 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
+    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)
+        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 }
+        );
+      }
+    }
+
+    // --- 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 }
+      { endpoints } // Pass all endpoints to the template
     );
     
-    console.log(chalk.gray('    -> package.json and routes.ts generated.'));
-
-    // --- Step 4: Modify the copied server.ts ---
-    // Check if the file exists before reading
-    if (!await fs.pathExists(serverDestPath)) {
-      throw new Error(`Critical error: server.ts was not found at ${serverDestPath} after copy.`);
-    }
-    
+    // --- Step 6: Inject Routes into the Main Server File ---
+    const serverDestPath = path.join(destSrcDir, 'server.ts');
     let serverFileContent = await fs.readFile(serverDestPath, 'utf-8');
-    serverFileContent = serverFileContent.replace('// INJECT:ROUTES', `import apiRoutes from './routes';\napp.use(apiRoutes);`);
-    await fs.writeFile(serverDestPath, serverFileContent);
+    
+    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));
+// -------------------------
+`;
+    }
 
-    console.log(chalk.gray('    -> server.ts modified successfully.'));
+    // 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);
 
-    // --- Step 5: Install Dependencies ---
-    console.log(chalk.magenta('  -> Installing dependencies (npm install)...'));
+    // --- Step 7: Install All Dependencies at Once ---
+    console.log(chalk.magenta('  -> Installing dependencies (npm install)... This might take a moment.'));
     await execa('npm', ['install'], { cwd: projectDir });
 
-    // --- Step 6: Generate README ---
+    // --- Step 8: Generate README ---
     await renderAndWrite(
       getTemplatePath('node-ts-express/partials/README.md.ejs'),
       path.join(projectDir, 'README.md'),
@@ -77,7 +120,8 @@ async function generateNodeProject(options) {
     );
 
   } catch (error) {
-    // Re-throw the error to be caught by the main CLI handler
+    // 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/Controller.ts.ejs

@@ -0,0 +1,57 @@
+// Auto-generated by create-backlist on <%= new Date().toISOString() %>
+import { Request, Response } from 'express';
+import <%= modelName %>, { I<%= modelName %> } from '../models/<%= modelName %>.model';
+
+// @desc    Create a new <%= modelName %>
+export const create<%= modelName %> = async (req: Request, res: Response) => {
+  try {
+    const newDoc = new <%= modelName %>(req.body);
+    await newDoc.save();
+    res.status(201).json(newDoc);
+  } catch (error) {
+    res.status(500).json({ message: 'Error creating document', error });
+  }
+};
+
+// @desc    Get all <%= modelName %>s
+export const getAll<%= modelName %>s = async (req: Request, res: Response) => {
+  try {
+    const docs = await <%= modelName %>.find();
+    res.status(200).json(docs);
+  } catch (error) {
+    res.status(500).json({ message: 'Error fetching documents', error });
+  }
+};
+
+// @desc    Get a single <%= modelName %> by ID
+export const get<%= modelName %>ById = async (req: Request, res: Response) => {
+  try {
+    const doc = await <%= modelName %>.findById(req.params.id);
+    if (!doc) return res.status(404).json({ message: 'Document not found' });
+    res.status(200).json(doc);
+  } catch (error) {
+    res.status(500).json({ message: 'Error fetching document', error });
+  }
+};
+
+// @desc    Update a <%= modelName %> by ID
+export const update<%= modelName %>ById = async (req: Request, res: Response) => {
+  try {
+    const doc = await <%= modelName %>.findByIdAndUpdate(req.params.id, req.body, { new: true, runValidators: true });
+    if (!doc) return res.status(404).json({ message: 'Document not found' });
+    res.status(200).json(doc);
+  } catch (error) {
+    res.status(500).json({ message: 'Error updating document', error });
+  }
+};
+
+// @desc    Delete a <%= modelName %> by ID
+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' });
+    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/Model.ts.ejs

@@ -0,0 +1,22 @@
+// Auto-generated by create-backlist on <%= new Date().toISOString() %>
+import mongoose, { Schema, Document } from 'mongoose';
+
+// Define the interface for the Document
+export interface I<%= modelName %> extends Document {
+<% Object.keys(schema).forEach(key => { %>
+  <%= key %>: <%= schema[key].toLowerCase() %>;
+<% }); %>
+}
+
+// Define the Mongoose Schema
+const <%= modelName %>Schema: Schema = new Schema({
+<% Object.keys(schema).forEach(key => { %>
+  <%= key %>: {
+    type: <%= schema[key] %>,
+    // TODO: Add 'required', 'unique', etc. here
+  },
+<% }); %>
+}, { timestamps: true });
+
+// Create and export the Model
+export default mongoose.model<I<%= modelName %>>('<%= modelName %>', <%= modelName %>Schema);

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

@@ -1,23 +1,60 @@
-// Auto-generated by Backlist on <%= new Date().toISOString() %>
+// Auto-generated by create-backlist 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')); %>
+
+// Import all the generated controllers
+<% for (const controller of controllersToImport) { %>
+import * as <%= controller %>Controller from '../controllers/<%= controller %>.controller';
+<% } %>
 
 const router = Router();
 
-<% if (endpoints.length === 0) { %>
-// No API endpoints were detected in the frontend code. Add your routes here.
-<% } else { %>
+<%# Loop through each endpoint found by the analyzer %>
 <% endpoints.forEach(endpoint => { %>
-<%# Convert /api/users/{id} to /users/:id %>
-<% const expressPath = endpoint.path.replace('/api', '').replace(/{(\w+)}/g, ':$1'); %>
+<%
+  // Convert URL path for Express router (e.g., /api/users/{id} -> /users/:id)
+  const expressPath = endpoint.path.replace('/api', '').replace(/{(\w+)}/g, ':$1');
+  const controllerName = endpoint.controllerName;
+  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 (!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 %>' });
+    }`;
+  }
+%>
 /**
- * Handler for <%= endpoint.method.toUpperCase() %> <%= endpoint.path %>
+ * Route for <%= endpoint.method.toUpperCase() %> <%= endpoint.path %>
+ * Mapped to: <%- handlerFunction.includes('=>') ? 'Inline Handler' : handlerFunction %>
  */
-router.<%= endpoint.method.toLowerCase() %>('<%- expressPath %>', (req: Request, res: Response) => {
-  console.log(`Request received for: ${req.method} ${req.path}`);
-  // TODO: Implement your logic here.
-  res.status(200).json({ message: 'Auto-generated response for <%= endpoint.path %>' });
-});
+router.<%= endpoint.method.toLowerCase() %>('<%- expressPath %>', <%- handlerFunction %>);
+
 <% }); %>
-<% } %>
 
 export default router;