create-backlist 5.0.6 → 6.0.0

package/package.json

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

package/src/generators/java.js

@@ -2,95 +2,177 @@ const chalk = require('chalk');
 const { execa } = require('execa');
 const fs = require('fs-extra');
 const path = require('path');
-const axios = require('axios'); // For making HTTP requests
-const unzipper = require('unzipper'); // For extracting .zip files
+const axios = require('axios');
+const unzipper = require('unzipper');
 const { analyzeFrontend } = require('../analyzer');
 const { renderAndWrite, getTemplatePath } = require('./template');
 
+function sanitizeArtifactId(name) {
+  // Lowercase, keep letters, numbers and dashes; replace others with dashes
+  return String(name || 'backend').toLowerCase().replace(/[^a-z0-9\-]/g, '-').replace(/-+/g, '-');
+}
+
+async function downloadInitializrZip({ groupId, artifactId, name, bootVersion, dependencies }) {
+  const params = new URLSearchParams({
+    type: 'maven-project',
+    language: 'java',
+    groupId,
+    artifactId,
+    name,
+    packageName: `${groupId}.${artifactId.replace(/-/g, '')}`, // com.example.myapp
+    dependencies: dependencies.join(','),
+  });
+
+  if (bootVersion) params.set('bootVersion', bootVersion);
+
+  const url = `https://start.spring.io/starter.zip?${params.toString()}`;
+
+  const res = await axios.get(url, {
+    responseType: 'stream',
+    headers: { Accept: 'application/zip' }
+  });
+
+  return res;
+}
+
+async function extractZipStream(stream, dest) {
+  await new Promise((resolve, reject) => {
+    const out = stream.pipe(unzipper.Extract({ path: dest }));
+    out.on('close', resolve);
+    out.on('finish', resolve);
+    out.on('error', reject);
+  });
+}
+
 async function generateJavaProject(options) {
   const { projectDir, projectName, frontendSrcDir } = options;
-  const group = 'com.backlist.generated'; // A default Java group ID
+  const groupId = 'com.backlist.generated';
+  const artifactId = sanitizeArtifactId(projectName || 'backend');
+  const name = projectName || 'backend';
 
   try {
-    // --- Step 1: Download Base Project from Spring Initializr ---
     console.log(chalk.blue('  -> Contacting Spring Initializr to download a base Spring Boot project...'));
-    
-    // Define standard dependencies for a web API
-    const dependencies = 'web,data-jpa,lombok,postgresql'; // Using PostgreSQL as an example DB driver
-    const springInitializrUrl = `https://start.spring.io/starter.zip?type=maven-project&language=java&bootVersion=3.2.0&groupId=${group}&artifactId=${projectName}&name=${projectName}&dependencies=${dependencies}`;
-
-    const response = await axios({
-      url: springInitializrUrl,
-      method: 'GET',
-      responseType: 'stream'
-    });
 
-    // --- Step 2: Unzip the Downloaded Project ---
-    console.log(chalk.blue('  -> Unzipping the Spring Boot project...'));
-    await new Promise((resolve, reject) => {
-      const stream = response.data.pipe(unzipper.Extract({ path: projectDir }));
-      stream.on('finish', () => {
-        console.log(chalk.gray('    -> Project unzipped successfully.'));
-        resolve();
+    // Primary attempt: current stable Boot version. If this fails, we’ll retry without bootVersion.
+    const deps = ['web', 'data-jpa', 'lombok', 'postgresql']; // valid Initializr ids
+
+    let response;
+    try {
+      response = await downloadInitializrZip({
+        groupId,
+        artifactId,
+        name,
+        bootVersion: '3.3.4', // current stable; adjust as needed
+        dependencies: deps
       });
-      stream.on('error', reject);
-    });
+    } catch (err) {
+      // Fallback – remove bootVersion and also try smaller dependency set if needed
+      const fallbackDeps = ['web', 'data-jpa', 'lombok'];
+      try {
+        console.log(chalk.yellow('    -> Initial attempt failed. Retrying with default Boot version...'));
+        response = await downloadInitializrZip({
+          groupId,
+          artifactId,
+          name,
+          bootVersion: '', // let Initializr pick latest
+          dependencies: deps
+        });
+      } catch {
+        console.log(chalk.yellow('    -> Second attempt failed. Retrying with minimal dependencies...'));
+        response = await downloadInitializrZip({
+          groupId,
+          artifactId,
+          name,
+          bootVersion: '',
+          dependencies: fallbackDeps
+        });
+      }
+    }
 
-    // --- Step 3: Analyze Frontend ---
+    console.log(chalk.blue('  -> Unzipping the Spring Boot project...'));
+    await extractZipStream(response.data, projectDir);
+
+    // Analyze frontend and plan entities/controllers
     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 })) });
