create-backlist 6.0.0 → 6.0.2

package/src/templates/node-ts-express/partials/App.test.ts.ejs

@@ -1,38 +1,38 @@
-// Auto-generated by create-backlist v5.0
+// Auto-generated by create-backlist v5.1
 import request from 'supertest';
 import express from 'express';
-// Import your main app configuration. This might need path adjustment.
-// For simplicity, we create a test server here.
-import apiRoutes from '../routes'; // Assuming main routes
-import authRoutes from '../routes/Auth.routes'; // Assuming auth routes
+
+import apiRoutes from '../routes'; 
+<% if (addAuth) { -%>
+import authRoutes from '../routes/Auth.routes';
+<% } -%>
 
 const app = express();
 app.use(express.json());
-app.use('/api', apiRoutes);
-app.use('/api/auth', authRoutes);
-
 
-describe('API Endpoints', () => {
+<% if (addAuth) { -%>
+app.use('/api/auth', authRoutes);
+<% } -%>
+app.use('/api', apiRoutes);
 
-  it('should respond to the root GET endpoint', async () => {
-    // This test assumes a GET /api/ endpoint exists or a similar public one.
-    // You might need to adjust this to a real endpoint from your app.
-    // Example for GET /api/users
-    // const res = await request(app).get('/api/users');
-    // expect(res.statusCode).toEqual(200);
-    
-    // For now, a placeholder test:
+describe('API Endpoints (Generated)', () => {
+  it('sanity check', () => {
     expect(1 + 1).toBe(2);
   });
 
-  // TODO: Add more specific tests for your generated endpoints
-  // describe('POST /api/users', () => {
-  //   it('should create a new user', async () => {
-  //     const res = await request(app)
-  //       .post('/api/users')
-  //       .send({ name: 'Test User', email: 'test@example.com', password: 'password123' });
-  //     expect(res.statusCode).toEqual(201);
-  //     expect(res.body).toHaveProperty('name', 'Test User');
-  //   });
-  // });
+  <% endpoints
+      .filter(ep => ep && ep.route && ep.method)
+      .forEach(ep => { 
+        const method = ep.method.toLowerCase();
+        const url = (ep.route.startsWith('/api/') ? ep.route.replace(/^\/api/, '') : ep.route)
+          .replace(/:\w+/g, '1'); // replace path params with dummy value
+  -%>
+  it('<%= ep.method %> <%= url %> should respond', async () => {
+    const res = await request(app).<%= method %>('<%= '/api' + url %>')<% if (['post','put','patch'].includes(method) && ep.schemaFields) { %>
+      .send(<%- JSON.stringify(Object.fromEntries(Object.entries(ep.schemaFields).map(([k,t]) => [k, t === 'Number' ? 1 : (t === 'Boolean' ? true : 'test') ]))) %>)<% } %>;
+    // We only assert "not 404" because generated handlers may be TODO stubs,
+    // and auth/validation may affect exact status codes.
+    expect(res.statusCode).not.toBe(404);
+  });
+  <% }) -%>
 });

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

@@ -3,87 +3,81 @@ 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 '../server';
-<% } %>
+<% } else if (dbType === 'prisma') { -%>
+import { prisma } from '../db/prisma';
+<% } -%>
 
-// @desc    Register a new user
+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
 export const registerUser = async (req: Request, res: Response) => {
-  const { name, email, password } = req.body;
+  const { name, email, password } = req.body || {};
 
   try {
-    <% if (dbType === 'mongoose') { %>
-    // Mongoose Logic
-    let user = await User.findOne({ email });
-    if (user) {
-      return res.status(400).json({ message: 'User already exists' });
+    if (!name || !email || !password) {
+      return res.status(400).json({ message: 'name, email, password are required' });
     }
-    user = new User({ name, email, password });
+
+<% 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
     await user.save();
-    <% } 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));
+<% } else if (dbType === 'prisma') { -%>
+    const existing = await prisma.user.findUnique({ where: { email } });
+    if (existing) return res.status(400).json({ message: 'User already exists' });
 
-    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');
+    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 });
   }
 };
 
-// @desc    Authenticate user & get token (Login)
+// Login
 export const loginUser = async (req: Request, res: Response) => {
-  const { email, password } = req.body;
+  const { email, password } = req.body || {};
 
   try {
-    <% if (dbType === 'mongoose') { %>
-    // Mongoose Logic
+    if (!email || !password) {
+      return res.status(400).json({ message: 'email and password are required' });
+    }
+
+<% if (dbType === 'mongoose') { -%>
     const user = await User.findOne({ email });
-    <% } else if (dbType === 'prisma') { %>
-    // Prisma Logic
+<% } else if (dbType === 'prisma') { -%>
     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' });
 
-    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');
+<% 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 });
   }
 };

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

@@ -1,27 +1,38 @@
-// Auto-generated by create-backlist v3.0 on <%= new Date().toISOString() %>
+// Auto-generated by create-backlist v5.1 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) => {
-  // Get token from header
-  const token = req.header('x-auth-token');
+  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();
+  }
 
