create-backlist 7.0.1 → 7.3.1

package/src/templates/js-express/partials/controller.js.ejs

@@ -0,0 +1,53 @@
+import { <%= modelName %>Service } from '../services/<%= modelName %>.service.js';
+
+export class <%= modelName %>Controller {
+
+  static async getAll(req, res) {
+    try {
+      const data = await <%= modelName %>Service.getAll();
+      res.status(200).json(data);
+    } catch (error) {
+      res.status(500).json({ message: error.message });
+    }
+  }
+
+  static async getById(req, res) {
+    try {
+      const { id } = req.params;
+      const data = await <%= modelName %>Service.getById(id);
+      if (!data) return res.status(404).json({ message: 'Not found' });
+      res.status(200).json(data);
+    } catch (error) {
+      res.status(500).json({ message: error.message });
+    }
+  }
+
+  static async create(req, res) {
+    try {
+      const data = await <%= modelName %>Service.create(req.body);
+      res.status(201).json(data);
+    } catch (error) {
+      res.status(400).json({ message: error.message });
+    }
+  }
+
+  static async update(req, res) {
+    try {
+      const { id } = req.params;
+      const data = await <%= modelName %>Service.update(id, req.body);
+      res.status(200).json(data);
+    } catch (error) {
+      res.status(400).json({ message: error.message });
+    }
+  }
+
+  static async delete(req, res) {
+    try {
+      const { id } = req.params;
+      await <%= modelName %>Service.delete(id);
+      res.status(204).send();
+    } catch (error) {
+      res.status(500).json({ message: error.message });
+    }
+  }
+}

package/src/templates/js-express/partials/db.js.ejs

@@ -0,0 +1,19 @@
+<% if (dbType === 'prisma') { %>
+import { PrismaClient } from '@prisma/client';
+
+export const prisma = new PrismaClient();
+<% } else { %>
+import mongoose from 'mongoose';
+
+const MONGO_URI = process.env.MONGO_URI || 'mongodb://127.0.0.1:27017/<%= projectName %>';
+
+export async function connectDB() {
+  try {
+    await mongoose.connect(MONGO_URI);
+    console.log('MongoDB Connected...');
+  } catch (err) {
+    console.error('MongoDB connection error:', err.message);
+    process.exit(1);
+  }
+}
+<% } %>

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

@@ -0,0 +1,46 @@
+version: '3.8'
+
+services:
+  app:
+    build: .
+    container_name: <%= projectName %>-app
+    ports:
+      - '<%= port %>:<%= port %>'
+    env_file:
+      - .env
+    depends_on:
+<% if (dbType === 'mongoose') { %>
+      - mongo
+<% } else { %>
+      - postgres
+<% } %>
+    restart: unless-stopped
+
+<% if (dbType === 'mongoose') { %>
+  mongo:
+    image: mongo:7
+    container_name: <%= projectName %>-mongo
+    ports:
+      - '27017:27017'
+    volumes:
+      - mongo_data:/data/db
+<% } else { %>
+  postgres:
+    image: postgres:16-alpine
+    container_name: <%= projectName %>-postgres
+    ports:
+      - '5432:5432'
+    environment:
+      POSTGRES_USER: user
+      POSTGRES_PASSWORD: password
+      POSTGRES_DB: <%= projectName %>
+    volumes:
+      - pg_data:/var/lib/postgresql/data
+<% } %>
+
+volumes:
+<% if (dbType === 'mongoose') { %>
+  mongo_data:
+<% } else { %>
+  pg_data:
+<% } %>

package/src/templates/js-express/partials/model.js.ejs

@@ -0,0 +1,18 @@
+import mongoose from 'mongoose';
+
+const <%= modelName %>Schema = new mongoose.Schema({
+<% fields.forEach((field, i) => { -%>
+  <%= field.name %>: {
+    type: <%= field.type %>,
+<% if (field.isUnique) { -%>
+    unique: true,
+<% } -%>
+<% if (field.name === 'email') { -%>
+    lowercase: true,
+    trim: true,
+<% } -%>
+  },
+<% }); -%>
+}, { timestamps: true });
+
+export default mongoose.model('<%= modelName %>', <%= modelName %>Schema);