+    (Array.isArray(endpoints) ? endpoints : []).forEach(ep => {
+      if (ep && ep.schemaFields && ep.controllerName && 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 4: Generate Java Entities and Controllers ---
+    // Generate Entities/Repositories/Controllers (basic)
     if (modelsToGenerate.size > 0) {
-      console.log(chalk.blue('  -> Generating Java entities and controllers...'));
-      
-      const javaSrcPath = path.join(projectDir, 'src', 'main', 'java', ...group.split('.'), projectName);
-      const entityDir = path.join(javaSrcPath, 'model');
-      const controllerDir = path.join(javaSrcPath, 'controller');
+      console.log(chalk.blue('  -> Generating Java entities, repositories, and controllers...'));
+
+      // Spring Initializr zips project as <artifactId> root folder; if you extracted to projectDir,
+      // files are already in the right place. Compute Java src path:
+      const javaSrcRoot = path.join(projectDir, 'src', 'main', 'java', ...groupId.split('.'), artifactId.replace(/-/g, ''));
+      const entityDir = path.join(javaSrcRoot, 'model');
+      const repoDir = path.join(javaSrcRoot, 'repository');
+      const controllerDir = path.join(javaSrcRoot, 'controller');
+
       await fs.ensureDir(entityDir);
+      await fs.ensureDir(repoDir);
       await fs.ensureDir(controllerDir);
 
       for (const [modelName, modelData] of modelsToGenerate.entries()) {
         await renderAndWrite(
           getTemplatePath('java-spring/partials/Entity.java.ejs'),
           path.join(entityDir, `${modelName}.java`),
-          { group, projectName, modelName, model: modelData }
+          { group: groupId, projectName: artifactId.replace(/-/g, ''), modelName, model: modelData }
+        );
+        await renderAndWrite(
+          getTemplatePath('java-spring/partials/Repository.java.ejs'),
+          path.join(repoDir, `${modelName}Repository.java`),
+          { group: groupId, projectName: artifactId.replace(/-/g, ''), modelName }
         );
         await renderAndWrite(
           getTemplatePath('java-spring/partials/Controller.java.ejs'),
           path.join(controllerDir, `${modelName}Controller.java`),
-          { group, projectName, controllerName: modelName }
+          { group: groupId, projectName: artifactId.replace(/-/g, ''), controllerName: modelName, model: modelData }
         );
       }
     }
 
-    // --- Step 5: Configure application.properties ---
-    console.log(chalk.blue('  -> Configuring database in application.properties...'));
-    const propsPath = path.join(projectDir, 'src', 'main', 'resources', 'application.properties');
-    const dbProps = [
-      `\n\n# --- Auto-generated by create-backlist ---`,
-      `# --- Database Configuration (PostgreSQL) ---`,
-      `spring.datasource.url=jdbc:postgresql://localhost:5432/${projectName}`,
-      `spring.datasource.username=postgres`,
-      `spring.datasource.password=password`,
-      `spring.jpa.hibernate.ddl-auto=update`,
-      `spring.jpa.show-sql=true`,
-    ];
-    await fs.appendFile(propsPath, dbProps.join('\n'));
-    
-    console.log(chalk.green('  -> Java (Spring Boot) backend generation is complete!'));
-    console.log(chalk.yellow('\nTo run your new Java backend:'));
-    console.log(chalk.cyan('  1. Open the project in a Java IDE (like IntelliJ IDEA or VS Code).'));
-    console.log(chalk.cyan('  2. Run the main application file.'));
+    // Append DB config (PostgreSQL) to application.properties (non-fatal if fails)
+    try {
+      const propsPath = path.join(projectDir, 'src', 'main', 'resources', 'application.properties');
+      const dbProps = [
+        `\n\n# --- Auto-generated by create-backlist ---`,
+        `spring.datasource.url=jdbc:postgresql://localhost:5432/${artifactId}`,
+        `spring.datasource.username=postgres`,
+        `spring.datasource.password=password`,
+        `spring.jpa.hibernate.ddl-auto=update`,
+        `spring.jpa.show-sql=true`,
+      ].join('\n');
+      await fs.appendFile(propsPath, dbProps);
+    } catch (e) {
+      console.log(chalk.yellow('  -> Could not update application.properties (continuing).'));
+    }
 
+    console.log(chalk.green('  -> Java (Spring Boot) backend generation is complete!'));
+    console.log(chalk.yellow('\nNext steps:'));
+    console.log(chalk.cyan(`  cd ${path.basename(projectDir)}`));
+    console.log(chalk.cyan('  ./mvnw spring-boot:run   # or use your IDE to run Application class'));
 
   } catch (error) {
-    if (error.response) {
+    if (error.response && error.response.status) {
+      console.error(chalk.red(`  -> Initializr error status: ${error.response.status}`));
+      if (error.response.data) {
+        try {
+          // Try read error text body for hints
+          const text = (await (async () => {
+            let buf = '';
+            for await (const chunk of error.response.data) buf += chunk.toString();
+            return buf;
+          })());
+          console.error(chalk.yellow('  -> Initializr response body:'), text);
+        } catch {}
+      }
       throw new Error(`Failed to download from Spring Initializr. Status: ${error.response.status}`);
     }
     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/templates/java-spring/partials/ApplicationSeeder.java.ejs

@@ -0,0 +1,25 @@
+// Auto-generated by create-backlist
+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 -> {
+      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

@@ -0,0 +1,49 @@
+// Auto-generated by create-backlist
+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;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.Optional;
+
+@RestController
+@RequestMapping("/api/auth")
+@CrossOrigin(origins = "*")
+public class AuthController {
+
+  private final UserRepository repo;
+  private final PasswordEncoder encoder;
+  private final JwtService jwt;
+
+  public AuthController(UserRepository repo, PasswordEncoder encoder, JwtService jwt) {
+    this.repo = repo; this.encoder = encoder; this.jwt = jwt;
+  }
+
+  @PostMapping("/register")
+  public ResponseEntity<?> register(@RequestBody User req) {
+    if (repo.findByEmail(req.getEmail()).isPresent()) {
+      return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("User already exists");
+    }
+    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 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.getPassword(), current.get().getPassword()))
+      return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("Invalid credentials");
+    String token = jwt.generateToken(req.getEmail());
+    return ResponseEntity.ok(new TokenResponse(token));
+  }
+
+  public record TokenResponse(String token) {}
+}

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

@@ -1,61 +1,40 @@
 // 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.http.HttpStatus;
 import org.springframework.web.bind.annotation.*;
-
 import java.util.List;
 import java.util.Optional;
+import <%= group %>.<%= projectName %>.service.<%= controllerName %>Service;
+import <%= group %>.<%= projectName %>.model.<%= controllerName %>;
 
 @RestController
-@CrossOrigin(origins = "*") // Allow all origins for development
 @RequestMapping("/api/<%= controllerName.toLowerCase() %>s")
+@CrossOrigin(origins = "*")
 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();
-    }
+  private final <%= controllerName %>Service service;
+  public <%= controllerName %>Controller(<%= controllerName %>Service service) { this.service = service; }
+
+  @GetMapping public List<<%= controllerName %>> all() { return service.findAll(); }
+
+  @GetMapping("/{id}")
+  public ResponseEntity<<%= controllerName %>> one(@PathVariable Long id) {
+    return service.findById(id).map(ResponseEntity::ok).orElse(ResponseEntity.notFound().build());
+  }
+
+  @PostMapping
+  public ResponseEntity<<%= controllerName %>> create(@RequestBody <%= controllerName %> m) {
+    return new ResponseEntity<>(service.create(m), HttpStatus.CREATED);
+  }
+
+  @PutMapping("/{id}")
+  public ResponseEntity<<%= controllerName %>> update(@PathVariable Long id, @RequestBody <%= controllerName %> m) {
+    return service.update(id, m).map(ResponseEntity::ok).orElse(ResponseEntity.notFound().build());
+  }
+
+  @DeleteMapping("/{id}")
+  public ResponseEntity<Void> delete(@PathVariable Long id) {
+    return service.delete(id) ? ResponseEntity.noContent().build() : ResponseEntity.notFound().build();
+  }
 }

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

@@ -0,0 +1,11 @@
+# Auto-generated by create-backlist
+FROM eclipse-temurin:21-jdk AS build
+WORKDIR /app
+COPY . .
+RUN ./mvnw -q -DskipTests package
+
+FROM eclipse-temurin:21-jre
+WORKDIR /app
+COPY --from=build /app/target/*.jar app.jar
+EXPOSE 8080
+ENTRYPOINT ["java", "-jar", "app.jar"]

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

@@ -1,24 +1,15 @@
-// Auto-generated by create-backlist v6.0
+// Auto-generated by create-backlist
 package <%= group %>.<%= projectName %>.model;
 
-import jakarta.persistence.Entity;
-import jakarta.persistence.Id;
-import jakarta.persistence.GeneratedValue;
-import jakarta.persistence.GenerationType;
+import jakarta.persistence.*;
 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 %>;
-    <% }); %>
+  @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
+  private Long id;
+  <% model.fields.forEach(f => { %>
+  private <%= f.type === 'Number' ? 'Integer' : (f.type === 'Boolean' ? 'Boolean' : 'String') %> <%= f.name %>;
+  <% }) %>
 }

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

@@ -0,0 +1,43 @@
+// Auto-generated by create-backlist
+package <%= group %>.<%= projectName %>.security;
+
+import jakarta.servlet.FilterChain;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import org.springframework.security.core.userdetails.UserDetailsService;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.stereotype.Component;
+import org.springframework.web.filter.OncePerRequestFilter;
+
+import java.io.IOException;
+
+@Component
+public class JwtAuthFilter extends OncePerRequestFilter {
+
+  private final JwtService jwtService;
+  private final UserDetailsService uds;
+
+  public JwtAuthFilter(JwtService jwtService, UserDetailsService uds) {
+    this.jwtService = jwtService;
+    this.uds = uds;
+  }
+
+  @Override
+  protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
+      throws ServletException, IOException {
+    String header = request.getHeader("Authorization");
+    if (header != null && header.startsWith("Bearer ")) {
+      String token = header.substring(7);
+      try {
+        String subject = jwtService.validateAndGetSubject(token);
+        UserDetails ud = uds.loadUserByUsername(subject);
+        var auth = new UsernamePasswordAuthenticationToken(ud, null, ud.getAuthorities());
+        SecurityContextHolder.getContext().setAuthentication(auth);
+      } catch (Exception ignored) {}
+    }
+    chain.doFilter(request, response);
+  }
+}

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

@@ -0,0 +1,30 @@
+// Auto-generated by create-backlist
+package <%= group %>.<%= projectName %>.security;
+
+import io.jsonwebtoken.*;
+import io.jsonwebtoken.security.Keys;
+import org.springframework.stereotype.Service;
+
+import java.security.Key;
+import java.util.Date;
+
+@Service
+public class JwtService {
+  private final Key key = Keys.hmacShaKeyFor(System.getenv("JWT_SECRET") != null
+          ? System.getenv("JWT_SECRET").getBytes()
+          : "change_this_dev_secret_change_this_dev_secret".getBytes());
+
+  public String generateToken(String userId) {
+    return Jwts.builder()
+      .setSubject(userId)
+      .setIssuedAt(new Date())
+      .setExpiration(new Date(System.currentTimeMillis() + 1000 * 60 * 60 * 5))
+      .signWith(key, SignatureAlgorithm.HS256)
+      .compact();
+  }
+
+  public String validateAndGetSubject(String token) {
+    return Jwts.parserBuilder().setSigningKey(key).build()
+      .parseClaimsJws(token).getBody().getSubject();
+  }
+}

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

@@ -1,12 +1,9 @@
 // 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;
+import <%= group %>.<%= projectName %>.model.<%= modelName %>;
 
 @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.
-}
+public interface <%= modelName %>Repository extends JpaRepository<<%= modelName %>, Long> {}

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

@@ -0,0 +1,44 @@
+// Auto-generated by create-backlist
+package <%= group %>.<%= projectName %>.config;
+
+import <%= group %>.<%= projectName %>.security.JwtAuthFilter;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
+import org.springframework.security.config.Customizer;
+import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.web.SecurityFilterChain;
+import org.springframework.security.authentication.AuthenticationManager;
+import org.springframework.security.authentication.AuthenticationManagerResolver;
+import org.springframework.security.authentication.dao.DaoAuthenticationProvider;
+import org.springframework.security.core.userdetails.UserDetailsService;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
+
+@Configuration
+@EnableWebSecurity
+public class SecurityConfig {
+
+  private final JwtAuthFilter jwtAuthFilter;
+  private final UserDetailsService userDetailsService;
+
+  public SecurityConfig(JwtAuthFilter jwtAuthFilter, UserDetailsService uds) {
+    this.jwtAuthFilter = jwtAuthFilter;
+    this.userDetailsService = uds;
+  }
+
+  @Bean
+  public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
+    http.csrf(csrf -> csrf.disable())
+        .authorizeHttpRequests(auth -> auth
+          .requestMatchers("/api/auth/**", "/actuator/**").permitAll()
+          .anyRequest().authenticated()
+        )
+        .addFilterBefore(jwtAuthFilter, UsernamePasswordAuthenticationFilter.class)
+        .httpBasic(Customizer.withDefaults());
+    return http.build();
+  }
+
+  @Bean public PasswordEncoder passwordEncoder() { return new BCryptPasswordEncoder(); }
+}

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

@@ -0,0 +1,31 @@
+// Auto-generated by create-backlist
+package <%= group %>.<%= projectName %>.service;
+
+import org.springframework.stereotype.Service;
+import java.util.List;
+import java.util.Optional;
+import <%= group %>.<%= projectName %>.repository.<%= modelName %>Repository;
+import <%= group %>.<%= projectName %>.model.<%= modelName %>;
+
+@Service
+public class <%= modelName %>Service {
+  private final <%= modelName %>Repository repo;
+  public <%= modelName %>Service(<%= modelName %>Repository repo) { this.repo = repo; }
+
+  public List<<%= modelName %>> findAll() { return repo.findAll(); }
+  public Optional<<%= modelName %>> findById(Long id) { return repo.findById(id); }
+  public <%= modelName %> create(<%= modelName %> m) { return repo.save(m); }
+  public Optional<<%= modelName %>> update(Long id, <%= modelName %> m) {
+    return repo.findById(id).map(existing -> {
+      <% model.fields.forEach(f => { %>
+      existing.set<%= f.name.charAt(0).toUpperCase() + f.name.slice(1) %>(m.get<%= f.name.charAt(0).toUpperCase() + f.name.slice(1) %>());
+      <% }) %>
+      return repo.save(existing);
+    });
+  }
+  public boolean delete(Long id) {
+    if (!repo.existsById(id)) return false;
+    repo.deleteById(id);
+    return true;
+  }
+}

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

@@ -0,0 +1,20 @@
+// Auto-generated by create-backlist
+package <%= group %>.<%= projectName %>.model;
+
+import jakarta.persistence.*;
+import lombok.Data;
+
+@Data
+@Entity
+@Table(name="users")
+public class User {
+  @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
+  private Long id;
+
+  private String name;
+
+  @Column(unique = true)
+  private String email;
+
+  private String password;
+}

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

@@ -0,0 +1,27 @@
+// Auto-generated by create-backlist
+package <%= group %>.<%= projectName %>.security;
+
+import <%= group %>.<%= projectName %>.model.User;
+import <%= group %>.<%= projectName %>.repository.UserRepository;
+import org.springframework.security.core.userdetails.UserDetailsService;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.security.core.userdetails.UsernameNotFoundException;
+import org.springframework.stereotype.Service;
+import org.springframework.security.core.userdetails.User.UserBuilder;
+import org.springframework.security.core.userdetails.User.*;
+
+@Service
+public class UserDetailsServiceImpl implements UserDetailsService {
+
+  private final UserRepository repo;
+
+  public UserDetailsServiceImpl(UserRepository repo) {
+    this.repo = repo;
+  }
+
+  @Override
+  public UserDetails loadUserByUsername(String email) throws UsernameNotFoundException {
+    User u = repo.findByEmail(email).orElseThrow(() -> new UsernameNotFoundException("Not found"));
+    return withUsername(u.getEmail()).password(u.getPassword()).authorities("USER").build();
+  }
+}

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

@@ -0,0 +1,12 @@
+// Auto-generated by create-backlist
+package <%= group %>.<%= projectName %>.repository;
+
+import java.util.Optional;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+import <%= group %>.<%= projectName %>.model.User;
+
+@Repository
+public interface UserRepository extends JpaRepository<User, Long> {
+  Optional<User> findByEmail(String email);
+}

package/src/templates/java-spring/partials/docker-compose.yml.ejs

@@ -0,0 +1,27 @@
+version: '3.8'
+services:
+  db:
+    image: postgres:16-alpine
+    environment:
+      POSTGRES_USER: ${DB_USER:-postgres}
+      POSTGRES_PASSWORD: ${DB_PASSWORD:-password}
+      POSTGRES_DB: ${DB_NAME:-<%= projectName %>}
+    ports:
+      - "5432:5432"
+    volumes:
+      - pgdata:/var/lib/postgresql/data
+
+  app:
+    build: .
+    depends_on:
+      - db
+    environment:
+      - JWT_SECRET=${JWT_SECRET:-change_me_long_secret}
+      - SPRING_DATASOURCE_URL=jdbc:postgresql://db:5432/${DB_NAME:-<%= projectName %>}
+      - SPRING_DATASOURCE_USERNAME=${DB_USER:-postgres}
+      - SPRING_DATASOURCE_PASSWORD=${DB_PASSWORD:-password}
+    ports:
+      - "8080:8080"
+
+volumes:
+  pgdata:

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

@@ -1,64 +1,58 @@
-// Auto-generated by create-backlist v3.0 on <%= new Date().toISOString() %>
+// Auto-generated by create-backlist on <%= new Date().toISOString() %>
 import { Router, Request, Response } from 'express';
-<%# Create a unique set of controller names from the endpoints array %>
-<% const controllersToImport = new Set(endpoints.map(ep => ep.controllerName).filter(name => name !== 'Default')); %>
-
-// Import all the generated controllers
-<% for (const controller of controllersToImport) { %>
-import * as <%= controller %>Controller from '../controllers/<%= controller %>.controller';
-<% } %>
+<% 
+// Build unique controller list safely
+const controllers = [];
+if (Array.isArray(endpoints)) {
+  endpoints.forEach((ep) => {
+    if (ep && ep.controllerName && ep.controllerName !== 'Default' && !controllers.includes(ep.controllerName)) {
+      controllers.push(ep.controllerName);
+    }
+  });
+}
+%>
+<% controllers.forEach((ctrl) => { %>
+import * as <%= ctrl %>Controller from './controllers/<%= ctrl %>.controller';
+<% }) %>
 
-<%# Import the protect middleware only if authentication is enabled %>
 <% if (addAuth) { %>
-import { protect } from '../middleware/Auth.middleware';
+import { protect } from './middleware/Auth.middleware';
 <% } %>
 
 const router = Router();
 
-<%# Loop through each endpoint found by the analyzer %>
-<% endpoints.forEach(endpoint => { %>
-<%
-  // Convert URL path for Express router (e.g., /api/users/{id} -> /users/:id)
-  const expressPath = endpoint.path.replace('/api', '').replace(/{(\w+)}/g, ':$1');
-  const controllerName = endpoint.controllerName;
-  let handlerFunction;
+// If no endpoints detected, emit a basic route so file is valid
+<% if (!Array.isArray(endpoints) || endpoints.length === 0) { %>
+router.get('/health', (_req: Request, res: Response) => {
+  res.status(200).json({ ok: true, message: 'Auto-generated routes alive' });
+});
+<% } %>
 
-  // --- LOGIC TO MAP ENDPOINT TO A CRUD CONTROLLER FUNCTION ---
-  if (controllerName !== 'Default') {
-    if (endpoint.method === 'POST' && !expressPath.includes(':')) {
-      handlerFunction = `${controllerName}Controller.create${controllerName}`;
-    } else if (endpoint.method === 'GET' && !expressPath.includes(':')) {
-      handlerFunction = `${controllerName}Controller.getAll${controllerName}s`;
-    } else if (endpoint.method === 'GET' && expressPath.includes(':')) {
-      handlerFunction = `${controllerName}Controller.get${controllerName}ById`;
-    } else if (endpoint.method === 'PUT' && expressPath.includes(':')) {
-      handlerFunction = `${controllerName}Controller.update${controllerName}ById`;
-    } else if (endpoint.method === 'DELETE' && expressPath.includes(':')) {
-      handlerFunction = `${controllerName}Controller.delete${controllerName}ById`;
+<% 
+if (Array.isArray(endpoints)) {
+  endpoints.forEach((ep) => { 
+    const rawPath = (ep && ep.path) ? ep.path : '/';
+    const expressPath = (rawPath.replace(/^\/api/, '') || '/').replace(/{(\w+)}/g, ':$1');
+    const method = ((ep && ep.method) ? ep.method : 'GET').toLowerCase();
+    const ctrl = (ep && ep.controllerName) ? ep.controllerName : 'Default';
+    const hasId = expressPath.includes(':');
+    let handler = '';
+
+    if (ctrl !== 'Default') {
+      if (method === 'post' && !hasId) handler = `${ctrl}Controller.create${ctrl}`;
+      else if (method === 'get' && !hasId) handler = `${ctrl}Controller.getAll${ctrl}s`;
+      else if (method === 'get' && hasId) handler = `${ctrl}Controller.get${ctrl}ById`;
+      else if (method === 'put' && hasId) handler = `${ctrl}Controller.update${ctrl}ById`;
+      else if (method === 'delete' && hasId) handler = `${ctrl}Controller.delete${ctrl}ById`;
     }
-  }
-
-  // If no specific CRUD function matches, create a placeholder handler.
-  if (!handlerFunction) {
-    handlerFunction = `(req: Request, res: Response) => {
-      res.status(501).json({ message: 'Handler not implemented for <%= endpoint.method %> <%= expressPath %>' });
-    }`;
-  }
 
-  // --- V3.0 AUTH LOGIC: Decide if the route should be protected ---
-  // We protect all routes that modify data (POST, PUT, DELETE) if auth is enabled.
-  // We leave GET routes public by default. This is a common pattern.
-  const middleware = (addAuth && (endpoint.method === 'POST' || endpoint.method === 'PUT' || endpoint.method === 'DELETE')) 
-    ? 'protect, ' 
-    : '';
+    const needsProtect = !!addAuth && (method === 'post' || method === 'put' || method === 'delete');
+    const middleware = needsProtect ? 'protect, ' : '';
+%>
+router.<%= method %>('<%- expressPath || "/" %>', <%- middleware %><%- handler || '(req: Request, res: Response) => res.status(501).json({ message: "Not Implemented" })' %>);
+<% 
+  });
+}
 %>
-/**
- * Route for <%= endpoint.method.toUpperCase() %> <%= endpoint.path %>
- * Mapped to: <%- handlerFunction.includes('=>') ? 'Inline Handler' : handlerFunction %>
- * Protected: <%= middleware ? 'Yes' : 'No' %>
- */
-router.<%= endpoint.method.toLowerCase() %>('<%- expressPath %>', <%- middleware %><%- handlerFunction %>);
-
-<% }); %>
 
 export default router;

