create-backlist 6.0.0 → 6.0.2

package/src/generators/node.js

@@ -7,27 +7,70 @@ const { analyzeFrontend } = require('../analyzer');
 const { renderAndWrite, getTemplatePath } = require('./template');
 
 async function generateNodeProject(options) {
-  // v5.0: Destructure all new options
-  const { projectDir, projectName, frontendSrcDir, dbType, addAuth, addSeeder, extraFeatures = [] } = 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...'));
+    console.log(chalk.blue('  -> Analyzing frontend for API endpoints (AST)...'));
     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 ---
+    // 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) ---
     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, isUnique: key === 'email' })) });
+
+    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()),
+        });
       }
-    });
+    }
+
+    // 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' }] });
+      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', []);
     }
 
     // --- Step 3: Base Scaffolding ---
@@ -36,28 +79,38 @@ 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';
-      packageJsonContent.prisma = { seed: `ts-node ${addSeeder ? 'scripts/seeder.ts' : 'prisma/seed.ts'}` };
+      // 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` };
     }
+
     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';
     }
-    if (addSeeder) {
+
+    // Seeder deps only if mongoose seeder enabled
+    if (addSeeder && dbType === 'mongoose') {
       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';
@@ -66,131 +119,255 @@ 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 & Controllers ---
+
+    // --- Step 5: Generate DB-specific files & Models ---
+    await fs.ensureDir(path.join(destSrcDir, 'controllers'));
+
     if (modelsToGenerate.size > 0) {
-        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 === '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 }
+          );
         }
+      }
+
+      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 6: Generate Authentication Boilerplate ---
+
+    // --- 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 ---
     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 });
-        
-        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);
-                }
-            }
+      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);
         }
+      }
     }
 
-    // --- Step 7: Generate Seeder Script ---
-    if (addSeeder) {
-      console.log(chalk.blue('  -> Generating database seeder script...'));
+    // --- Step 7: Seeder Script (mongoose only) ---
+    if (addSeeder && dbType === 'mongoose') {
+      console.log(chalk.blue('  -> Generating database seeder script (mongoose)...'));
       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 Extra Features ---
+    // --- Step 8: 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 });
+      await renderAndWrite(
+        getTemplatePath('node-ts-express/partials/ApiDocs.ts.ejs'),
+        path.join(destSrcDir, 'utils', 'swagger.ts'),
+        { projectName, port, addAuth }
+      );
     }
+
     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};`;
+      const jestConfig =
+        `/** @type {import('ts-jest').JestConfigWithTsJest} */\n` +
+        `module.exports = {\n` +
+        `  preset: 'ts-jest',\n` +
+        `  testEnvironment: 'node',\n` +
+        `  verbose: true,\n` +
+        `};\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 });
+      await renderAndWrite(
+        getTemplatePath('node-ts-express/partials/App.test.ts.ejs'),
+        path.join(projectDir, 'src', '__tests__', 'api.test.ts'),
+        { addAuth, endpoints }
+      );
     }
 
-    // --- 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: 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 }
+    );
+
     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 ---\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`;
+      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`;
     }