package/src/templates/js-express/partials/package.json.ejs

@@ -0,0 +1,17 @@
+<%= JSON.stringify({
+  name: projectName,
+  version: "1.0.0",
+  type: "module",
+  scripts: {
+    start: "node src/server.js",
+    dev: "node --watch src/server.js"
+  },
+  dependencies: {
+    express: "^4.18.2",
+    cors: "^2.8.5",
+    dotenv: "^16.3.1",
+    helmet: "^7.1.0",
+    morgan: "^1.10.0"
+  },
+  devDependencies: {}
+}, null, 2) %>

package/src/templates/js-express/partials/prisma.schema.ejs

@@ -0,0 +1,21 @@
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "postgresql"
+  url      = env("DATABASE_URL")
+}
+
+<% models.forEach(model => { %>
+model <%= model.name %> {
+  id        String   @id @default(cuid())
+<% model.fields.forEach(field => { %>
+<% const prismaType = field.type === 'Number' ? 'Int' : field.type === 'Boolean' ? 'Boolean' : 'String'; %>
+  <%= field.name.padEnd(10) %> <%= prismaType %><%= field.isUnique ? '   @unique' : '' %>
+<% }); %>
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}
+
+<% }); %>

package/src/templates/js-express/partials/routes.js.ejs

@@ -0,0 +1,19 @@
+import { Router } from 'express';
+<% endpoints.forEach(ep => { %>
+import { <%= ep.controllerName %>Controller } from '../controllers/<%= ep.controllerName %>.controller.js';
+<% }); %>
+
+const router = Router();
+
+<% const grouped = {}; endpoints.forEach(ep => { if (!grouped[ep.controllerName]) grouped[ep.controllerName] = []; grouped[ep.controllerName].push(ep); }); %>
+<% Object.entries(grouped).forEach(([ctrl, eps]) => { %>
+// --- <%= ctrl %> routes ---
+<% eps.forEach(ep => {
+  const method = ep.method.toLowerCase();
+  const routePath = ep.route.replace(/^\/api/, '');
+%>
+router.<%= method %>('<%= routePath %>', <%= ctrl %>Controller.<%= ep.functionName %>);
+<% }); %>
+<% }); %>
+
+export default router;

package/src/templates/js-express/partials/seeder.js.ejs