package/src/templates/python-fastapi/Dockerfile.ejs

@@ -0,0 +1,8 @@
+FROM python:3.12-slim
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY ./app ./app
+ENV PORT=8000
+EXPOSE 8000
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000", "--reload"]

package/src/templates/python-fastapi/app/core/config.py.ejs

@@ -0,0 +1,8 @@
+from pydantic import BaseSettings
+
+class Settings(BaseSettings):
+    DB_URL: str = "postgresql://postgres:password@localhost:5432/<%= projectName %>"
+    JWT_SECRET: str = "change_me_super_secret"
+    JWT_EXPIRE_MINUTES: int = 300
+
+settings = Settings()

package/src/templates/python-fastapi/app/core/security.py.ejs

@@ -0,0 +1,8 @@
+from datetime import datetime, timedelta
+from jose import jwt
+from app.core.config import settings
+
+def create_token(sub: str):
+    expire = datetime.utcnow() + timedelta(minutes=settings.JWT_EXPIRE_MINUTES)
+    payload = {"sub": sub, "exp": expire}
+    return jwt.encode(payload, settings.JWT_SECRET, algorithm="HS256")

package/src/templates/python-fastapi/app/db.py.ejs

@@ -0,0 +1,7 @@
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker, declarative_base
+from app.core.config import settings
+
+engine = create_engine(settings.DB_URL)
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+Base = declarative_base()

