create-coreback 1.0.3 → 1.0.5

package/src/generators/sourceFiles/core/configFiles.ts

@@ -0,0 +1,158 @@
+import { ProjectConfig } from '../../../types.js';
+import fs from 'fs-extra';
+import path from 'path';
+
+export async function generateConfigFiles(configDir: string, config: ProjectConfig): Promise<void> {
+  // env.ts
+  const envContent = `import { z } from 'zod';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+const envSchema = z.object({
+  NODE_ENV: z.enum(['development', 'production', 'test']).default('development'),
+  PORT: z.coerce.number().default(3000),
+  DATABASE_URL: z.string(),
+${config.includeAuth ? `  JWT_SECRET: z.string(),
+  JWT_EXPIRES_IN: z.string().default('7d'),
+  EMAIL_HOST: z.string().optional(),
+  EMAIL_PORT: z.coerce.number().optional(),
+  EMAIL_SECURE: z.coerce.boolean().default(false),
+  EMAIL_USER: z.string().optional(),
+  EMAIL_PASSWORD: z.string().optional(),
+  EMAIL_FROM: z.string().default('noreply@coreback.app'),
+  APP_URL: z.string().default('http://localhost:3000'),` : ''}${config.includeFileUpload ? `
+  MAX_FILE_SIZE: z.coerce.number().default(5242880),
+  ALLOWED_FILE_TYPES: z.string().default('image/jpeg,image/png,image/gif,application/pdf'),
+  UPLOAD_DIR: z.string().default('uploads'),${config.fileStorage === 's3' ? `
+  AWS_REGION: z.string().default('us-east-1'),
+  AWS_ACCESS_KEY_ID: z.string().optional(),
+  AWS_SECRET_ACCESS_KEY: z.string().optional(),
+  AWS_S3_BUCKET: z.string().optional(),` : ''}` : ''}${config.includeRedis ? `
+  REDIS_HOST: z.string().default('localhost'),
+  REDIS_PORT: z.coerce.number().default(6379),
+  REDIS_PASSWORD: z.string().optional(),
+  REDIS_DB: z.coerce.number().default(0),` : ''}
+  RATE_LIMIT_WINDOW_MS: z.coerce.number().default(900000),
+  RATE_LIMIT_MAX: z.coerce.number().default(100),
+});
+
+export const config = envSchema.parse(process.env);
+`;
+
+  await fs.writeFile(path.join(configDir, 'env.ts'), envContent);
+
+  // database.ts
+  const databaseContent = `import { PrismaClient } from '@prisma/client';
+import { logger } from '../utils/logger.js';
+
+const prisma = new PrismaClient({
+  log: [
+    { level: 'query', emit: 'event' },
+    { level: 'error', emit: 'stdout' },
+    { level: 'warn', emit: 'stdout' },
+  ],
+});
+
+prisma.$on('query', (e) => {
+  logger.debug('Query: ' + e.query);
+  logger.debug('Params: ' + e.params);
+  logger.debug('Duration: ' + e.duration + 'ms');
+});
+
+export { prisma };
+`;
+
+  await fs.writeFile(path.join(configDir, 'database.ts'), databaseContent);
+
+  // middlewares.ts
+  const middlewaresContent = `import express, { Express } from 'express';
+import cors from 'cors';
+import helmet from 'helmet';
+import compression from 'compression';
+import rateLimit from 'express-rate-limit';
+import { config } from './env.js';
+
+export function setupMiddlewares(app: Express): void {
+  app.use(helmet());
+  app.use(cors());
+  app.use(compression());
+  app.use(express.json());
+  app.use(express.urlencoded({ extended: true }));
+
+  const limiter = rateLimit({
+    windowMs: config.RATE_LIMIT_WINDOW_MS,
+    max: config.RATE_LIMIT_MAX,
+    message: 'Too many requests from this IP, please try again later.',
+  });
+
+  app.use('/api/', limiter);
+}
+`;
+
+  await fs.writeFile(path.join(configDir, 'middlewares.ts'), middlewaresContent);
+
+  // swagger.ts
+  const swaggerContent = `import { Express } from 'express';
+import swaggerJsdoc from 'swagger-jsdoc';
+import swaggerUi from 'swagger-ui-express';
+import { config } from './env.js';
+
+const options: swaggerJsdoc.Options = {
+  definition: {
+    openapi: '3.0.0',
+    info: {
+      title: 'CoreBack API',
+      version: '1.0.0',
+      description: 'Production-ready backend API',
+    },
+    servers: [
+      {
+        url: \`http://localhost:\\\${config.PORT}\`,
+        description: 'Development server',
+      },
+    ],
+  },
+  apis: ['./src/routes/**/*.ts', './src/controllers/**/*.ts'],
+};
+
+const swaggerSpec = swaggerJsdoc(options);
+
+export function setupSwagger(app: Express): void {
+  app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerSpec));
+}
+`;
+
+  await fs.writeFile(path.join(configDir, 'swagger.ts'), swaggerContent);
+
+  if (config.includeRedis) {
+    // redis.ts
+    const redisContent = `import Redis from 'ioredis';
+import { config } from './env.js';
+import { logger } from '../utils/logger.js';
+
+const redis = new Redis({
+  host: config.REDIS_HOST,
+  port: config.REDIS_PORT,
+  password: config.REDIS_PASSWORD || undefined,
+  db: config.REDIS_DB,
+  retryStrategy: (times) => {
+    const delay = Math.min(times * 50, 2000);
+    return delay;
+  },
+});
+
+redis.on('connect', () => {
+  logger.info('✅ Redis connected');
+});
+
+redis.on('error', (err) => {
+  logger.error('❌ Redis connection error:', err);
+});
+
+export { redis };
+`;
+
+    await fs.writeFile(path.join(configDir, 'redis.ts'), redisContent);
+  }
+}

