create-backlist 4.0.0 → 5.0.1

package/src/generators/node.js

@@ -6,76 +6,94 @@ const { analyzeFrontend } = require('../analyzer');
 const { renderAndWrite, getTemplatePath } = require('./template');
 
 async function generateNodeProject(options) {
-  // v4.0: Destructure the new 'addSeeder' option
-  const { projectDir, projectName, frontendSrcDir, addAuth, addSeeder } = options;
+  // v5.0: Destructure all new options
+  const { projectDir, projectName, frontendSrcDir, dbType, addAuth, addSeeder, extraFeatures = [] } = options;
+  const port = 8000;
 
   try {
-    // --- Step 1: Analyze Frontend to get Endpoints and Schema Info ---
+    // --- Step 1: Analyze Frontend ---
     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.`));
-    } else {
-      console.log(chalk.yellow('  -> No API endpoints found. A basic project will be created.'));
-    }
+    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 which Database Models to Generate ---
+    // --- Step 2: Identify Models to Generate ---
     const modelsToGenerate = new Map();
     endpoints.forEach(ep => {
       if (ep.schemaFields && ep.controllerName !== 'Default' && !modelsToGenerate.has(ep.controllerName)) {
-        modelsToGenerate.set(ep.controllerName, ep.schemaFields);
+        modelsToGenerate.set(ep.controllerName, { name: ep.controllerName, fields: Object.entries(ep.schemaFields).map(([key, type]) => ({ name: key, type, isUnique: key === 'email' })) });
       }
     });
-
     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' });
+      modelsToGenerate.set('User', { name: 'User', fields: [{ name: 'name', type: 'String' }, { name: 'email', type: 'String', isUnique: true }, { name: 'password', type: 'String' }] });
     }
 
-    // --- Step 3: Scaffold Base Project Structure & Files ---
-    console.log(chalk.blue('  -> Scaffolding Node.js (Express + TS) project...'));
+    // --- 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 4: Prepare and Write package.json with all conditional dependencies ---
-    const packageJsonContent = JSON.parse(
-      await ejs.renderFile(getTemplatePath('node-ts-express/partials/package.json.ejs'), { projectName })
-    );
-
-    if (modelsToGenerate.size > 0 || addAuth) {
-      packageJsonContent.dependencies['mongoose'] = '^7.5.0';
+    // --- 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';
+    if (dbType === 'prisma') {
+      packageJsonContent.dependencies['@prisma/client'] = '^5.6.0';
+      packageJsonContent.devDependencies['prisma'] = '^5.6.0';
+      packageJsonContent.prisma = { seed: `ts-node ${addSeeder ? 'scripts/seeder.ts' : 'prisma/seed.ts'}` };
     }
     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';
+      packageJsonContent.devDependencies['@types/jsonwebtoken'] = '^9.0.5';
+      packageJsonContent.devDependencies['@types/bcryptjs'] = '^2.4.6';
     }
-    // v4.0: Add seeder dependencies and scripts
     if (addSeeder) {
-      packageJsonContent.devDependencies['@faker-js/faker'] = '^8.2.0';
-      // We also need chalk for the seeder script's console logs
-      packageJsonContent.dependencies['chalk'] = '^4.1.2';
-      packageJsonContent.scripts['seed'] = 'ts-node scripts/seeder.ts';
-      packageJsonContent.scripts['destroy'] = 'ts-node scripts/seeder.ts -d';
+      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`;
+    }
+    if (extraFeatures.includes('testing')) {
+      packageJsonContent.devDependencies['jest'] = '^29.7.0';
+      packageJsonContent.devDependencies['supertest'] = '^6.3.3';
+      packageJsonContent.devDependencies['@types/jest'] = '^29.5.10';
+      packageJsonContent.devDependencies['@types/supertest'] = '^2.0.16';
+      packageJsonContent.devDependencies['ts-jest'] = '^29.1.1';
+      packageJsonContent.scripts['test'] = 'jest --detectOpenHandles --forceExit';
+    }
+    if (extraFeatures.includes('swagger')) {
+      packageJsonContent.dependencies['swagger-ui-express'] = '^5.0.0';
+      packageJsonContent.dependencies['swagger-jsdoc'] = '^6.2.8';
+      packageJsonContent.devDependencies['@types/swagger-ui-express'] = '^4.1.6';
     }
     await fs.writeJson(path.join(projectDir, 'package.json'), packageJsonContent, { spaces: 2 });
     
-    // --- Step 5 & 6: Generate Models, Controllers, and Auth boilerplate ---
+    // --- Step 5: Generate DB-specific files & 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 (let [modelName, schema] of modelsToGenerate.entries()) {
-            if (addAuth && modelName === 'User') {
-                schema = { name: 'String', email: 'String', password: 'String', ...schema };
+        if (dbType === 'mongoose') {
+            console.log(chalk.blue('  -> Generating Mongoose models and controllers...'));
+            await fs.ensureDir(path.join(destSrcDir, 'models'));
+            for (const [modelName, modelData] of modelsToGenerate.entries()) {
+                const schema = modelData.fields.reduce((acc, field) => { acc[field.name] = field.type; return acc; }, {});
+                await renderAndWrite(getTemplatePath('node-ts-express/partials/Model.ts.ejs'), path.join(destSrcDir, 'models', `${modelName}.model.ts`), { modelName, schema });
+                await renderAndWrite(getTemplatePath('node-ts-express/partials/Controller.ts.ejs'), path.join(destSrcDir, 'controllers', `${modelName}.controller.ts`), { modelName });
+            }
+        } else if (dbType === 'prisma') {
+            console.log(chalk.blue('  -> Generating Prisma schema and controllers...'));
+            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()) });
+            for (const [modelName] of modelsToGenerate.entries()) {
+                await renderAndWrite(getTemplatePath('node-ts-express/partials/PrismaController.ts.ejs'), path.join(destSrcDir, 'controllers', `${modelName}.controller.ts`), { modelName });
             }
