@objectstack/core 0.6.1 → 0.7.1

package/dist/kernel-base.js

@@ -0,0 +1,219 @@
+/**
+ * ObjectKernelBase - Abstract Base Class for Microkernel
+ *
+ * Provides common functionality for both ObjectKernel and EnhancedObjectKernel:
+ * - Plugin management (Map storage)
+ * - Dependency resolution (topological sort)
+ * - Hook/Event system
+ * - Context creation
+ * - State validation
+ *
+ * This eliminates ~120 lines of duplicate code between the two implementations.
+ */
+export class ObjectKernelBase {
+    constructor(logger) {
+        this.plugins = new Map();
+        this.services = new Map();
+        this.hooks = new Map();
+        this.state = 'idle';
+        this.logger = logger;
+    }
+    /**
+     * Validate kernel state
+     * @param requiredState - Required state for the operation
+     * @throws Error if current state doesn't match
+     */
+    validateState(requiredState) {
+        if (this.state !== requiredState) {
+            throw new Error(`[Kernel] Invalid state: expected '${requiredState}', got '${this.state}'`);
+        }
+    }
+    /**
+     * Validate kernel is in idle state (for plugin registration)
+     */
+    validateIdle() {
+        if (this.state !== 'idle') {
+            throw new Error('[Kernel] Cannot register plugins after bootstrap has started');
+        }
+    }
+    /**
+     * Create the plugin context
+     * Subclasses can override to customize context creation
+     */
+    createContext() {
+        return {
+            registerService: (name, service) => {
+                if (this.services instanceof Map) {
+                    if (this.services.has(name)) {
+                        throw new Error(`[Kernel] Service '${name}' already registered`);
+                    }
+                    this.services.set(name, service);
+                }
+                else {
+                    // IServiceRegistry implementation
+                    this.services.register(name, service);
+                }
+                this.logger.info(`Service '${name}' registered`, { service: name });
+            },
+            getService: (name) => {
+                if (this.services instanceof Map) {
+                    const service = this.services.get(name);
+                    if (!service) {
+                        throw new Error(`[Kernel] Service '${name}' not found`);
+                    }
+                    return service;
+                }
+                else {
+                    // IServiceRegistry implementation
+                    return this.services.get(name);
+                }
+            },
+            hook: (name, handler) => {
+                if (!this.hooks.has(name)) {
+                    this.hooks.set(name, []);
+                }
+                this.hooks.get(name).push(handler);
+            },
+            trigger: async (name, ...args) => {
+                const handlers = this.hooks.get(name) || [];
+                for (const handler of handlers) {
+                    await handler(...args);
+                }
+            },
+            getServices: () => {
+                if (this.services instanceof Map) {
+                    return new Map(this.services);
+                }
+                else {
+                    // For IServiceRegistry, we need to return the underlying Map
+                    // This is a compatibility method
+                    return new Map();
+                }
+            },
+            logger: this.logger,
+            getKernel: () => this,
+        };
+    }
+    /**
+     * Resolve plugin dependencies using topological sort
+     * @returns Ordered list of plugins (dependencies first)
+     */
+    resolveDependencies() {
+        const resolved = [];
+        const visited = new Set();
+        const visiting = new Set();
+        const visit = (pluginName) => {
+            if (visited.has(pluginName))
+                return;
+            if (visiting.has(pluginName)) {
+                throw new Error(`[Kernel] Circular dependency detected: ${pluginName}`);
+            }
+            const plugin = this.plugins.get(pluginName);
+            if (!plugin) {
+                throw new Error(`[Kernel] Plugin '${pluginName}' not found`);
+            }
+            visiting.add(pluginName);
+            // Visit dependencies first
+            const deps = plugin.dependencies || [];
+            for (const dep of deps) {
+                if (!this.plugins.has(dep)) {
+                    throw new Error(`[Kernel] Dependency '${dep}' not found for plugin '${pluginName}'`);
+                }
+                visit(dep);
+            }
+            visiting.delete(pluginName);
+            visited.add(pluginName);
+            resolved.push(plugin);
+        };
+        // Visit all plugins
+        for (const pluginName of this.plugins.keys()) {
+            visit(pluginName);
+        }
+        return resolved;
+    }
+    /**
+     * Run plugin init phase
+     * @param plugin - Plugin to initialize
+     */
+    async runPluginInit(plugin) {
+        const pluginName = plugin.name;
+        this.logger.info(`Initializing plugin: ${pluginName}`);
+        try {
+            await plugin.init(this.context);
+            this.logger.info(`Plugin initialized: ${pluginName}`);
+        }
+        catch (error) {
+            this.logger.error(`Plugin init failed: ${pluginName}`, error);
+            throw error;
+        }
+    }
+    /**
+     * Run plugin start phase
+     * @param plugin - Plugin to start
+     */
+    async runPluginStart(plugin) {
+        if (!plugin.start)
+            return;
+        const pluginName = plugin.name;
+        this.logger.info(`Starting plugin: ${pluginName}`);
+        try {
+            await plugin.start(this.context);
+            this.logger.info(`Plugin started: ${pluginName}`);
+        }
+        catch (error) {
+            this.logger.error(`Plugin start failed: ${pluginName}`, error);
+            throw error;
+        }
+    }
+    /**
+     * Run plugin destroy phase
+     * @param plugin - Plugin to destroy
+     */
+    async runPluginDestroy(plugin) {
+        if (!plugin.destroy)
+            return;
+        const pluginName = plugin.name;
+        this.logger.info(`Destroying plugin: ${pluginName}`);
+        try {
+            await plugin.destroy();
+            this.logger.info(`Plugin destroyed: ${pluginName}`);
+        }
+        catch (error) {
+            this.logger.error(`Plugin destroy failed: ${pluginName}`, error);
+            throw error;
+        }
+    }
+    /**
+     * Trigger a hook with all registered handlers
+     * @param name - Hook name
+     * @param args - Arguments to pass to handlers
+     */
+    async triggerHook(name, ...args) {
+        const handlers = this.hooks.get(name) || [];
+        this.logger.debug(`Triggering hook: ${name}`, {
+            hook: name,
+            handlerCount: handlers.length
+        });
+        for (const handler of handlers) {
+            try {
+                await handler(...args);
+            }
+            catch (error) {
+                this.logger.error(`Hook handler failed: ${name}`, error);
+                // Continue with other handlers even if one fails
+            }
+        }
+    }
+    /**
+     * Get current kernel state
+     */
+    getState() {
+        return this.state;
+    }
+    /**
+     * Get all registered plugins
+     */
+    getPlugins() {
+        return new Map(this.plugins);
+    }
+}

