create-backlist 6.0.6 → 6.0.8

package/src/generators/node.js

@@ -7,70 +7,27 @@ const { analyzeFrontend } = require('../analyzer');
 const { renderAndWrite, getTemplatePath } = require('./template');
 
 async function generateNodeProject(options) {
-  const {
-    projectDir,
-    projectName,
-    frontendSrcDir,
-    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: Analyze Frontend ---
-    console.log(chalk.blue('  -> Analyzing frontend for API endpoints (AST)...'));
+    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.'));
 
-    // Group endpoints by controller
-    const endpointsByController = new Map();
-    for (const ep of endpoints) {
-      const c = ep && ep.controllerName ? ep.controllerName : 'Default';
-      if (c === 'Default') continue;
-      if (!endpointsByController.has(c)) endpointsByController.set(c, []);
-      endpointsByController.get(c).push(ep);
-    }
-
-    // --- Step 2: Identify Models to Generate (merge fields per controller) ---
+    // --- Step 2: Identify Models to Generate ---
     const modelsToGenerate = new Map();
-
-    for (const [controllerName, eps] of endpointsByController.entries()) {
-      const fieldMap = new Map();
-
-      for (const ep of eps) {
-        const fields = ep?.requestBody?.fields || ep?.schemaFields;
-        if (!fields) continue;
-
-        for (const [key, type] of Object.entries(fields)) {
-          fieldMap.set(key, { name: key, type, isUnique: key === 'email' });
-        }
-      }
-
-      if (fieldMap.size > 0) {
-        modelsToGenerate.set(controllerName, {
-          name: controllerName,
-          fields: Array.from(fieldMap.values()),
-        });
+    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, isUnique: key === 'email' })) });
       }
-    }
-
-    // Ensure User model if auth enabled
+    });
     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' },
-        ],
-      });
-      // Also ensure controller exists so routes/controller can generate if frontend didn't call /api/users
-      if (!endpointsByController.has('User')) endpointsByController.set('User', []);
+      modelsToGenerate.set('User', { name: 'User', fields: [{ name: 'name', type: 'String' }, { name: 'email', type: 'String', isUnique: true }, { name: 'password', type: 'String' }] });
     }
 
     // --- Step 3: Base Scaffolding ---
@@ -79,38 +36,28 @@ async function generateNodeProject(options) {
     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 ---
-    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';
-    }
-
+    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';
-      // prisma seed entry is fine, but if you do mongoose seeder only, don't point prisma seed to scripts/seeder.ts
-      packageJsonContent.prisma = { seed: `ts-node prisma/seed.ts` };
+      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.5';
       packageJsonContent.devDependencies['@types/bcryptjs'] = '^2.4.6';
     }