-            await renderAndWrite(getTemplatePath('node-ts-express/partials/Model.ts.ejs'), path.join(destSrcDir, 'models', `${modelName}.model.ts`), { modelName, schema });
-            await renderAndWrite(getTemplatePath('node-ts-express/partials/Controller.ts.ejs'), path.join(destSrcDir, 'controllers', `${modelName}.controller.ts`), { modelName });
         }
     }
+    
+    // --- Step 6: Generate Authentication Boilerplate ---
     if (addAuth) {
         console.log(chalk.blue('  -> Generating authentication boilerplate...'));
         await fs.ensureDir(path.join(destSrcDir, 'routes'));
@@ -83,60 +101,94 @@ async function generateNodeProject(options) {
         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'), {});
-
-        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 = `\n// Hash password before saving\nUserSchema.pre('save', async function(next) {\n  if (!this.isModified('password')) {\n    return next();\n  }\n  const salt = await bcrypt.genSalt(10);\n  this.password = await bcrypt.hash(this.password, salt);\n  next();\n});\n`;
-                userModelContent = userModelContent.replace(`// Create and export the Model`, `${preSaveHook}\n// Create and export the Model`);
-                await fs.writeFile(userModelPath, userModelContent);
+        
+        if (dbType === 'mongoose') {
+            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 = `\n// Hash password before saving\nUserSchema.pre('save', async function(next) {\n  if (!this.isModified('password')) {\n    return next();\n  }\n  const salt = await bcrypt.genSalt(10);\n  this.password = await bcrypt.hash(this.password, salt);\n  next();\n});\n`;
+                    userModelContent = userModelContent.replace(`// Create and export the Model`, `${preSaveHook}\n// Create and export the Model`);
+                    await fs.writeFile(userModelPath, userModelContent);
+                }
             }
         }
     }
 
-    // --- Step 7 (v4.0): Generate Seeder Script ---
+    // --- 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 }
-      );
+      await renderAndWrite(getTemplatePath('node-ts-express/partials/Seeder.ts.ejs'), path.join(projectDir, 'scripts', 'seeder.ts'), { projectName });
     }
 
-    // --- Step 8: 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 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 });
     
-    // --- Step 9: Inject Logic into Main Server File ---
     let serverFileContent = await fs.readFile(path.join(destSrcDir, 'server.ts'), 'utf-8');