package/dist/kernel.d.ts

@@ -1,4 +1,6 @@
 import { Plugin } from './types.js';
+import type { LoggerConfig } from '@objectstack/spec/system';
+import { ObjectKernelBase } from './kernel-base.js';
 /**
  * ObjectKernel - MiniKernel Architecture
  *
@@ -7,31 +9,22 @@ import { Plugin } from './types.js';
  * - 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 declare class ObjectKernel {
-    private plugins;
-    private services;
-    private hooks;
-    private state;
-    /**
-     * Plugin context - shared across all plugins
-     */
-    private context;
+export declare class ObjectKernel extends ObjectKernelBase {
+    constructor(config?: {
+        logger?: Partial<LoggerConfig>;
+    });
     /**
      * Register a plugin
      * @param plugin - Plugin instance
      */
     use(plugin: Plugin): this;
-    /**
-     * Resolve plugin dependencies using topological sort
-     * @returns Ordered list of plugins
-     */
-    private resolveDependencies;
     /**
      * Bootstrap the kernel
      * 1. Resolve dependencies (topological sort)
@@ -45,6 +38,10 @@ export declare class ObjectKernel {
      * Calls destroy on all plugins in reverse order
      */
     shutdown(): Promise<void>;
+    /**
+     * Graceful shutdown - destroy all plugins in reverse order
+     */
+    destroy(): Promise<void>;
     /**
      * Get a service from the registry
      * Convenience method for external access
@@ -54,9 +51,5 @@ export declare class ObjectKernel {
      * Check if kernel is running
      */
     isRunning(): boolean;
-    /**
-     * Get kernel state
-     */
-    getState(): string;
 }
 //# sourceMappingURL=kernel.d.ts.map

