create-backlist 5.0.7 → 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/python.js

@@ -19,52 +19,81 @@ async function generatePythonProject(options) {
       }
     });
 
-    // --- Step 2: Scaffold Base Python Project ---
-    console.log(chalk.blue('  -> Scaffolding Python (FastAPI) project...'));
+    // Add a default User model if none was detected but auth might be added later
+    if (!modelsToGenerate.has('User')) {
+        modelsToGenerate.set('User', { name: 'User', fields: [{ name: 'name', type: 'String' }, { name: 'email', type: 'String'}] });
+    }
+
+    // --- Step 2: Scaffold Base Python Project Directories ---
+    console.log(chalk.blue('  -> Scaffolding Python (FastAPI) project structure...'));
     const appDir = path.join(projectDir, 'app');
-    const routesDir = path.join(appDir, 'routes');
+    const coreDir = path.join(appDir, 'core');
+    const dbDir = path.join(appDir, 'db'); // For DB connection
+    const modelsDir = path.join(appDir, 'models');
+    const schemasDir = path.join(appDir, 'schemas');
+    const routesDir = path.join(appDir, 'routers');
+    
     await fs.ensureDir(appDir);
+    await fs.ensureDir(coreDir);
+    await fs.ensureDir(dbDir);
+    await fs.ensureDir(modelsDir);
+    await fs.ensureDir(schemasDir);
     await fs.ensureDir(routesDir);
 
-    // --- Step 3: Generate Files from Templates ---
+    // --- Step 3: Generate All Python Files from Templates ---
     const controllers = Array.from(modelsToGenerate.keys());
 
-    // Generate main.py
+    // Generate main application file
     await renderAndWrite(getTemplatePath('python-fastapi/main.py.ejs'), path.join(projectDir, 'app', 'main.py'), { projectName, controllers });
-
-    // Generate requirements.txt
+    // Generate dependency file
     await renderAndWrite(getTemplatePath('python-fastapi/requirements.txt.ejs'), path.join(projectDir, 'requirements.txt'), {});
     
-    // Generate route file for each model
+    // Generate core files (config, security)
+    await renderAndWrite(getTemplatePath('python-fastapi/app/core/config.py.ejs'), path.join(coreDir, 'config.py'), { projectName });
+    await renderAndWrite(getTemplatePath('python-fastapi/app/core/security.py.ejs'), path.join(coreDir, 'security.py'), {});
+
+    // Generate DB connection and base model
+    await renderAndWrite(getTemplatePath('python-fastapi/app/db.py.ejs'), path.join(appDir, 'db.py'), {});
+
+    // Generate model and schema files for User (for auth)
+    await renderAndWrite(getTemplatePath('python-fastapi/app/models/user.py.ejs'), path.join(modelsDir, 'user.py'), {});
+    await renderAndWrite(getTemplatePath('python-fastapi/app/schemas/user.py.ejs'), path.join(schemasDir, 'user.py'), {});
+
+    // Generate router for auth
+    await renderAndWrite(getTemplatePath('python-fastapi/app/routers/auth.py.ejs'), path.join(routesDir, 'auth.py'), {});
+
+    // Generate router for each detected 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 }
-        );
+        if(modelName.toLowerCase() !== 'user') { // User model is handled separately
+            // In a full implementation, you'd have generic model/schema templates too
+        }
+        await renderAndWrite(getTemplatePath('python-fastapi/app/routers/model_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
+    const pipPath = process.platform === 'win32' ? path.join('venv', 'Scripts', 'pip') : path.join('venv', 'bin', '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`'));
+    // --- Step 5: Generate Docker and .env files ---
+    await renderAndWrite(getTemplatePath('python-fastapi/Dockerfile.ejs'), path.join(projectDir, 'Dockerfile'), {});
+    await renderAndWrite(getTemplatePath('python-fastapi/docker-compose.yml.ejs'), path.join(projectDir, 'docker-compose.yml'), { projectName });
+    
+    const envContent = `DATABASE_URL="postgresql://postgres:password@db:5432/${projectName}"\nJWT_SECRET="a_very_secret_key_change_this"`;
+    await fs.writeFile(path.join(projectDir, '.env'), envContent);
+    await fs.writeFile(path.join(projectDir, '.env.example'), envContent);
+
+
+    console.log(chalk.green('  -> Python (FastAPI) backend generation is complete!'));
+    console.log(chalk.yellow('\nTo run your new Python backend with Docker:'));
+    console.log(chalk.cyan('  1. Make sure Docker Desktop is running.'));
+    console.log(chalk.cyan('  2. Run: `docker-compose up --build`'));
+    console.log(chalk.cyan('  3. API will be available at http://localhost:8000 and docs at http://localhost:8000/docs'));
 
 
   } 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.`);
     }

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 || {}));