@@ -0,0 +1,103 @@
+import { faker } from '@faker-js/faker';
+<% if (dbType === 'mongoose') { %>
+import mongoose from 'mongoose';
+<% models.forEach(m => { %>
+import <%= m.name %> from '../src/models/<%= m.name %>.model.js';
+<% }); %>
+
+const MONGO_URI = process.env.MONGO_URI || 'mongodb://127.0.0.1:27017/<%= projectName %>';
+
+async function seed() {
+  await mongoose.connect(MONGO_URI);
+  console.log('Connected to MongoDB for seeding...');
+
+<% models.forEach(m => { %>
+  await <%= m.name %>.deleteMany({});
+  const <%= m.name.toLowerCase() %>Data = Array.from({ length: 10 }, () => ({
+<% m.fields.forEach(f => { %>
+<% if (f.name === 'email') { %>
+    email: faker.internet.email(),
+<% } else if (f.name === 'name') { %>
+    name: faker.person.fullName(),
+<% } else if (f.name === 'password') { %>
+    password: faker.internet.password(),
+<% } else if (f.type === 'Number') { %>
+    <%= f.name %>: faker.number.int({ min: 1, max: 1000 }),
+<% } else if (f.type === 'Boolean') { %>
+    <%= f.name %>: faker.datatype.boolean(),
+<% } else { %>
+    <%= f.name %>: faker.lorem.word(),
+<% } %>
+<% }); %>
+  }));
+  await <%= m.name %>.insertMany(<%= m.name.toLowerCase() %>Data);
+  console.log('<%= m.name %>: seeded 10 records');
+<% }); %>
+
+  await mongoose.disconnect();
+  console.log('Seeding complete.');
+}
+<% } else { %>
+import { prisma } from '../src/db.js';
+
+async function seed() {
+  console.log('Seeding database...');
+
+<% models.forEach(m => { %>
+  await prisma.<%= m.name.charAt(0).toLowerCase() + m.name.slice(1) %>.deleteMany({});
+  for (let i = 0; i < 10; i++) {
+    await prisma.<%= m.name.charAt(0).toLowerCase() + m.name.slice(1) %>.create({
+      data: {
+<% m.fields.forEach(f => { %>
+<% if (f.name === 'email') { %>
+        email: faker.internet.email(),
+<% } else if (f.name === 'name') { %>
+        name: faker.person.fullName(),
+<% } else if (f.name === 'password') { %>
+        password: faker.internet.password(),
+<% } else if (f.type === 'Number' || f.type === 'Int') { %>
+        <%= f.name %>: faker.number.int({ min: 1, max: 1000 }),
+<% } else if (f.type === 'Boolean') { %>
+        <%= f.name %>: faker.datatype.boolean(),
+<% } else { %>
+        <%= f.name %>: faker.lorem.word(),
+<% } %>
+<% }); %>
+      },
+    });
+  }
+  console.log('<%= m.name %>: seeded 10 records');
+<% }); %>
+
+  await prisma.$disconnect();
+  console.log('Seeding complete.');
+}
+<% } %>
+
+const isDestroy = process.argv.includes('-d');
+
+if (isDestroy) {
+<% if (dbType === 'mongoose') { %>
+  import('mongoose').then(async (m) => {
+    await m.default.connect(process.env.MONGO_URI || 'mongodb://127.0.0.1:27017/<%= projectName %>');
+<% models.forEach(m => { %>
+    await <%= m.name %>.deleteMany({});
+<% }); %>
+    await m.default.disconnect();
+    console.log('All data destroyed.');
+  });
+<% } else { %>
+  (async () => {
+<% models.forEach(m => { %>
+    await prisma.<%= m.name.charAt(0).toLowerCase() + m.name.slice(1) %>.deleteMany({});
+<% }); %>
+    await prisma.$disconnect();
+    console.log('All data destroyed.');
+  })();
+<% } %>
+} else {
+  seed().catch(err => {
+    console.error(err);
+    process.exit(1);
+  });
+}

package/src/templates/js-express/partials/service.js.ejs

@@ -0,0 +1,51 @@
+<% if (dbType === 'mongoose') { %>
+import <%= modelName %> from '../models/<%= modelName %>.model.js';
+
+export class <%= modelName %>Service {
+
+  static async getAll() {
+    return <%= modelName %>.find();
+  }
+
+  static async getById(id) {
+    return <%= modelName %>.findById(id);
+  }
+
+  static async create(data) {
+    return <%= modelName %>.create(data);
+  }
+
+  static async update(id, data) {
+    return <%= modelName %>.findByIdAndUpdate(id, data, { new: true, runValidators: true });
+  }
+
+  static async delete(id) {
+    return <%= modelName %>.findByIdAndDelete(id);
+  }
+}
+<% } else { %>
+import { prisma } from '../db.js';
+
+export class <%= modelName %>Service {
+
+  static async getAll() {
+    return prisma.<%= modelName.charAt(0).toLowerCase() + modelName.slice(1) %>.findMany();
+  }
+
+  static async getById(id) {
+    return prisma.<%= modelName.charAt(0).toLowerCase() + modelName.slice(1) %>.findUnique({ where: { id } });
+  }
+
+  static async create(data) {
+    return prisma.<%= modelName.charAt(0).toLowerCase() + modelName.slice(1) %>.create({ data });
+  }
+
+  static async update(id, data) {
+    return prisma.<%= modelName.charAt(0).toLowerCase() + modelName.slice(1) %>.update({ where: { id }, data });
+  }
+
+  static async delete(id) {
+    return prisma.<%= modelName.charAt(0).toLowerCase() + modelName.slice(1) %>.delete({ where: { id } });
+  }
+}
+<% } %>

