bootifyjs 0.0.2 → 0.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bootifyjs",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "Spring Boot inspired framework fro Node.js built on top of fastify and express",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/application/Application.ts

@@ -1,355 +0,0 @@
-import Fastify, {
-  FastifyInstance,
-  FastifyPluginAsync,
-  FastifyPluginCallback,
-  FastifyServerOptions,
-} from 'fastify';
-import { registerControllers } from '../decorators/controller.decorator';
-import Logger from '../logger/Logger';
-import { requestContext } from '../middleware/requestcontext';
-import { httpLoggerMiddleware } from '../middleware/http';
-
-interface FastifyServerConfig {
-  port?: number;
-  host?: string;
-  route?: FastifyPluginCallback | FastifyPluginAsync;
-  enableCors?: boolean;
-  enableSwagger?: boolean;
-  enableLogging?: boolean;
-  enableErrorHandling?: boolean;
-  enableDatabase?: boolean;
-  enableRedis?: boolean;
-  corsOptions?: {
-    origin?: string | string[];
-    methods?: string[];
-    credentials?: boolean;
-  };
-  swaggerOptions?: {
-    routePrefix?: string;
-    swaggerDoc?: any;
-  };
-  enableMetrics?: boolean;
-  enableCookie?: boolean;
-  enableAuth?: boolean;
-}
-
-export class Application {
-  private server: FastifyInstance;
-  private config: FastifyServerConfig;
-
-  constructor(config: FastifyServerConfig = {}) {
-    this.config = {
-      port: 3000,
-      host: '0.0.0.0',
-      enableCors: true,
-      enableSwagger: false,
-      enableLogging: true,
-      enableErrorHandling: true,
-      enableDatabase: false,
-      enableRedis: false,
-      enableCookie: false,
-      enableAuth: false,
-      enableMetrics: false,
-      corsOptions: {
-        origin: [
-          'http://localhost:4000',
-          'http://localhost:3000',
-          'http://localhost:5173',
-        ],
-        methods: ['GET', 'PUT', 'PATCH', 'POST', 'DELETE'],
-        credentials: true,
-      },
-      swaggerOptions: {
-        routePrefix: '/docs',
-        swaggerDoc: {
-          info: {
-            title: 'API Documentation',
-            version: '1.0.0',
-          },
-        },
-      },
-      ...config,
-    };
-
-    this.server = Fastify({
-      ajv: {
-        customOptions: {
-          strict: false,
-        },
-      },
-      genReqId: (req) => {
-        const requestId = req.headers['x-request-id'];
-        return Array.isArray(requestId) ? requestId[0] : requestId || crypto.randomUUID();
-      },
-    });
-
-    this.setupServer();
-  }
-
-  private async setupServer() {
-    try {
-      // Register CORS
-      // if (this.config.enableCors) {
-      //   Logger.info('Registering CORS');
-      //   await this.server.register(require('@fastify/cors'), this.config.corsOptions);
-      // }
-
-      // Register Swagger
-      // if (this.config.enableSwagger) {
-      //   await this.server.register(require('@fastify/swagger'), this.config.swaggerOptions?.swaggerDoc);
-      //   await this.server.register(require('@fastify/swagger-ui'), {
-      //     routePrefix: this.config.swaggerOptions?.routePrefix,
-      //   });
-      // }
-
-      // Register Cookie support
-      // if (this.config.enableCookie) {
-      //   await this.server.register(require('@fastify/cookie'), {
-      //     hook: 'onRequest',
-      //     parseOptions: {},
-      //   });
-      // }
-
-      // Register Metrics
-      // if (this.config.enableMetrics) {
-      //   await this.server.register(require('fastify-metrics'), {
-      //     endpoint: '/metrics',
-      //   });
-      // }
-
-      // Register error handling
-      if (this.config.enableErrorHandling) {
-        this.server.setErrorHandler(this.globalErrorHandler);
-      }
-
-      // Add common schemas
-      this.addCommonSchemas();
-
-      // Add logging hooks
-      if (this.config.enableLogging) {
-        this.setupLogging();
-      }
-
-      // Setup route logging
-      this.setupRouteLogging();
-
-      // Register custom routes
-      if (this.config.route) {
-        await this.server.register(this.config.route);
-      }
-
-    } catch (error) {
-      Logger.error('Failed to setup server:', error as Error);
-      throw error;
-    }
-  }
-
-  private globalErrorHandler = (error: any, request: any, reply: any) => {
-    Logger.error('Global error handler:', error);
-
-    const statusCode = error.statusCode || 500;
-    const message = error.message || 'Internal Server Error';
-
-    reply.status(statusCode).send({
-      statusCode,
-      error: error.name || 'Error',
-      message,
-    });
-  };
-
-  private addCommonSchemas() {
-    this.server.addSchema({
-      $id: 'errorResponseSchema',
-      type: 'object',
-      description: 'Error Response',
-      properties: {
-        statusCode: { type: 'number' },
-        error: { type: 'string' },
-        message: { type: 'string' },
-      },
-    });
-
-    this.server.addSchema({
-      $id: 'messageResponseSchema',
-      type: 'object',
-      description: 'Message Response',
-      properties: {
-        message: { type: 'string' },
-      },
-    });
-  }
-
-  private setupLogging() {
-    // requestContext.run
-
-    this.server.addHook('preHandler', (request, reply, done) => {
-      request.raw.id = request.id
-      reply.header('x-request-id', request.id)
-      httpLoggerMiddleware(request.raw, reply.raw)
-      // console.log('Request ID:', request.id)
-      // console.log('User ID:', request.user)
-
-      requestContext.run(
-        { requestId: request.id, userId: "pxpxpx", username: "priyadarship4@gmail.com" },
-        () => {
-          done()
-        }
-      )
-    })
-
-    // this.server.addHook('onRequest', async (request, reply) => {
-    //   const startTime = Date.now();
-    //   request.raw.startTime = startTime;
-    //   reply.header('x-request-id', request.id);
-
-    //   Logger.info({
-    //     requestId: request.id,
-    //     method: request.method,
-    //     url: request.url,
-    //     userAgent: request.headers['user-agent'],
-    //     ip: request.ip,
-    //     message: 'Incoming request'
-    //   });
-    // });
-
-    // this.server.addHook('onResponse', async (request, reply) => {
-    //   const duration = Date.now() - (request.raw.startTime || Date.now());
-
-    //   Logger.info({
-    //     requestId: request.id,
-    //     method: request.method,
-    //     url: request.url,
-    //     statusCode: reply.statusCode,
-    //     duration: `${duration}ms`,
-    //     message: 'Request completed'
-    //   });
-    // });
-  }
-
-  private setupRouteLogging() {
-    const routeOptions: any[] = [];
-
-    this.server.addHook('onRoute', (routeOption) => {
-      routeOptions.push(routeOption);
-    });
-
-    this.server.addHook('onReady', (done) => {
-      this.printFastifyRoutes(routeOptions, { colors: true });
-      done();
-    });
-  }
-
-  private printFastifyRoutes(routeOptions: any[], opts: { colors: boolean }) {
-    const { colors } = opts;
-
-    if (routeOptions.length === 0) {
-      return;
-    }
-
-    routeOptions.sort((a, b) => a.url.localeCompare(b.url));
-
-    const logEntries = [];
-    logEntries.push("Available routes:");
-
-    for (const routeOption of routeOptions) {
-      const { method, url } = routeOption;
-      if (method === "HEAD") continue;
-      const formattedMethod = colors ? this.colorMethod(method) : method;
-      logEntries.push(`${formattedMethod}\t${url}`);
-    }
-
-    Logger.info(logEntries.join("\n"));
-  }
-
-  private colorMethod(method: string): string {
-    const COLORS = {
-      yellow: 33,
-      green: 32,
-      blue: 34,
-      red: 31,
-      grey: 90,
-      clear: 39,
-    };
-
-    const colorText = (color: number, string: string): string => {
-      return `\u001b[${color}m${string}\u001b[${COLORS.clear}m`;
-    };
-
-    switch (method) {
-      case "POST": return colorText(COLORS.yellow, method);
-      case "GET": return colorText(COLORS.green, method);
-      case "PUT": return colorText(COLORS.blue, method);
-      case "DELETE": return colorText(COLORS.red, method);
-      case "PATCH": return colorText(COLORS.grey, method);
-      default: return method;
-    }
-  }
-
-  public registerControllers(controllers: Function[]) {
-    registerControllers(this.server, controllers);
-  }
-
-  public async start(port?: number, host?: string) {
-    const serverPort = port || this.config.port || 3000;
-    const serverHost = host || this.config.host || '0.0.0.0';
-
-    try {
-      // Initialize Redis if enabled
-      if (this.config.enableRedis) {
-        Logger.info('Connecting to Redis...');
-        // Add Redis initialization logic here
-        Logger.info('Redis connected');
-      }
-
-      // Initialize Database if enabled
-      if (this.config.enableDatabase) {
-        Logger.info('Connecting to database...');
-        // Add Database initialization logic here
-        Logger.info('Database connected');
-      }
-
-      Logger.info(`Starting server at http://${serverHost}:${serverPort}`);
-      await this.server.listen({ port: serverPort, host: serverHost });
-      Logger.info(`Server listening on http://${serverHost}:${serverPort}`);
-
-      // Setup graceful shutdown
-      this.setupGracefulShutdown();
-
-    } catch (err) {
-      // Logger.error(err)
-      Logger.error('Failed to start server:', err as Error);
-      process.exit(1);
-    }
-  }
-
-  private setupGracefulShutdown() {
-    const signals: NodeJS.Signals[] = ['SIGINT', 'SIGTERM'];
-
-    signals.forEach((signal) => {
-      process.on(signal, async () => {
-        try {
-          await this.server.close();
-          Logger.info(`Closed application on ${signal}`);
-          process.exit(0);
-        } catch (err) {
-          Logger.error(`Error closing application on ${signal}`, err as Error);
-          process.exit(1);
-        }
-      });
-    });
-
-    process.on('unhandledRejection', (err: Error) => {
-      // Logger.error(err)
-      Logger.error('Unhandled Rejection:', err as Error);
-      process.exit(1);
-    });
-  }
-
-  public getServer(): FastifyInstance {
-    return this.server;
-  }
-
-  public updateConfig(newConfig: Partial<FastifyServerConfig>) {
-    this.config = { ...this.config, ...newConfig };
-  }
-}

