create-backlist 6.0.6 → 6.0.8

package/src/templates/node-ts-express/partials/Auth.controller.ts.ejs

@@ -3,81 +3,87 @@ import { Request, Response } from 'express';
 import bcrypt from 'bcryptjs';
 import jwt from 'jsonwebtoken';
 
-<% if (dbType === 'mongoose') { -%>
+<% if (dbType === 'mongoose') { %>
 import User from '../models/User.model';
-<% } else if (dbType === 'prisma') { -%>
-import { prisma } from '../db/prisma';
-<% } -%>
+<% } else if (dbType === 'prisma') { %>
+import { prisma } from '../server';
+<% } %>
 
-function signToken(res: Response, userId: string) {
-  const secret = process.env.JWT_SECRET;
-  if (!secret) {
-    return res.status(500).json({ message: 'JWT_SECRET is not configured' });
-  }
-
-  const payload = { user: { id: userId } };
-
-  jwt.sign(payload, secret, { expiresIn: '5h' }, (err, token) => {
-    if (err || !token) return res.status(500).json({ message: 'Failed to sign token' });
-    return res.status(201).json({ token });
-  });
-}
-
-// Register
+// @desc    Register a new user
 export const registerUser = async (req: Request, res: Response) => {
-  const { name, email, password } = req.body || {};
+  const { name, email, password } = req.body;
 
   try {
-    if (!name || !email || !password) {
-      return res.status(400).json({ message: 'name, email, password are required' });
+    <% if (dbType === 'mongoose') { %>
+    // Mongoose Logic
+    let user = await User.findOne({ email });
+    if (user) {
+      return res.status(400).json({ message: 'User already exists' });
     }
-
-<% if (dbType === 'mongoose') { -%>
-    const existing = await User.findOne({ email });
-    if (existing) return res.status(400).json({ message: 'User already exists' });
-
-    const user = new User({ name, email, password }); // password will be hashed by pre-save hook
+    user = new User({ name, email, password });
     await user.save();
-    return signToken(res, String(user._id));
-<% } else if (dbType === 'prisma') { -%>
-    const existing = await prisma.user.findUnique({ where: { email } });
-    if (existing) return res.status(400).json({ message: 'User already exists' });
-
+    <% } else if (dbType === 'prisma') { %>
+    // Prisma Logic
+    const existingUser = await prisma.user.findUnique({ where: { email } });
+    if (existingUser) {
+        return res.status(400).json({ message: 'User already exists' });
+    }
     const hashedPassword = await bcrypt.hash(password, 10);
-    const user = await prisma.user.create({ data: { name, email, password: hashedPassword } });
-    return signToken(res, String(user.id));
-<% } -%>
-  } catch (error: any) {
-    return res.status(500).json({ message: 'Server Error', error: error?.message || error });
+    const user = await prisma.user.create({
+        data: { name, email, password: hashedPassword },
+    });
+    <% } %>
+
+    const payload = { user: { id: user.id } };
+    jwt.sign(
+      payload,
+      process.env.JWT_SECRET as string,
+      { expiresIn: '5h' },
+      (err, token) => {
+        if (err) throw err;
+        res.status(201).json({ token });
+      }
+    );
+  } catch (error) {
+    console.error(error);
+    res.status(500).send('Server Error');
   }
 };
 
-// Login
+// @desc    Authenticate user & get token (Login)
 export const loginUser = async (req: Request, res: Response) => {
-  const { email, password } = req.body || {};
+  const { email, password } = req.body;
 
   try {
-    if (!email || !password) {
-      return res.status(400).json({ message: 'email and password are required' });
-    }
-
-<% if (dbType === 'mongoose') { -%>
+    <% if (dbType === 'mongoose') { %>
+    // Mongoose Logic
     const user = await User.findOne({ email });
-<% } else if (dbType === 'prisma') { -%>
+    <% } else if (dbType === 'prisma') { %>
+    // Prisma Logic
     const user = await prisma.user.findUnique({ where: { email } });
-<% } -%>
+    <% } %>
 
-    if (!user) return res.status(400).json({ message: 'Invalid Credentials' });
+    if (!user) {
+      return res.status(400).json({ message: 'Invalid Credentials' });
+    }
 
     const isMatch = await bcrypt.compare(password, user.password);
-    if (!isMatch) return res.status(400).json({ message: 'Invalid Credentials' });
+    if (!isMatch) {
+      return res.status(400).json({ message: 'Invalid Credentials' });
+    }
 
-<% if (dbType === 'mongoose') { -%>
-    return signToken(res, String(user._id));
-<% } else { -%>
-    return signToken(res, String(user.id));
-<% } -%>
-  } catch (error: any) {
-    return res.status(500).json({ message: 'Server Error', error: error?.message || error });
+    const payload = { user: { id: user.id } };
+    jwt.sign(
+      payload,
+      process.env.JWT_SECRET as string,
+      { expiresIn: '5h' },
+      (err, token) => {
+        if (err) throw err;
+        res.json({ token });
+      }
+    );
+  } catch (error) {
+    console.error(error);
+    res.status(500).send('Server Error');
   }
 };

package/src/templates/node-ts-express/partials/Auth.middleware.ts.ejs

@@ -1,38 +1,27 @@
-// Auto-generated by create-backlist v5.1 on <%= new Date().toISOString() %>
+// Auto-generated by create-backlist v3.0 on <%= new Date().toISOString() %>
 import { Request, Response, NextFunction } from 'express';
 import jwt from 'jsonwebtoken';
 
+// Extend the default Request interface to include our 'user' property
 interface AuthRequest extends Request {
   user?: any;
 }
 
 export const protect = (req: AuthRequest, res: Response, next: NextFunction) => {
-  const secret = process.env.JWT_SECRET;
-  if (!secret) return res.status(500).json({ message: 'JWT_SECRET is not configured' });
-
-  // Support both:
-  // 1) Authorization: Bearer <token>
-  // 2) x-auth-token: <token>
-  const authHeader = req.header('authorization');
-  const xToken = req.header('x-auth-token');
-
-  let token: string | undefined;
-
-  if (authHeader && authHeader.toLowerCase().startsWith('bearer ')) {
-    token = authHeader.slice(7).trim();
-  } else if (xToken) {
-    token = xToken.trim();
-  }
+  // Get token from header
+  const token = req.header('x-auth-token');
 
+  // Check if not token
   if (!token) {
     return res.status(401).json({ message: 'No token, authorization denied' });
   }
 
+  // Verify token
   try {
-    const decoded: any = jwt.verify(token, secret);
+    const decoded = jwt.verify(token, process.env.JWT_SECRET as string);
     req.user = decoded.user;
-    return next();
-  } catch {
-    return res.status(401).json({ message: 'Token is not valid' });
+    next();
+  } catch (err) {
+    res.status(401).json({ message: 'Token is not valid' });
   }
 };

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

@@ -1,50 +1,50 @@
 // Auto-generated by create-backlist on <%= new Date().toISOString() %>
 import { Request, Response } from 'express';
 
-/**
- * Controller: <%= controllerName %>
- * Generated from frontend AST scan.
- */
-
-<%
-function safeAction(name, fallback) {
-  if (!name) return fallback;
-  return String(name).replace(/[^a-zA-Z0-9_]/g, '');
-}
+export const create<%= modelName %> = async (req: Request, res: Response) => {
+  try {
+    // TODO: implement create logic
+    res.status(201).json({ message: '<%= modelName %> created', data: req.body });
+  } catch (error) {
+    res.status(500).json({ message: 'Error creating <%= modelName %>', error });
+  }
+};
 
-function hasBody(method) {
-  const m = String(method || 'GET').toUpperCase();
-  return ['POST', 'PUT', 'PATCH'].includes(m);
-}
-%>
+export const getAll<%= modelName %>s = async (_req: Request, res: Response) => {
+  try {
+    // TODO: implement list logic
+    res.status(200).json([]);
+  } catch (error) {
+    res.status(500).json({ message: 'Error fetching <%= modelName %>s', error });
+  }
+};
 
-<% if (!Array.isArray(endpoints) || endpoints.length === 0) { %>
-export async function health(_req: Request, res: Response) {
-  return res.status(200).json({ ok: true });
-}
-<% } %>
+export const get<%= modelName %>ById = async (req: Request, res: Response) => {
+  try {
+    const { id } = req.params;
+    // TODO: implement get by id logic
+    res.status(200).json({ id });
+  } catch (error) {
+    res.status(500).json({ message: 'Error fetching <%= modelName %>', error });
+  }
+};
 
-<% (endpoints || []).forEach((ep, i) => { 
-  const method = String(ep.method || 'GET').toUpperCase();
-  const actionName = safeAction(ep.actionName, `handler${i}`);
-  const route = ep.route || ep.path || '';
--%>
-/**
- * <%= method %> <%= route %>
- */
-export async function <%= actionName %>(req: Request, res: Response) {
+export const update<%= modelName %>ById = async (req: Request, res: Response) => {
   try {
-<% if (hasBody(method)) { -%>
-    // Body schema (inferred):
-    // <%- JSON.stringify(ep.schemaFields || ep.requestBody?.fields || {}, null, 2).split('\n').map(l => '// ' + l).join('\n') %>
-    const payload = req.body;
-    return res.status(<%= method === 'POST' ? 201 : 200 %>).json({ message: 'TODO: implement', payload });
-<% } else { -%>
-    return res.status(200).json({ message: 'TODO: implement', params: req.params, query: req.query });
-<% } -%>
+    const { id } = req.params;
+    // TODO: implement update logic
+    res.status(200).json({ id, ...req.body });
   } catch (error) {
-    return res.status(500).json({ message: 'Internal Server Error', error });
+    res.status(500).json({ message: 'Error updating <%= modelName %>', error });
   }
-}
+};
 
-<% }) -%>
+export const delete<%= modelName %>ById = async (req: Request, res: Response) => {
+  try {
+    const { id } = req.params;
+    // TODO: implement delete logic
+    res.status(204).send();
+  } catch (error) {
+    res.status(500).json({ message: 'Error deleting <%= modelName %>', error });
+  }
+};

package/src/templates/node-ts-express/partials/DbContext.cs.ejs

@@ -8,8 +8,8 @@ namespace <%= projectName %>.Data
     {
         public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options) : base(options) { }
 
-<% modelsToGenerate.forEach(model => { -%>
-        public DbSet<<%= model.name %>> <%= model.name %> { get; set; } = default!;
-<% }); -%>
+        <% modelsToGenerate.forEach(model => { %>
+        public DbSet<<%= model.name %>> <%= model.name %>s { get; set; }
+        <% }); %>
     }
 }

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