-
-    // Seeder deps only if mongoose seeder enabled
-    if (addSeeder && dbType === 'mongoose') {
+    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`;
     }
-
     if (extraFeatures.includes('testing')) {
       packageJsonContent.devDependencies['jest'] = '^29.7.0';
       packageJsonContent.devDependencies['supertest'] = '^6.3.3';
@@ -119,255 +66,131 @@ async function generateNodeProject(options) {
       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: Generate DB-specific files & Models ---
-    await fs.ensureDir(path.join(destSrcDir, 'controllers'));
-
+    
+    // --- Step 5: Generate DB-specific files & Controllers ---
     if (modelsToGenerate.size > 0) {
-      if (dbType === 'mongoose') {
-        console.log(chalk.blue('  -> Generating Mongoose models...'));
-        await fs.ensureDir(path.join(destSrcDir, 'models'));
-
-        for (const [modelName, modelData] of modelsToGenerate.entries()) {
-          // normalize schema fields to simple types (string/number/boolean)
-          const schema = {};
-          for (const field of modelData.fields || []) {
-            const t = String(field.type || 'string').toLowerCase();
-            schema[field.name] = (t === 'number' || t === 'boolean') ? t : 'string';
-          }
-
-          await renderAndWrite(
-            getTemplatePath('node-ts-express/partials/Model.ts.ejs'),
-            path.join(destSrcDir, 'models', `${modelName}.model.ts`),
-            { modelName, schema, projectName }
-          );
+        await fs.ensureDir(path.join(destSrcDir, 'controllers'));
+        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, projectName });
+            }
+        } else if (dbType === 'prisma') {
+            console.log(chalk.blue('  -> Generating Prisma schema...'));
+            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()) });
+        }
+        console.log(chalk.blue('  -> Generating controllers...'));
+        for (const [modelName] of modelsToGenerate.entries()) {
+            const templateFile = dbType === 'mongoose' ? 'Controller.ts.ejs' : 'PrismaController.ts.ejs';
+            await renderAndWrite(getTemplatePath(`node-ts-express/partials/${templateFile}`), path.join(destSrcDir, 'controllers', `${modelName}.controller.ts`), { modelName, projectName });
         }
-      }
-
-      if (dbType === 'prisma') {
-        console.log(chalk.blue('  -> Generating Prisma schema + client...'));
-        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()), projectName }
-        );
-
-        // Prisma client singleton
-        await fs.ensureDir(path.join(destSrcDir, 'db'));
-        await renderAndWrite(
-          getTemplatePath('node-ts-express/partials/prismaClient.ts.ejs'),
-          path.join(destSrcDir, 'db', 'prisma.ts'),
-          { projectName }
-        );
-      }
-    }
-
-    // --- Step 5b: Generate Controllers from Endpoints (AST-driven) ---
-    console.log(chalk.blue('  -> Generating controllers (from endpoints)...'));
-    for (const [controllerName, controllerEndpoints] of endpointsByController.entries()) {
-      const tpl =
-        dbType === 'prisma'
-          ? 'node-ts-express/partials/PrismaController.FromEndpoints.ts.ejs'
-          : 'node-ts-express/partials/Controller.FromEndpoints.ts.ejs';
-
-      await renderAndWrite(
-        getTemplatePath(tpl),
-        path.join(destSrcDir, 'controllers', `${controllerName}.controller.ts`),
-        { controllerName, endpoints: controllerEndpoints, projectName, dbType }
-      );
     }
-
-    // --- Step 6: Authentication Boilerplate ---
+    
+    // --- Step 6: Generate Authentication Boilerplate ---
     if (addAuth) {
-      console.log(chalk.blue('  -> Generating authentication boilerplate...'));
-      await fs.ensureDir(path.join(destSrcDir, 'routes'));
-      await fs.ensureDir(path.join(destSrcDir, 'middleware'));
-
-      await renderAndWrite(
-        getTemplatePath('node-ts-express/partials/Auth.controller.ts.ejs'),
-        path.join(destSrcDir, 'controllers', 'Auth.controller.ts'),
-        { dbType, projectName }
-      );
-
-      await renderAndWrite(
-        getTemplatePath('node-ts-express/partials/Auth.routes.ts.ejs'),
-        path.join(destSrcDir, 'routes', 'Auth.routes.ts'),
-        { projectName }
-      );
-
-      await renderAndWrite(
-        getTemplatePath('node-ts-express/partials/Auth.middleware.ts.ejs'),
-        path.join(destSrcDir, 'middleware', 'Auth.middleware.ts'),
-        { projectName }
-      );
-
-      // For mongoose: inject password hashing hook into User.model.ts if exists
-      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(`import bcrypt`)) {
-            userModelContent = userModelContent.replace(
-              `import mongoose, { Schema, Document } from 'mongoose';`,
-              `import mongoose, { Schema, Document } from 'mongoose';\nimport bcrypt from 'bcryptjs';`
-            );
-          }
-
-          if (!userModelContent.includes(`pre('save'`)) {
-            const preSaveHook =
-              `\n// Hash password before saving\n` +
-              `UserSchema.pre('save', async function(next) {\n` +
-              `  if (!this.isModified('password')) { return next(); }\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);
+        console.log(chalk.blue('  -> Generating authentication boilerplate...'));
+        await fs.ensureDir(path.join(destSrcDir, 'routes'));
+        await fs.ensureDir(path.join(destSrcDir, 'middleware'));
+        await renderAndWrite(getTemplatePath('node-ts-express/partials/Auth.controller.ts.ejs'), path.join(destSrcDir, 'controllers', 'Auth.controller.ts'), { dbType, projectName });
+        await renderAndWrite(getTemplatePath('node-ts-express/partials/Auth.routes.ts.ejs'), path.join(destSrcDir, 'routes', 'Auth.routes.ts'), { projectName });
+        await renderAndWrite(getTemplatePath('node-ts-express/partials/Auth.middleware.ts.ejs'), path.join(destSrcDir, 'middleware', 'Auth.middleware.ts'), { projectName });
+        
+        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')) { return next(); }\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: Seeder Script (mongoose only) ---
-    if (addSeeder && dbType === 'mongoose') {
-      console.log(chalk.blue('  -> Generating database seeder script (mongoose)...'));
+    // --- 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: Extra Features ---
+    // --- 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 }
-      );
+      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, addAuth }
-      );
+      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} */\n` +
-        `module.exports = {\n` +
-        `  preset: 'ts-jest',\n` +
-        `  testEnvironment: 'node',\n` +
-        `  verbose: true,\n` +
-        `};\n`;
+      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, endpoints }
-      );
+      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 into server.ts ---
-    await renderAndWrite(
-      getTemplatePath('node-ts-express/partials/routes.ts.ejs'),
-      path.join(destSrcDir, 'routes.ts'),
-      { endpoints, addAuth, dbType }
-    );
-
+    // --- 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');
+    let dbConnectionCode = '', swaggerInjector = '', authRoutesInjector = '';
 