-  // Check if not token
   if (!token) {
     return res.status(401).json({ message: 'No token, authorization denied' });
   }
 
-  // Verify token
   try {
-    const decoded = jwt.verify(token, process.env.JWT_SECRET as string);
+    const decoded: any = jwt.verify(token, secret);
     req.user = decoded.user;
-    next();
-  } catch (err) {
-    res.status(401).json({ message: 'Token is not valid' });
+    return next();
+  } catch {
+    return 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';
 
-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 });
-  }
-};
+/**
+ * Controller: <%= controllerName %>
+ * Generated from frontend AST scan.
+ */
 
-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 });
-  }
-};
+<%
+function safeAction(name, fallback) {
+  if (!name) return fallback;
+  return String(name).replace(/[^a-zA-Z0-9_]/g, '');
+}
 
-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 });
-  }
-};
+function hasBody(method) {
+  const m = String(method || 'GET').toUpperCase();
+  return ['POST', 'PUT', 'PATCH'].includes(m);
+}
+%>
 
-export const update<%= modelName %>ById = async (req: Request, res: Response) => {
-  try {
-    const { id } = req.params;
-    // TODO: implement update logic
-    res.status(200).json({ id, ...req.body });
-  } catch (error) {
-    res.status(500).json({ message: 'Error updating <%= modelName %>', 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 delete<%= modelName %>ById = async (req: Request, res: Response) => {
+<% (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) {
   try {
-    const { id } = req.params;
-    // TODO: implement delete logic
-    res.status(204).send();
+<% 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 });
+<% } -%>
   } catch (error) {
-    res.status(500).json({ message: 'Error deleting <%= modelName %>', error });
+    return res.status(500).json({ message: 'Internal Server Error', 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 %>s { get; set; }
-        <% }); %>
+<% modelsToGenerate.forEach(model => { -%>
+        public DbSet<<%= model.name %>> <%= model.name %> { get; set; } = default!;
+<% }); -%>
     }
 }

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

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

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

@@ -1,16 +1,34 @@
 // Auto-generated by create-backlist
+using System;
+
 namespace <%= projectName %>.Models
 {
     public class <%= modelName %>
     {
-        public Guid Id { get; set; }
+        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";
+}
+-%>
 
-        <% 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; }
-        <% }); %>
+<% (model.fields || []).forEach(field => { -%>
+        public <%= mapType(field.type) %> <%= pascal(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,22 +1,30 @@
 // Auto-generated by create-backlist on <%= new Date().toISOString() %>
 import mongoose, { Schema, Document } from 'mongoose';
 
-// Define the interface for the Document
+type FieldType = 'string' | 'number' | 'boolean';
+
 export interface I<%= modelName %> extends Document {
-<% Object.keys(schema).forEach(key => { %>
-  <%= key %>: <%= schema[key].toLowerCase() %>;
+<% Object.keys(schema).forEach(key => { 
+  const t = String(schema[key] || 'string').toLowerCase();
+  const tsType = (t === 'number') ? 'number' : (t === 'boolean') ? 'boolean' : 'string';
+-%>
+  <%= key %>: <%= tsType %>;
 <% }); %>
 }
 
-// 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
-  },
+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,
+    },
 <% }); %>
-}, { 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,66 +1,83 @@
-// Auto-generated by create-backlist v5.0 (Prisma Version)
+// Auto-generated by create-backlist v5.1 (Prisma, From Endpoints)
 import { Request, Response } from 'express';
-import { prisma } from '../server'; // Import the Prisma client instance
+import { prisma } from '../db/prisma';
 
-// @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 });
-  }
-};
+<%
+function safeAction(name, fallback) {
+  if (!name) return fallback;
+  return String(name).replace(/[^a-zA-Z0-9_]/g, '');
+}
 
-// @desc    Get all <%= modelName %>s
-export const getAll<%= modelName %>s = async (req: Request, res: Response) => {
-  try {
-    const docs = await prisma.<%= modelName.toLowerCase() %>.findMany();
-    res.status(200).json(docs);
-  } catch (error) {
-    res.status(500).json({ message: 'Error fetching documents', error });
-  }
-};
+function hasIdInRoute(route) {
+  return /:\w+/.test(route || '');
+}
 
-// @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 });
-  }
-};
+function hasBody(method) {
+  const m = String(method || 'GET').toUpperCase();
+  return ['POST', 'PUT', 'PATCH'].includes(m);
+}
 
-// @desc    Update a <%= modelName %> by ID
-export const update<%= modelName %>ById = async (req: Request, res: Response) => {
+// 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.
+ */
+
+<% (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) {
   try {
-    const { id } = req.params;
-    const doc = await prisma.<%= modelName.toLowerCase() %>.update({
+<% 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 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;
+
+    const updated = await prisma.<%= prismaAccessor %>.update({
       where: { id },
       data: req.body,
     });
-    res.status(200).json(doc);
-  } catch (error) {
-    res.status(500).json({ message: 'Error updating document', error });
-  }
-};
+    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;
 
-// @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 });
+    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 });
   }
-};
+}
+
+<% }) -%>