@objectstack/core 1.0.4 → 1.0.5

package/dist/lite-kernel.test.js

@@ -1,161 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { LiteKernel } from './lite-kernel';
-describe('LiteKernel with Configurable Logger', () => {
-    let kernel;
-    beforeEach(() => {
-        kernel = new LiteKernel();
-    });
-    describe('Logger Configuration', () => {
-        it('should create kernel with default logger', () => {
-            expect(kernel).toBeDefined();
-        });
-        it('should create kernel with custom logger config', async () => {
-            const customKernel = new LiteKernel({
-                logger: {
-                    level: 'debug',
-                    format: 'pretty',
-                    sourceLocation: true
-                }
-            });
-            expect(customKernel).toBeDefined();
-            // Cleanup
-            await customKernel.bootstrap();
-            await customKernel.shutdown();
-        });
-        it('should create kernel with file logging config', async () => {
-            const fileKernel = new LiteKernel({
-                logger: {
-                    level: 'info',
-                    format: 'json',
-                    file: '/tmp/test-kernel.log'
-                }
-            });
-            expect(fileKernel).toBeDefined();
-            // Cleanup
-            await fileKernel.bootstrap();
-            await fileKernel.shutdown();
-        });
-    });
-    describe('Plugin Context Logger', () => {
-        it('should provide logger to plugins', async () => {
-            let loggerReceived = false;
-            const testPlugin = {
-                name: 'test-plugin',
-                init: async (ctx) => {
-                    if (ctx.logger) {
-                        loggerReceived = true;
-                        ctx.logger.info('Plugin initialized', { plugin: 'test-plugin' });
-                    }
-                }
-            };
-            kernel.use(testPlugin);
-            await kernel.bootstrap();
-            expect(loggerReceived).toBe(true);
-            await kernel.shutdown();
-        });
-        it('should allow plugins to use all log levels', async () => {
-            const logCalls = [];
-            const loggingPlugin = {
-                name: 'logging-plugin',
-                init: async (ctx) => {
-                    ctx.logger.debug('Debug message');
-                    logCalls.push('debug');
-                    ctx.logger.info('Info message');
-                    logCalls.push('info');
-                    ctx.logger.warn('Warning message');
-                    logCalls.push('warn');
-                    ctx.logger.error('Error message');
-                    logCalls.push('error');
-                }
-            };
-            kernel.use(loggingPlugin);
-            await kernel.bootstrap();
-            expect(logCalls).toContain('debug');
-            expect(logCalls).toContain('info');
-            expect(logCalls).toContain('warn');
-            expect(logCalls).toContain('error');
-            await kernel.shutdown();
-        });
-        it('should support metadata in logs', async () => {
-            const metadataPlugin = {
-                name: 'metadata-plugin',
-                init: async (ctx) => {
-                    ctx.logger.info('User action', {
-                        userId: '123',
-                        action: 'create',
-                        resource: 'document'
-                    });
-                }
-            };
-            kernel.use(metadataPlugin);
-            await kernel.bootstrap();
-            await kernel.shutdown();
-        });
-    });
-    describe('Kernel Lifecycle Logging', () => {
-        it('should log bootstrap process', async () => {
-            const plugin = {
-                name: 'lifecycle-test',
-                init: async () => {
-                    // Init logic
-                },
-                start: async () => {
-                    // Start logic
-                }
-            };
-            kernel.use(plugin);
-            await kernel.bootstrap();
-            expect(kernel.isRunning()).toBe(true);
-            await kernel.shutdown();
-        });
-        it('should log shutdown process', async () => {
-            const plugin = {
-                name: 'shutdown-test',
-                init: async () => { },
-                destroy: async () => {
-                    // Cleanup
-                }
-            };
-            kernel.use(plugin);
-            await kernel.bootstrap();
-            await kernel.shutdown();
-            expect(kernel.getState()).toBe('stopped');
-        });
-    });
-    describe('Environment Compatibility', () => {
-        it('should work in Node.js environment', async () => {
-            const nodeKernel = new LiteKernel({
-                logger: {
-                    level: 'info',
-                    format: 'json'
-                }
-            });
-            const plugin = {
-                name: 'node-test',
-                init: async (ctx) => {
-                    ctx.logger.info('Running in Node.js');
-                }
-            };
-            nodeKernel.use(plugin);
-            await nodeKernel.bootstrap();
-            await nodeKernel.shutdown();
-        });
-        it('should support browser-friendly logging', async () => {
-            const browserKernel = new LiteKernel({
-                logger: {
-                    level: 'info',
-                    format: 'pretty'
-                }
-            });
-            const plugin = {
-                name: 'browser-test',
-                init: async (ctx) => {
-                    ctx.logger.info('Browser-friendly format');
-                }
-            };
-            browserKernel.use(plugin);
-            await browserKernel.bootstrap();
-            await browserKernel.shutdown();
-        });
-    });
-});

