create-coreback 1.0.4 → 1.0.5

package/src/generators/sourceFiles/phase3/moduleSystem.ts

@@ -0,0 +1,170 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+export async function generateModuleSystem(srcDir: string): Promise<void> {
+  const modulesDir = path.join(srcDir, 'modules');
+  await fs.ensureDir(modulesDir);
+
+  const moduleContent = `import { Express } from 'express';
+import { container } from '../di/container.js';
+
+export interface ModuleConfig {
+  name: string;
+  routes?: (app: Express) => void;
+  services?: Array<{ identifier: string | symbol; factory: any; singleton?: boolean }>;
+  middlewares?: Array<(app: Express) => void>;
+  onInit?: () => void | Promise<void>;
+  onDestroy?: () => void | Promise<void>;
+}
+
+export class Module {
+  private config: ModuleConfig;
+
+  constructor(config: ModuleConfig) {
+    this.config = config;
+  }
+
+  /**
+   * Register module services
+   */
+  registerServices(): void {
+    if (this.config.services) {
+      this.config.services.forEach(({ identifier, factory, singleton = true }) => {
+        if (singleton) {
+          container.singleton(identifier, factory);
+        } else {
+          container.transient(identifier, factory);
+        }
+      });
+    }
+  }
+
+  /**
+   * Register module routes
+   */
+  registerRoutes(app: Express): void {
+    if (this.config.routes) {
+      this.config.routes(app);
+    }
+  }
+
+  /**
+   * Register module middlewares
+   */
+  registerMiddlewares(app: Express): void {
+    if (this.config.middlewares) {
+      this.config.middlewares.forEach((middleware) => middleware(app));
+    }
+  }
+
+  /**
+   * Initialize module
+   */
+  async init(): Promise<void> {
+    this.registerServices();
+    if (this.config.onInit) {
+      await this.config.onInit();
+    }
+  }
+
+  /**
+   * Destroy module
+   */
+  async destroy(): Promise<void> {
+    if (this.config.onDestroy) {
+      await this.config.onDestroy();
+    }
+  }
+
+  getName(): string {
+    return this.config.name;
+  }
+}
+
+/**
+ * Module registry
+ */
+class ModuleRegistry {
+  private modules: Map<string, Module> = new Map();
+
+  /**
+   * Register a module
+   */
+  register(module: Module): void {
+    this.modules.set(module.getName(), module);
+  }
+
+  /**
+   * Get a module
+   */
+  get(name: string): Module | undefined {
+    return this.modules.get(name);
+  }
+
+  /**
+   * Get all modules
+   */
+  getAll(): Module[] {
+    return Array.from(this.modules.values());
+  }
+
+  /**
+   * Initialize all modules
+   */
+  async initAll(): Promise<void> {
+    for (const module of this.modules.values()) {
+      await module.init();
+    }
+  }
+
+  /**
+   * Register all routes
+   */
+  registerRoutes(app: Express): void {
+    for (const module of this.modules.values()) {
+      module.registerRoutes(app);
+    }
+  }
+
+  /**
+   * Register all middlewares
+   */
+  registerMiddlewares(app: Express): void {
+    for (const module of this.modules.values()) {
+      module.registerMiddlewares(app);
+    }
+  }
+}
+
+export const moduleRegistry = new ModuleRegistry();
+`;
+
+  await fs.writeFile(path.join(modulesDir, 'module.ts'), moduleContent);
+
+  // Example module
+  const exampleModuleContent = `import { Module } from './module.js';
+import { Express } from 'express';
+import { healthRoutes } from '../routes/health.routes.js';
+
+/**
+ * Example: Health Module
+ */
+export const healthModule = new Module({
+  name: 'health',
+  routes: (app: Express) => {
+    app.use('/api/health', healthRoutes);
+  },
+  services: [
+    {
+      identifier: 'healthService',
+      factory: () => ({
+        check: () => ({ status: 'ok' }),
+      }),
+      singleton: true,
+    },
+  ],
+});
+`;
+
+  await fs.writeFile(path.join(modulesDir, 'examples.ts'), exampleModuleContent);
+}

package/src/generators/sourceFiles/phase3/structuredLogging.ts