package/src/templates/js-express/partials/swagger.js.ejs

@@ -0,0 +1,30 @@
+import swaggerJsdoc from 'swagger-jsdoc';
+import swaggerUi from 'swagger-ui-express';
+
+const options = {
+  definition: {
+    openapi: '3.0.0',
+    info: {
+      title: '<%= projectName %> API',
+      version: '1.0.0',
+      description: 'Auto-generated API documentation by create-backlist',
+    },
+    servers: [{ url: `http://localhost:${process.env.PORT || <%= port %>}` }],
+<% if (addAuth) { %>
+    components: {
+      securitySchemes: {
+        bearerAuth: { type: 'http', scheme: 'bearer', bearerFormat: 'JWT' },
+      },
+    },
+    security: [{ bearerAuth: [] }],
+<% } %>
+  },
+  apis: ['./src/routes*.js', './src/controllers/**/*.js'],
+};
+
+const swaggerSpec = swaggerJsdoc(options);
+
+export function setupSwagger(app) {
+  app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerSpec));
+  console.log(`Swagger docs available at /api-docs`);
+}

package/src/templates/js-express/partials/test.js.ejs

@@ -0,0 +1,46 @@
+import { describe, it, expect } from 'vitest';
+import request from 'supertest';
+
+const BASE_URL = `http://localhost:${process.env.PORT || 8000}`;
+
+describe('API Health Check', () => {
+  it('GET /api/health should return 200', async () => {
+    const res = await request(BASE_URL).get('/api/health');
+    expect(res.status).toBe(200);
+    expect(res.body.status).toBe('ok');
+  });
+});
+
+<% if (addAuth) { %>
+describe('Auth Endpoints', () => {
+  const testUser = {
+    name: 'Test User',
+    email: `test_${Date.now()}@example.com`,
+    password: 'TestPass123!',
+  };
+
+  it('POST /api/auth/register should create a user', async () => {
+    const res = await request(BASE_URL).post('/api/auth/register').send(testUser);
+    expect(res.status).toBe(201);
+    expect(res.body).toHaveProperty('token');
+  });
+
+  it('POST /api/auth/login should return a token', async () => {
+    const res = await request(BASE_URL).post('/api/auth/login').send({
+      email: testUser.email,
+      password: testUser.password,
+    });
+    expect(res.status).toBe(200);
+    expect(res.body).toHaveProperty('token');
+  });
+});
+<% } %>
+
+<% endpoints.forEach(ep => { %>
+describe('<%= ep.method.toUpperCase() %> <%= ep.path %>', () => {
+  it('should respond without 500', async () => {
+    const res = await request(BASE_URL).<%= ep.method.toLowerCase() %>('<%= ep.path %>');
+    expect(res.status).not.toBe(500);
+  });
+});
+<% }); %>

package/src/templates/nestjs/base/app.module.ts

@@ -0,0 +1,9 @@
+import { Module } from '@nestjs/common';
+// INJECT:IMPORTS
+
+@Module({
+  imports: [
+    // INJECT:MODULES
+  ],
+})
+export class AppModule {}

package/src/templates/nestjs/base/main.ts

@@ -0,0 +1,23 @@
+import { NestFactory } from '@nestjs/core';
+import { ValidationPipe } from '@nestjs/common';
+import { AppModule } from './app.module';
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+
+  app.enableCors({
+    origin: process.env.CORS_ORIGIN
+      ? process.env.CORS_ORIGIN.split(',').map(s => s.trim())
+      : ['http://localhost:3000', 'http://localhost:5173'],
+    credentials: true,
+  });
+
+  app.setGlobalPrefix('api');
+  app.useGlobalPipes(new ValidationPipe({ whitelist: true, transform: true }));
+
+  const port = process.env.PORT || 8000;
+  await app.listen(port);
+  console.log(`NestJS server running on http://localhost:${port}`);
+}
+
+bootstrap();

