create-backlist 5.0.4 → 5.0.6

package/package.json

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

package/src/generators/node.js

@@ -7,13 +7,18 @@ const { analyzeFrontend } = require('../analyzer');
 const { renderAndWrite, getTemplatePath } = require('./template');
 
 async function generateNodeProject(options) {
-  const { projectDir, projectName, dbType, addAuth, addSeeder, extraFeatures = [] } = options;
+  // v5.0: Destructure all new options
+  const { projectDir, projectName, frontendSrcDir, dbType, addAuth, addSeeder, extraFeatures = [] } = options;
   const port = 8000;
 
   try {
-    // --- Step 1: Analysis & Model Identification ---
+    // --- Step 1: Analyze Frontend ---
     console.log(chalk.blue('  -> Analyzing frontend for API endpoints...'));
-    const endpoints = await analyzeFrontend(options.frontendSrcDir);
+    const endpoints = await analyzeFrontend(frontendSrcDir);
+    if (endpoints.length > 0) console.log(chalk.green(`  -> Found ${endpoints.length} endpoints.`));
+    else console.log(chalk.yellow('  -> No API endpoints found. A basic project will be created.'));
+
+    // --- Step 2: Identify Models to Generate ---
     const modelsToGenerate = new Map();
     endpoints.forEach(ep => {
       if (ep.schemaFields && ep.controllerName !== 'Default' && !modelsToGenerate.has(ep.controllerName)) {
@@ -21,17 +26,18 @@ async function generateNodeProject(options) {
       }
     });
     if (addAuth && !modelsToGenerate.has('User')) {
+      console.log(chalk.yellow('  -> Authentication requires a "User" model. Creating a default one.'));
       modelsToGenerate.set('User', { name: 'User', fields: [{ name: 'name', type: 'String' }, { name: 'email', type: 'String', isUnique: true }, { name: 'password', type: 'String' }] });
     }
-    
-    // --- Step 2: Base Scaffolding ---
+
+    // --- Step 3: Base Scaffolding ---
     console.log(chalk.blue('  -> Scaffolding Node.js project...'));
     const destSrcDir = path.join(projectDir, 'src');
     await fs.ensureDir(destSrcDir);
     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: Prepare package.json ---
+    // --- Step 4: Prepare and Write package.json ---
     const packageJsonContent = JSON.parse(await ejs.renderFile(getTemplatePath('node-ts-express/partials/package.json.ejs'), { projectName }));
     
     if (dbType === 'mongoose') packageJsonContent.dependencies['mongoose'] = '^7.6.3';
@@ -49,8 +55,8 @@ async function generateNodeProject(options) {
     if (addSeeder) {
       packageJsonContent.devDependencies['@faker-js/faker'] = '^8.3.1';
       if (!packageJsonContent.dependencies['chalk']) packageJsonContent.dependencies['chalk'] = '^4.1.2';
-      packageJsonContent.scripts['seed'] = 'ts-node scripts/seeder.ts';
-      packageJsonContent.scripts['destroy'] = 'ts-node scripts/seeder.ts -d';
+      packageJsonContent.scripts['seed'] = `ts-node scripts/seeder.ts`;
+      packageJsonContent.scripts['destroy'] = `ts-node scripts/seeder.ts -d`;
     }
     if (extraFeatures.includes('testing')) {
       packageJsonContent.devDependencies['jest'] = '^29.7.0';
@@ -67,7 +73,7 @@ async function generateNodeProject(options) {
     }
     await fs.writeJson(path.join(projectDir, 'package.json'), packageJsonContent, { spaces: 2 });
     
-    // --- Step 4: Generate DB-specific files & Controllers ---
+    // --- Step 5: Generate DB-specific files & Controllers ---
     if (modelsToGenerate.size > 0) {
         await fs.ensureDir(path.join(destSrcDir, 'controllers'));
         if (dbType === 'mongoose') {
@@ -82,7 +88,6 @@ async function generateNodeProject(options) {
             await fs.ensureDir(path.join(projectDir, 'prisma'));
             await renderAndWrite(getTemplatePath('node-ts-express/partials/PrismaSchema.prisma.ejs'), path.join(projectDir, 'prisma', 'schema.prisma'), { modelsToGenerate: Array.from(modelsToGenerate.values()) });
         }
-        // Generate controllers for both DB types
         console.log(chalk.blue('  -> Generating controllers...'));
         for (const [modelName] of modelsToGenerate.entries()) {
             const templateFile = dbType === 'mongoose' ? 'Controller.ts.ejs' : 'PrismaController.ts.ejs';
@@ -90,7 +95,7 @@ async function generateNodeProject(options) {
         }
     }
     
-    // --- Step 5: Generate Auth, Seeder, and Extra Features ---
+    // --- Step 6: Generate Authentication Boilerplate ---
     if (addAuth) {
         console.log(chalk.blue('  -> Generating authentication boilerplate...'));
         await fs.ensureDir(path.join(destSrcDir, 'routes'));
@@ -112,12 +117,34 @@ async function generateNodeProject(options) {
             }
         }
     }
-    if (addSeeder) { /* ... Seeder logic as before ... */ }
-    if (extraFeatures.includes('docker')) { /* ... Docker logic as before ... */ }
-    if (extraFeatures.includes('swagger')) { /* ... Swagger logic as before ... */ }
-    if (extraFeatures.includes('testing')) { /* ... Testing logic as before ... */ }
 
-    // --- Step 6: Generate Main Route File & Inject Logic into Server ---
+    // --- Step 7: 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 Extra Features ---
+    if (extraFeatures.includes('docker')) {
+      console.log(chalk.blue('  -> Generating Docker files...'));
+      await renderAndWrite(getTemplatePath('node-ts-express/partials/Dockerfile.ejs'), path.join(projectDir, 'Dockerfile'), { dbType, port });
+      await renderAndWrite(getTemplatePath('node-ts-express/partials/docker-compose.yml.ejs'), path.join(projectDir, 'docker-compose.yml'), { projectName, dbType, port });
+    }
+    if (extraFeatures.includes('swagger')) {
+      console.log(chalk.blue('  -> Generating API documentation setup...'));
+      await fs.ensureDir(path.join(destSrcDir, 'utils'));
+      await renderAndWrite(getTemplatePath('node-ts-express/partials/ApiDocs.ts.ejs'), path.join(destSrcDir, 'utils', 'swagger.ts'), { projectName, port });
+    }
+    if (extraFeatures.includes('testing')) {
+      console.log(chalk.blue('  -> Generating testing boilerplate...'));
+      const jestConfig = `/** @type {import('ts-jest').JestConfigWithTsJest} */\nmodule.exports = {\n  preset: 'ts-jest',\n  testEnvironment: 'node',\n  verbose: true,\n};`;
+      await fs.writeFile(path.join(projectDir, 'jest.config.js'), jestConfig);
+      await fs.ensureDir(path.join(projectDir, 'src', '__tests__'));
+      await renderAndWrite(getTemplatePath('node-ts-express/partials/App.test.ts.ejs'), path.join(projectDir, 'src', '__tests__', 'api.test.ts'), { addAuth });
+    }
+
+    // --- Step 9: Generate Main Route File & Inject Logic into Server ---
     await renderAndWrite(getTemplatePath('node-ts-express/partials/routes.ts.ejs'), path.join(destSrcDir, 'routes.ts'), { endpoints, addAuth, dbType });
     
     let serverFileContent = await fs.readFile(path.join(destSrcDir, 'server.ts'), 'utf-8');
@@ -143,17 +170,27 @@ async function generateNodeProject(options) {
     serverFileContent = serverFileContent.replace(listenRegex, `${swaggerInjector}\n$1`);
     await fs.writeFile(path.join(destSrcDir, 'server.ts'), serverFileContent);
 
-    // --- Step 7: Install Dependencies & Post-install ---
-    console.log(chalk.magenta('  -> Installing dependencies...'));
+    // --- Step 10: Install Dependencies & Run Post-install Scripts ---
+    console.log(chalk.magenta('  -> Installing dependencies... This may take a moment.'));
     await execa('npm', ['install'], { cwd: projectDir });
     if (dbType === 'prisma') {
       console.log(chalk.blue('  -> Running `prisma generate`...'));
       await execa('npx', ['prisma', 'generate'], { cwd: projectDir });
     }
     
-    // --- Step 8: Generate Final Files (.env.example) ---
-    // ... logic as before ...
-
+    // --- Step 11: Generate Final Files (.env.example) ---
+    let envContent = `PORT=${port}\n`;
+    if (dbType === 'mongoose') {
+        envContent += `MONGO_URI=mongodb://root:example@db:27017/${projectName}?authSource=admin\n`;
+    } else if (dbType === 'prisma') {
+        envContent += `DATABASE_URL="postgresql://user:password@db:5432/${projectName}?schema=public"\n`;
+    }
+    if (addAuth) envContent += `JWT_SECRET=your_super_secret_jwt_key_12345\n`;
+    if (extraFeatures.includes('docker')) {
+        envContent += `\n# Docker-compose credentials (used in docker-compose.yml)\nDB_USER=user\nDB_PASSWORD=password\nDB_NAME=${projectName}`;
+    }
+    await fs.writeFile(path.join(projectDir, '.env.example'), envContent);
+    
   } catch (error) {
     throw error;
   }

package/src/generators/template.js

@@ -1,11 +1,17 @@
-const ejs = require('ejs');
 const fs = require('fs-extra');
+const ejs = require('ejs');
 const path = require('path');
 
-async function renderAndWrite(templatePath, destinationPath, data) {
-  const template = await fs.readFile(templatePath, 'utf-8');
-  const content = ejs.render(template, data);
-  await fs.outputFile(destinationPath, content);
+async function renderAndWrite(templatePath, outPath, data) {
+  try {
+    const tpl = await fs.readFile(templatePath, 'utf-8');
+    const code = ejs.render(tpl, data || {}, { filename: templatePath }); // filename helps with EJS errors
+    await fs.outputFile(outPath, code);
+  } catch (err) {
+    console.error('EJS render failed for:', templatePath);
+    console.error('Data keys:', Object.keys(data || {}));
+    throw err;
+  }
 }
 
 function getTemplatePath(subpath) {

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

@@ -1,42 +1,44 @@
-// Auto-generated by create-backlist v3.0 on <%= new Date().toISOString() %>
+// Auto-generated by create-backlist 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'
+
+<% if (dbType === 'mongoose') { %>
+import User from '../models/User.model';
+<% } else if (dbType === 'prisma') { %>
+import { prisma } from '../server';
+<% } %>
 
 // @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
+    <% if (dbType === 'mongoose') { %>
+    // Mongoose Logic
     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
+    user = new User({ name, email, password });
     await user.save();
+    <% } else if (dbType === 'prisma') { %>
+    // Prisma Logic
+    const existingUser = await prisma.user.findUnique({ where: { email } });
+    if (existingUser) {
+        return res.status(400).json({ message: 'User already exists' });
+    }
+    const hashedPassword = await bcrypt.hash(password, 10);
+    const user = await prisma.user.create({
+        data: { name, email, password: hashedPassword },
+    });
+    <% } %>
 
-    // Create JWT Payload
-    const payload = {
-      user: {
-        id: user.id,
-      },
-    };
-
-    // Sign the token
+    const payload = { user: { id: user.id } };
     jwt.sign(
       payload,
       process.env.JWT_SECRET as string,
-      { expiresIn: '5h' }, // Token expires in 5 hours
+      { expiresIn: '5h' },
       (err, token) => {
         if (err) throw err;
         res.status(201).json({ token });
@@ -53,26 +55,24 @@ export const loginUser = async (req: Request, res: Response) => {
   const { email, password } = req.body;
 
   try {
-    // Check if user exists
+    <% if (dbType === 'mongoose') { %>
+    // Mongoose Logic
     const user = await User.findOne({ email });
+    <% } else if (dbType === 'prisma') { %>
+    // Prisma Logic
+    const user = await prisma.user.findUnique({ where: { 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
+    const payload = { user: { id: user.id } };
     jwt.sign(
       payload,
       process.env.JWT_SECRET as string,

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

@@ -1,125 +1,50 @@
-// Auto-generated by create-backlist v5.0
-using Microsoft.AspNetCore.Mvc;
-using Microsoft.EntityFrameworkCore;
-using <%= projectName %>.Data;
-using <%= projectName %>.Models;
-
-namespace <%= projectName %>.Controllers
-{
-    [ApiController]
-    [Route("api/[controller]")]
-    public class <%= controllerName %>Controller : ControllerBase
-    {
-        private readonly ApplicationDbContext _context;
-
-        public <%= controllerName %>Controller(ApplicationDbContext context)
-        {
-            _context = context;
-        }
-
-        // GET: api/<%= controllerName.toLowerCase() %>
-        // Retrieves all items.
-        [HttpGet]
-        public async Task<ActionResult<IEnumerable<<%= controllerName %>>>> Get<%= controllerName %>s()
-        {
-            if (_context.<%= controllerName %>s == null)
-            {
-                return NotFound("Entity set '<%= controllerName %>s' is null.");
-            }
-            return await _context.<%= controllerName %>s.ToListAsync();
-        }
-
-        // GET: api/<%= controllerName.toLowerCase() %>/{id}
-        // Retrieves a specific item by its ID.
-        [HttpGet("{id}")]
-        public async Task<ActionResult<<%= controllerName %>>> Get<%= controllerName %>(Guid id)
-        {
-            if (_context.<%= controllerName %>s == null)
-            {
-                return NotFound();
-            }
-            var item = await _context.<%= controllerName %>s.FindAsync(id);
-
-            if (item == null)
-            {
-                return NotFound();
-            }
-
-            return item;
-        }
-
-        // PUT: api/<%= controllerName.toLowerCase() %>/{id}
-        // Updates a specific item.
-        [HttpPut("{id}")]
-        public async Task<IActionResult> Put<%= controllerName %>(Guid id, <%= controllerName %> item)
-        {
-            if (id != item.Id)
-            {
-                return BadRequest();
-            }
-
-            _context.Entry(item).State = EntityState.Modified;
-
-            try
-            {
-                await _context.SaveChangesAsync();
-            }
-            catch (DbUpdateConcurrencyException)
-            {
-                if (!ItemExists(id))
-                {
-                    return NotFound();
-                }
-                else
-                {
-                    throw;
-                }
-            }
-
-            return NoContent();
-        }
-
-        // POST: api/<%= controllerName.toLowerCase() %>
-        // Creates a new item.
-        [HttpPost]
-        public async Task<ActionResult<<%= controllerName %>>> Post<%= controllerName %>(<%= controllerName %> item)
-        {
-            if (_context.<%= controllerName %>s == null)
-            {
-                return Problem("Entity set '<%= controllerName %>s' is null.");
-            }
-            // Ensure a new Guid is created for the new item
-            item.Id = Guid.NewGuid();
-            _context.<%= controllerName %>s.Add(item);
-            await _context.SaveChangesAsync();
-
-            return CreatedAtAction(nameof(Get<%= controllerName %>), new { id = item.Id }, item);
-        }
-
-        // DELETE: api/<%= controllerName.toLowerCase() %>/{id}
-        // Deletes a specific item.
-        [HttpDelete("{id}")]
-        public async Task<IActionResult> Delete<%= controllerName %>(Guid id)
-        {
-            if (_context.<%= controllerName %>s == null)
-            {
-                return NotFound();
-            }
-            var item = await _context.<%= controllerName %>s.FindAsync(id);
-            if (item == null)
-            {
-                return NotFound();
-            }
-
-            _context.<%= controllerName %>s.Remove(item);
-            await _context.SaveChangesAsync();
-
-            return NoContent();
-        }
-
-        private bool ItemExists(Guid id)
-        {
-            return (_context.<%= controllerName %>s?.Any(e => e.Id == id)).GetValueOrDefault();
-        }
-    }
-}
+// Auto-generated by create-backlist on <%= new Date().toISOString() %>
+import { Request, Response } from 'express';
+
+export const create<%= modelName %> = async (req: Request, res: Response) => {
+  try {
+    // TODO: implement create logic
+    res.status(201).json({ message: '<%= modelName %> created', data: req.body });
+  } catch (error) {
+    res.status(500).json({ message: 'Error creating <%= modelName %>', error });
+  }
+};
+
+export const getAll<%= modelName %>s = async (_req: Request, res: Response) => {
+  try {
+    // TODO: implement list logic
+    res.status(200).json([]);
+  } catch (error) {
+    res.status(500).json({ message: 'Error fetching <%= modelName %>s', error });
+  }
+};
+
+export const get<%= modelName %>ById = async (req: Request, res: Response) => {
+  try {
+    const { id } = req.params;
+    // TODO: implement get by id logic
+    res.status(200).json({ id });
+  } catch (error) {
+    res.status(500).json({ message: 'Error fetching <%= modelName %>', error });
+  }
+};
+
+export const update<%= modelName %>ById = async (req: Request, res: Response) => {
+  try {
+    const { id } = req.params;
+    // TODO: implement update logic
+    res.status(200).json({ id, ...req.body });
+  } catch (error) {
+    res.status(500).json({ message: 'Error updating <%= modelName %>', error });
+  }
+};
+
+export const delete<%= modelName %>ById = async (req: Request, res: Response) => {
+  try {
+    const { id } = req.params;
+    // TODO: implement delete logic
+    res.status(204).send();
+  } catch (error) {
+    res.status(500).json({ message: 'Error deleting <%= modelName %>', error });
+  }
+};