package/src/container/container.ts

@@ -1,28 +0,0 @@
-import { Container, injectable } from "inversify";
-const container = new Container();
-
-interface BeanOptions {
-    scope?: 'singleton' | 'transient';
-    bindTo?: Function[];  // Array of interfaces to bind to
-}
-export function Bean(options: BeanOptions) {
-    return function (target: any) {
-        const { scope = 'singleton', bindTo = [] } = options || {};
-
-        injectable()(target);
-
-        // Bind to self (class constructor)
-        const binding = container.bind(target).toSelf();
-        scope === 'singleton' ? binding.inSingletonScope() : binding.inTransientScope();
-
-        // Bind to each specified interface
-        bindTo.forEach(intrfc => {
-            const interfaceBinding = container.bind(intrfc).to(target);
-            scope === 'singleton'
-                ? interfaceBinding.inSingletonScope()
-                : interfaceBinding.inTransientScope();
-        });
-    };
-}
-
-export default container;

package/src/decorators/cache/ICacheClient.ts

@@ -1,5 +0,0 @@
-export interface ICacheClient {
-    get(key: string): Promise<string | null>;
-    set(key: string, value: string, ttlSeconds?: number): Promise<void>;
-    del(key: string): Promise<void>;
-}

package/src/decorators/cache/cache.decorator.ts

