@objectstack/core 0.9.1 → 0.9.2

package/src/lite-kernel.test.ts

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

package/src/lite-kernel.ts

@@ -0,0 +1,135 @@
+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.ts

@@ -204,7 +204,8 @@ export class ObjectLogger implements Logger {
             info: '\x1b[32m',    // Green
             warn: '\x1b[33m',    // Yellow
             error: '\x1b[31m',   // Red
-            fatal: '\x1b[35m'    // Magenta
+            fatal: '\x1b[35m',   // Magenta
+            silent: ''
         };
         const reset = '\x1b[0m';
         const color = levelColors[level] || '';
@@ -263,21 +264,41 @@ export class ObjectLogger implements Logger {
         }
     }
 
-    error(message: string, error?: Error, meta?: Record<string, any>): void {
+    error(message: string, errorOrMeta?: Error | Record<string, any>, meta?: Record<string, any>): void {
+        let error: Error | undefined;
+        let context: Record<string, any> = {};
+
+        if (errorOrMeta instanceof Error) {
+            error = errorOrMeta;
+            context = meta || {};
+        } else {
+             context = errorOrMeta || {};
+        }
+
         if (this.isNode && this.pinoLogger) {
-            const errorContext = error ? { err: error, ...meta } : meta || {};
+            const errorContext = error ? { err: error, ...context } : context;
             this.pinoLogger.error(errorContext, message);
         } else {
-            this.logBrowser('error', message, meta, error);
+            this.logBrowser('error', message, context, error);
         }
     }
 
-    fatal(message: string, error?: Error, meta?: Record<string, any>): void {
+    fatal(message: string, errorOrMeta?: Error | Record<string, any>, meta?: Record<string, any>): void {
+        let error: Error | undefined;
+        let context: Record<string, any> = {};
+
+        if (errorOrMeta instanceof Error) {
+            error = errorOrMeta;
+            context = meta || {};
+        } else {
+             context = errorOrMeta || {};
+        }
+
         if (this.isNode && this.pinoLogger) {
-            const errorContext = error ? { err: error, ...meta } : meta || {};
+            const errorContext = error ? { err: error, ...context } : context;
             this.pinoLogger.fatal(errorContext, message);
         } else {
-            this.logBrowser('fatal', message, meta, error);
+            this.logBrowser('fatal', message, context, error);
         }
     }
 

package/src/plugin-loader.test.ts

@@ -1,7 +1,7 @@
 import { describe, it, expect, beforeEach } from 'vitest';
 import { PluginLoader, ServiceLifecycle, PluginMetadata } from './plugin-loader';
 import { createLogger } from './logger';
-import type { Plugin } from './types';
+import type { Plugin, PluginContext } from './types';
 
 describe('PluginLoader', () => {
     let loader: PluginLoader;
@@ -9,6 +9,15 @@ describe('PluginLoader', () => {
     beforeEach(() => {
         const logger = createLogger({ level: 'error' }); // Suppress logs in tests
         loader = new PluginLoader(logger);
+        loader.setContext({
+            registerService: () => {},
+            getService: () => { throw new Error('Mock service not found'); },
+            hook: () => {},
+            trigger: async () => {},
+            getServices: () => new Map(),
+            logger: logger,
+            getKernel: () => ({}) as any
+        } as PluginContext);
     });
 
     describe('Plugin Loading', () => {

package/src/plugin-loader.ts

@@ -1,6 +1,7 @@
 import { Plugin, PluginContext } from './types.js';
 import type { Logger } from '@objectstack/spec/contracts';
 import { z } from 'zod';
+import { PluginConfigValidator } from './security/plugin-config-validator.js';
 
 /**
  * Service Lifecycle Types
@@ -111,13 +112,31 @@ export interface VersionCompatibility {
  */
 export class PluginLoader {
     private logger: Logger;
+    private context?: PluginContext;
+    private configValidator: PluginConfigValidator;
     private loadedPlugins: Map<string, PluginMetadata> = new Map();
     private serviceFactories: Map<string, ServiceRegistration> = new Map();
     private serviceInstances: Map<string, any> = new Map();
     private scopedServices: Map<string, Map<string, any>> = new Map();
+    private creating: Set<string> = new Set();
 
     constructor(logger: Logger) {
         this.logger = logger;
+        this.configValidator = new PluginConfigValidator(logger);
+    }
+
+    /**
+     * Set the plugin context for service factories
+     */
+    setContext(context: PluginContext): void {
+        this.context = context;
+    }
+
+    /**
+     * Get a synchronous service instance if it exists (Sync Helper)
+     */
+    getServiceInstance<T>(name: string): T | undefined {
+        return this.serviceInstances.get(name) as T;
     }
 
     /**
@@ -371,16 +390,16 @@ export class PluginLoader {
         if (!plugin.configSchema) {
             return;
         }
-        
-        if (!config) {
-            this.logger.debug(`Plugin ${plugin.name} has configuration schema but no config provided`);
-            return;
+
+        if (config === undefined) {
+             // In loadPlugin, we often don't have the config yet.
+             // We skip validation here or valid against empty object if schema allows?
+             // For now, let's keep the logging behavior but note it's delegating
+             this.logger.debug(`Plugin ${plugin.name} has configuration schema (config validation postponed)`);
+             return;
         }
-        
-        // Configuration validation is now implemented in PluginConfigValidator
-        // This is a placeholder that logs the validation would happen
-        // The actual validation should be done by the caller when config is available
-        this.logger.debug(`Plugin ${plugin.name} has configuration schema (use PluginConfigValidator for validation)`);
+
+        this.configValidator.validatePluginConfig(plugin, config);
     }
 
     private async verifyPluginSignature(plugin: PluginMetadata): Promise<void> {
@@ -431,9 +450,19 @@ export class PluginLoader {
     }
 
     private async createServiceInstance(registration: ServiceRegistration): Promise<any> {
-        // This is a simplified version - in real implementation,
-        // we would need to pass proper context with resolved dependencies
-        const mockContext = {} as PluginContext;
-        return await registration.factory(mockContext);
+        if (!this.context) {
+            throw new Error(`[PluginLoader] Context not set - cannot create service '${registration.name}'`);
+        }
+
+        if (this.creating.has(registration.name)) {
+            throw new Error(`Circular dependency detected: ${Array.from(this.creating).join(' -> ')} -> ${registration.name}`);
+        }
+
+        this.creating.add(registration.name);
+        try {
+            return await registration.factory(this.context);
+        } finally {
+            this.creating.delete(registration.name);
+        }
     }
 }

package/src/security/index.ts

@@ -27,3 +27,22 @@ export {
   type PluginPermissions,
   type PermissionCheckResult,
 } from './plugin-permission-enforcer.js';
+
+// Advanced security components (Phase 2)
+export {
+  PluginPermissionManager,
+  type PermissionGrant,
+  type PermissionCheckResult as PluginPermissionCheckResult,
+} from './permission-manager.js';
+
+export {
+  PluginSandboxRuntime,
+  type SandboxContext,
+  type ResourceUsage,
+} from './sandbox-runtime.js';
+
+export {
+  PluginSecurityScanner,
+  type ScanTarget,
+  type SecurityIssue,
+} from './security-scanner.js';