package/dist/logger.d.ts

@@ -1,71 +0,0 @@
-import type { LoggerConfig } from '@objectstack/spec/system';
-import type { Logger } from '@objectstack/spec/contracts';
-/**
- * Universal Logger Implementation
- *
- * A configurable logger that works in both browser and Node.js environments.
- * - Node.js: Uses Pino for high-performance structured logging
- * - Browser: Simple console-based implementation
- *
- * Features:
- * - Structured logging with multiple formats (json, text, pretty)
- * - Log level filtering
- * - Sensitive data redaction
- * - File logging with rotation (Node.js only via Pino)
- * - Browser console integration
- * - Distributed tracing support (traceId, spanId)
- */
-export declare class ObjectLogger implements Logger {
-    private config;
-    private isNode;
-    private pinoLogger?;
-    private pinoInstance?;
-    private require?;
-    constructor(config?: Partial<LoggerConfig>);
-    /**
-     * Initialize Pino logger for Node.js
-     */
-    private initPinoLogger;
-    /**
-     * Redact sensitive keys from context object (for browser)
-     */
-    private redactSensitive;
-    /**
-     * Format log entry for browser
-     */
-    private formatBrowserLog;
-    /**
-     * Log using browser console
-     */
-    private logBrowser;
-    /**
-     * Public logging methods
-     */
-    debug(message: string, meta?: Record<string, any>): void;
-    info(message: string, meta?: Record<string, any>): void;
-    warn(message: string, meta?: Record<string, any>): void;
-    error(message: string, errorOrMeta?: Error | Record<string, any>, meta?: Record<string, any>): void;
-    fatal(message: string, errorOrMeta?: Error | Record<string, any>, meta?: Record<string, any>): void;
-    /**
-     * Create a child logger with additional context
-     * Note: Child loggers share the parent's Pino instance
-     */
-    child(context: Record<string, any>): ObjectLogger;
-    /**
-     * Set trace context for distributed tracing
-     */
-    withTrace(traceId: string, spanId?: string): ObjectLogger;
-    /**
-     * Cleanup resources
-     */
-    destroy(): Promise<void>;
-    /**
-     * Compatibility method for console.log usage
-     */
-    log(message: string, ...args: any[]): void;
-}
-/**
- * Create a logger instance
- */
-export declare function createLogger(config?: Partial<LoggerConfig>): ObjectLogger;
-//# sourceMappingURL=logger.d.ts.map

package/dist/logger.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAY,MAAM,0BAA0B,CAAC;AACvE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,6BAA6B,CAAC;AAG1D;;;;;;;;;;;;;;GAcG;AACH,qBAAa,YAAa,YAAW,MAAM;IACvC,OAAO,CAAC,MAAM,CAAkJ;IAChK,OAAO,CAAC,MAAM,CAAU;IACxB,OAAO,CAAC,UAAU,CAAC,CAAM;IACzB,OAAO,CAAC,YAAY,CAAC,CAAM;IAC3B,OAAO,CAAC,OAAO,CAAC,CAAM;gBAEV,MAAM,GAAE,OAAO,CAAC,YAAY,CAAM;IAwB9C;;OAEG;IACH,OAAO,CAAC,cAAc;IAuGtB;;OAEG;IACH,OAAO,CAAC,eAAe;IAqBvB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAuCxB;;OAEG;IACH,OAAO,CAAC,UAAU;IAelB;;OAEG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI;IAQxD,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI;IAQvD,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI;IAQvD,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI;IAmBnG,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI;IAmBnG;;;OAGG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,YAAY;IAYjD;;OAEG;IACH,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,YAAY;IAIzD;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ9B;;OAEG;IACH,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;CAG7C;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG,YAAY,CAEzE"}

package/dist/logger.js

