create-backlist 6.0.0 → 6.0.2

package/src/templates/node-ts-express/partials/PrismaSchema.prisma.ejs

@@ -1,26 +1,41 @@
-// Auto-generated by create-backlist v5.0
+// Auto-generated by create-backlist v5.1
 
 generator client {
   provider = "prisma-client-js"
 }
 
 datasource db {
-  provider = "postgresql" // User can change to "mysql", "sqlite", "sqlserver", etc.
+  provider = "postgresql"
   url      = env("DATABASE_URL")
 }
 
-<%# Loop through each model identified by the analyzer %>
+<%
+function mapPrismaType(t) {
+  const x = String(t || '').toLowerCase();
+  if (x === 'number' || x === 'int' || x === 'integer') return 'Int';
+  if (x === 'float' || x === 'double') return 'Float';
+  if (x === 'boolean' || x === 'bool') return 'Boolean';
+  if (x === 'date' || x === 'datetime') return 'DateTime';
+  return 'String';
+}
+
+function safeName(n) {
+  return String(n || '').replace(/[^a-zA-Z0-9_]/g, '');
+}
+%>
+
 <% modelsToGenerate.forEach(model => { %>
-model <%= model.name %> {
+model <%= safeName(model.name) %> {
   id        String   @id @default(cuid())
-  <%# Loop through each field in the model %>
-  <% model.fields.forEach(field => { %>
-  <%# Map JS types to Prisma types. This is a basic mapping. %>
-  <% let prismaType = 'String'; %>
-  <% if (field.type === 'Number') prismaType = 'Int'; %>
-  <% if (field.type === 'Boolean') prismaType = 'Boolean'; %>
-  <%= field.name.padEnd(10) %>  <%= prismaType %><%- field.isOptional ? '?' : '' %><%- field.isUnique ? ' @unique' : '' %>
-  <% }); %>
+
+<% (model.fields || []).forEach(field => { 
+  const fname = safeName(field.name);
+  const prismaType = mapPrismaType(field.type);
+  const optional = field.isOptional ? '?' : '';
+  const unique = field.isUnique ? ' @unique' : '';
+-%>
+  <%= fname %> <%= prismaType %><%= optional %><%= unique %>
+<% }); -%>
 
   createdAt DateTime @default(now())
   updatedAt DateTime @updatedAt

package/src/templates/node-ts-express/partials/README.md.ejs

@@ -2,15 +2,12 @@
 
 This backend was auto-generated by **Backlist**.
 
-## 🚀 Getting Started
-
-1.  **Navigate to the directory:**
-    ```bash
-    cd <%= projectName %>
-    ```
-
-2.  **Run the development server:**
-    ```bash
-    npm run dev
-    ```
-    The server will start on `http://localhost:8000`.
+## Requirements
+- Node.js 18+
+- npm 9+
+
+<% if (dbType === 'prisma') { -%>
+## Database (Prisma + PostgreSQL)
+1. Copy env:
+```bash
+cp .env.example .env

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

@@ -1,83 +1,63 @@
-// Auto-generated by create-backlist v4.0 on <%= new Date().toISOString() %>
+// Auto-generated by create-backlist v5.1 on <%= new Date().toISOString() %>
 import mongoose from 'mongoose';
 import dotenv from 'dotenv';
 import { faker } from '@faker-js/faker';
-import chalk from 'chalk'; // For colorful console logs
+import chalk from 'chalk';
 
-// Load env vars
 dotenv.config();
 
-// We assume a User model exists for seeding.
-// The path is relative to the generated 'backend' project root.
 import User from '../src/models/User.model';
 
-// --- Connect to DB ---
-const connectDB = async () => {
-  try {
-    const MONGO_URI = process.env.MONGO_URI || 'mongodb://127.0.0.1:27017/<%= projectName %>';
-    if (!MONGO_URI) {
-        throw new Error('MONGO_URI is not defined in your .env file');
-    }
-    await mongoose.connect(MONGO_URI);
-    console.log(chalk.green('MongoDB Connected for Seeder...'));
-  } catch (err) {
-    console.error(chalk.red(`Seeder DB Connection Error: ${err.message}`));
-    process.exit(1);
-  }
-};
+function getErrorMessage(err: unknown) {
+  if (err instanceof Error) return err.message;
+  return String(err);
+}
 
-// --- Import Data ---
-const importData = async () => {
-  try {
-    // Clear existing data
-    await User.deleteMany();
+async function connectDB() {
+  const MONGO_URI = process.env.MONGO_URI || 'mongodb://127.0.0.1:27017/<%= projectName %>';
+  if (!MONGO_URI) throw new Error('MONGO_URI is not defined');
 
-    const sampleUsers = [];
-    const userCount = 10; // Number of sample users to create
+  await mongoose.connect(MONGO_URI);
+  console.log(chalk.green('MongoDB Connected for Seeder...'));
+}
 
-    for (let i = 0; i < userCount; i++) {
-      sampleUsers.push({
-        name: faker.person.fullName(),
-        email: faker.internet.email().toLowerCase(),
-        password: 'password123', // All sample users will have the same password for easy testing
-      });
-    }
+async function importData() {
+  // Clear existing data
+  await User.deleteMany({});
 
-    await User.insertMany(sampleUsers);
+  const sampleUsers = Array.from({ length: 10 }).map(() => ({
+    name: faker.person.fullName(),
+    email: faker.internet.email().toLowerCase(),
+    password: 'password123',
+  }));
 
-    console.log(chalk.green.bold('✅ Data Imported Successfully!'));
-    process.exit();
-  } catch (error) {
-    console.error(chalk.red(`Error with data import: ${error.message}`));
-    process.exit(1);
-  }
-};
+  await User.insertMany(sampleUsers);
 
-// --- Destroy Data ---
-const destroyData = async () => {
-  try {
-    await User.deleteMany();
-    // If you have other models, you can add them here for destruction
-    // e.g., await Product.deleteMany();
+  console.log(chalk.green.bold('Data Imported Successfully!'));
+}
 
-    console.log(chalk.red.bold('🔥 Data Destroyed Successfully!'));
-    process.exit();
-  } catch (error) {
-    console.error(chalk.red(`Error with data destruction: ${error.message}`));
-    process.exit(1);
-  }
-};
+async function destroyData() {
+  await User.deleteMany({});
+  console.log(chalk.red.bold('Data Destroyed Successfully!'));
+}
 
-// --- CLI Logic to run the seeder ---
-const runSeeder = async () => {
-  await connectDB();
+async function run() {
+  try {
+    await connectDB();
 
-  // process.argv[2] will be '-d' if the script is run with `npm run destroy`
-  if (process.argv[2] === '-d') {
-    await destroyData();
-  } else {
-    await importData();
+    if (process.argv.includes('-d')) {
+      await destroyData();
+    } else {
+      await importData();
+    }
+  } catch (err) {
+    console.error(chalk.red(`Seeder error: ${getErrorMessage(err)}`));
+    process.exitCode = 1;
+  } finally {
+    try {
+      await mongoose.disconnect();
+    } catch {}
   }
-};
+}
 
-runSeeder();
+run();

package/src/templates/node-ts-express/partials/docker-compose.yml.ejs

@@ -1,4 +1,4 @@
-# Auto-generated by create-backlist v5.0
+# Auto-generated by create-backlist v5.1
 version: '3.8'
 
 services:
@@ -8,40 +8,55 @@ services:
     ports:
       - '<%= port %>:<%= port %>'
     environment:
-      - PORT=<%= port %>
-      - DATABASE_URL=${DATABASE_URL}
-      - JWT_SECRET=${JWT_SECRET}
+      PORT: <%= port %>
+      JWT_SECRET: ${JWT_SECRET:-change_me_long_secret_change_me_long_secret}
+<% if (dbType === 'mongoose') { -%>
+      MONGO_URI: ${MONGO_URI:-mongodb://db:27017/<%= projectName %>}
+<% } else if (dbType === 'prisma') { -%>
+      DATABASE_URL: ${DATABASE_URL:-postgresql://${DB_USER:-postgres}:${DB_PASSWORD:-password}@db:5432/${DB_NAME:-<%= projectName %>}?schema=public}
+<% } -%>
     depends_on:
-      - db
+      db:
+        condition: service_healthy
     volumes:
       - .:/usr/src/app
       - /usr/src/app/node_modules
     command: npm run dev
 
   db:
-    <% if (dbType === 'mongoose') { %>
-    image: mongo:latest
+<% if (dbType === 'mongoose') { -%>
+    image: mongo:7
     container_name: <%= projectName %>-mongo-db
     ports:
       - '27017:27017'
     volumes:
       - mongo-data:/data/db
-    <% } else if (dbType === 'prisma') { %>
-    image: postgres:14-alpine
+    healthcheck:
+      test: ["CMD", "mongosh", "--quiet", "mongodb://localhost:27017/admin", "--eval", "db.adminCommand('ping').ok"]
+      interval: 5s
+      timeout: 5s
+      retries: 20
+<% } else if (dbType === 'prisma') { -%>
+    image: postgres:16-alpine
     container_name: <%= projectName %>-postgres-db
     ports:
       - '5432:5432'
     environment:
-      - POSTGRES_USER=${DB_USER}
-      - POSTGRES_PASSWORD=${DB_PASSWORD}
-      - POSTGRES_DB=${DB_NAME}
+      POSTGRES_USER: ${DB_USER:-postgres}
+      POSTGRES_PASSWORD: ${DB_PASSWORD:-password}
+      POSTGRES_DB: ${DB_NAME:-<%= projectName %>}
     volumes:
       - postgres-data:/var/lib/postgresql/data
-    <% } %>
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U ${DB_USER:-postgres} -d ${DB_NAME:-<%= projectName %>}"]
+      interval: 5s
+      timeout: 5s
+      retries: 20
+<% } -%>
 
 volumes:
-  <% if (dbType === 'mongoose') { %>
+<% if (dbType === 'mongoose') { -%>
   mongo-data:
-  <% } else if (dbType === 'prisma') { %>
+<% } else if (dbType === 'prisma') { -%>
   postgres-data:
-  <% } %>
+<% } -%>

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

@@ -4,9 +4,11 @@
   "private": true,
   "main": "dist/server.js",
   "scripts": {
+    "dev": "ts-node-dev --respawn --transpile-only src/server.ts",
     "build": "tsc",
     "start": "node dist/server.js",
-    "dev": "ts-node-dev --respawn --transpile-only src/server.ts"
+    "typecheck": "tsc --noEmit",
+    "clean": "rimraf dist"
   },
   "dependencies": {
     "cors": "^2.8.5",

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

@@ -0,0 +1,4 @@
+// Auto-generated by create-backlist
+import { PrismaClient } from '@prisma/client';
+
+export const prisma = new PrismaClient();

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

@@ -1,56 +1,67 @@
 // Auto-generated by create-backlist on <%= new Date().toISOString() %>
 import { Router, Request, Response } from 'express';
-<% 
-// Build unique controller list safely
+
+<%
+/**
+ * Collect controllers safely
+ */
 const controllers = [];
 if (Array.isArray(endpoints)) {
-  endpoints.forEach((ep) => {
+  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';
 <% }) %>
 
-<% if (addAuth) { %>
+<% if (addAuth) { -%>
 import { protect } from './middleware/Auth.middleware';
-<% } %>
+<% } -%>
 
 const router = Router();
 
-// 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' });
 });
 <% } %>
 
-<% 
+<%
+/**
+ * Render endpoints
+ * Prefer ep.route (normalized) and fallback to ep.path
+ */
 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 = '';
+  endpoints.forEach((ep) => {
+    if (!ep) return;
 
-    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`;
-    }
+    const raw = (ep.route || ep.path || '/');
+    // mount router at /api in server.ts, so here we remove leading /api
+    const expressPath = (String(raw).replace(/^\/api/, '') || '/')
+      .replace(/{(\w+)}/g, ':$1'); // backward compat if analyzer still produces {id}
+
+    const method = String(ep.method || 'GET').toLowerCase();
+    const ctrl = ep.controllerName || 'Default';
+    const action = ep.actionName || null;
 
-    const needsProtect = !!addAuth && (method === 'post' || method === 'put' || method === 'delete');
+    const needsProtect = !!addAuth && method !== 'get'; // default: protect non-GET
     const middleware = needsProtect ? 'protect, ' : '';
+
+    let handler = '';
+    if (ctrl !== 'Default' && action) {
+      handler = `${ctrl}Controller.${action}`;
+    }
 %>
-router.<%= method %>('<%- expressPath || "/" %>', <%- middleware %><%- handler || '(req: Request, res: Response) => res.status(501).json({ message: "Not Implemented" })' %>);
-<% 
+router.<%= method %>(
+  '<%- expressPath %>',
+  <%- middleware %><%- handler || '(req: Request, res: Response) => res.status(501).json({ message: "Not Implemented" })' %>
+);
+<%
   });
 }
 %>

package/src/utils.js

@@ -1,12 +1,27 @@
 const { execa } = require('execa');
 
+const VERSION_ARGS = {
+  java: ['-version'],
+  python: ['--version'],
+  python3: ['--version'],
+  node: ['--version'],
+  npm: ['--version'],
+  dotnet: ['--version'],
+  mvn: ['-v'],
+  git: ['--version'],
+};
+
 async function isCommandAvailable(command) {
+  const args = VERSION_ARGS[command] || ['--version'];
+
   try {
-    // Using a harmless version command to check for presence
-    const checkCommand = command === 'java' ? '-version' : '--version';
-    await execa(command, [checkCommand]);
+    // Reject false only if spawn fails (ENOENT). Non-zero exit still counts as "available".
+    await execa(command, args, { reject: false });
     return true;
-  } catch {
+  } catch (err) {
+    // If command not found, execa throws with code 'ENOENT'
+    if (err && err.code === 'ENOENT') return false;
+    // Other unexpected errors: treat as not available
     return false;
   }
 }

package/bin/index.js

@@ -1,141 +0,0 @@
-#!/usr/bin/env node
-
-const inquirer = require('inquirer');
-const chalk = require('chalk');
-const fs = require('fs-extra');
-const path = require('path'); // FIX: Correctly require the 'path' module
-const { isCommandAvailable } = require('../src/utils');
-
-// Import ALL generators
-const { generateNodeProject } = require('../src/generators/node');
-const { generateDotnetProject } = require('../src/generators/dotnet');
-const { generateJavaProject } = require('../src/generators/java');
-const { generatePythonProject } = require('../src/generators/python');
-
-async function main() {
-  console.log(chalk.cyan.bold('🚀 Welcome to Backlist! The Polyglot Backend Generator.'));
-  
-  const answers = await inquirer.prompt([
-    // --- General Questions ---
-    {
-      type: 'input',
-      name: 'projectName',
-      message: 'Enter a name for your backend directory:',
-      default: 'backend',
-      validate: input => input ? true : 'Project name cannot be empty.'
-    },
-    {
-      type: 'list',
-      name: 'stack',
-      message: 'Select the backend stack:',
-      choices: [
-        { name: 'Node.js (TypeScript, Express)', value: 'node-ts-express' },
-        { name: 'C# (ASP.NET Core Web API)', value: 'dotnet-webapi' },
-        { name: 'Java (Spring Boot)', value: 'java-spring' },
-        { name: 'Python (FastAPI)', value: 'python-fastapi' },
-      ],
-    },
-    {
-      type: 'input',
-      name: 'srcPath',
-      message: 'Enter the path to your frontend `src` directory:',
-      default: 'src',
-    },
-
-    // --- Node.js Specific Questions ---
-    {
-      type: 'list',
-      name: 'dbType',
-      message: 'Select your database type for Node.js:',
-      choices: [
-        { name: 'NoSQL (MongoDB with Mongoose)', value: 'mongoose' },
-        { name: 'SQL (PostgreSQL/MySQL with Prisma)', value: 'prisma' },
-      ],
-      when: (answers) => answers.stack === 'node-ts-express'
-    },
-    {
-      type: 'confirm',
-      name: 'addAuth',
-      message: 'Add JWT authentication boilerplate?',
-      default: true,
-      when: (answers) => answers.stack === 'node-ts-express'
-    },
-    {
-      type: 'confirm',
-      name: 'addSeeder',
-      message: 'Add a database seeder with sample data?',
-      default: true,
-      // Seeder only makes sense if there's an auth/user model to seed
-      when: (answers) => answers.stack === 'node-ts-express' && answers.addAuth
-    },
-    {
-      type: 'checkbox',
-      name: 'extraFeatures',
-      message: 'Select additional features for Node.js:',
-      choices: [
-          { name: 'Docker Support (Dockerfile & docker-compose.yml)', value: 'docker', checked: true },
-          { name: 'API Testing Boilerplate (Jest & Supertest)', value: 'testing', checked: true },
-          { name: 'API Documentation (Swagger UI)', value: 'swagger', checked: true },
-      ],
-      when: (answers) => answers.stack === 'node-ts-express'
-    }
-  ]);
-
-  const options = {
-    ...answers,
-    projectDir: path.resolve(process.cwd(), answers.projectName),
-    frontendSrcDir: path.resolve(process.cwd(), answers.srcPath),
-  };
-
-  try {
-    console.log(chalk.blue(`\n✨ Starting backend generation for: ${chalk.bold(options.stack)}`));
-
-    // --- Dispatcher Logic for ALL Stacks ---
-    switch (options.stack) {
-      case 'node-ts-express':
-        await generateNodeProject(options);
-        break;
-
-      case 'dotnet-webapi':
-        if (!await isCommandAvailable('dotnet')) {
-          throw new Error('.NET SDK is not installed. Please install it from https://dotnet.microsoft.com/download');
-        }
-        await generateDotnetProject(options);
-        break;
-
-      case 'java-spring':
-        if (!await isCommandAvailable('java')) {
-          throw new Error('Java (JDK 17 or newer) is not installed. Please install a JDK to continue.');
-        }
-        await generateJavaProject(options); 
-        break;
-      
-      case 'python-fastapi':
-        if (!await isCommandAvailable('python')) {
-            throw new Error('Python is not installed. Please install Python (3.8+) and pip to continue.');
-        }
-        await generatePythonProject(options);
-        break;
-
-      default:
-        throw new Error(`The selected stack '${options.stack}' is not supported yet.`);
-    }
-
-    console.log(chalk.green.bold('\n✅ Backend generation complete!'));
-    console.log('\nNext Steps:');
-    console.log(chalk.cyan(`  cd ${options.projectName}`));
-    console.log(chalk.cyan('  (Check the generated README.md for instructions)'));
-
-  } catch (error) {
-    console.error(chalk.red.bold('\n❌ An error occurred during generation:'));
-    console.error(error); 
-    
-    if (fs.existsSync(options.projectDir)) {
-      console.log(chalk.yellow('  -> Cleaning up failed installation...'));
-      fs.removeSync(options.projectDir);
-    }
-    process.exit(1);
-  }
-}
-
-main();