package/src/templates/nestjs/base/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "declaration": true,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "target": "ES2021",
+    "sourceMap": true,
+    "outDir": "./dist",
+    "baseUrl": "./",
+    "incremental": true,
+    "skipLibCheck": true,
+    "strictNullChecks": true,
+    "noImplicitAny": true,
+    "strictBindCallApply": true,
+    "forceConsistentCasingInFileNames": true,
+    "noFallthroughCasesInSwitch": true
+  }
+}

package/src/templates/nestjs/partials/auth.controller.ts.ejs

@@ -0,0 +1,17 @@
+import { Controller, Post, Body } from '@nestjs/common';
+import { AuthService } from './auth.service';
+
+@Controller('auth')
+export class AuthController {
+  constructor(private readonly authService: AuthService) {}
+
+  @Post('register')
+  register(@Body() body: { name: string; email: string; password: string }) {
+    return this.authService.register(body.name, body.email, body.password);
+  }
+
+  @Post('login')
+  login(@Body() body: { email: string; password: string }) {
+    return this.authService.login(body.email, body.password);
+  }
+}

package/src/templates/nestjs/partials/auth.module.ts.ejs

@@ -0,0 +1,17 @@
+import { Module } from '@nestjs/common';
+import { JwtModule } from '@nestjs/jwt';
+import { AuthController } from './auth.controller';
+import { AuthService } from './auth.service';
+
+@Module({
+  imports: [
+    JwtModule.register({
+      secret: process.env.JWT_SECRET || 'changeme',
+      signOptions: { expiresIn: process.env.JWT_EXPIRES_IN || '5h' },
+    }),
+  ],
+  controllers: [AuthController],
+  providers: [AuthService],
+  exports: [AuthService, JwtModule],
+})
+export class AuthModule {}

package/src/templates/nestjs/partials/auth.service.ts.ejs

@@ -0,0 +1,70 @@
+<% if (dbType === 'mongoose') { %>
+import { Injectable, ConflictException, UnauthorizedException } from '@nestjs/common';
+import { JwtService } from '@nestjs/jwt';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import * as bcrypt from 'bcryptjs';
+
+@Injectable()
+export class AuthService {
+  constructor(
+    @InjectModel('User') private readonly userModel: Model<any>,
+    private readonly jwtService: JwtService,
+  ) {}
+
+  async register(name: string, email: string, password: string) {
+    const existing = await this.userModel.findOne({ email });
+    if (existing) throw new ConflictException('Email already in use');
+
+    const hashed = await bcrypt.hash(password, 12);
+    const user = await this.userModel.create({ name, email, password: hashed });
+    const token = this.jwtService.sign({ id: user._id, email: user.email });
+    return { token, user: { id: user._id, name: user.name, email: user.email } };
+  }
+
+  async login(email: string, password: string) {
+    const user = await this.userModel.findOne({ email });
+    if (!user) throw new UnauthorizedException('Invalid credentials');
+
+    const isMatch = await bcrypt.compare(password, user.password);
+    if (!isMatch) throw new UnauthorizedException('Invalid credentials');
+
+    const token = this.jwtService.sign({ id: user._id, email: user.email });
+    return { token, user: { id: user._id, name: user.name, email: user.email } };
+  }
+}
+<% } else { %>
+import { Injectable, ConflictException, UnauthorizedException } from '@nestjs/common';
+import { JwtService } from '@nestjs/jwt';
+import { PrismaService } from '../prisma/prisma.service';
+import * as bcrypt from 'bcryptjs';
+
+@Injectable()
+export class AuthService {
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly jwtService: JwtService,
+  ) {}
+
+  async register(name: string, email: string, password: string) {
+    const existing = await this.prisma.user.findUnique({ where: { email } });
+    if (existing) throw new ConflictException('Email already in use');
+
+    const hashed = await bcrypt.hash(password, 12);
+    const user = await this.prisma.user.create({ data: { name, email, password: hashed } });
+    const token = this.jwtService.sign({ id: user.id, email: user.email });
+    return { token, user: { id: user.id, name: user.name, email: user.email } };
+  }
+
+  async login(email: string, password: string) {
+    const user = await this.prisma.user.findUnique({ where: { email } });
+    if (!user) throw new UnauthorizedException('Invalid credentials');
+
+    const isMatch = await bcrypt.compare(password, user.password);
+    if (!isMatch) throw new UnauthorizedException('Invalid credentials');
+
+    const token = this.jwtService.sign({ id: user.id, email: user.email });
+    return { token, user: { id: user.id, name: user.name, email: user.email } };
+  }
+}
+<% } %>