package/src/templates/python-fastapi/app/main.py.ejs

@@ -0,0 +1,24 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from app.db import Base, engine
+from app.models.user import User
+from app.routers import auth as auth_routes
+<% (controllers || []).forEach(c => { %>from app.routers import <%= c.toLowerCase() %>_routes
+<% }) %>
+
+app = FastAPI(title="<%= projectName %>")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"],
+)
+
+Base.metadata.create_all(bind=engine)
+
+@app.get("/")
+def root():
+    return {"ok": True, "message": "FastAPI backend generated by create-backlist"}
+
+app.include_router(auth_routes.router)
+<% (controllers || []).forEach(c => { %>app.include_router(<%= c.toLowerCase() %>_routes.router)
+<% }) %>

package/src/templates/python-fastapi/app/models/user.py.ejs

@@ -0,0 +1,9 @@
+from sqlalchemy import Column, Integer, String
+from app.db import Base
+
+class User(Base):
+    __tablename__ = "users"
+    id = Column(Integer, primary_key=True, index=True)
+    name = Column(String)
+    email = Column(String, unique=True, index=True)
+    password = Column(String)

package/src/templates/python-fastapi/app/routers/auth.py.ejs

@@ -0,0 +1,33 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+from passlib.hash import bcrypt
+from app.db import SessionLocal
+from app.models.user import User
+from app.schemas.user import UserCreate, Token
+from app.core.security import create_token
+
+router = APIRouter(prefix="/api/auth", tags=["Auth"])
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+@router.post("/register", response_model=Token, status_code=status.HTTP_201_CREATED)
+def register(payload: UserCreate, db: Session = Depends(get_db)):
+    if db.query(User).filter(User.email == payload.email).first():
+        raise HTTPException(status_code=400, detail="User already exists")
+    u = User(name=payload.name, email=payload.email, password=bcrypt.hash(payload.password))
+    db.add(u)
+    db.commit()
+    db.refresh(u)
+    return {"token": create_token(u.email)}
+
+@router.post("/login", response_model=Token)
+def login(payload: UserCreate, db: Session = Depends(get_db)):
+    u = db.query(User).filter(User.email == payload.email).first()
+    if not u or not bcrypt.verify(payload.password, u.password):
+        raise HTTPException(status_code=400, detail="Invalid credentials")
+    return {"token": create_token(u.email)}

