create-backlist 1.3.3 → 2.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-backlist",
-  "version": "1.3.3",
+  "version": "2.0.0",
   "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

@@ -5,81 +5,137 @@ const path = require('path');
 const { analyzeFrontend } = require('../analyzer');
 const { renderAndWrite, getTemplatePath } = require('./template');
 
+/**
+ * Generate a Node.js + TypeScript (Express) backend project automatically.
+ */
 async function generateNodeProject(options) {
   const { projectDir, projectName, frontendSrcDir } = options;
 
   try {
     // --- Step 1: Analyze Frontend ---
-    console.log(chalk.blue('  -> Analyzing frontend for API endpoints...'));
+    console.log(chalk.blue(' -> Analyzing frontend for API endpoints...'));
     const endpoints = await analyzeFrontend(frontendSrcDir);
+
     if (endpoints.length > 0) {
-      console.log(chalk.green(`  -> Found ${endpoints.length} endpoints.`));
+      console.log(chalk.green(` -> Found ${endpoints.length} endpoints.`));
     } else {
-      console.log(chalk.yellow('  -> No API endpoints found. A basic project will be created.'));
+      console.log(
+        chalk.yellow(' -> No API endpoints found. A basic project will be created.')
+      );
     }
 
     // --- Step 2: Scaffold Base Project ---
     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');
-    
+
     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.'));
-    
-    // --- Step 3: Generate Dynamic Files ---
+
+    console.log(chalk.gray('    -> Base server.ts and tsconfig.json copied.'));
+
+    // --- Step 3: Generate package.json and routes.ts ---
     await renderAndWrite(
       getTemplatePath('node-ts-express/partials/package.json.ejs'),
       path.join(projectDir, 'package.json'),
       { projectName }
     );
+
     await renderAndWrite(
       getTemplatePath('node-ts-express/partials/routes.ts.ejs'),
       path.join(destSrcDir, 'routes.ts'),
       { endpoints }
     );
-    
+
     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 4: Analyze endpoints for models/controllers ---
+    const modelsToGenerate = new Map();
+
+    endpoints.forEach((ep) => {
+      if (ep.schemaFields && !modelsToGenerate.has(ep.controllerName)) {
+        modelsToGenerate.set(ep.controllerName, ep.schemaFields);
+      }
+    });
+
+    // --- Step 5: Generate Models and Controllers if applicable ---
+    if (modelsToGenerate.size > 0) {
+      console.log(chalk.blue(' -> Generating database models and controllers...'));
+
+      await fs.ensureDir(path.join(projectDir, 'src', 'models'));
+      await fs.ensureDir(path.join(projectDir, 'src', 'controllers'));
+
+      for (const [modelName, schema] of modelsToGenerate.entries()) {
+        // Generate Model file
+        await renderAndWrite(
+          getTemplatePath('node-ts-express/partials/Model.ts.ejs'),
+          path.join(projectDir, 'src', 'models', `${modelName}.model.ts`),
+          { modelName, schema }
+        );
+
+        // Generate Controller file
+        await renderAndWrite(
+          getTemplatePath('node-ts-express/partials/Controller.ts.ejs'),
+          path.join(projectDir, 'src', 'controllers', `${modelName}.controller.ts`),
+          { modelName }
+        );
+      }
+
+      console.log(chalk.gray('    -> Models and controllers generated.'));
+    }
+
+    // --- Step 6: Modify server.ts ---
+    if (!(await fs.pathExists(serverDestPath))) {
+      throw new Error(`Critical error: server.ts was not found at ${serverDestPath}.`);
     }
-    
+
     let serverFileContent = await fs.readFile(serverDestPath, 'utf-8');
-    serverFileContent = serverFileContent.replace('// INJECT:ROUTES', `import apiRoutes from './routes';\napp.use(apiRoutes);`);
+    serverFileContent = serverFileContent.replace(
+      '// INJECT:ROUTES',
+      `import apiRoutes from './routes';\napp.use(apiRoutes);`
+    );
     await fs.writeFile(serverDestPath, serverFileContent);
 
     console.log(chalk.gray('    -> server.ts modified successfully.'));
 
-    // --- Step 5: Install Dependencies ---
+    // --- Step 7: Install dependencies ---
     console.log(chalk.magenta('  -> Installing dependencies (npm install)...'));
     await execa('npm', ['install'], { cwd: projectDir });
 
-    // --- Step 6: Generate README ---
+    // --- Step 8: Add mongoose if models were generated ---
+    if (modelsToGenerate.size > 0) {
+      console.log(chalk.gray(' -> Adding Mongoose to dependencies...'));
+
+      const packageJsonPath = path.join(projectDir, 'package.json');
+      const packageJson = await fs.readJson(packageJsonPath);
+      packageJson.dependencies = packageJson.dependencies || {};
+      packageJson.dependencies['mongoose'] = '^7.5.0';
+
+      await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+
+      console.log(chalk.magenta('  -> Installing new dependencies (mongoose)...'));
+      await execa('npm', ['install'], { cwd: projectDir });
+    }
+
+    // --- Step 9: Generate README ---
     await renderAndWrite(
       getTemplatePath('node-ts-express/partials/README.md.ejs'),
       path.join(projectDir, 'README.md'),
       { projectName }
     );
 
+    console.log(chalk.green('✅ Project generation completed successfully!'));
   } catch (error) {
-    // Re-throw the error to be caught by the main CLI handler
-    throw error;
+    console.error(chalk.red('❌ Error generating Node project:'), error);
+    throw error; // Pass to main CLI handler
   }
 }
 
-module.exports = { generateNodeProject };
+module.exports = { generateNodeProject };

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;