@objectstack/core 4.0.4 → 4.0.5

package/src/lite-kernel.test.ts

@@ -1,248 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { LiteKernel } from './lite-kernel';
-import type { Plugin } from './types';
-
-describe('LiteKernel with Configurable Logger', () => {
-    let kernel: LiteKernel;
-
-    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: Plugin = {
-                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: string[] = [];
-            
-            const loggingPlugin: Plugin = {
-                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: Plugin = {
-                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: 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: 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: 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: Plugin = {
-                name: 'browser-test',
-                init: async (ctx) => {
-                    ctx.logger.info('Browser-friendly format');
-                }
-            };
-
-            browserKernel.use(plugin);
-            await browserKernel.bootstrap();
-            await browserKernel.shutdown();
-        });
-    });
-
-    describe('Service Replacement', () => {
-        it('should replace an existing service via replaceService', async () => {
-            const originalService = { value: 'original' };
-            const replacementService = { value: 'replaced' };
-
-            const plugin: Plugin = {
-                name: 'register-plugin',
-                init: async (ctx) => {
-                    ctx.registerService('metadata', originalService);
-                },
-            };
-
-            const optimizationPlugin: Plugin = {
-                name: 'optimization-plugin',
-                dependencies: ['register-plugin'],
-                init: async (ctx) => {
-                    const existing = ctx.getService('metadata');
-                    expect(existing).toBe(originalService);
-                    ctx.replaceService('metadata', replacementService);
-                },
-            };
-
-            kernel.use(plugin);
-            kernel.use(optimizationPlugin);
-            await kernel.bootstrap();
-
-            const result = kernel.getService('metadata');
-            expect(result).toBe(replacementService);
-
-            await kernel.shutdown();
-        });
-
-        it('should throw when replacing a non-existent service', async () => {
-            const plugin: Plugin = {
-                name: 'bad-replace-plugin',
-                init: async (ctx) => {
-                    expect(() => {
-                        ctx.replaceService('nonexistent', { value: 'test' });
-                    }).toThrow("Service 'nonexistent' not found");
-                },
-            };
-
-            kernel.use(plugin);
-            await kernel.bootstrap();
-            await kernel.shutdown();
-        });
-    });
-});

package/src/lite-kernel.ts

@@ -1,137 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-import { Plugin } from './types.js';
-import { createLogger, ObjectLogger } from './logger.js';
-import type { LoggerConfig } from '@objectstack/spec/system';
-import { ObjectKernelBase } from './kernel-base.js';
-
-/**
- * ObjectKernel - MiniKernel Architecture
- * 
- * A highly modular, plugin-based microkernel that:
- * - Manages plugin lifecycle (init, start, destroy)
- * - Provides dependency injection via service registry
- * - Implements event/hook system for inter-plugin communication
- * - Handles dependency resolution (topological sort)
- * - Provides configurable logging for server and browser
- * 
- * Core philosophy:
- * - Business logic is completely separated into plugins
- * - Kernel only manages lifecycle, DI, and hooks
- * - Plugins are loaded as equal building blocks
- */
-export class LiteKernel extends ObjectKernelBase {
-    constructor(config?: { logger?: Partial<LoggerConfig> }) {
-        const logger = createLogger(config?.logger);
-        super(logger);
-        
-        // Initialize context after logger is created
-        this.context = this.createContext();
-    }
-
-    /**
-     * Register a plugin
-     * @param plugin - Plugin instance
-     */
-    use(plugin: Plugin): this {
-        this.validateIdle();
-
-        const pluginName = plugin.name;
-        if (this.plugins.has(pluginName)) {
-            throw new Error(`[Kernel] Plugin '${pluginName}' already registered`);
-        }
-
-        this.plugins.set(pluginName, plugin);
-        return this;
-    }
-
-    /**
-     * Bootstrap the kernel
-     * 1. Resolve dependencies (topological sort)
-     * 2. Init phase - plugins register services
-     * 3. Start phase - plugins execute business logic
-     * 4. Trigger 'kernel:ready' hook
-     */
-    async bootstrap(): Promise<void> {
-        this.validateState('idle');
-
-        this.state = 'initializing';
-        this.logger.info('Bootstrap started');
-
-        // Resolve dependencies
-        const orderedPlugins = this.resolveDependencies();
-
-        // Phase 1: Init - Plugins register services
-        this.logger.info('Phase 1: Init plugins');
-        for (const plugin of orderedPlugins) {
-            await this.runPluginInit(plugin);
-        }
-
-        // Phase 2: Start - Plugins execute business logic
-        this.logger.info('Phase 2: Start plugins');
-        this.state = 'running';
-        
-        for (const plugin of orderedPlugins) {
-            await this.runPluginStart(plugin);
-        }
-
-        // Trigger ready hook
-        await this.triggerHook('kernel:ready');
-        this.logger.info('✅ Bootstrap complete', { 
-            pluginCount: this.plugins.size 
-        });
-    }
-
-    /**
-     * Shutdown the kernel
-     * Calls destroy on all plugins in reverse order
-     */
-    async shutdown(): Promise<void> {
-        await this.destroy();
-    }
-
-    /**
-     * Graceful shutdown - destroy all plugins in reverse order
-     */
-    async destroy(): Promise<void> {
-        if (this.state === 'stopped') {
-            this.logger.warn('Kernel already stopped');
-            return;
-        }
-
-        this.state = 'stopping';
-        this.logger.info('Shutdown started');
-
-        // Trigger shutdown hook
-        await this.triggerHook('kernel:shutdown');
-
-        // Destroy plugins in reverse order
-        const orderedPlugins = this.resolveDependencies();
-        for (const plugin of orderedPlugins.reverse()) {
-            await this.runPluginDestroy(plugin);
-        }
-
-        this.state = 'stopped';
-        this.logger.info('✅ Shutdown complete');
-        
-        // Cleanup logger resources
-        if (this.logger && typeof (this.logger as ObjectLogger).destroy === 'function') {
-            await (this.logger as ObjectLogger).destroy();
-        }
-    }
-
-    /**
-     * Get a service from the registry
-     * Convenience method for external access
-     */
-    getService<T>(name: string): T {
-        return this.context.getService<T>(name);
-    }
-
-    /**
-     * Check if kernel is running
-     */
-    isRunning(): boolean {
-        return this.state === 'running';
-    }
-}

package/src/logger.test.ts

@@ -1,116 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { createLogger, ObjectLogger } from './logger';
-
-describe('ObjectLogger', () => {
-    let logger: ObjectLogger;
-
-    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();
-        });
-    });
-});