@objectstack/core 0.6.1 → 0.7.1

package/dist/logger.d.ts

@@ -0,0 +1,70 @@
+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?;
+    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, error?: Error, meta?: Record<string, any>): void;
+    fatal(message: string, error?: Error, 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

@@ -0,0 +1 @@
+{"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;AAE1D;;;;;;;;;;;;;;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;gBAEf,MAAM,GAAE,OAAO,CAAC,YAAY,CAAM;IAwB9C;;OAEG;IACH,OAAO,CAAC,cAAc;IA+EtB;;OAEG;IACH,OAAO,CAAC,eAAe;IAqBvB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAsCxB;;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,KAAK,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI;IASvE,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI;IASvE;;;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

@@ -0,0 +1,268 @@
+/**
+ * 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 = typeof process !== 'undefined' && process.versions?.node !== undefined;
+        // 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 {
+            // Dynamic import for Pino (Node.js only)
+            const pino = 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') {
+                targets.push({
+                    target: 'pino-pretty',
+                    options: {
+                        colorize: true,
+                        translateTime: 'SYS:standard',
+                        ignore: 'pid,hostname'
+                    },
+                    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
+        };
+        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, error, meta) {
+        if (this.isNode && this.pinoLogger) {
+            const errorContext = error ? { err: error, ...meta } : meta || {};
+            this.pinoLogger.error(errorContext, message);
+        }
+        else {
+            this.logBrowser('error', message, meta, error);
+        }
+    }
+    fatal(message, error, meta) {
+        if (this.isNode && this.pinoLogger) {
+            const errorContext = error ? { err: error, ...meta } : meta || {};
+            this.pinoLogger.fatal(errorContext, message);
+        }
+        else {
+            this.logBrowser('fatal', message, meta, 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

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

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

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

package/dist/logger.test.js

@@ -0,0 +1,92 @@
+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();
+        });
+    });
+});

package/dist/plugin-loader.d.ts

@@ -0,0 +1,148 @@
+import { Plugin, PluginContext } from './types.js';
+import type { Logger } from '@objectstack/spec/contracts';
+import { z } from 'zod';
+/**
+ * Service Lifecycle Types
+ * Defines how services are instantiated and managed
+ */
+export declare enum ServiceLifecycle {
+    /** Single instance shared across all requests */
+    SINGLETON = "singleton",
+    /** New instance created for each request */
+    TRANSIENT = "transient",
+    /** New instance per scope (e.g., per HTTP request) */
+    SCOPED = "scoped"
+}
+/**
+ * Service Factory
+ * Function that creates a service instance
+ */
+export type ServiceFactory<T = any> = (ctx: PluginContext) => T | Promise<T>;
+/**
+ * Service Registration Options
+ */
+export interface ServiceRegistration {
+    name: string;
+    factory: ServiceFactory;
+    lifecycle: ServiceLifecycle;
+    dependencies?: string[];
+}
+/**
+ * Plugin Configuration Validator
+ * Uses Zod for runtime validation of plugin configurations
+ */
+export interface PluginConfigValidator {
+    schema: z.ZodSchema;
+    validate(config: any): any;
+}
+/**
+ * Plugin Metadata with Enhanced Features
+ */
+export interface PluginMetadata extends Plugin {
+    /** Semantic version (e.g., "1.0.0") */
+    version: string;
+    /** Configuration schema for validation */
+    configSchema?: z.ZodSchema;
+    /** Plugin signature for security verification */
+    signature?: string;
+    /** Plugin health check function */
+    healthCheck?(): Promise<PluginHealthStatus>;
+    /** Startup timeout in milliseconds (default: 30000) */
+    startupTimeout?: number;
+    /** Whether plugin supports hot reload */
+    hotReloadable?: boolean;
+}
+/**
+ * Plugin Health Status
+ */
+export interface PluginHealthStatus {
+    healthy: boolean;
+    message?: string;
+    details?: Record<string, any>;
+    lastCheck?: Date;
+}
+/**
+ * Plugin Load Result
+ */
+export interface PluginLoadResult {
+    success: boolean;
+    plugin?: PluginMetadata;
+    error?: Error;
+    loadTime?: number;
+}
+/**
+ * Plugin Startup Result
+ */
+export interface PluginStartupResult {
+    success: boolean;
+    pluginName: string;
+    startTime?: number;
+    error?: Error;
+    timedOut?: boolean;
+}
+/**
+ * Version Compatibility Result
+ */
+export interface VersionCompatibility {
+    compatible: boolean;
+    pluginVersion: string;
+    requiredVersion?: string;
+    message?: string;
+}
+/**
+ * Enhanced Plugin Loader
+ * Provides advanced plugin loading capabilities with validation, security, and lifecycle management
+ */
+export declare class PluginLoader {
+    private logger;
+    private loadedPlugins;
+    private serviceFactories;
+    private serviceInstances;
+    private scopedServices;
+    constructor(logger: Logger);
+    /**
+     * Load a plugin asynchronously with validation
+     */
+    loadPlugin(plugin: Plugin): Promise<PluginLoadResult>;
+    /**
+     * Register a service with factory function
+     */
+    registerServiceFactory(registration: ServiceRegistration): void;
+    /**
+     * Get or create a service instance based on lifecycle type
+     */
+    getService<T>(name: string, scopeId?: string): Promise<T>;
+    /**
+     * Register a static service instance (legacy support)
+     */
+    registerService(name: string, service: any): void;
+    /**
+     * Detect circular dependencies in service factories
+     * Note: This only detects cycles in service dependencies, not plugin dependencies.
+     * Plugin dependency cycles are detected in the kernel's resolveDependencies method.
+     */
+    detectCircularDependencies(): string[];
+    /**
+     * Check plugin health
+     */
+    checkPluginHealth(pluginName: string): Promise<PluginHealthStatus>;
+    /**
+     * Clear scoped services for a scope
+     */
+    clearScope(scopeId: string): void;
+    /**
+     * Get all loaded plugins
+     */
+    getLoadedPlugins(): Map<string, PluginMetadata>;
+    private toPluginMetadata;
+    private validatePluginStructure;
+    private checkVersionCompatibility;
+    private isValidSemanticVersion;
+    private validatePluginConfig;
+    private verifyPluginSignature;
+    private getSingletonService;
+    private createTransientService;
+    private getScopedService;
+    private createServiceInstance;
+}
+//# sourceMappingURL=plugin-loader.d.ts.map

package/dist/plugin-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-loader.d.ts","sourceRoot":"","sources":["../src/plugin-loader.ts"],"names":[],"mappings":"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"}