package/dist/kernel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"kernel.d.ts","sourceRoot":"","sources":["../src/kernel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAiB,MAAM,YAAY,CAAC;AAEnD;;;;;;;;;;;;;GAaG;AACH,qBAAa,YAAY;IACrB,OAAO,CAAC,OAAO,CAAkC;IACjD,OAAO,CAAC,QAAQ,CAA+B;IAC/C,OAAO,CAAC,KAAK,CAA2E;IACxF,OAAO,CAAC,KAAK,CAA2D;IAExE;;OAEG;IACH,OAAO,CAAC,OAAO,CAgCb;IAEF;;;OAGG;IACH,GAAG,CAAC,MAAM,EAAE,MAAM;IAclB;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAyC3B;;;;;;OAMG;IACG,SAAS;IAmCf;;;OAGG;IACG,QAAQ;IAmBd;;;OAGG;IACH,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC;IAI9B;;OAEG;IACH,SAAS,IAAI,OAAO;IAIpB;;OAEG;IACH,QAAQ,IAAI,MAAM;CAGrB"}
+{"version":3,"file":"kernel.d.ts","sourceRoot":"","sources":["../src/kernel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAEpC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEpD;;;;;;;;;;;;;;GAcG;AACH,qBAAa,YAAa,SAAQ,gBAAgB;gBAClC,MAAM,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,CAAA;KAAE;IAQvD;;;OAGG;IACH,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAYzB;;;;;;OAMG;IACG,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IA8BhC;;;OAGG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAI/B;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IA2B9B;;;OAGG;IACH,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC;IAI9B;;OAEG;IACH,SAAS,IAAI,OAAO;CAGvB"}

package/dist/kernel.js

@@ -1,3 +1,5 @@
+import { createLogger } from './logger.js';
+import { ObjectKernelBase } from './kernel-base.js';
 /**
  * ObjectKernel - MiniKernel Architecture
  *
@@ -6,63 +8,26 @@
  * - 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 ObjectKernel {
-    constructor() {
-        this.plugins = new Map();
-        this.services = new Map();
-        this.hooks = new Map();
-        this.state = 'idle';
-        /**
-         * Plugin context - shared across all plugins
-         */
-        this.context = {
-            registerService: (name, service) => {
-                if (this.services.has(name)) {
-                    throw new Error(`[Kernel] Service '${name}' already registered`);
-                }
-                this.services.set(name, service);
-                this.context.logger.log(`[Kernel] Service '${name}' registered`);
-            },
-            getService: (name) => {
-                const service = this.services.get(name);
-                if (!service) {
-                    throw new Error(`[Kernel] Service '${name}' not found`);
-                }
-                return service;
-            },
-            hook: (name, handler) => {
-                if (!this.hooks.has(name)) {
-                    this.hooks.set(name, []);
-                }
-                this.hooks.get(name).push(handler);
-            },
-            trigger: async (name, ...args) => {
-                const handlers = this.hooks.get(name) || [];
-                for (const handler of handlers) {
-                    await handler(...args);
-                }
-            },
-            getServices: () => {
-                return new Map(this.services);
-            },
-            logger: console,
-            getKernel: () => this,
-        };
+export class ObjectKernel extends ObjectKernelBase {
+    constructor(config) {
+        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) {
-        if (this.state !== 'idle') {
-            throw new Error('[Kernel] Cannot register plugins after bootstrap has started');
-        }
+        this.validateIdle();
         const pluginName = plugin.name;
         if (this.plugins.has(pluginName)) {
             throw new Error(`[Kernel] Plugin '${pluginName}' already registered`);
@@ -70,43 +35,6 @@ export class ObjectKernel {
         this.plugins.set(pluginName, plugin);
         return this;
     }
-    /**
-     * Resolve plugin dependencies using topological sort
-     * @returns Ordered list of plugins
-     */
-    resolveDependencies() {
-        const resolved = [];
-        const visited = new Set();
-        const visiting = new Set();
-        const visit = (pluginName) => {
-            if (visited.has(pluginName))
-                return;
-            if (visiting.has(pluginName)) {
-                throw new Error(`[Kernel] Circular dependency detected: ${pluginName}`);
-            }
-            const plugin = this.plugins.get(pluginName);
-            if (!plugin) {
-                throw new Error(`[Kernel] Plugin '${pluginName}' not found`);
-            }
-            visiting.add(pluginName);
-            // Visit dependencies first
-            const deps = plugin.dependencies || [];
-            for (const dep of deps) {
-                if (!this.plugins.has(dep)) {
-                    throw new Error(`[Kernel] Dependency '${dep}' not found for plugin '${pluginName}'`);
-                }
-                visit(dep);
-            }
-            visiting.delete(pluginName);
-            visited.add(pluginName);
-            resolved.push(plugin);
-        };
-        // Visit all plugins
-        for (const pluginName of this.plugins.keys()) {
-            visit(pluginName);
-        }
-        return resolved;
-    }
     /**
      * Bootstrap the kernel
      * 1. Resolve dependencies (topological sort)
@@ -115,51 +43,58 @@ export class ObjectKernel {
      * 4. Trigger 'kernel:ready' hook
      */
     async bootstrap() {
-        if (this.state !== 'idle') {
-            throw new Error('[Kernel] Kernel already bootstrapped');
-        }
+        this.validateState('idle');
         this.state = 'initializing';
-        this.context.logger.log('[Kernel] Bootstrap started...');
+        this.logger.info('Bootstrap started');
         // Resolve dependencies
         const orderedPlugins = this.resolveDependencies();
         // Phase 1: Init - Plugins register services
-        this.context.logger.log('[Kernel] Phase 1: Init plugins...');
+        this.logger.info('Phase 1: Init plugins');
         for (const plugin of orderedPlugins) {
-            this.context.logger.log(`[Kernel] Init: ${plugin.name}`);
-            await plugin.init(this.context);
+            await this.runPluginInit(plugin);
         }
         // Phase 2: Start - Plugins execute business logic
-        this.context.logger.log('[Kernel] Phase 2: Start plugins...');
+        this.logger.info('Phase 2: Start plugins');
         this.state = 'running';
         for (const plugin of orderedPlugins) {
-            if (plugin.start) {
-                this.context.logger.log(`[Kernel] Start: ${plugin.name}`);
-                await plugin.start(this.context);
-            }
+            await this.runPluginStart(plugin);
         }
-        // Phase 3: Trigger kernel:ready hook
-        this.context.logger.log('[Kernel] Triggering kernel:ready hook...');
-        await this.context.trigger('kernel:ready');
-        this.context.logger.log('[Kernel] ✅ Bootstrap complete');
+        // 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() {
-        if (this.state !== 'running') {
-            throw new Error('[Kernel] Kernel not running');
+        await this.destroy();
+    }
+    /**
+     * Graceful shutdown - destroy all plugins in reverse order
+     */
+    async destroy() {
+        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.context.logger.log('[Kernel] Shutdown started...');
         this.state = 'stopped';
-        const orderedPlugins = Array.from(this.plugins.values()).reverse();
-        for (const plugin of orderedPlugins) {
-            if (plugin.destroy) {
-                this.context.logger.log(`[Kernel] Destroy: ${plugin.name}`);
-                await plugin.destroy();
-            }
+        this.logger.info('✅ Shutdown complete');
+        // Cleanup logger resources
+        if (this.logger && typeof this.logger.destroy === 'function') {
+            await this.logger.destroy();
         }
-        this.context.logger.log('[Kernel] ✅ Shutdown complete');
     }
     /**
      * Get a service from the registry
@@ -174,10 +109,4 @@ export class ObjectKernel {
     isRunning() {
         return this.state === 'running';
     }
-    /**
-     * Get kernel state
-     */
-    getState() {
-        return this.state;
-    }
 }

package/dist/kernel.test.d.ts

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

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

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

package/dist/kernel.test.js

@@ -0,0 +1,161 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { ObjectKernel } from './kernel';
+describe('ObjectKernel with Configurable Logger', () => {
+    let kernel;
+    beforeEach(() => {
+        kernel = new ObjectKernel();
+    });
+    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 ObjectKernel({
+                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 ObjectKernel({
+                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 ObjectKernel({
+                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 ObjectKernel({
+                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();
+        });
+    });
+});