-    // Mongoose db connect injection only; prisma uses src/db/prisma.ts
-    let dbConnectionCode = '';
     if (dbType === 'mongoose') {
-      dbConnectionCode =
-        `\n// --- Database Connection ---\n` +
-        `import mongoose from 'mongoose';\n` +
-        `const MONGO_URI = process.env.MONGO_URI || 'mongodb://127.0.0.1:27017/${projectName}';\n` +
-        `mongoose.connect(MONGO_URI)\n` +
-        `  .then(() => console.log('MongoDB Connected...'))\n` +
-        `  .catch(err => console.error(err));\n` +
-        `// -------------------------\n`;
+        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`;
     }
-
-    let swaggerInjector = '';
     if (extraFeatures.includes('swagger')) {
-      swaggerInjector = `\nimport { setupSwagger } from './utils/swagger';\nsetupSwagger(app);\n`;
+        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);\n`);
-
-    // place swagger setup before listen
+      .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 Dependencies & Post-install ---
+    // --- 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 11: Final Files (.env.example) ---
+    
+    // --- Step 11: Generate Final Files (.env.example) ---
     let envContent = `PORT=${port}\n`;
-
     if (dbType === 'mongoose') {
-      envContent += `MONGO_URI=mongodb://127.0.0.1:27017/${projectName}\n`;
+        envContent += `MONGO_URI=mongodb://root:example@db:27017/${projectName}?authSource=admin\n`;
     } else if (dbType === 'prisma') {
-      envContent += `DATABASE_URL="postgresql://user:password@localhost:5432/${projectName}?schema=public"\n`;
+        envContent += `DATABASE_URL="postgresql://user:password@db:5432/${projectName}?schema=public"\n`;
     }
