create-coreback 1.0.4 → 1.0.5

package/src/generators/sourceFiles/phase1/cliGenerators.ts

@@ -0,0 +1,338 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+export async function generateCLIGenerators(projectPath: string): Promise<void> {
+  const scriptsDir = path.join(projectPath, 'scripts');
+  await fs.ensureDir(scriptsDir);
+
+  // make.ts - CLI generator
+  const makeContent = `#!/usr/bin/env node
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const projectRoot = path.resolve(__dirname, '..');
+
+const templates = {
+  controller: \`import { Request, Response } from 'express';
+import { AppError } from '../middlewares/errorHandler.js';
+
+export const {{name}}Controller = {
+  index: async (req: Request, res: Response) => {
+    try {
+      res.json({
+        status: 'success',
+        data: [],
+      });
+    } catch (error) {
+      if (error instanceof AppError) {
+        throw error;
+      }
+      throw new AppError(500, 'Failed to fetch {{name}}');
+    }
+  },
+
+  show: async (req: Request, res: Response) => {
+    try {
+      const { id } = req.params;
+      res.json({
+        status: 'success',
+        data: { id },
+      });
+    } catch (error) {
+      if (error instanceof AppError) {
+        throw error;
+      }
+      throw new AppError(500, 'Failed to fetch {{name}}');
+    }
+  },
+
+  create: async (req: Request, res: Response) => {
+    try {
+      res.status(201).json({
+        status: 'success',
+        data: req.body,
+      });
+    } catch (error) {
+      if (error instanceof AppError) {
+        throw error;
+      }
+      throw new AppError(500, 'Failed to create {{name}}');
+    }
+  },
+
+  update: async (req: Request, res: Response) => {
+    try {
+      const { id } = req.params;
+      res.json({
+        status: 'success',
+        data: { id, ...req.body },
+      });
+    } catch (error) {
+      if (error instanceof AppError) {
+        throw error;
+      }
+      throw new AppError(500, 'Failed to update {{name}}');
+    }
+  },
+
+  delete: async (req: Request, res: Response) => {
+    try {
+      const { id } = req.params;
+      res.json({
+        status: 'success',
+        message: '{{name}} deleted successfully',
+      });
+    } catch (error) {
+      if (error instanceof AppError) {
+        throw error;
+      }
+      throw new AppError(500, 'Failed to delete {{name}}');
+    }
+  },
+};
+\`,
+
+  service: \`import { AppError } from '../middlewares/errorHandler.js';
+
+export const {{name}}Service = {
+  findAll: async () => {
+    // Implement your logic here
+    return [];
+  },
+
+  findById: async (id: string) => {
+    // Implement your logic here
+    return { id };
+  },
+
+  create: async (data: unknown) => {
+    // Implement your logic here
+    return data;
+  },
+
+  update: async (id: string, data: unknown) => {
+    // Implement your logic here
+    return { id, ...data };
+  },
+
+  delete: async (id: string) => {
+    // Implement your logic here
+    return true;
+  },
+};
+\`,
+
+  repository: \`import { prisma } from '../config/database.js';
+
+export const {{name}}Repository = {
+  findAll: async () => {
+    return prisma.{{modelName}}.findMany();
+  },
+
+  findById: async (id: string) => {
+    return prisma.{{modelName}}.findUnique({
+      where: { id },
+    });
+  },
+
+  create: async (data: unknown) => {
+    return prisma.{{modelName}}.create({
+      data: data as any,
+    });
+  },
+
+  update: async (id: string, data: unknown) => {
+    return prisma.{{modelName}}.update({
+      where: { id },
+      data: data as any,
+    });
+  },
+
+  delete: async (id: string) => {
+    return prisma.{{modelName}}.delete({
+      where: { id },
+    });
+  },
+};
+\`,
+
+  route: \`import { Router } from 'express';
+import { {{name}}Controller } from '../controllers/{{name}}.controller.js';
+// Uncomment if you need authentication:
+// import { authenticate } from '../middlewares/auth.js';
+
+const router = Router();
+
+/**
+ * @swagger
+ * tags:
+ *   name: {{Name}}
+ *   description: {{Name}} management endpoints
+ */
+
+// Uncomment if you need authentication:
+// router.use(authenticate);
+
+/**
+ * @swagger
+ * /api/{{name}}:
+ *   get:
+ *     summary: Get all {{name}}
+ *     tags: [{{Name}}]
+ *     responses:
+ *       200:
+ *         description: List of {{name}}
+ */
+router.get('/', {{name}}Controller.index);
+
+/**
+ * @swagger
+ * /api/{{name}}/{id}:
+ *   get:
+ *     summary: Get {{name}} by ID
+ *     tags: [{{Name}}]
+ *     parameters:
+ *       - in: path
+ *         name: id
+ *         required: true
+ *         schema:
+ *           type: string
+ *     responses:
+ *       200:
+ *         description: {{Name}} details
+ */
+router.get('/:id', {{name}}Controller.show);
+
+/**
+ * @swagger
+ * /api/{{name}}:
+ *   post:
+ *     summary: Create {{name}}
+ *     tags: [{{Name}}]
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *     responses:
+ *       201:
+ *         description: {{Name}} created
+ */
+router.post('/', {{name}}Controller.create);
+
+/**
+ * @swagger
+ * /api/{{name}}/{id}:
+ *   put:
+ *     summary: Update {{name}}
+ *     tags: [{{Name}}]
+ *     parameters:
+ *       - in: path
+ *         name: id
+ *         required: true
+ *         schema:
+ *           type: string
+ *     responses:
+ *       200:
+ *         description: {{Name}} updated
+ */
+router.put('/:id', {{name}}Controller.update);
+
+/**
+ * @swagger
+ * /api/{{name}}/{id}:
+ *   delete:
+ *     summary: Delete {{name}}
+ *     tags: [{{Name}}]
+ *     parameters:
+ *       - in: path
+ *         name: id
+ *         required: true
+ *         schema:
+ *           type: string
+ *     responses:
+ *       200:
+ *         description: {{Name}} deleted
+ */
+router.delete('/:id', {{name}}Controller.delete);
+
+export { router as {{name}}Routes };
+\`,
+};
+
+function toPascalCase(str: string): string {
+  return str
+    .split(/[-_]/)
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join('');
+}
+
+function toCamelCase(str: string): string {
+  const pascal = toPascalCase(str);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+
+function replacePlaceholders(content: string, name: string, modelName?: string): string {
+  const Name = toPascalCase(name);
+  const camelName = toCamelCase(name);
+  const model = modelName || Name;
+  
+  return content
+    .replace(/{{name}}/g, camelName)
+    .replace(/{{Name}}/g, Name)
+    .replace(/{{modelName}}/g, model.toLowerCase());
+}
+
+async function generateFile(type: string, name: string, modelName?: string) {
+  const template = templates[type as keyof typeof templates];
+  if (!template) {
+    console.error(\`Unknown type: \\\${type}\`);
+    process.exit(1);
+  }
+
+  const content = replacePlaceholders(template, name, modelName);
+  const dirMap: Record<string, string> = {
+    controller: 'src/controllers',
+    service: 'src/services',
+    repository: 'src/repositories',
+    route: 'src/routes',
+  };
+
+  const dir = path.join(projectRoot, dirMap[type] || 'src');
+  await fs.ensureDir(dir);
+
+  const fileName = \`\\\${toCamelCase(name)}.\\\${type === 'route' ? 'routes' : type}.ts\`;
+  const filePath = path.join(dir, fileName);
+
+  if (await fs.pathExists(filePath)) {
+    console.error(\`File already exists: \\\${filePath}\`);
+    process.exit(1);
+  }
+
+  await fs.writeFile(filePath, content);
+  console.log(\`✅ Created \\\${filePath}\`);
+}
+
+const args = process.argv.slice(2);
+if (args.length < 2) {
+  console.error('Usage: npm run make:<type> <name> [modelName]');
+  console.error('Example: npm run make:controller user');
+  console.error('Example: npm run make:repository user User');
+  process.exit(1);
+}
+
+const [type, name] = args;
+const modelName = args[2];
+
+generateFile(type, name, modelName).catch((error) => {
+  console.error('Error:', error);
+  process.exit(1);
+});
+`;
+
+  await fs.writeFile(path.join(scriptsDir, 'make.ts'), makeContent);
+}