package/src/generators/sourceFiles/core/index.ts

@@ -0,0 +1,28 @@
+import { ProjectConfig } from '../../../types.js';
+import { generateIndex } from './indexFile.js';
+import { generateConfigFiles } from './configFiles.js';
+import { generateMiddlewares } from './middlewares.js';
+import { generateUtils } from './utils.js';
+import { generateRoutes } from './routes.js';
+import { generateTypes } from './types.js';
+import { generateValidators } from './validators.js';
+
+export async function generateCoreFiles(
+  srcDir: string,
+  configDir: string,
+  middlewaresDir: string,
+  utilsDir: string,
+  routesDir: string,
+  typesDir: string,
+  validatorsDir: string,
+  config: ProjectConfig
+): Promise<void> {
+  await generateIndex(srcDir, config);
+  await generateConfigFiles(configDir, config);
+  await generateMiddlewares(middlewaresDir, config);
+  await generateUtils(utilsDir);
+  await generateRoutes(routesDir, config);
+  await generateTypes(typesDir);
+  await generateValidators(validatorsDir, config);
+}
+

package/src/generators/sourceFiles/core/indexFile.ts

@@ -0,0 +1,49 @@
+import { ProjectConfig } from '../../../types.js';
+import fs from 'fs-extra';
+import path from 'path';
+
+export async function generateIndex(srcDir: string, config: ProjectConfig): Promise<void> {
+  const indexContent = `import express from 'express';
+import { config } from './config/env.js';
+import { setupMiddlewares } from './config/middlewares.js';
+import { setupRoutes } from './routes/index.js';
+import { setupSwagger } from './config/swagger.js';
+import { logger } from './utils/logger.js';
+import { errorHandler } from './middlewares/errorHandler.js';
+import { registerListeners } from './events/listeners/index.js';
+import { registerScheduledTasks } from './tasks/index.js';${config.includeRedis ? `
+import { redis } from './config/redis.js';` : ''}${config.includeQueue ? `
+import { startQueueWorkers } from './queue/workers.js';` : ''}
+
+const app = express();
+
+setupMiddlewares(app);
+setupSwagger(app);
+setupRoutes(app);
+app.use(errorHandler);
+
+// Register event listeners
+registerListeners();
+
+// Register scheduled tasks
+registerScheduledTasks();
+
+${config.includeQueue ? `// Start queue workers
+startQueueWorkers();` : ''}
+
+const server = app.listen(config.PORT, () => {
+  logger.info(\`🚀 Server: http://localhost:\${config.PORT}\`);
+  logger.info(\`📚 Docs: http://localhost:\${config.PORT}/api-docs\`);${config.includeQueue ? `
+  logger.info(\`📊 Queue Dashboard: http://localhost:\${config.PORT}/admin/queues\`);` : ''}
+});
+
+process.on('SIGTERM', async () => {
+  logger.info('SIGTERM received, shutting down gracefully...');
+  server.close();
+  ${config.includeRedis ? `await redis.quit();` : ''}
+  process.exit(0);
+});
+`;
+
+  await fs.writeFile(path.join(srcDir, 'index.ts'), indexContent);
+}

package/src/generators/sourceFiles/core/middlewares.ts

@@ -0,0 +1,129 @@
+import { ProjectConfig } from '../../../types.js';
+import fs from 'fs-extra';
+import path from 'path';
+
+export async function generateMiddlewares(middlewaresDir: string, config: ProjectConfig): Promise<void> {
+  // errorHandler.ts
+  const errorHandlerContent = `import { Request, Response, NextFunction } from 'express';
+import { ZodError } from 'zod';
+import { logger } from '../utils/logger.js';
+
+export class AppError extends Error {
+  constructor(
+    public statusCode: number,
+    message: string,
+    public isOperational = true
+  ) {
+    super(message);
+    Object.setPrototypeOf(this, AppError.prototype);
+  }
+}
+
+export const errorHandler = (
+  err: Error,
+  req: Request,
+  res: Response,
+  next: NextFunction
+) => {
+  logger.error(err);
+
+  if (err instanceof ZodError) {
+    return res.status(400).json({
+      status: 'error',
+      message: 'Validation error',
+      errors: err.errors,
+    });
+  }
+
+  if (err instanceof AppError) {
+    return res.status(err.statusCode).json({
+      status: 'error',
+      message: err.message,
+    });
+  }
+
+  res.status(500).json({
+    status: 'error',
+    message: 'Internal server error',
+  });
+};
+`;
+
+  await fs.writeFile(path.join(middlewaresDir, 'errorHandler.ts'), errorHandlerContent);
+
+  // validator.ts
+  const validatorContent = `import { Request, Response, NextFunction } from 'express';
+import { ZodSchema, ZodError } from 'zod';
+
+export const validate = (schema: ZodSchema) => {
+  return (req: Request, res: Response, next: NextFunction) => {
+    try {
+      schema.parse({
+        body: req.body,
+        query: req.query,
+        params: req.params,
+      });
+      next();
+    } catch (error) {
+      if (error instanceof ZodError) {
+        return res.status(400).json({
+          status: 'error',
+          message: 'Validation error',
+          errors: error.errors,
+        });
+      }
+      next(error);
+    }
+  };
+};
+`;
+
+  await fs.writeFile(path.join(middlewaresDir, 'validator.ts'), validatorContent);
+
+  if (config.includeAuth) {
+    // auth.ts
+    const authContent = `import { Request, Response, NextFunction } from 'express';
+import jwt from 'jsonwebtoken';
+import { config } from '../config/env.js';
+import { AppError } from './errorHandler.js';
+
+export interface AuthRequest extends Request {
+  user?: {
+    id: string;
+    email: string;
+  };
+}
+
+export const authenticate = (
+  req: AuthRequest,
+  res: Response,
+  next: NextFunction
+) => {
+  try {
+    const authHeader = req.headers.authorization;
+    
+    if (!authHeader || !authHeader.startsWith('Bearer ')) {
+      throw new AppError(401, 'Authentication required');
+    }
+
+    const token = authHeader.substring(7);
+    const decoded = jwt.verify(token, config.JWT_SECRET) as {
+      id: string;
+      email: string;
+    };
+
+    req.user = decoded;
+    next();
+  } catch (error) {
+    if (error instanceof jwt.JsonWebTokenError) {
+      next(new AppError(401, 'Invalid token'));
+    } else {
+      next(error);
+    }
+  }
+};
+`;
+
+    await fs.writeFile(path.join(middlewaresDir, 'auth.ts'), authContent);
+  }
+}

package/src/generators/sourceFiles/core/routes.ts

@@ -0,0 +1,295 @@
+import { ProjectConfig } from '../../../types.js';
+import fs from 'fs-extra';
+import path from 'path';
+
+export async function generateRoutes(routesDir: string, config: ProjectConfig): Promise<void> {
+  // index.ts
+  let indexContent = `import { Express } from 'express';
+import { healthRoutes } from './health.routes.js';
+`;
+
+  if (config.includeAuth) {
+    indexContent += `import { authRoutes } from './auth.routes.js';
+`;
+  }
+
+  if (config.includeFileUpload) {
+    indexContent += `import { fileUploadRoutes } from './fileUpload.routes.js';
+`;
+  }
+
+  if (config.includeQueue) {
+    indexContent += `import { queueRoutes } from './queue.routes.js';
+import { queueDashboardRouter } from '../queue/dashboard.js';
+`;
+  }
+
+  indexContent += `
+export function setupRoutes(app: Express): void {
+  app.use('/api/health', healthRoutes);
+`;
+
+  if (config.includeAuth) {
+    indexContent += `  app.use('/api/auth', authRoutes);
+`;
+  }
+
+  if (config.includeFileUpload) {
+    indexContent += `  app.use('/api/files', fileUploadRoutes);
+`;
+  }
+
+  if (config.includeQueue) {
+    indexContent += `  app.use('/api/queue', queueRoutes);
+  app.use('/admin/queues', queueDashboardRouter);
+`;
+  }
+
+  indexContent += `}
+`;
+
+  await fs.writeFile(path.join(routesDir, 'index.ts'), indexContent);
+
+  // health.routes.ts
+  const healthRoutesContent = `import { Router } from 'express';
+import { healthController } from '../controllers/health.controller.js';
+
+/**
+ * @swagger
+ * tags:
+ *   name: Health
+ *   description: Health check endpoints
+ */
+
+const router = Router();
+
+/**
+ * @swagger
+ * /api/health:
+ *   get:
+ *     summary: Health check endpoint
+ *     tags: [Health]
+ *     responses:
+ *       200:
+ *         description: Service is healthy
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 status:
+ *                   type: string
+ *                   example: ok
+ *                 timestamp:
+ *                   type: string
+ *                   example: 2024-01-01T00:00:00.000Z
+ */
+router.get('/', healthController.check);
+
+export { router as healthRoutes };
+`;
+
+  await fs.writeFile(path.join(routesDir, 'health.routes.ts'), healthRoutesContent);
+
+  if (config.includeAuth) {
+    // auth.routes.ts
+    const authRoutesContent = `import { Router } from 'express';
+import { authController } from '../controllers/auth.controller.js';
+import { validate } from '../middlewares/validator.js';
+import { registerSchema, loginSchema, emailSchema, resetPasswordSchema } from '../validators/auth.validator.js';
+import { authenticate } from '../middlewares/auth.js';
+
+/**
+ * @swagger
+ * tags:
+ *   name: Auth
+ *   description: Authentication endpoints
+ */
+
+const router = Router();
+
+/**
+ * @swagger
+ * /api/auth/register:
+ *   post:
+ *     summary: Register a new user
+ *     tags: [Auth]
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             required:
+ *               - email
+ *               - password
+ *             properties:
+ *               email:
+ *                 type: string
+ *                 format: email
+ *               password:
+ *                 type: string
+ *                 minLength: 8
+ *               name:
+ *                 type: string
+ *     responses:
+ *       201:
+ *         description: User created successfully
+ *       400:
+ *         description: Validation error
+ */
+router.post('/register', validate(registerSchema), authController.register);
+
+/**
+ * @swagger
+ * /api/auth/login:
+ *   post:
+ *     summary: Login user
+ *     tags: [Auth]
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             required:
+ *               - email
+ *               - password
+ *             properties:
+ *               email:
+ *                 type: string
+ *                 format: email
+ *               password:
+ *                 type: string
+ *     responses:
+ *       200:
+ *         description: Login successful
+ *       401:
+ *         description: Invalid credentials
+ */
+router.post('/login', validate(loginSchema), authController.login);
+
+/**
+ * @swagger
+ * /api/auth/me:
+ *   get:
+ *     summary: Get current user
+ *     tags: [Auth]
+ *     security:
+ *       - bearerAuth: []
+ *     responses:
+ *       200:
+ *         description: Current user information
+ *       401:
+ *         description: Unauthorized
+ */
+router.get('/me', authenticate, authController.me);
+
+/**
+ * @swagger
+ * /api/auth/verify-email:
+ *   get:
+ *     summary: Verify email address
+ *     tags: [Auth]
+ *     parameters:
+ *       - in: query
+ *         name: token
+ *         required: true
+ *         schema:
+ *           type: string
+ *     responses:
+ *       200:
+ *         description: Email verified successfully
+ *       400:
+ *         description: Invalid or expired token
+ */
+router.get('/verify-email', authController.verifyEmail);
+
+/**
+ * @swagger
+ * /api/auth/resend-verification:
+ *   post:
+ *     summary: Resend verification email
+ *     tags: [Auth]
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             required:
+ *               - email
+ *             properties:
+ *               email:
+ *                 type: string
+ *                 format: email
+ *     responses:
+ *       200:
+ *         description: Verification email sent
+ *       400:
+ *         description: Email already verified
+ */
+router.post('/resend-verification', validate(emailSchema), authController.resendVerification);
+
+/**
+ * @swagger
+ * /api/auth/forgot-password:
+ *   post:
+ *     summary: Request password reset
+ *     tags: [Auth]
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             required:
+ *               - email
+ *             properties:
+ *               email:
+ *                 type: string
+ *                 format: email
+ *     responses:
+ *       200:
+ *         description: Password reset email sent
+ */
+router.post('/forgot-password', validate(emailSchema), authController.forgotPassword);
+
+/**
+ * @swagger
+ * /api/auth/reset-password:
+ *   post:
+ *     summary: Reset password
+ *     tags: [Auth]
+ *     parameters:
+ *       - in: query
+ *         name: token
+ *         required: true
+ *         schema:
+ *           type: string
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             required:
+ *               - password
+ *             properties:
+ *               password:
+ *                 type: string
+ *                 minLength: 8
+ *     responses:
+ *       200:
+ *         description: Password reset successfully
+ *       400:
+ *         description: Invalid or expired token
+ */
+router.post('/reset-password', validate(resetPasswordSchema), authController.resetPassword);
+
+export { router as authRoutes };
+`;
+
+    await fs.writeFile(path.join(routesDir, 'auth.routes.ts'), authRoutesContent);
+  }
+}