@@ -1,31 +1,33 @@
-# Auto-generated by create-backlist v5.1
+# Auto-generated by create-backlist v5.0
 
+# ---- Base Stage ----
 FROM node:18-alpine AS base
 WORKDIR /usr/src/app
 COPY package*.json ./
 
+# ---- Dependencies Stage ----
 FROM base AS dependencies
-# Use npm ci for reproducible installs
-RUN npm ci
+RUN npm install --frozen-lockfile
 
+# ---- Build Stage ----
 FROM base AS build
 COPY --from=dependencies /usr/src/app/node_modules ./node_modules
 COPY . .
-<% if (dbType === 'prisma') { -%>
+<% if (dbType === 'prisma') { %>
 RUN npx prisma generate
-<% } -%>
+<% } %>
 RUN npm run build
 
+# ---- Production Stage ----
 FROM node:18-alpine AS production
 WORKDIR /usr/src/app
-ENV NODE_ENV=production
-
 COPY --from=build /usr/src/app/dist ./dist
 COPY --from=dependencies /usr/src/app/node_modules ./node_modules
 COPY package*.json ./
-<% if (dbType === 'prisma') { -%>
+<% if (dbType === 'prisma') { %>
+# Copy Prisma schema for runtime
 COPY prisma ./prisma
-<% } -%>
+<% } %>
 
 EXPOSE <%= port %>
 CMD ["node", "dist/server.js"]

