bootifyjs 0.0.1 → 0.0.3

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>()