@@ -1,312 +0,0 @@
-import { isNode } from './utils/env.js';
-/**
- * Universal Logger Implementation
- *
- * A configurable logger that works in both browser and Node.js environments.
- * - Node.js: Uses Pino for high-performance structured logging
- * - Browser: Simple console-based implementation
- *
- * Features:
- * - Structured logging with multiple formats (json, text, pretty)
- * - Log level filtering
- * - Sensitive data redaction
- * - File logging with rotation (Node.js only via Pino)
- * - Browser console integration
- * - Distributed tracing support (traceId, spanId)
- */
-export class ObjectLogger {
-    constructor(config = {}) {
-        // Detect runtime environment
-        this.isNode = isNode;
-        // Set defaults
-        this.config = {
-            name: config.name,
-            level: config.level ?? 'info',
-            format: config.format ?? (this.isNode ? 'json' : 'pretty'),
-            redact: config.redact ?? ['password', 'token', 'secret', 'key'],
-            sourceLocation: config.sourceLocation ?? false,
-            file: config.file,
-            rotation: config.rotation ?? {
-                maxSize: '10m',
-                maxFiles: 5
-            }
-        };
-        // Initialize Pino logger for Node.js
-        if (this.isNode) {
-            this.initPinoLogger();
-        }
-    }
-    /**
-     * Initialize Pino logger for Node.js
-     */
-    initPinoLogger() {
-        if (!this.isNode)
-            return;
-        try {
-            // Create require function dynamically for Node.js (avoids bundling issues in browser)
-            // @ts-ignore - dynamic import of Node.js module
-            const { createRequire } = eval('require("module")');
-            this.require = createRequire(import.meta.url);
-            // Synchronous import for Pino using createRequire (works in ESM)
-            const pino = this.require('pino');
-            // Build Pino options
-            const pinoOptions = {
-                level: this.config.level,
-                redact: {
-                    paths: this.config.redact,
-                    censor: '***REDACTED***'
-                }
-            };
-            // Add name if provided
-            if (this.config.name) {
-                pinoOptions.name = this.config.name;
-            }
-            // Transport configuration for pretty printing or file output
-            const targets = [];
-            // Console transport
-            if (this.config.format === 'pretty') {
-                // Check if pino-pretty is available
-                let hasPretty = false;
-                try {
-                    this.require.resolve('pino-pretty');
-                    hasPretty = true;
-                }
-                catch (e) {
-                    // ignore
-                }
-                if (hasPretty) {
-                    targets.push({
-                        target: 'pino-pretty',
-                        options: {
-                            colorize: true,
-                            translateTime: 'SYS:standard',
-                            ignore: 'pid,hostname'
-                        },
-                        level: this.config.level
-                    });
-                }
-                else {
-                    console.warn('[Logger] pino-pretty not found. Install it for pretty logging: pnpm add -D pino-pretty');
-                    // Fallback to text/simple
-                    targets.push({
-                        target: 'pino/file',
-                        options: { destination: 1 },
-                        level: this.config.level
-                    });
-                }
-            }
-            else if (this.config.format === 'json') {
-                // JSON to stdout
-                targets.push({
-                    target: 'pino/file',
-                    options: { destination: 1 }, // stdout
-                    level: this.config.level
-                });
-            }
-            else {
-                // text format (simple)
-                targets.push({
-                    target: 'pino/file',
-                    options: { destination: 1 },
-                    level: this.config.level
-                });
-            }
-            // File transport (if configured)
-            if (this.config.file) {
-                targets.push({
-                    target: 'pino/file',
-                    options: {
-                        destination: this.config.file,
-                        mkdir: true
-                    },
-                    level: this.config.level
-                });
-            }
-            // Create transport
-            if (targets.length > 0) {
-                pinoOptions.transport = targets.length === 1 ? targets[0] : { targets };
-            }
-            // Create Pino logger
-            this.pinoInstance = pino(pinoOptions);
-            this.pinoLogger = this.pinoInstance;
-        }
-        catch (error) {
-            // Fallback to console if Pino is not available
-            console.warn('[Logger] Pino not available, falling back to console:', error);
-            this.pinoLogger = null;
-        }
-    }
-    /**
-     * Redact sensitive keys from context object (for browser)
-     */
-    redactSensitive(obj) {
-        if (!obj || typeof obj !== 'object')
-            return obj;
-        const redacted = Array.isArray(obj) ? [...obj] : { ...obj };
-        for (const key in redacted) {
-            const lowerKey = key.toLowerCase();
-            const shouldRedact = this.config.redact.some((pattern) => lowerKey.includes(pattern.toLowerCase()));
-            if (shouldRedact) {
-                redacted[key] = '***REDACTED***';
-            }
-            else if (typeof redacted[key] === 'object' && redacted[key] !== null) {
-                redacted[key] = this.redactSensitive(redacted[key]);
-            }
-        }
-        return redacted;
-    }
-    /**
-     * Format log entry for browser
-     */
-    formatBrowserLog(level, message, context) {
-        if (this.config.format === 'json') {
-            return JSON.stringify({
-                timestamp: new Date().toISOString(),
-                level,
-                message,
-                ...context
-            });
-        }
-        if (this.config.format === 'text') {
-            const parts = [new Date().toISOString(), level.toUpperCase(), message];
-            if (context && Object.keys(context).length > 0) {
-                parts.push(JSON.stringify(context));
-            }
-            return parts.join(' | ');
-        }
-        // Pretty format
-        const levelColors = {
-            debug: '\x1b[36m', // Cyan
-            info: '\x1b[32m', // Green
-            warn: '\x1b[33m', // Yellow
-            error: '\x1b[31m', // Red
-            fatal: '\x1b[35m', // Magenta
-            silent: ''
-        };
-        const reset = '\x1b[0m';
-        const color = levelColors[level] || '';
-        let output = `${color}[${level.toUpperCase()}]${reset} ${message}`;
-        if (context && Object.keys(context).length > 0) {
-            output += ` ${JSON.stringify(context, null, 2)}`;
-        }
-        return output;
-    }
-    /**
-     * Log using browser console
-     */
-    logBrowser(level, message, context, error) {
-        const redactedContext = context ? this.redactSensitive(context) : undefined;
-        const mergedContext = error ? { ...redactedContext, error: { message: error.message, stack: error.stack } } : redactedContext;
-        const formatted = this.formatBrowserLog(level, message, mergedContext);
-        const consoleMethod = level === 'debug' ? 'debug' :
-            level === 'info' ? 'log' :
-                level === 'warn' ? 'warn' :
-                    level === 'error' || level === 'fatal' ? 'error' :
-                        'log';
-        console[consoleMethod](formatted);
-    }
-    /**
-     * Public logging methods
-     */
-    debug(message, meta) {
-        if (this.isNode && this.pinoLogger) {
-            this.pinoLogger.debug(meta || {}, message);
-        }
-        else {
-            this.logBrowser('debug', message, meta);
-        }
-    }
-    info(message, meta) {
-        if (this.isNode && this.pinoLogger) {
-            this.pinoLogger.info(meta || {}, message);
-        }
-        else {
-            this.logBrowser('info', message, meta);
-        }
-    }
-    warn(message, meta) {
-        if (this.isNode && this.pinoLogger) {
-            this.pinoLogger.warn(meta || {}, message);
-        }
-        else {
-            this.logBrowser('warn', message, meta);
-        }
-    }
-    error(message, errorOrMeta, meta) {
-        let error;
-        let context = {};
-        if (errorOrMeta instanceof Error) {
-            error = errorOrMeta;
-            context = meta || {};
-        }
-        else {
-            context = errorOrMeta || {};
-        }
-        if (this.isNode && this.pinoLogger) {
-            const errorContext = error ? { err: error, ...context } : context;
-            this.pinoLogger.error(errorContext, message);
-        }
-        else {
-            this.logBrowser('error', message, context, error);
-        }
-    }
-    fatal(message, errorOrMeta, meta) {
-        let error;
-        let context = {};
-        if (errorOrMeta instanceof Error) {
-            error = errorOrMeta;
-            context = meta || {};
-        }
-        else {
-            context = errorOrMeta || {};
-        }
-        if (this.isNode && this.pinoLogger) {
-            const errorContext = error ? { err: error, ...context } : context;
-            this.pinoLogger.fatal(errorContext, message);
-        }
-        else {
-            this.logBrowser('fatal', message, context, error);
-        }
-    }
-    /**
-     * Create a child logger with additional context
-     * Note: Child loggers share the parent's Pino instance
-     */
-    child(context) {
-        const childLogger = new ObjectLogger(this.config);
-        // For Node.js with Pino, create a Pino child logger
-        if (this.isNode && this.pinoInstance) {
-            childLogger.pinoLogger = this.pinoInstance.child(context);
-            childLogger.pinoInstance = this.pinoInstance;
-        }
-        return childLogger;
-    }
-    /**
-     * Set trace context for distributed tracing
-     */
-    withTrace(traceId, spanId) {
-        return this.child({ traceId, spanId });
-    }
-    /**
-     * Cleanup resources
-     */
-    async destroy() {
-        if (this.pinoLogger && this.pinoLogger.flush) {
-            await new Promise((resolve) => {
-                this.pinoLogger.flush(() => resolve());
-            });
-        }
-    }
-    /**
-     * Compatibility method for console.log usage
-     */
-    log(message, ...args) {
-        this.info(message, args.length > 0 ? { args } : undefined);
-    }
-}
-/**
- * Create a logger instance
- */
-export function createLogger(config) {
-    return new ObjectLogger(config);
-}

