create-backlist 2.0.0 → 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": "2.0.0",
+  "version": "2.0.1",
   "description": "An advanced, multi-language backend generator based on frontend analysis.",
   "type": "commonjs",
   "bin": {

package/src/generators/node.js

@@ -5,137 +5,125 @@ 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...'));
+    // --- 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) {
-      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...'));
-
-    const baseDir = getTemplatePath('node-ts-express/base');
-    const serverTemplatePath = path.join(baseDir, 'server.ts');
-    const tsconfigTemplatePath = path.join(baseDir, 'tsconfig.json');
+    // --- 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...'));
+    
+    // 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');
-
     await fs.ensureDir(destSrcDir);
-    await fs.copy(serverTemplatePath, serverDestPath);
-    await fs.copy(tsconfigTemplatePath, tsconfigDestPath);
-
-    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 }
-    );
+    // 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) ---
 
-    await renderAndWrite(
-      getTemplatePath('node-ts-express/partials/routes.ts.ejs'),
-      path.join(destSrcDir, 'routes.ts'),
-      { endpoints }
+    // Prepare package.json content (in memory)
+    const packageJsonContent = JSON.parse(
+      await ejs.renderFile(getTemplatePath('node-ts-express/partials/package.json.ejs'), { projectName })
     );
 
-    console.log(chalk.gray('    -> package.json and routes.ts generated.'));
-
-    // --- 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 ---
+    // Conditionally add Mongoose if we are generating models
     if (modelsToGenerate.size > 0) {
-      console.log(chalk.blue(' -> Generating database models and controllers...'));
+      console.log(chalk.gray('    -> Preparing to add Mongoose to dependencies...'));
+      packageJsonContent.dependencies['mongoose'] = '^7.5.0'; // Use a recent, stable version
+    }
 
-      await fs.ensureDir(path.join(projectDir, 'src', 'models'));
-      await fs.ensureDir(path.join(projectDir, 'src', 'controllers'));
+    // 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
+        // Generate Model File (e.g., models/User.model.ts)
         await renderAndWrite(
           getTemplatePath('node-ts-express/partials/Model.ts.ejs'),
-          path.join(projectDir, 'src', 'models', `${modelName}.model.ts`),
+          path.join(destSrcDir, 'models', `${modelName}.model.ts`),
           { modelName, schema }
         );
-
-        // Generate Controller file
+        // Generate Controller File (e.g., controllers/User.controller.ts)
         await renderAndWrite(
           getTemplatePath('node-ts-express/partials/Controller.ts.ejs'),
-          path.join(projectDir, 'src', 'controllers', `${modelName}.controller.ts`),
+          path.join(destSrcDir, '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}.`);
+    // --- 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');
+    
+    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));
+// -------------------------
+`;
     }
 
-    let serverFileContent = await fs.readFile(serverDestPath, 'utf-8');
-    serverFileContent = serverFileContent.replace(
-      '// INJECT:ROUTES',
-      `import apiRoutes from './routes';\napp.use(apiRoutes);`
-    );
+    // 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);
 
-    console.log(chalk.gray('    -> server.ts modified successfully.'));
-
-    // --- Step 7: 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 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 ---
+    // --- Step 8: 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) {
-    console.error(chalk.red('❌ Error generating Node project:'), error);
-    throw error; // Pass to 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;
   }
 }
 
-module.exports = { generateNodeProject };
+module.exports = { generateNodeProject };