package/src/generators/sourceFiles/phase1/seedersFactories.ts

@@ -0,0 +1,97 @@
+import { ProjectConfig } from '../../../types.js';
+import fs from 'fs-extra';
+import path from 'path';
+
+export async function generateSeedersAndFactories(
+  projectPath: string,
+  config: ProjectConfig
+): Promise<void> {
+  const prismaDir = path.join(projectPath, 'prisma');
+  const factoriesDir = path.join(projectPath, 'src', 'factories');
+  await fs.ensureDir(factoriesDir);
+
+  // seed.ts
+  const seedContent = `import { PrismaClient } from '@prisma/client';
+
+const prisma = new PrismaClient();
+
+async function main() {
+  console.log('🌱 Seeding database...');
+
+  // Add your seed data here
+  // Example:
+  // await prisma.user.create({
+  //   data: {
+  //     email: 'admin@example.com',
+  //     password: '$2b$10$...', // hashed password
+  //     name: 'Admin User',
+  //     emailVerified: true,
+  //   },
+  // });
+
+  console.log('✅ Seeding completed');
+}
+
+main()
+  .catch((e) => {
+    console.error('❌ Seeding failed:', e);
+    process.exit(1);
+  })
+  .finally(async () => {
+    await prisma.$disconnect();
+  });
+`;
+
+  await fs.writeFile(path.join(prismaDir, 'seed.ts'), seedContent);
+
+  // user.factory.ts (if auth is enabled)
+  if (config.includeAuth) {
+    const userFactoryContent = `import bcrypt from 'bcrypt';
+import { PrismaClient } from '@prisma/client';
+
+const prisma = new PrismaClient();
+
+export interface UserFactoryData {
+  email?: string;
+  password?: string;
+  name?: string;
+  emailVerified?: boolean;
+}
+
+export async function createUser(data: UserFactoryData = {}) {
+  const defaultPassword = data.password || 'password123';
+  const hashedPassword = await bcrypt.hash(defaultPassword, 10);
+
+  return prisma.user.create({
+    data: {
+      email: data.email || \`user-\${Date.now()}@example.com\`,
+      password: hashedPassword,
+      name: data.name || 'Test User',
+      emailVerified: data.emailVerified ?? true,
+    },
+  });
+}
+
+export async function createManyUsers(count: number, data: UserFactoryData = {}) {
+  const users = [];
+  for (let i = 0; i < count; i++) {
+    const defaultPassword = data.password || 'password123';
+    const hashedPassword = await bcrypt.hash(defaultPassword, 10);
+    
+    users.push({
+      email: data.email || \`user-\${Date.now()}-\${i}@example.com\`,
+      password: hashedPassword,
+      name: data.name || \`Test User \${i + 1}\`,
+      emailVerified: data.emailVerified ?? true,
+    });
+  }
+
+  return prisma.user.createMany({
+    data: users,
+  });
+}
+`;
+
+    await fs.writeFile(path.join(factoriesDir, 'user.factory.ts'), userFactoryContent);
+  }
+}