@@ -1,36 +0,0 @@
-import container from '../../container/container';
-import { ICacheClient } from './ICacheClient';
-
-export function Cache(ttlSeconds: number = 60, keyGenerator?: (...args: any[]) => string): MethodDecorator {
-    return (target, propertyKey, descriptor) => {
-        const originalMethod = descriptor.value as (...args: any[]) => any;
-        const className = target.constructor.name;
-        const methodName = String(propertyKey);
-
-        descriptor.value = async function (this: any, ...args: any[]) {
-            const cacheClient = container.get<ICacheClient>('CacheClient');
-            const cacheKey = keyGenerator
-                ? keyGenerator(...args)
-                : `cache:${className}:${methodName}:${JSON.stringify(args)}`;
-
-            try {
-                const cached = await cacheClient.get(cacheKey);
-                if (cached) return JSON.parse(cached);
-            } catch (err) {
-                console.error('Cache read error:', err);
-            }
-
-            const result = await originalMethod.apply(this, args);
-
-            try {
-                await cacheClient.set(cacheKey, JSON.stringify(result), ttlSeconds);
-            } catch (err) {
-                console.error('Cache write error:', err);
-            }
-
-            return result;
-        } as any;
-
-        return descriptor;
-    };
-}

package/src/decorators/controller.decorator.ts