package/src/templates/nestjs/partials/controller.ts.ejs

@@ -0,0 +1,34 @@
+import { Controller, Get, Post, Put, Delete, Param, Body } from '@nestjs/common';
+import { <%= modelName %>Service } from './<%= modelName.toLowerCase() %>.service';
+import { Create<%= modelName %>Dto } from './dto/create-<%= modelName.toLowerCase() %>.dto';
+import { Update<%= modelName %>Dto } from './dto/update-<%= modelName.toLowerCase() %>.dto';
+
+@Controller('<%= modelName.toLowerCase() %>s')
+export class <%= modelName %>Controller {
+  constructor(private readonly <%= modelName.toLowerCase() %>Service: <%= modelName %>Service) {}
+
+  @Get()
+  findAll() {
+    return this.<%= modelName.toLowerCase() %>Service.findAll();
+  }
+
+  @Get(':id')
+  findOne(@Param('id') id: string) {
+    return this.<%= modelName.toLowerCase() %>Service.findOne(id);
+  }
+
+  @Post()
+  create(@Body() dto: Create<%= modelName %>Dto) {
+    return this.<%= modelName.toLowerCase() %>Service.create(dto);
+  }
+
+  @Put(':id')
+  update(@Param('id') id: string, @Body() dto: Update<%= modelName %>Dto) {
+    return this.<%= modelName.toLowerCase() %>Service.update(id, dto);
+  }
+
+  @Delete(':id')
+  remove(@Param('id') id: string) {
+    return this.<%= modelName.toLowerCase() %>Service.remove(id);
+  }
+}

package/src/templates/nestjs/partials/create-dto.ts.ejs

@@ -0,0 +1,22 @@
+import { IsString, IsOptional, IsNotEmpty } from 'class-validator';
+
+export class Create<%= modelName %>Dto {
+<% fields.forEach(field => { %>
+<% if (field.name === 'password' || field.name === 'email' || field.name === 'name') { %>
+  @IsString()
+  @IsNotEmpty()
+  <%= field.name %>: string;
+<% } else if (field.type === 'Number' || field.type === 'Int') { %>
+  @IsOptional()
+  <%= field.name %>?: number;
+<% } else if (field.type === 'Boolean') { %>
+  @IsOptional()
+  <%= field.name %>?: boolean;
+<% } else { %>
+  @IsOptional()
+  @IsString()
+  <%= field.name %>?: string;
+<% } %>
+
+<% }); %>
+}

package/src/templates/nestjs/partials/jwt-guard.ts.ejs

@@ -0,0 +1,24 @@
+import { Injectable, CanActivate, ExecutionContext, UnauthorizedException } from '@nestjs/common';
+import { JwtService } from '@nestjs/jwt';
+
+@Injectable()
+export class JwtAuthGuard implements CanActivate {
+  constructor(private readonly jwtService: JwtService) {}
+
+  canActivate(context: ExecutionContext): boolean {
+    const request = context.switchToHttp().getRequest();
+    const authHeader = request.headers.authorization;
+
+    if (!authHeader || !authHeader.startsWith('Bearer ')) {
+      throw new UnauthorizedException('Access denied. No token provided.');
+    }
+
+    const token = authHeader.split(' ')[1];
+    try {
+      request.user = this.jwtService.verify(token);
+      return true;
+    } catch {
+      throw new UnauthorizedException('Invalid or expired token.');
+    }
+  }
+}