package/dist/logger.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=logger.test.d.ts.map

package/dist/logger.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"logger.test.d.ts","sourceRoot":"","sources":["../src/logger.test.ts"],"names":[],"mappings":""}

package/dist/logger.test.js

@@ -1,92 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { createLogger } from './logger';
-describe('ObjectLogger', () => {
-    let logger;
-    beforeEach(() => {
-        logger = createLogger();
-    });
-    afterEach(async () => {
-        await logger.destroy();
-    });
-    describe('Basic Logging', () => {
-        it('should create a logger with default config', () => {
-            expect(logger).toBeDefined();
-            expect(logger.info).toBeDefined();
-            expect(logger.debug).toBeDefined();
-            expect(logger.warn).toBeDefined();
-            expect(logger.error).toBeDefined();
-        });
-        it('should log info messages', () => {
-            expect(() => logger.info('Test message')).not.toThrow();
-        });
-        it('should log debug messages', () => {
-            expect(() => logger.debug('Debug message')).not.toThrow();
-        });
-        it('should log warn messages', () => {
-            expect(() => logger.warn('Warning message')).not.toThrow();
-        });
-        it('should log error messages', () => {
-            const error = new Error('Test error');
-            expect(() => logger.error('Error occurred', error)).not.toThrow();
-        });
-        it('should log with metadata', () => {
-            expect(() => logger.info('Message with metadata', { userId: '123', action: 'login' })).not.toThrow();
-        });
-    });
-    describe('Configuration', () => {
-        it('should respect log level configuration', async () => {
-            const warnLogger = createLogger({ level: 'warn' });
-            // These should not throw but might not output anything
-            expect(() => warnLogger.debug('Debug message')).not.toThrow();
-            expect(() => warnLogger.info('Info message')).not.toThrow();
-            expect(() => warnLogger.warn('Warning message')).not.toThrow();
-            await warnLogger.destroy();
-        });
-        it('should support different formats', async () => {
-            const jsonLogger = createLogger({ format: 'json' });
-            const textLogger = createLogger({ format: 'text' });
-            const prettyLogger = createLogger({ format: 'pretty' });
-            expect(() => jsonLogger.info('JSON format')).not.toThrow();
-            expect(() => textLogger.info('Text format')).not.toThrow();
-            expect(() => prettyLogger.info('Pretty format')).not.toThrow();
-            await jsonLogger.destroy();
-            await textLogger.destroy();
-            await prettyLogger.destroy();
-        });
-        it('should redact sensitive keys', async () => {
-            const logger = createLogger({ redact: ['password', 'apiKey'] });
-            // This should work without exposing the password
-            expect(() => logger.info('User login', {
-                username: 'john',
-                password: 'secret123',
-                apiKey: 'key-12345'
-            })).not.toThrow();
-            await logger.destroy();
-        });
-    });
-    describe('Child Loggers', () => {
-        it('should create child logger with context', () => {
-            const childLogger = logger.child({ service: 'api', requestId: '123' });
-            expect(childLogger).toBeDefined();
-            expect(() => childLogger.info('Child log message')).not.toThrow();
-        });
-        it('should support trace context', () => {
-            const tracedLogger = logger.withTrace('trace-123', 'span-456');
-            expect(tracedLogger).toBeDefined();
-            expect(() => tracedLogger.info('Traced message')).not.toThrow();
-        });
-    });
-    describe('Environment Detection', () => {
-        it('should detect Node.js environment', async () => {
-            // This test runs in Node.js, so logger should detect it
-            const nodeLogger = createLogger({ format: 'json' });
-            expect(() => nodeLogger.info('Node environment')).not.toThrow();
-            await nodeLogger.destroy();
-        });
-    });
-    describe('Compatibility', () => {
-        it('should support console.log compatibility', () => {
-            expect(() => logger.log('Compatible log')).not.toThrow();
-        });
-    });
-});