create-backlist 6.0.6 → 6.0.8

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

@@ -1,63 +1,83 @@
-// Auto-generated by create-backlist v5.1 on <%= new Date().toISOString() %>
+// Auto-generated by create-backlist v4.0 on <%= new Date().toISOString() %>
 import mongoose from 'mongoose';
 import dotenv from 'dotenv';
 import { faker } from '@faker-js/faker';
-import chalk from 'chalk';
+import chalk from 'chalk'; // For colorful console logs
 
+// 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';
 
-function getErrorMessage(err: unknown) {
-  if (err instanceof Error) return err.message;
-  return String(err);
-}
+// --- 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);
+  }
+};
 
-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');
+// --- Import Data ---
+const importData = async () => {
+  try {
+    // Clear existing data
+    await User.deleteMany();
 
-  await mongoose.connect(MONGO_URI);
-  console.log(chalk.green('MongoDB Connected for Seeder...'));
-}
+    const sampleUsers = [];
+    const userCount = 10; // Number of sample users to create
 
-async function importData() {
-  // Clear existing data
-  await User.deleteMany({});
+    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
+      });
+    }
 
-  const sampleUsers = Array.from({ length: 10 }).map(() => ({
-    name: faker.person.fullName(),
-    email: faker.internet.email().toLowerCase(),
-    password: 'password123',
-  }));
+    await User.insertMany(sampleUsers);
 
-  await User.insertMany(sampleUsers);
+    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);
+  }
+};
 
-  console.log(chalk.green.bold('Data Imported Successfully!'));
-}
+// --- 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();
 
-async function destroyData() {
-  await User.deleteMany({});
-  console.log(chalk.red.bold('Data Destroyed 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 run() {
-  try {
-    await connectDB();
+// --- CLI Logic to run the seeder ---
+const runSeeder = async () => {
+  await connectDB();
 
-    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 {}
+  // 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();
   }
-}
+};
 
-run();
+runSeeder();

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

@@ -1,4 +1,4 @@
-# Auto-generated by create-backlist v5.1
+# Auto-generated by create-backlist v5.0
 version: '3.8'
 
 services:
@@ -8,55 +8,40 @@ services:
     ports:
       - '<%= port %>:<%= port %>'
     environment:
-      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}
-<% } -%>
+      - PORT=<%= port %>
+      - DATABASE_URL=${DATABASE_URL}
+      - JWT_SECRET=${JWT_SECRET}
     depends_on:
-      db:
-        condition: service_healthy
+      - db
     volumes:
       - .:/usr/src/app
       - /usr/src/app/node_modules
     command: npm run dev
 
   db:
-<% if (dbType === 'mongoose') { -%>
-    image: mongo:7
+    <% if (dbType === 'mongoose') { %>
+    image: mongo:latest
     container_name: <%= projectName %>-mongo-db
     ports:
       - '27017:27017'
     volumes:
       - mongo-data:/data/db
-    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
+    <% } else if (dbType === 'prisma') { %>
+    image: postgres:14-alpine
     container_name: <%= projectName %>-postgres-db
     ports:
       - '5432:5432'
     environment:
-      POSTGRES_USER: ${DB_USER:-postgres}
-      POSTGRES_PASSWORD: ${DB_PASSWORD:-password}
-      POSTGRES_DB: ${DB_NAME:-<%= projectName %>}
+      - POSTGRES_USER=${DB_USER}
+      - POSTGRES_PASSWORD=${DB_PASSWORD}
+      - POSTGRES_DB=${DB_NAME}
     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,11 +4,9 @@
   "private": true,
   "main": "dist/server.js",
   "scripts": {
-    "dev": "ts-node-dev --respawn --transpile-only src/server.ts",
     "build": "tsc",
     "start": "node dist/server.js",
-    "typecheck": "tsc --noEmit",
-    "clean": "rimraf dist"
+    "dev": "ts-node-dev --respawn --transpile-only src/server.ts"
   },
   "dependencies": {
     "cors": "^2.8.5",

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

@@ -1,67 +1,56 @@
 // Auto-generated by create-backlist on <%= new Date().toISOString() %>
 import { Router, Request, Response } from 'express';
-
-<%
-/**
- * Collect controllers safely
- */
+<% 
+// Build unique controller list 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) => {
-    if (!ep) return;
-
-    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}
+  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 = '';
 
-    const method = String(ep.method || 'GET').toLowerCase();
-    const ctrl = ep.controllerName || 'Default';
-    const action = ep.actionName || null;
+    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 needsProtect = !!addAuth && method !== 'get'; // default: protect non-GET
+    const needsProtect = !!addAuth && (method === 'post' || method === 'put' || method === 'delete');
     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,27 +1,12 @@
 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 {
-    // Reject false only if spawn fails (ENOENT). Non-zero exit still counts as "available".
-    await execa(command, args, { reject: false });
+    // Using a harmless version command to check for presence
+    const checkCommand = command === 'java' ? '-version' : '--version';
+    await execa(command, [checkCommand]);
     return true;
-  } 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
+  } catch {
     return false;
   }
 }

package/bin/backlist.js