+
+    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);`);
-      
+      .replace('dotenv.config();', `dotenv.config();${dbConnectionCode}`)
+      .replace('// INJECT:ROUTES', `${authRoutesInjector}import apiRoutes from './routes';\napp.use('/api', apiRoutes);\n`);
+
+    // place swagger setup before listen
     const listenRegex = /(app\.listen\()/;
     serverFileContent = serverFileContent.replace(listenRegex, `${swaggerInjector}\n$1`);
+
     await fs.writeFile(path.join(destSrcDir, 'server.ts'), serverFileContent);
 
-    // --- Step 10: Install Dependencies & Run Post-install Scripts ---
+    // --- Step 10: Install Dependencies & Post-install ---
     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: Generate Final Files (.env.example) ---
+
+    // --- Step 11: Final Files (.env.example) ---
     let envContent = `PORT=${port}\n`;
+
     if (dbType === 'mongoose') {
-        envContent += `MONGO_URI=mongodb://root:example@db:27017/${projectName}?authSource=admin\n`;
+      envContent += `MONGO_URI=mongodb://127.0.0.1:27017/${projectName}\n`;
     } else if (dbType === 'prisma') {
-        envContent += `DATABASE_URL="postgresql://user:password@db:5432/${projectName}?schema=public"\n`;
+      envContent += `DATABASE_URL="postgresql://user:password@localhost: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}`;
+
+    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`;
     }
+
     await fs.writeFile(path.join(projectDir, '.env.example'), envContent);
-    
+
   } catch (error) {
     throw error;
   }

package/src/generators/template.js

@@ -2,11 +2,47 @@ 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 || {}, { filename: templatePath }); // filename helps with EJS errors
-    await fs.outputFile(outPath, code);
+    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');
   } catch (err) {
     console.error('EJS render failed for:', templatePath);
     console.error('Data keys:', Object.keys(data || {}));

package/src/scanner/index.js

@@ -0,0 +1,99 @@
+const path = require('path');
+const fg = require('fast-glob');
+const { Project, SyntaxKind } = require('ts-morph');
+const fs = require('fs-extra');
+
+function normalizeMethod(name) {
+  const m = String(name).toUpperCase();
+  return ['GET','POST','PUT','PATCH','DELETE'].includes(m) ? m : null;
+}
+
+// Very first-pass extractor: axios.<method>('url') OR fetch('url', { method: 'POST' })
+async function scanFrontend({ frontendSrcDir }) {
+  const patterns = [
+    '**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx'
+  ];
+
+  const files = await fg(patterns, {
+    cwd: frontendSrcDir,
+    absolute: true,
+    ignore: ['**/node_modules/**', '**/dist/**', '**/.next/**', '**/build/**']
+  });
+
+  const project = new Project({
+    tsConfigFilePath: fs.existsSync(path.join(frontendSrcDir, '../tsconfig.json'))
+      ? path.join(frontendSrcDir, '../tsconfig.json')
+      : undefined,
+    skipAddingFilesFromTsConfig: true
+  });
+
+  files.forEach(f => project.addSourceFileAtPathIfExists(f));
+
+  const endpoints = [];
+
+  for (const sf of project.getSourceFiles()) {
+    // axios.get('/x') | axios.post('/x')
+    const callExprs = sf.getDescendantsOfKind(SyntaxKind.CallExpression);
+
+    for (const call of callExprs) {
+      const expr = call.getExpression();
+
+      // axios.<method>(...)
+      if (expr.getKind() === SyntaxKind.PropertyAccessExpression) {
+        const pae = expr;
+        const method = normalizeMethod(pae.getName());
+        const target = pae.getExpression().getText(); // axios / api / client etc (basic)
+        const args = call.getArguments();
+        if (method && args.length >= 1 && args[0].getKind() === SyntaxKind.StringLiteral) {
+          const url = args[0].getText().slice(1, -1);
+          endpoints.push({
+            source: sf.getFilePath(),
+            kind: 'axios',
+            client: target,
+            method,
+            url
+          });
+        }
+      }
+
+      // fetch('/x', { method: 'POST' })
+      if (expr.getText() === 'fetch') {
+        const args = call.getArguments();
+        if (args.length >= 1 && args[0].getKind() === SyntaxKind.StringLiteral) {
+          const url = args[0].getText().slice(1, -1);
+          let method = 'GET';
+          if (args[1] && args[1].getKind() === SyntaxKind.ObjectLiteralExpression) {
+            const obj = args[1];
+            const methodProp = obj.getProperty('method');
+            if (methodProp && methodProp.getKind() === SyntaxKind.PropertyAssignment) {
+              const init = methodProp.getInitializer();
+              if (init && init.getKind() === SyntaxKind.StringLiteral) {
+                method = init.getText().slice(1, -1).toUpperCase();
+              }
+            }
+          }
+          endpoints.push({
+            source: sf.getFilePath(),
+            kind: 'fetch',
+            method,
+            url
+          });
+        }
+      }
+    }
+  }
+
+  return {
+    version: 1,
+    generatedAt: new Date().toISOString(),
+    frontendSrcDir,
+    endpoints
+  };
+}
+
+async function writeContracts(outFile, contracts) {
+  await fs.ensureDir(path.dirname(outFile));
+  await fs.writeJson(outFile, contracts, { spaces: 2 });
+}
+
+module.exports = { scanFrontend, writeContracts };

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

@@ -3,22 +3,15 @@ using Microsoft.AspNetCore.Mvc;
 namespace <%= projectName %>.Controllers;
 
 [ApiController]
-[Route("api/[controller]")]
+[Route("[controller]")]
 public class <%= controllerName %>Controller : ControllerBase
 {
-    // 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' %>()
+<% 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) %>()
     {
-        // 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 %>" });
+        return Ok(new { message = "TODO: Implement <%= ep.method %> <%= ep.route %>" });
     }
-<% }); %>
+
+<% }) -%>
 }

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

@@ -0,0 +1,8 @@
+namespace <%= projectName %>.Models.DTOs;
+
+public class <%= model.name %>
+{
+<% for (const [name, type] of Object.entries(model.fields || {})) { -%>
+    public <%= mapCSharpType(type) %> <%= pascal(name) %> { get; set; }
+<% } -%>
+}