-    let dbConnectionCode = '';
-    if (modelsToGenerate.size > 0 || addAuth) {
-      dbConnectionCode = `\n// --- Database Connection ---\nimport mongoose from 'mongoose';\nconst MONGO_URI = process.env.MONGO_URI || 'mongodb://127.0.0.1:27017/${projectName}';\nmongoose.connect(MONGO_URI)\n  .then(() => console.log('MongoDB Connected...'))\n  .catch(err => console.error('MongoDB Connection Error:', err));\n// -------------------------\n`;
+    let dbConnectionCode = '', swaggerInjector = '', authRoutesInjector = '';
+
+    if (dbType === 'mongoose') {
+        dbConnectionCode = `\n// --- Database Connection ---\nimport mongoose from 'mongoose';\nconst MONGO_URI = process.env.MONGO_URI || 'mongodb://127.0.0.1:27017/${projectName}';\nmongoose.connect(MONGO_URI).then(() => console.log('MongoDB Connected...')).catch(err => console.error(err));\n// -------------------------\n`;
+    } else if (dbType === 'prisma') {
+        dbConnectionCode = `\nimport { PrismaClient } from '@prisma/client';\nexport const prisma = new PrismaClient();\n`;
+    }
+    if (extraFeatures.includes('swagger')) {
+        swaggerInjector = `\nimport { setupSwagger } from './utils/swagger';\nsetupSwagger(app);\n`;
     }
-    let authRoutesInjector = '';
     if (addAuth) {
-      authRoutesInjector = `import authRoutes from './routes/Auth.routes';\napp.use('/api/auth', authRoutes);\n\n`;
+        authRoutesInjector = `import authRoutes from './routes/Auth.routes';\napp.use('/api/auth', authRoutes);\n\n`;
     }
+
     serverFileContent = serverFileContent
       .replace("dotenv.config();", `dotenv.config();${dbConnectionCode}`)
       .replace('// INJECT:ROUTES', `${authRoutesInjector}import apiRoutes from './routes';\napp.use('/api', apiRoutes);`);
+      
+    const listenRegex = /(app\.listen\()/;
+    serverFileContent = serverFileContent.replace(listenRegex, `${swaggerInjector}\n$1`);
     await fs.writeFile(path.join(destSrcDir, 'server.ts'), serverFileContent);
 
-    // --- Step 10: Install All Dependencies ---
-    console.log(chalk.magenta('  -> Installing all dependencies... This might take a moment.'));
+    // --- 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 });
-
-    // --- Step 11: 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);
+    if (dbType === 'prisma') {
+      console.log(chalk.blue('  -> Running `prisma generate`...'));
+      await execa('npx', ['prisma', 'generate'], { cwd: projectDir });
     }
-
+    
+    // --- 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/python.js

@@ -0,0 +1,75 @@
+const chalk = require('chalk');
+const { execa } = require('execa');
+const fs = require('fs-extra');
+const path = require('path');
+const { analyzeFrontend } = require('../analyzer');
+const { renderAndWrite, getTemplatePath } = require('./template');
+
+async function generatePythonProject(options) {
+  const { projectDir, projectName, frontendSrcDir } = options;
+
+  try {
+    // --- Step 1: Analysis & Model Identification ---
+    console.log(chalk.blue('  -> Analyzing frontend for Python (FastAPI) backend...'));
+    const endpoints = await analyzeFrontend(frontendSrcDir);
+    const modelsToGenerate = new Map();
+    endpoints.forEach(ep => {
+      if (ep.schemaFields && ep.controllerName !== 'Default' && !modelsToGenerate.has(ep.controllerName)) {
+        modelsToGenerate.set(ep.controllerName, { name: ep.controllerName, fields: Object.entries(ep.schemaFields).map(([key, type]) => ({ name: key, type })) });
+      }
+    });
+
+    // --- Step 2: Scaffold Base Python Project ---
+    console.log(chalk.blue('  -> Scaffolding Python (FastAPI) project...'));
+    const appDir = path.join(projectDir, 'app');
+    const routesDir = path.join(appDir, 'routes');
+    await fs.ensureDir(appDir);
+    await fs.ensureDir(routesDir);
+
+    // --- Step 3: Generate Files from Templates ---
+    const controllers = Array.from(modelsToGenerate.keys());
+
+    // Generate main.py
+    await renderAndWrite(getTemplatePath('python-fastapi/main.py.ejs'), path.join(projectDir, 'app', 'main.py'), { projectName, controllers });
+
+    // Generate requirements.txt
+    await renderAndWrite(getTemplatePath('python-fastapi/requirements.txt.ejs'), path.join(projectDir, 'requirements.txt'), {});
+    
+    // Generate route file for each model
+    for (const [modelName, modelData] of modelsToGenerate.entries()) {
+        await renderAndWrite(
+            getTemplatePath('python-fastapi/routes.py.ejs'),
+            path.join(routesDir, `${modelName.toLowerCase()}_routes.py`),
+            { modelName, schema: modelData }
+        );
+    }
+    
+    // --- Step 4: Setup Virtual Environment and Install Dependencies ---
+    console.log(chalk.magenta('  -> Setting up virtual environment and installing dependencies...'));
+    // Create a virtual environment
+    await execa('python', ['-m', 'venv', 'venv'], { cwd: projectDir });
+    
+    // Determine the correct pip executable path based on OS
+    const pipPath = process.platform === 'win32' 
+        ? path.join('venv', 'Scripts', 'pip') 
+        : path.join('venv', 'bin', 'pip');
+
+    // Install dependencies using the virtual environment's pip
+    await execa(path.join(projectDir, pipPath), ['install', '-r', 'requirements.txt'], { cwd: projectDir });
+    
+    console.log(chalk.green('  -> Python backend generation is complete!'));
+    console.log(chalk.yellow('\nTo run your new Python backend:'));
+    console.log(chalk.cyan('  1. Activate the virtual environment: `source venv/bin/activate` (or `venv\\Scripts\\activate` on Windows)'));
+    console.log(chalk.cyan('  2. Start the server: `uvicorn app.main:app --reload`'));
+
+
+  } catch (error) {
+    // Improve error message for command not found
+    if (error.code === 'ENOENT') {
+        throw new Error(`'${error.command}' command not found. Please ensure Python and venv are installed and in your system's PATH.`);
+    }
+    throw error;
+  }
+}
+
+module.exports = { generatePythonProject };

package/src/templates/java-spring/partials/Controller.java.ejs

@@ -0,0 +1,61 @@
+// Auto-generated by create-backlist
+package <%= group %>.<%= projectName %>.controller;
+
+import <%= group %>.<%= projectName %>.model.<%= controllerName %>;
+import <%= group %>.<%= projectName %>.repository.<%= controllerName %>Repository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.Optional;
+
+@RestController
+@CrossOrigin(origins = "*") // Allow all origins for development
+@RequestMapping("/api/<%= controllerName.toLowerCase() %>s")
+public class <%= controllerName %>Controller {
+
+    @Autowired
+    private <%= controllerName %>Repository repository;
+
+    @GetMapping
+    public List<<%= controllerName %>> getAll<%= controllerName %>s() {
+        return repository.findAll();
+    }
+
+    @GetMapping("/{id}")
+    public ResponseEntity<<%= controllerName %>> get<%= controllerName %>ById(@PathVariable Long id) {
+        Optional<<%= controllerName %>> item = repository.findById(id);
+        return item.map(ResponseEntity::ok).orElseGet(() -> ResponseEntity.notFound().build());
+    }
+
+    @PostMapping
+    public ResponseEntity<<%= controllerName %>> create<%= controllerName %>(@RequestBody <%= controllerName %> newItem) {
+        <%= controllerName %> savedItem = repository.save(newItem);
+        return new ResponseEntity<>(savedItem, HttpStatus.CREATED);
+    }
+
+    @PutMapping("/{id}")
+    public ResponseEntity<<%= controllerName %>> update<%= controllerName %>(@PathVariable Long id, @RequestBody <%= controllerName %> updatedItem) {
+        return repository.findById(id)
+                .map(item -> {
+                    // Manually map fields to update. For simplicity, we assume all fields are updatable.
+                    <% model.fields.forEach(field => { %>
+                    item.set<%= field.name.charAt(0).toUpperCase() + field.name.slice(1) %>(updatedItem.get<%= field.name.charAt(0).toUpperCase() + field.name.slice(1) %>());
+                    <% }); %>
+                    <%= controllerName %> savedItem = repository.save(item);
+                    return ResponseEntity.ok(savedItem);
+                })
+                .orElseGet(() -> ResponseEntity.notFound().build());
+    }
+
+    @DeleteMapping("/{id}")
+    public ResponseEntity<Void> delete<%= controllerName %>(@PathVariable Long id) {
+        if (!repository.existsById(id)) {
+            return ResponseEntity.notFound().build();
+        }
+        repository.deleteById(id);
+        return ResponseEntity.noContent().build();
+    }
+}

package/src/templates/java-spring/partials/Entity.java.ejs

@@ -0,0 +1,24 @@
+// Auto-generated by create-backlist v6.0
+package <%= group %>.<%= projectName %>.model;
+
+import jakarta.persistence.Entity;
+import jakarta.persistence.Id;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import lombok.Data;
+
+@Data
+@Entity
+public class <%= modelName %> {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.AUTO)
+    private Long id;
+
+    <% model.fields.forEach(field => { %>
+    <% let javaType = 'String'; %>
+    <% if (field.type === 'Number') javaType = 'Integer'; %>
+    <% if (field.type === 'Boolean') javaType = 'boolean'; %>
+    private <%= javaType %> <%= field.name %>;
+    <% }); %>
+}

package/src/templates/java-spring/partials/Repository.java.ejs

@@ -0,0 +1,12 @@
+// Auto-generated by create-backlist
+package <%= group %>.<%= projectName %>.repository;
+
+import <%= group %>.<%= projectName %>.model.<%= modelName %>;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface <%= modelName %>Repository extends JpaRepository<<%= modelName %>, Long> {
+    // Spring Data JPA automatically provides CRUD methods like findAll(), findById(), save(), deleteById()
+    // You can add custom query methods here if needed.
+}

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

@@ -0,0 +1,33 @@
+// Auto-generated by create-backlist v5.0
+import swaggerUi from 'swagger-ui-express';
+import swaggerJsdoc from 'swagger-jsdoc';
+import { Express } from 'express';
+
+const options: swaggerJsdoc.Options = {
+  definition: {
+    openapi: '3.0.0',
+    info: {
+      title: '<%= projectName %> API Documentation',
+      version: '1.0.0',
+      description: 'API documentation for the auto-generated backend.',
+    },
+    servers: [
+      {
+        url: 'http://localhost:<%= port %>',
+        description: 'Development server',
+      },
+    ],
+    // TODO: Add components (e.g., securitySchemes for JWT)
+  },
+  // Path to the API docs
+  apis: ['./src/routes/*.ts', './src/routes.ts'], // Looks for JSDoc comments in routes
+};
+
+const swaggerSpec = swaggerJsdoc(options);
+
+export function setupSwagger(app: Express) {
+  app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerSpec));
+  console.log(
+    `📄 API documentation is available at http://localhost:<%= port %>/api-docs`
+  );
+}