-
-    if (addAuth) envContent += `JWT_SECRET=change_me_long_secret_change_me_long_secret\n`;
-
-    if (extraFeatures.includes('docker') && dbType === 'prisma') {
-      envContent += `\n# Docker-compose credentials\nDB_USER=postgres\nDB_PASSWORD=password\nDB_NAME=${projectName}\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

@@ -2,47 +2,11 @@ const fs = require('fs-extra');
 const ejs = require('ejs');
 const path = require('path');
 
-function pascalCase(str) {
-  return String(str || '')
-    .replace(/[-_]+(.)/g, (_, c) => c.toUpperCase())
-    .replace(/^\w/, c => c.toUpperCase())
-    .replace(/[^a-zA-Z0-9]/g, '');
-}
-
-function camelCase(str) {
-  const p = pascalCase(str);
-  return p ? p.charAt(0).toLowerCase() + p.slice(1) : '';
-}
-
-function mapTsType(t) {
-  const x = String(t || '').toLowerCase();
-  if (x === 'number' || x === 'int' || x === 'integer' || x === 'float' || x === 'double') return 'number';
-  if (x === 'boolean' || x === 'bool') return 'boolean';
-  return 'string';
-}
-
-function mapMongooseType(t) {
-  const x = String(t || '').toLowerCase();
-  if (x === 'number' || x === 'int' || x === 'integer' || x === 'float' || x === 'double') return 'Number';
-  if (x === 'boolean' || x === 'bool') return 'Boolean';
-  return 'String';
-}
-
 async function renderAndWrite(templatePath, outPath, data) {
-  const helpers = { pascalCase, camelCase, mapTsType, mapMongooseType };
-
   try {
     const tpl = await fs.readFile(templatePath, 'utf-8');
-    const code = ejs.render(tpl, { ...(data || {}), ...helpers }, { filename: templatePath });
-
-    // avoid rewriting identical content (useful in watch mode)
-    const exists = await fs.pathExists(outPath);
-    if (exists) {
-      const current = await fs.readFile(outPath, 'utf-8');
-      if (current === code) return;
-    }
-
-    await fs.outputFile(outPath, code.endsWith('\n') ? code : code + '\n');
+    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 || {}));

package/src/templates/dotnet/partials/Controller.cs.ejs

@@ -3,15 +3,22 @@ using Microsoft.AspNetCore.Mvc;
 namespace <%= projectName %>.Controllers;
 
 [ApiController]
-[Route("[controller]")]
+[Route("api/[controller]")]
 public class <%= controllerName %>Controller : ControllerBase
 {
-<% endpoints.forEach(ep => { -%>
-    [Http<%= ep.method.charAt(0) + ep.method.slice(1).toLowerCase() %>("<%= ep.route.replace(`/${controllerName.toLowerCase()}`, "") %>")]
-    public IActionResult <%= ep.actionName || (ep.method.toLowerCase() + controllerName) %>()
+    // Endpoints for <%= controllerName %> auto-generated by Backlist
+
+<% endpoints.forEach(endpoint => { %>
+    <%# Convert /api/users/{id} to just {id} for the route attribute %>
+    <% const routePath = endpoint.path.replace(`/api/${controllerName.toLowerCase()}`, '').substring(1); %>
+    /**
+     * <%= endpoint.method.toUpperCase() %> <%= endpoint.path %>
+     */
+    [Http<%= endpoint.method.charAt(0) + endpoint.method.slice(1).toLowerCase() %>("<%- routePath %>")]
+    public IActionResult AutoGenerated_<%= endpoint.method %>_<%= routePath.replace(/{|}/g, 'By_').replace(/[^a-zA-Z0-9_]/g, '') || 'Index' %>()
     {
-        return Ok(new { message = "TODO: Implement <%= ep.method %> <%= ep.route %>" });
+        // TODO: Implement logic here. You can access route parameters like: public IActionResult Get(int id)
+        return Ok(new { message = "Auto-generated response for <%= endpoint.method.toUpperCase() %> <%= endpoint.path %>" });
     }
-
-<% }) -%>
+<% }); %>
 }

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

@@ -4,27 +4,22 @@ package <%= group %>.<%= projectName %>;
 import org.springframework.boot.CommandLineRunner;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
-
 import <%= group %>.<%= projectName %>.model.User;
 import <%= group %>.<%= projectName %>.repository.UserRepository;
-
 import org.springframework.security.crypto.password.PasswordEncoder;
 
 @Configuration
 public class ApplicationSeeder {
-
   @Bean
   CommandLineRunner seed(UserRepository userRepository, PasswordEncoder encoder) {
     return args -> {
-      userRepository.findByEmail("admin@example.com").ifPresentOrElse(u -> {
-        // already exists
-      }, () -> {
+      if (userRepository.findByEmail("admin@example.com").isEmpty()) {
         User admin = new User();
         admin.setName("Admin");
         admin.setEmail("admin@example.com");
         admin.setPassword(encoder.encode("admin123"));
         userRepository.save(admin);
-      });
+      }
     };
   }
 }

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

@@ -4,7 +4,6 @@ package <%= group %>.<%= projectName %>.controller;
 import <%= group %>.<%= projectName %>.model.User;
 import <%= group %>.<%= projectName %>.repository.UserRepository;
 import <%= group %>.<%= projectName %>.security.JwtService;
-
 import org.springframework.http.ResponseEntity;
 import org.springframework.http.HttpStatus;
 import org.springframework.security.crypto.password.PasswordEncoder;
@@ -22,41 +21,29 @@ public class AuthController {
   private final JwtService jwt;
 
   public AuthController(UserRepository repo, PasswordEncoder encoder, JwtService jwt) {
-    this.repo = repo;
-    this.encoder = encoder;
-    this.jwt = jwt;
+    this.repo = repo; this.encoder = encoder; this.jwt = jwt;
   }
 
   @PostMapping("/register")
-  public ResponseEntity<?> register(@RequestBody AuthRequest req) {
-    if (repo.findByEmail(req.email()).isPresent()) {
+  public ResponseEntity<?> register(@RequestBody User req) {
+    if (repo.findByEmail(req.getEmail()).isPresent()) {
       return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("User already exists");
     }
-
-    User user = new User();
-    user.setName(req.name());
-    user.setEmail(req.email());
-    user.setPassword(encoder.encode(req.password()));
-    repo.save(user);
-
-    String token = jwt.generateToken(user.getEmail());
+    req.setPassword(encoder.encode(req.getPassword()));
+    repo.save(req);
+    String token = jwt.generateToken(req.getEmail());
     return ResponseEntity.status(HttpStatus.CREATED).body(new TokenResponse(token));
   }
 
   @PostMapping("/login")
-  public ResponseEntity<?> login(@RequestBody LoginRequest req) {
-    Optional<User> current = repo.findByEmail(req.email());
+  public ResponseEntity<?> login(@RequestBody User req) {
+    Optional<User> current = repo.findByEmail(req.getEmail());
     if (current.isEmpty()) return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("Invalid credentials");
-
-    if (!encoder.matches(req.password(), current.get().getPassword())) {
+    if (!encoder.matches(req.getPassword(), current.get().getPassword()))
       return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("Invalid credentials");
-    }
-
-    String token = jwt.generateToken(current.get().getEmail());
+    String token = jwt.generateToken(req.getEmail());
     return ResponseEntity.ok(new TokenResponse(token));
   }
 
-  public record AuthRequest(String name, String email, String password) {}
-  public record LoginRequest(String email, String password) {}
   public record TokenResponse(String token) {}
 }