package/src/generators/sourceFiles/phase2/dtos.ts

@@ -0,0 +1,60 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+export async function generateDTOs(validatorsDir: string): Promise<void> {
+  const dtoContent = `import { z } from 'zod';
+
+/**
+ * Base DTO class with Zod validation
+ */
+export class DTO<T extends z.ZodTypeAny> {
+  constructor(private schema: T) {}
+
+  /**
+   * Validate and parse data
+   */
+  parse(data: unknown): z.infer<T> {
+    return this.schema.parse(data);
+  }
+
+  /**
+   * Safe parse (returns result object)
+   */
+  safeParse(data: unknown): z.SafeParseReturnType<unknown, z.infer<T>> {
+    return this.schema.safeParse(data);
+  }
+
+  /**
+   * Get the schema
+   */
+  getSchema(): T {
+    return this.schema;
+  }
+}
+
+/**
+ * Create a DTO from a Zod schema
+ */
+export function createDTO<T extends z.ZodTypeAny>(schema: T): DTO<T> {
+  return new DTO(schema);
+}
+
+/**
+ * Common DTOs
+ */
+export const PaginationDTO = createDTO(
+  z.object({
+    page: z.coerce.number().int().min(1).default(1).optional(),
+    limit: z.coerce.number().int().min(1).max(100).default(10).optional(),
+  })
+);
+
+export const IdDTO = createDTO(
+  z.object({
+    id: z.string().min(1),
+  })
+);
+`;
+
+  await fs.writeFile(path.join(validatorsDir, 'dto.ts'), dtoContent);
+}

package/src/generators/sourceFiles/phase2/events.ts