package/src/templates/python-fastapi/app/routers/model_routes.py.ejs

@@ -0,0 +1,72 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from typing import List
+from sqlalchemy.orm import Session
+from app.db import SessionLocal
+from pydantic import BaseModel
+
+# Build schema from fields
+<% if (schema && schema.fields) { %>
+class <%= modelName %>Base(BaseModel):
+<% schema.fields.forEach(f => { %>
+    <%= f.name %>: <%= f.type === 'Number' ? 'int' : 'str' %>
+<% }) %>
+
+class <%= modelName %>Create(<%= modelName %>Base):
+    pass
+
+class <%= modelName %>(<%= modelName %>Base):
+    id: int
+    class Config:
+        orm_mode = True
+<% } %>
+
+router = APIRouter(prefix="/api/<%= modelName.toLowerCase() %>s", tags=["<%= modelName %>s"])
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+# NOTE: For brevity this uses a generic in-memory table replacement.
+# In a full implementation you'd generate SQLAlchemy model files per entity.
+
+_db = []
+_counter = 0
+
+@router.get("/", response_model=List[<%= modelName %>])
+def list_items():
+    return _db
+
+@router.post("/", response_model=<%= modelName %>, status_code=status.HTTP_201_CREATED)
+def create_item(payload: <%= modelName %>Create):
+    global _counter
+    _counter += 1
+    item = {"id": _counter, **payload.dict()}
+    _db.append(item)
+    return item
+
+@router.get("/{item_id}", response_model=<%= modelName %>)
+def get_item(item_id: int):
+    for it in _db:
+        if it["id"] == item_id:
+            return it
+    raise HTTPException(status_code=404, detail="Not found")
+
+@router.put("/{item_id}", response_model=<%= modelName %>)
+def update_item(item_id: int, payload: <%= modelName %>Create):
+    for idx, it in enumerate(_db):
+        if it["id"] == item_id:
+            new_it = {"id": item_id, **payload.dict()}
+            _db[idx] = new_it
+            return new_it
+    raise HTTPException(status_code=404, detail="Not found")
+
+@router.delete("/{item_id}", status_code=status.HTTP_204_NO_CONTENT)
+def delete_item(item_id: int):
+    for idx, it in enumerate(_db):
+        if it["id"] == item_id:
+            _db.pop(idx)
+            return
+    raise HTTPException(status_code=404, detail="Not found")