@@ -1,119 +0,0 @@
-import 'reflect-metadata';
-import { FastifyInstance, FastifyRequest, FastifyReply, RouteOptions } from 'fastify';
-import container from '../container/container';
-import Logger from '../logger/Logger';
-
-const CONTROLLER_METADATA = 'controller:metadata';
-export const ROUTE_METADATA = 'route:metadata';
-
-type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
-
-interface RouteDefinition {
-  path: string;
-  method: HttpMethod;
-  handlerName: string;
-  options?: Partial<RouteOptions>;
-}
-
-export function Controller(prefix: string = ''): ClassDecorator {
-  return (target: Function) => {
-    Reflect.defineMetadata(CONTROLLER_METADATA, { prefix }, target);
-  };
-}
-
-export function registerControllers(fastify: FastifyInstance, controllers: Function[]) {
-  const routeOptions: any[] = [];
-
-  const fastifyWithHooks = fastify as unknown as {
-    addHook: (hookName: string, handler: (...args: any[]) => void) => void;
-  };
-
-  fastifyWithHooks.addHook("onRoute", (routeOption) => {
-    routeOptions.push(routeOption);
-  });
-
-  fastifyWithHooks.addHook("onReady", (done) => {
-    printFastifyRoutes(routeOptions, { colors: true });
-    done();
-  });
-
-  controllers.forEach(Controller => {
-    const controllerMetadata = Reflect.getMetadata(CONTROLLER_METADATA, Controller);
-    const routes: RouteDefinition[] = Reflect.getMetadata(ROUTE_METADATA, Controller) || [];
-    const controllerInstance = container.get(Controller) as Record<string, (request: FastifyRequest, reply: FastifyReply) => Promise<any>>;
-
-    const prefix = controllerMetadata?.prefix || '';
-
-    routes.forEach(route => {
-      const fullPath = `${prefix}${route.path}`.replace(/\/\//g, '/');
-
-      const handler = async (request: FastifyRequest, reply: FastifyReply) => {
-        try {
-          const result = await controllerInstance[route.handlerName](request, reply);
-          if (result !== undefined) return result;
-        } catch (error: any) {
-          Logger.error('Controller error:', error);
-          const statusCode = error.statusCode || 500;
-          const message = error.message || 'Internal Server Error';
-          reply.status(statusCode).send({ error: message });
-        }
-      };
-
-      const routeConfig = {
-        ...route.options,
-        handler,
-        url: fullPath,
-        method: route.method
-      };
-
-      (fastify as any).route(routeConfig);
-    });
-  });
-}
-
-export function printFastifyRoutes(routeOptions: any[], opts: { colors: boolean }) {
-  const { colors } = opts;
-
-  if (routeOptions.length === 0) {
-    return;
-  }
-
-  routeOptions.sort((a, b) => a.url.localeCompare(b.url));
-
-  const logEntries = [];
-  logEntries.push("Available routes:");
-
-  for (const routeOption of routeOptions) {
-    const { method, url } = routeOption;
-    if (method === "HEAD") continue;
-    const formattedMethod = colors ? colorMethod(method) : method;
-    logEntries.push(`${formattedMethod}\t${url}`);
-  }
-
-  Logger.info(logEntries.join("\n"));
-}
-
-const COLORS = {
-  yellow: 33,
-  green: 32,
-  blue: 34,
-  red: 31,
-  grey: 90,
-  magenta: 35,
-  clear: 39,
-};
-
-function colorText(color: number, string: string): string {
-  return `\u001b[${color}m${string}\u001b[${COLORS.clear}m`;
-}
-
-function colorMethod(method: string): string {
-  switch (method) {
-    case "POST": return colorText(COLORS.yellow, method);
-    case "GET": return colorText(COLORS.green, method);
-    case "PUT": return colorText(COLORS.blue, method);
-    case "DELETE": return colorText(COLORS.red, method);
-    case "PATCH": return colorText(COLORS.grey, method);
-    default: return method;
-  }
-}

package/src/decorators/http.decorator.ts

@@ -1,25 +0,0 @@
-import { ROUTE_METADATA } from './controller.decorator';
-
-export function createMethodDecorator(method: string) {
-  return (path: string = '', options?: any): MethodDecorator => {
-    return (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {
-      const routes: any[] = Reflect.getMetadata(ROUTE_METADATA, target.constructor) || [];
-
-      routes.push({
-        path,
-        method: method.toUpperCase(),
-        handlerName: propertyKey,
-        options
-      });
-
-      Reflect.defineMetadata(ROUTE_METADATA, routes, target.constructor);
-      return descriptor;
-    };
-  };
-}
-
-export const Get = createMethodDecorator('GET');
-export const Post = createMethodDecorator('POST');
-export const Put = createMethodDecorator('PUT');
-export const Delete = createMethodDecorator('DELETE');
-export const Patch = createMethodDecorator('PATCH');

package/src/decorators/timing.decorator.ts

@@ -1,23 +0,0 @@
-export function Timed(): MethodDecorator {
-    return (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {
-        const originalMethod = descriptor.value;
-
-        descriptor.value = async function (...args: any[]) {
-            const start = process.hrtime.bigint();
-            try {
-                const result = await originalMethod.apply(this, args);
-                const end = process.hrtime.bigint();
-                const duration = Number(end - start) / 1_000_000;
-                console.log(`[TIMED] ${target.constructor.name}.${String(propertyKey)} took ${duration.toFixed(2)}ms`);
-                return result;
-            } catch (error) {
-                const end = process.hrtime.bigint();
-                const duration = Number(end - start) / 1_000_000;
-                console.error(`[TIMED-ERROR] ${target.constructor.name}.${String(propertyKey)} failed after ${duration.toFixed(2)}ms`, error);
-                throw error;
-            }
-        };
-
-        return descriptor;
-    };
-}

package/src/decorators/transaction/IDatabaseClient.ts

@@ -1,9 +0,0 @@
-export interface ITransaction {
-    transaction: any;
-    commit: () => Promise<void>;
-    rollback: () => Promise<void>;
-}
-
-export interface IDatabaseClient {
-    startTransaction(): Promise<ITransaction>;
-}

package/src/decorators/transaction/transactional.decorator.ts

@@ -1,24 +0,0 @@
-import container from '../../container/container';
-import { IDatabaseClient } from './IDatabaseClient';
-
-export function Transactional(): MethodDecorator {
-    return (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {
-        const originalMethod = descriptor.value;
-
-        descriptor.value = async function (...args: any[]) {
-            const dbClient = container.get<IDatabaseClient>('DatabaseClient');
-            const transaction = await dbClient.startTransaction();
-
-            try {
-                const result = await originalMethod.apply(this, [...args, transaction.transaction]);
-                await transaction.commit();
-                return result;
-            } catch (error) {
-                await transaction.rollback();
-                throw error;
-            }
-        };
-
-        return descriptor;
-    };
-}

package/src/index.ts

@@ -1,10 +0,0 @@
-export * from './application/Application';
-export { default as container, Bean } from './container/container';
-export * from './decorators/controller.decorator';
-export * from './decorators/http.decorator';
-export * from './decorators/timing.decorator';
-export * from './decorators/cache/cache.decorator';
-export * from './decorators/cache/ICacheClient';
-export * from './decorators/transaction/transactional.decorator';
-export * from './decorators/transaction/IDatabaseClient';
-export { default as logger, } from './logger/Logger';

package/src/logger/Logger.ts

@@ -1,179 +0,0 @@
-import pino from 'pino'
-import { LogContext, requestContext } from '../middleware/requestcontext'
-// import { requestContext, LogContext } from '../middleware/requestcontext'
-
-// --- Define interfaces for your specific log types ---
-interface AppLogPayload {
-    // For general application messages
-    message: string
-    [key: string]: any // Allow other custom fields
-}
-
-interface AuditLogPayload {
-    // Based on your AuditLog type
-    action: string
-    resources: string[]
-    details: any // Renamed from 'data' to avoid conflict if 'data' is a generic field
-    [key: string]: any
-}
-
-interface EventLogPayload {
-    // Based on your EventLog type
-    eventName: string
-    status: 'success' | 'failure' | 'pending'
-    metadata: any
-    [key: string]: any
-}
-
-// (HttpLogPayload is implicitly handled by pino-http)
-
-class Logger {
-    private pinoInstance: pino.Logger
-    private static instance: Logger
-
-    private constructor() {
-        const basePinoOptions: pino.LoggerOptions = {
-            level: process.env.LOG_LEVEL || 'info',
-            timestamp: () => `,"time":"${new Date().toISOString()}"`,
-            messageKey: 'message', // Consistent message key
-            base: {
-                // Remove default pino fields if not needed
-                pid: undefined,
-                hostname: undefined,
-            },
-            formatters: {
-                level: (label: string) => ({ level: label.toLowerCase() }), // Ensure lowercase level
-            },
-            mixin: () => {
-                const store = requestContext.getStore()
-                return {
-                    // Common context fields from AsyncLocalStorage
-                    requestId: store?.requestId,
-                    userId: store?.userId, // This might be overridden by specific log methods like audit
-                    traceId: store?.traceId,
-                    username: store?.username,
-                    // 'additionalContext' from ALS will be merged into the 'context' field for ClickHouse by the transport
-                    //   context: store?.additionalContext || {},
-                }
-            },
-        }
-
-        const transports = []
-        // const clickHouseTransportPath = path.resolve(__dirname, 'pino-clickhouse-transport.js')
-
-        transports.push({
-            level: 'info', // Minimum level for ClickHouse transport
-            //   target: clickHouseTransportPath,
-            options: {
-                url: process.env.CLICKHOUSE_URL || 'http://localhost:8123',
-                username: process.env.CLICKHOUSE_USER || 'default',
-                password: process.env.CLICKHOUSE_PASSWORD || '',
-                database: process.env.CLICKHOUSE_DB || 'default',
-                maxBatchSize: parseInt(process.env.CLICKHOUSE_MAX_BATCH_SIZE || '1000', 10),
-                flushInterval: parseInt(process.env.CLICKHOUSE_FLUSH_INTERVAL || '3000', 10),
-                application: process.env.APP_NAME || 'my-application',
-            },
-        })
-
-        if (process.env.NODE_ENV !== 'production') {
-            transports.push({
-                level: 'debug',
-                target: 'pino-pretty',
-                options: {
-                    colorize: true,
-                    translateTime: 'SYS:standard',
-                    ignore: 'pid,hostname,context,username,requestId,userId,traceId,application',
-                    messageKey: 'message', // Ensure pino-pretty uses the same messageKey
-                },
-            })
-        }
-
-        this.pinoInstance = pino({
-            ...basePinoOptions,
-            //   transport: transports.length > 0 ? { targets: transports } : undefined,
-        })
-    }
-
-    public static getInstance(): Logger {
-        if (!Logger.instance) {
-            try {
-                Logger.instance = new Logger()
-            } catch (error: any) {
-                console.error('CRITICAL: Error creating logger instance:', error.message)
-                // Fallback to a very basic console logger if main setup fails
-                const fallbackPino = pino({ level: 'info', messageKey: 'message' })
-                fallbackPino.error(
-                    { err: error },
-                    'Fallback console logger activated due to error in primary logger setup.'
-                )
-                const fallbackInstance = Object.create(Logger.prototype) as Logger
-                fallbackInstance.pinoInstance = fallbackPino
-                Logger.instance = fallbackInstance
-            }
-        }
-        return Logger.instance
-    }
-
-    /**
-     * Provides access to the raw pino instance, primarily for use with pino-http.
-     */
-    public getPinoInstance(): pino.Logger {
-        return this.pinoInstance
-    }
-
-    // --- Application Logging Methods ---
-    private appLog(level: pino.Level, payload: AppLogPayload): void {
-        this.pinoInstance[level]({ ...payload, logType: 'application' })
-    }
-    public info(message: string, data?: Record<string, any>): void {
-        this.appLog('info', { message, ...data })
-    }
-    public error(message: string, error?: Error, data?: Record<string, any>): void {
-        const payload: AppLogPayload = { message, ...data }
-        if (error) {
-            payload.err = error // pino stdSerializers.err will handle this
-        }
-        this.appLog('error', payload)
-    }
-    public warn(message: string, data?: Record<string, any>): void {
-        this.appLog('warn', { message, ...data })
-    }
-    public debug(message: string, data?: Record<string, any>): void {
-        this.appLog('debug', { message, ...data })
-    }
-    public fatal(message: string, error?: Error, data?: Record<string, any>): void {
-        const payload: AppLogPayload = { message, ...data }
-        if (error) {
-            payload.err = error
-        }
-        this.appLog('fatal', payload)
-    }
-    public trace(message: string, data?: Record<string, any>): void {
-        this.appLog('trace', { message, ...data })
-    }
-
-    // --- Audit Logging Method ---
-    public audit(payload: AuditLogPayload): void {
-        // userId from payload will override userId from mixin if both exist
-        this.pinoInstance.info({ ...payload, logType: 'audit' })
-    }
-
-    // --- Event Logging Method ---
-    public event(payload: EventLogPayload): void {
-        this.pinoInstance.info({ ...payload, logType: 'event' })
-    }
-
-    // --- Child Logger ---
-    public child(bindings: Partial<LogContext> & Record<string, any> = {}): Logger {
-        // Create a new pino child logger instance with additional static bindings
-        const pinoChild = this.pinoInstance.child(bindings)
-        // Create a new Logger wrapper for this pino child
-        const childLoggerInstance = Object.create(Logger.prototype) as Logger
-        childLoggerInstance.pinoInstance = pinoChild
-        return childLoggerInstance
-    }
-}
-
-const logger = Logger.getInstance()
-
-export default logger

package/src/middleware/http.ts

@@ -1,81 +0,0 @@
-import PinoHttp from 'pino-http'
-import pino from 'pino'
-import logger from '../logger/Logger'
-export const httpLoggerMiddleware = PinoHttp({
-    logger: logger.getPinoInstance(), // Use the main pino instance
-
-    customLogLevel: (req, res, err) => {
-        if (res.statusCode >= 500 || err) return 'error'
-        if (res.statusCode >= 400) return 'warn'
-        return 'info'
-    },
-    serializers: {
-        req: (req) => ({
-            id: req.id, // Made available as objFromPinoHttp.req.id
-            method: req.method,
-            url: req.url,
-            remoteAddress: req.remoteAddress || req.socket?.remoteAddress,
-        }),
-        res: (res) => ({
-            statusCode: res.statusCode,
-        }),
-        err: pino.stdSerializers.err,
-    },
-
-    // This formatter *must* return the complete, flat object you want to log.
-    formatters: {
-        log: (objFromPinoHttp: any) => {
-            // objFromPinoHttp contains:
-            // - .req, .res, .err (from serializers above)
-            // - .responseTime (number)
-            // - .level (string, from customLogLevel)
-            // - .message (string, from customSuccessMessage/customErrorMessage)
-            // - properties from `customProps` (e.g., .requestId from req.id fallback)
-            // - IMPORTANT: It ALSO contains properties from the parent `appLogger`'s `mixin`
-            //   because pino-http uses the parent logger, and its mixin will have run.
-
-            const finalHttpLog: Record<string, any> = {
-                // Standard fields (time will be added by parent pino instance when it actually logs)
-                level: 'hello',
-                test: '123',
-                message: objFromPinoHttp.message,
-
-                // Contextual fields (these should be present in objFromPinoHttp thanks to parent logger's mixin)
-                requestId: objFromPinoHttp.requestId, // This should be the definitive one after mixin
-                userId: objFromPinoHttp.userId,
-                username: objFromPinoHttp.username,
-                traceId: objFromPinoHttp.traceId,
-                context: objFromPinoHttp.context, // from ALS additionalContext
-                application: objFromPinoHttp.application, // from parent logger or transport default
-
-                // HTTP specific data, flattened:
-                logType: 'http',
-                method: objFromPinoHttp.req?.method,
-                url: objFromPinoHttp.req?.url,
-                remoteAddress: objFromPinoHttp.req?.remoteAddress,
-                statusCode: objFromPinoHttp.res?.statusCode,
-                responseTimeMs: objFromPinoHttp.responseTime,
-                // If you need req.id specifically, and it's different from the main requestId:
-                // originalHttpRequestId: objFromPinoHttp.req?.id,
-
-                // Error object (already serialized)
-                err: objFromPinoHttp.err,
-            }
-
-            // Clean up any top-level undefined properties from the explicitly built object
-            Object.keys(finalHttpLog).forEach((key) => {
-                if (finalHttpLog[key] === undefined) {
-                    delete (finalHttpLog as any)[key]
-                }
-            })
-
-            // DEBUG: Log what this formatter is about to return
-            // console.log('--- pino-http formatters.log IS RETURNING: ---', JSON.stringify(finalHttpLog, null, 2));
-
-            return finalHttpLog
-        },
-    },
-
-    customSuccessMessage: (req, res) => `${req.method} ${req.url} request_completed`,
-    customErrorMessage: (req, res, err) => `${req.method} ${req.url} request_errored`,
-})

package/src/middleware/requestcontext.ts

@@ -1,12 +0,0 @@
-import { AsyncLocalStorage } from 'async_hooks'
-import { FastifyRequest } from 'fastify'
-
-export interface LogContext {
-    requestId: string
-    userId?: string
-    traceId?: string
-    username?: string
-    additionalContext?: { [key: string]: any } // Additional context data
-}
-
-export const requestContext = new AsyncLocalStorage<LogContext>()