@@ -0,0 +1,80 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+export async function generateEventsAndListeners(srcDir: string): Promise<void> {
+  const eventsDir = path.join(srcDir, 'events');
+  const listenersDir = path.join(eventsDir, 'listeners');
+  await fs.ensureDir(eventsDir);
+  await fs.ensureDir(listenersDir);
+
+  // eventEmitter.ts
+  const eventEmitterContent = `import { EventEmitter } from 'events';
+import { logger } from '../utils/logger.js';
+
+class AppEventEmitter extends EventEmitter {
+  emit(event: string | symbol, ...args: any[]): boolean {
+    logger.debug(\`Event emitted: \${String(event)}\`);
+    return super.emit(event, ...args);
+  }
+}
+
+export const eventEmitter = new AppEventEmitter();
+
+// Event names
+export const Events = {
+  USER_REGISTERED: 'user.registered',
+  USER_VERIFIED: 'user.verified',
+  PASSWORD_RESET_REQUESTED: 'password.reset.requested',
+  PASSWORD_RESET: 'password.reset',
+  EMAIL_SENT: 'email.sent',
+} as const;
+
+export type EventName = typeof Events[keyof typeof Events];
+`;
+
+  await fs.writeFile(path.join(eventsDir, 'eventEmitter.ts'), eventEmitterContent);
+
+  // listeners/index.ts
+  const listenersContent = `import { eventEmitter, Events } from '../eventEmitter.js';
+import { logger } from '../utils/logger.js';
+
+/**
+ * Register all event listeners
+ */
+export function registerListeners() {
+  // User registered listener
+  eventEmitter.on(Events.USER_REGISTERED, (data) => {
+    logger.info(\`User registered: \${data.email}\`);
+    // Add your custom logic here
+  });
+
+  // User verified listener
+  eventEmitter.on(Events.USER_VERIFIED, (data) => {
+    logger.info(\`User verified: \${data.email}\`);
+    // Add your custom logic here
+  });
+
+  // Password reset requested listener
+  eventEmitter.on(Events.PASSWORD_RESET_REQUESTED, (data) => {
+    logger.info(\`Password reset requested for: \${data.email}\`);
+    // Add your custom logic here
+  });
+
+  // Password reset listener
+  eventEmitter.on(Events.PASSWORD_RESET, (data) => {
+    logger.info(\`Password reset for: \${data.email}\`);
+    // Add your custom logic here
+  });
+
+  // Email sent listener
+  eventEmitter.on(Events.EMAIL_SENT, (data) => {
+    logger.debug(\`Email sent to: \${data.to}\`);
+    // Add your custom logic here
+  });
+
+  logger.info('Event listeners registered');
+}
+`;
+
+  await fs.writeFile(path.join(listenersDir, 'index.ts'), listenersContent);
+}

package/src/generators/sourceFiles/phase2/exceptionHandling.ts

@@ -0,0 +1,111 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+export async function generateAdvancedExceptionHandling(middlewaresDir: string): Promise<void> {
+  const exceptionHandlerContent = `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,
+    public code?: string
+  ) {
+    super(message);
+    Object.setPrototypeOf(this, AppError.prototype);
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+
+export class ValidationError extends AppError {
+  constructor(message: string, public errors?: unknown[]) {
+    super(400, message, true, 'VALIDATION_ERROR');
+    this.name = 'ValidationError';
+  }
+}
+
+export class NotFoundError extends AppError {
+  constructor(resource: string = 'Resource') {
+    super(404, \`\${resource} not found\`, true, 'NOT_FOUND');
+    this.name = 'NotFoundError';
+  }
+}
+
+export class UnauthorizedError extends AppError {
+  constructor(message: string = 'Unauthorized') {
+    super(401, message, true, 'UNAUTHORIZED');
+    this.name = 'UnauthorizedError';
+  }
+}
+
+export class ForbiddenError extends AppError {
+  constructor(message: string = 'Forbidden') {
+    super(403, message, true, 'FORBIDDEN');
+    this.name = 'ForbiddenError';
+  }
+}
+
+export class ConflictError extends AppError {
+  constructor(message: string = 'Resource conflict') {
+    super(409, message, true, 'CONFLICT');
+    this.name = 'ConflictError';
+  }
+}
+
+export const errorHandler = (
+  err: Error,
+  req: Request,
+  res: Response,
+  next: NextFunction
+) => {
+  // Log error
+  logger.error('Error:', {
+    message: err.message,
+    stack: err.stack,
+    url: req.url,
+    method: req.method,
+    ip: req.ip,
+  });
+
+  // Zod validation errors
+  if (err instanceof ZodError) {
+    return res.status(400).json({
+      status: 'error',
+      code: 'VALIDATION_ERROR',
+      message: 'Validation error',
+      errors: err.errors,
+    });
+  }
+
+  // App errors (operational)
+  if (err instanceof AppError && err.isOperational) {
+    return res.status(err.statusCode).json({
+      status: 'error',
+      code: err.code || 'APP_ERROR',
+      message: err.message,
+    });
+  }
+
+  // Unknown errors (programming errors, etc.)
+  const statusCode = err instanceof AppError ? err.statusCode : 500;
+  const message =
+    process.env.NODE_ENV === 'production'
+      ? 'Internal server error'
+      : err.message;
+
+  return res.status(statusCode).json({
+    status: 'error',
+    code: 'INTERNAL_ERROR',
+    message,
+    ...(process.env.NODE_ENV !== 'production' && { stack: err.stack }),
+  });
+};
+`;
+
+  await fs.writeFile(
+    path.join(middlewaresDir, 'errorHandler.ts'),
+    exceptionHandlerContent
+  );
+}