package/src/templates/python-fastapi/app/schemas/user.py.ejs

@@ -0,0 +1,16 @@
+from pydantic import BaseModel
+
+class UserBase(BaseModel):
+    name: str
+    email: str
+
+class UserCreate(UserBase):
+    password: str
+
+class UserOut(UserBase):
+    id: int
+    class Config:
+        orm_mode = True
+
+class Token(BaseModel):
+    token: str

package/src/templates/python-fastapi/docker-compose.yml.ejs

@@ -0,0 +1,19 @@
+version: '3.8'
+services:
+  db:
+    image: postgres:16-alpine
+    environment:
+      POSTGRES_USER: ${DB_USER:-postgres}
+      POSTGRES_PASSWORD: ${DB_PASSWORD:-password}
+      POSTGRES_DB: ${DB_NAME:-<%= projectName %>}
+    ports: ["5432:5432"]
+    volumes: [pgdata:/var/lib/postgresql/data]
+  api:
+    build: .
+    environment:
+      - DB_URL=postgresql://postgres:password@db:5432/<%= projectName %>
+      - JWT_SECRET=change_me_super_secret
+    ports: ["8000:8000"]
+    depends_on: [db]
+volumes:
+  pgdata:

package/src/templates/python-fastapi/requirements.txt.ejs

@@ -1,4 +1,8 @@
 fastapi
 uvicorn[standard]
+python-dotenv
+sqlalchemy
+psycopg2-binary
 pydantic
-# Add other dependencies like 'sqlalchemy', 'psycopg2-binary' if using a database
+passlib[bcrypt]
+python-jose[cryptography]