@@ -0,0 +1,160 @@
+import { ProjectConfig } from '../../../types.js';
+import fs from 'fs-extra';
+import path from 'path';
+
+export async function generateStructuredLogging(
+  utilsDir: string,
+  config: ProjectConfig
+): Promise<void> {
+  // Replace the existing logger with structured logging
+  const loggingContent = `import winston from 'winston';
+import { config as envConfig } from '../config/env.js';
+import fs from 'fs-extra';
+import path from 'path';
+
+// Ensure logs directory exists
+const logsDir = path.join(process.cwd(), 'logs');
+fs.ensureDirSync(logsDir);
+
+/**
+ * Log channels configuration
+ */
+const channels = {
+  // Application logs
+  app: winston.createLogger({
+    level: envConfig.NODE_ENV === 'production' ? 'info' : 'debug',
+    format: winston.format.combine(
+      winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
+      winston.format.errors({ stack: true }),
+      winston.format.json()
+    ),
+    transports: [
+      new winston.transports.File({
+        filename: path.join(logsDir, 'app.log'),
+        maxsize: 5242880, // 5MB
+        maxFiles: 5,
+      }),
+    ],
+  }),
+
+  // Error logs
+  error: winston.createLogger({
+    level: 'error',
+    format: winston.format.combine(
+      winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
+      winston.format.errors({ stack: true }),
+      winston.format.json()
+    ),
+    transports: [
+      new winston.transports.File({
+        filename: path.join(logsDir, 'error.log'),
+        maxsize: 5242880, // 5MB
+        maxFiles: 5,
+      }),
+    ],
+  }),
+
+  // Access logs (HTTP requests)
+  access: winston.createLogger({
+    level: 'info',
+    format: winston.format.combine(
+      winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
+      winston.format.json()
+    ),
+    transports: [
+      new winston.transports.File({
+        filename: path.join(logsDir, 'access.log'),
+        maxsize: 5242880, // 5MB
+        maxFiles: 5,
+      }),
+    ],
+  }),
+
+  // Query logs (Database queries)
+  query: winston.createLogger({
+    level: 'debug',
+    format: winston.format.combine(
+      winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
+      winston.format.json()
+    ),
+    transports: [
+      new winston.transports.File({
+        filename: path.join(logsDir, 'query.log'),
+        maxsize: 5242880, // 5MB
+        maxFiles: 5,
+      }),
+    ],
+  }),
+};
+
+// Add console transport in development
+if (envConfig.NODE_ENV !== 'production') {
+  Object.values(channels).forEach((channel) => {
+    channel.add(
+      new winston.transports.Console({
+        format: winston.format.combine(
+          winston.format.colorize(),
+          winston.format.simple()
+        ),
+      })
+    );
+  });
+}
+
+/**
+ * Main logger (default channel: app)
+ */
+export const logger = channels.app;
+
+/**
+ * Channel-specific loggers
+ */
+export const loggers = {
+  app: channels.app,
+  error: channels.error,
+  access: channels.access,
+  query: channels.query,
+};
+
+/**
+ * Log levels
+ */
+export const LogLevel = {
+  ERROR: 'error',
+  WARN: 'warn',
+  INFO: 'info',
+  DEBUG: 'debug',
+} as const;
+
+/**
+ * Structured logging helper
+ */
+export function log(level: keyof typeof LogLevel, message: string, meta?: any) {
+  const channel = level === 'error' ? channels.error : channels.app;
+  channel[level](message, meta);
+}
+
+/**
+ * Access log middleware
+ */
+export function accessLog(req: any, res: any, next: any) {
+  const start = Date.now();
+
+  res.on('finish', () => {
+    const duration = Date.now() - start;
+    channels.access.info('HTTP Request', {
+      method: req.method,
+      url: req.url,
+      status: res.statusCode,
+      duration: \`\${duration}ms\`,
+      ip: req.ip,
+      userAgent: req.get('user-agent'),
+    });
+  });
+
+  next();
+}
+`;
+
+  await fs.writeFile(path.join(utilsDir, 'logger.ts'), loggingContent);
+}

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

@@ -0,0 +1,114 @@
+import { ProjectConfig } from '../../../types.js';
+import fs from 'fs-extra';
+import path from 'path';
+
+export async function generateRepositories(repositoriesDir: string, config: ProjectConfig): Promise<void> {
+  if (config.includeAuth) {
+    const userRepositoryContent = `import { prisma } from '../config/database.js';
+
+export const userRepository = {
+  async findByEmail(email: string) {
+    return prisma.user.findUnique({
+      where: { email },
+    });
+  },
+
+  async findById(id: string) {
+    return prisma.user.findUnique({
+      where: { id },
+      select: {
+        id: true,
+        email: true,
+        name: true,
+        createdAt: true,
+        updatedAt: true,
+      },
+    });
+  },
+
+  async create(data: { email: string; password: string; name?: string; emailVerificationToken?: string; emailVerificationExpires?: Date }) {
+    return prisma.user.create({
+      data,
+      select: {
+        id: true,
+        email: true,
+        name: true,
+        emailVerified: true,
+        createdAt: true,
+        updatedAt: true,
+      },
+    });
+  },
+
+  async updateEmailVerification(id: string, verified: boolean) {
+    return prisma.user.update({
+      where: { id },
+      data: {
+        emailVerified: verified,
+        emailVerificationToken: null,
+        emailVerificationExpires: null,
+      },
+    });
+  },
+
+  async findByVerificationToken(token: string) {
+    return prisma.user.findFirst({
+      where: {
+        emailVerificationToken: token,
+        emailVerificationExpires: {
+          gt: new Date(),
+        },
+      },
+    });
+  },
+
+  async updateVerificationToken(id: string, token: string, expires: Date) {
+    return prisma.user.update({
+      where: { id },
+      data: {
+        emailVerificationToken: token,
+        emailVerificationExpires: expires,
+      },
+    });
+  },
+
+  async updatePasswordResetToken(id: string, token: string, expires: Date) {
+    return prisma.user.update({
+      where: { id },
+      data: {
+        passwordResetToken: token,
+        passwordResetExpires: expires,
+      },
+    });
+  },
+
+  async findByPasswordResetToken(token: string) {
+    return prisma.user.findFirst({
+      where: {
+        passwordResetToken: token,
+        passwordResetExpires: {
+          gt: new Date(),
+        },
+      },
+    });
+  },
+
+  async updatePassword(id: string, password: string) {
+    return prisma.user.update({
+      where: { id },
+      data: {
+        password,
+        passwordResetToken: null,
+        passwordResetExpires: null,
+      },
+    });
+  },
+};
+`;
+
+    await fs.writeFile(
+      path.join(repositoriesDir, 'user.repository.ts'),
+      userRepositoryContent
+    );
+  }
+}