package/src/templates/node-ts-express/partials/App.test.ts.ejs

@@ -0,0 +1,38 @@
+// Auto-generated by create-backlist v5.0
+import request from 'supertest';
+import express from 'express';
+// Import your main app configuration. This might need path adjustment.
+// For simplicity, we create a test server here.
+import apiRoutes from '../routes'; // Assuming main routes
+import authRoutes from '../routes/Auth.routes'; // Assuming auth routes
+
+const app = express();
+app.use(express.json());
+app.use('/api', apiRoutes);
+app.use('/api/auth', authRoutes);
+
+
+describe('API Endpoints', () => {
+
+  it('should respond to the root GET endpoint', async () => {
+    // This test assumes a GET /api/ endpoint exists or a similar public one.
+    // You might need to adjust this to a real endpoint from your app.
+    // Example for GET /api/users
+    // const res = await request(app).get('/api/users');
+    // expect(res.statusCode).toEqual(200);
+    
+    // For now, a placeholder test:
+    expect(1 + 1).toBe(2);
+  });
+
+  // TODO: Add more specific tests for your generated endpoints
+  // describe('POST /api/users', () => {
+  //   it('should create a new user', async () => {
+  //     const res = await request(app)
+  //       .post('/api/users')
+  //       .send({ name: 'Test User', email: 'test@example.com', password: 'password123' });
+  //     expect(res.statusCode).toEqual(201);
+  //     expect(res.body).toHaveProperty('name', 'Test User');
+  //   });
+  // });
+});