@@ -1,227 +0,0 @@
-#!/usr/bin/env node
-
-const inquirer = require('inquirer');
-const chalk = require('chalk');
-const fs = require('fs-extra');
-const path = require('path');
-const { Command } = require('commander');
-const chokidar = require('chokidar');
-
-const { isCommandAvailable } = require('../src/utils');
-
-const { generateNodeProject } = require('../src/generators/node');
-const { generateDotnetProject } = require('../src/generators/dotnet');
-const { generateJavaProject } = require('../src/generators/java');
-const { generatePythonProject } = require('../src/generators/python');
-
-const { scanFrontend, writeContracts } = require('../src/scanner');
-
-function resolveOptionsFromFlags(flags) {
-  return {
-    projectName: flags.projectName || 'backend',
-    srcPath: flags.srcPath || 'src',
-    stack: flags.stack || 'node-ts-express',
-    dbType: flags.dbType,
-    addAuth: flags.addAuth,
-    addSeeder: flags.addSeeder,
-    extraFeatures: flags.extraFeatures || [],
-    projectDir: path.resolve(process.cwd(), flags.projectName || 'backend'),
-    frontendSrcDir: path.resolve(process.cwd(), flags.srcPath || 'src'),
-  };
-}
-
-async function runGeneration(options, contracts) {
-  switch (options.stack) {
-    case 'node-ts-express':
-      await generateNodeProject({ ...options, contracts });
-      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, contracts });
-      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, contracts });
-      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, contracts });
-      break;
-
-    default:
-      throw new Error(`The selected stack '${options.stack}' is not supported yet.`);
-  }
-}
-
-async function interactiveMain() {
-  console.log(chalk.cyan.bold('Welcome to Backlist! The Polyglot Backend Generator.'));
-
-  const answers = await inquirer.prompt([
-    {
-      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',
-    },
-    {
-      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,
-      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),
-  };
-
-  const contracts = await scanFrontend({ frontendSrcDir: options.frontendSrcDir });
-
-  try {
-    console.log(chalk.blue(`\nStarting backend generation for: ${chalk.bold(options.stack)}`));
-    await runGeneration(options, contracts);
-
-    console.log(chalk.green.bold('\nBackend 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('\nAn 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);
-  }
-}
-
-async function main() {
-  const program = new Command();
-
-  program
-    .name('backlist')
-    .description('Backlist CLI - generate backend from frontend via AST scan')
-    .version('1.0.0');
-
-  program.command('scan')
-    .description('Scan frontend and write contracts JSON')
-    .option('-s, --srcPath <path>', 'frontend src path', 'src')
-    .option('-o, --out <file>', 'output contracts file', '.backlist/contracts.json')
-    .action(async (flags) => {
-      const frontendSrcDir = path.resolve(process.cwd(), flags.srcPath);
-      const outFile = path.resolve(process.cwd(), flags.out);
-      const contracts = await scanFrontend({ frontendSrcDir });
-      await writeContracts(outFile, contracts);
-      console.log(chalk.green(`Wrote contracts to ${outFile}`));
-    });
-
-  program.command('generate')
-    .description('Generate backend using contracts')
-    .requiredOption('-k, --stack <stack>', 'stack: node-ts-express | dotnet-webapi | java-spring | python-fastapi')
-    .option('-p, --projectName <name>', 'backend directory', 'backend')
-    .option('-s, --srcPath <path>', 'frontend src path', 'src')
-    .option('-c, --contracts <file>', 'contracts file', '.backlist/contracts.json')
-    .action(async (flags) => {
-      const options = resolveOptionsFromFlags(flags);
-      const contractsPath = path.resolve(process.cwd(), flags.contracts);
-      const contracts = fs.existsSync(contractsPath)
-        ? await fs.readJson(contractsPath)
-        : await scanFrontend({ frontendSrcDir: options.frontendSrcDir });
-
-      await runGeneration(options, contracts);
-      console.log(chalk.green('Generation complete.'));
-    });
-
-  program.command('watch')
-    .description('Watch frontend and regenerate backend on changes')
-    .requiredOption('-k, --stack <stack>', 'stack')
-    .option('-p, --projectName <name>', 'backend directory', 'backend')
-    .option('-s, --srcPath <path>', 'frontend src path', 'src')
-    .action(async (flags) => {
-      const options = resolveOptionsFromFlags(flags);
-      const watcher = chokidar.watch(options.frontendSrcDir, { ignoreInitial: true });
-
-      const run = async () => {
-        const contracts = await scanFrontend({ frontendSrcDir: options.frontendSrcDir });
-        await runGeneration(options, contracts);
-        console.log(chalk.green(`[watch] regenerated at ${new Date().toLocaleTimeString()}`));
-      };
-
-      await run();
-      watcher.on('add', run).on('change', run).on('unlink', run);
-      console.log(chalk.cyan(`[watch] watching ${options.frontendSrcDir}`));
-    });
-
-  // If no args => old interactive mode
-  if (process.argv.length <= 2) {
-    await interactiveMain();
-    return;
-  }
-
-  await program.parseAsync(process.argv);
-}
-
-main().catch((e) => {
-  console.error(e);
-  process.exit(1);
-});

package/src/db/prisma.ts

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