package/src/templates/node-ts-express/partials/Model.cs.ejs

@@ -1,34 +1,16 @@
 // Auto-generated by create-backlist
-using System;
-
 namespace <%= projectName %>.Models
 {
     public class <%= modelName %>
     {
-        public Guid Id { get; set; } = Guid.NewGuid();
-
-<%
-function pascal(s){
-  return String(s || '')
-    .replace(/[-_]+(.)/g, (_,c)=>c.toUpperCase())
-    .replace(/^\w/, c => c.toUpperCase())
-    .replace(/[^a-zA-Z0-9]/g,'');
-}
-
-function mapType(t){
-  if (!t) return "string";
-  const x = String(t).toLowerCase();
-  if (x === 'number' || x === 'int' || x === 'integer') return "int";
-  if (x === 'float' || x === 'double') return "double";
-  if (x === 'boolean' || x === 'bool') return "bool";
-  if (x === 'date' || x === 'datetime') return "DateTime";
-  return "string";
-}
--%>
+        public Guid Id { get; set; }
 
-<% (model.fields || []).forEach(field => { -%>
-        public <%= mapType(field.type) %> <%= pascal(field.name) %> { get; set; }
-<% }); -%>
+        <% model.fields.forEach(field => { %>
+        <% let csharpType = 'string'; %>
+        <% if (field.type === 'Number') csharpType = 'int'; %>
+        <% if (field.type === 'Boolean') csharpType = 'bool'; %>
+        public <%= csharpType %> <%= field.name %> { get; set; }
+        <% }); %>
 
         public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
         public DateTime UpdatedAt { get; set; } = DateTime.UtcNow;

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

@@ -1,30 +1,22 @@
 // Auto-generated by create-backlist on <%= new Date().toISOString() %>
 import mongoose, { Schema, Document } from 'mongoose';
 
-type FieldType = 'string' | 'number' | 'boolean';
-
+// Define the interface for the Document
 export interface I<%= modelName %> extends Document {
-<% Object.keys(schema).forEach(key => { 
-  const t = String(schema[key] || 'string').toLowerCase();
-  const tsType = (t === 'number') ? 'number' : (t === 'boolean') ? 'boolean' : 'string';
--%>
-  <%= key %>: <%= tsType %>;
+<% Object.keys(schema).forEach(key => { %>
+  <%= key %>: <%= schema[key].toLowerCase() %>;
 <% }); %>
 }
 
-const <%= modelName %>Schema: Schema = new Schema(
-  {
-<% Object.keys(schema).forEach(key => { 
-  const t = String(schema[key] || 'string').toLowerCase();
-  const mongoType = (t === 'number') ? 'Number' : (t === 'boolean') ? 'Boolean' : 'String';
--%>
-    <%= key %>: {
-      type: <%= mongoType %>,
-      required: false,
-    },
-<% }); %>
+// Define the Mongoose Schema
+const <%= modelName %>Schema: Schema = new Schema({
+<% Object.keys(schema).forEach(key => { %>
+  <%= key %>: {
+    type: <%= schema[key] %>,
+    // TODO: Add 'required', 'unique', etc. here
   },
-  { timestamps: true }
-);
+<% }); %>
+}, { timestamps: true });
 
+// Create and export the Model
 export default mongoose.model<I<%= modelName %>>('<%= modelName %>', <%= modelName %>Schema);

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

@@ -1,83 +1,66 @@
-// Auto-generated by create-backlist v5.1 (Prisma, From Endpoints)
+// Auto-generated by create-backlist v5.0 (Prisma Version)
 import { Request, Response } from 'express';
-import { prisma } from '../db/prisma';
+import { prisma } from '../server'; // Import the Prisma client instance
 
-<%
-function safeAction(name, fallback) {
-  if (!name) return fallback;
-  return String(name).replace(/[^a-zA-Z0-9_]/g, '');
-}
-
-function hasIdInRoute(route) {
-  return /:\w+/.test(route || '');
-}
-
-function hasBody(method) {
-  const m = String(method || 'GET').toUpperCase();
-  return ['POST', 'PUT', 'PATCH'].includes(m);
-}
-
-// prisma client accessor name. Usually lowerCamelCase in prisma client.
-const prismaAccessor = controllerName.charAt(0).toLowerCase() + controllerName.slice(1);
-%>
-
-/**
- * Prisma model: <%= controllerName %>  (client: prisma.<%= prismaAccessor %>)
- * NOTE: If your prisma model name differs, adjust mapping in generator.
- */
+// @desc    Create a new <%= modelName %>
+export const create<%= modelName %> = async (req: Request, res: Response) => {
+  try {
+    const newDoc = await prisma.<%= modelName.toLowerCase() %>.create({
+      data: req.body,
+    });
+    res.status(201).json(newDoc);
+  } catch (error) {
+    res.status(500).json({ message: 'Error creating document', error });
+  }
+};
 
-<% (endpoints || []).forEach((ep, i) => { 
-  const method = String(ep.method || 'GET').toUpperCase();
-  const actionName = safeAction(ep.actionName, `handler${i}`);
-  const route = (ep.route || ep.path || '').replace(/^\/api/, '');
-  const usesId = hasIdInRoute(route);
--%>
-/**
- * <%= method %> <%= ep.route || ep.path || '' %>
- */
-export async function <%= actionName %>(req: Request, res: Response) {
+// @desc    Get all <%= modelName %>s
+export const getAll<%= modelName %>s = async (req: Request, res: Response) => {
   try {
-<% if (method === 'POST') { -%>
-    const created = await prisma.<%= prismaAccessor %>.create({ data: req.body });
-    return res.status(201).json(created);
-<% } else if (method === 'GET' && !usesId) { -%>
-    const list = await prisma.<%= prismaAccessor %>.findMany();
-    return res.status(200).json(list);
-<% } else if (method === 'GET' && usesId) { -%>
-    const idRaw = req.params.id;
-    // Try number first; fallback to string
-    const id: any = (idRaw !== undefined && idRaw !== null && String(Number(idRaw)) === idRaw) ? Number(idRaw) : idRaw;
+    const docs = await prisma.<%= modelName.toLowerCase() %>.findMany();
+    res.status(200).json(docs);
+  } catch (error) {
+    res.status(500).json({ message: 'Error fetching documents', error });
+  }
+};
 
-    const found = await prisma.<%= prismaAccessor %>.findUnique({ where: { id } });
-    if (!found) return res.status(404).json({ message: 'Not found' });
-    return res.status(200).json(found);
-<% } else if ((method === 'PUT' || method === 'PATCH') && usesId) { -%>
-    const idRaw = req.params.id;
-    const id: any = (idRaw !== undefined && idRaw !== null && String(Number(idRaw)) === idRaw) ? Number(idRaw) : idRaw;
+// @desc    Get a single <%= modelName %> by ID
+export const get<%= modelName %>ById = async (req: Request, res: Response) => {
+  try {
+    const { id } = req.params;
+    const doc = await prisma.<%= modelName.toLowerCase() %>.findUnique({
+      where: { id },
+    });
+    if (!doc) return res.status(404).json({ message: 'Document not found' });
+    res.status(200).json(doc);
+  } catch (error) {
+    res.status(500).json({ message: 'Error fetching document', error });
+  }
+};
 
-    const updated = await prisma.<%= prismaAccessor %>.update({
+// @desc    Update a <%= modelName %> by ID
+export const update<%= modelName %>ById = async (req: Request, res: Response) => {
+  try {
+    const { id } = req.params;
+    const doc = await prisma.<%= modelName.toLowerCase() %>.update({
       where: { id },
       data: req.body,
     });
-    return res.status(200).json(updated);
-<% } else if (method === 'DELETE' && usesId) { -%>
-    const idRaw = req.params.id;
-    const id: any = (idRaw !== undefined && idRaw !== null && String(Number(idRaw)) === idRaw) ? Number(idRaw) : idRaw;
-
-    await prisma.<%= prismaAccessor %>.delete({ where: { id } });
-    return res.status(200).json({ message: 'Deleted' });
-<% } else { -%>
-    // Non-CRUD or route not matching the default patterns
-    // TODO: implement custom logic (query params, nested routes, etc.)
-<% if (hasBody(method)) { -%>
-    return res.status(200).json({ message: 'TODO: implement', body: req.body, params: req.params, query: req.query });
-<% } else { -%>
-    return res.status(200).json({ message: 'TODO: implement', params: req.params, query: req.query });
-<% } -%>
-<% } -%>
-  } catch (error: any) {
-    return res.status(500).json({ message: 'Internal Server Error', error: error?.message || error });
+    res.status(200).json(doc);
+  } catch (error) {
+    res.status(500).json({ message: 'Error updating document', error });
   }
-}
+};
 
-<% }) -%>
+// @desc    Delete a <%= modelName %> by ID
+export const delete<%= modelName %>ById = async (req: Request, res: Response) => {
+  try {
+    const { id } = req.params;
+    await prisma.<%= modelName.toLowerCase() %>.delete({
+      where: { id },
+    });
+    res.status(200).json({ message: 'Document deleted successfully' });
+  } catch (error) {
+    res.status(500).json({ message: 'Error deleting document', error });
+  }
+};

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

@@ -1,41 +1,26 @@
-// Auto-generated by create-backlist v5.1
+// Auto-generated by create-backlist v5.0
 
 generator client {
   provider = "prisma-client-js"
 }
 
 datasource db {
-  provider = "postgresql"
+  provider = "postgresql" // User can change to "mysql", "sqlite", "sqlserver", etc.
   url      = env("DATABASE_URL")
 }
 
-<%
-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, '');
-}
-%>
-
+<%# Loop through each model identified by the analyzer %>
 <% modelsToGenerate.forEach(model => { %>
-model <%= safeName(model.name) %> {
+model <%= model.name %> {
   id        String   @id @default(cuid())
-
-<% (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 %>
-<% }); -%>
+  <%# 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' : '' %>
+  <% }); %>
 
   createdAt DateTime @default(now())
   updatedAt DateTime @updatedAt

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

@@ -2,12 +2,15 @@
 
 This backend was auto-generated by **Backlist**.
 
-## Requirements
-- Node.js 18+
-- npm 9+
-
-<% if (dbType === 'prisma') { -%>
-## Database (Prisma + PostgreSQL)
-1. Copy env:
-```bash
-cp .env.example .env
+## 🚀 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`.