@objectstack/runtime 0.9.2 → 1.0.1

package/src/runtime.test.ts

@@ -0,0 +1,65 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Runtime } from './runtime';
+import { IHttpServer, PluginContext } from '@objectstack/core';
+
+// Mock ObjectKernel to isolate Runtime logic
+vi.mock('@objectstack/core', async () => {
+    const actual = await vi.importActual<any>('@objectstack/core');
+    return {
+        ...actual,
+        ObjectKernel: class {
+            use = vi.fn();
+            registerService = vi.fn();
+            bootstrap = vi.fn().mockResolvedValue(undefined);
+            getServices = vi.fn().mockReturnValue(new Map());
+        }
+    };
+});
+
+describe('Runtime', () => {
+    it('should initialize successfully', () => {
+        const runtime = new Runtime();
+        expect(runtime).toBeDefined();
+        // Should create a kernel
+        expect(runtime.getKernel()).toBeDefined();
+    });
+
+    it('should register api registry plugin by default', () => {
+        const runtime = new Runtime();
+        const kernel = runtime.getKernel();
+        // Check if use was called (at least once for api registry)
+        expect(kernel.use).toHaveBeenCalled();
+    });
+
+    it('should register external http server if provided', () => {
+        const mockServer: IHttpServer = {
+            listen: vi.fn(),
+            close: vi.fn(),
+            get: vi.fn(),
+            post: vi.fn(),
+            put: vi.fn(),
+            delete: vi.fn(),
+            patch: vi.fn(),
+            use: vi.fn(),
+        };
+        
+        const runtime = new Runtime({ server: mockServer });
+        const kernel = runtime.getKernel();
+        
+        expect(kernel.registerService).toHaveBeenCalledWith('http.server', mockServer);
+    });
+
+    it('should delegate use() to kernel', () => {
+        const runtime = new Runtime();
+        const mockPlugin = { name: 'test', init: vi.fn() };
+        
+        runtime.use(mockPlugin);
+        expect(runtime.getKernel().use).toHaveBeenCalledWith(mockPlugin);
+    });
+
+    it('should delegate start() to kernel.bootstrap()', async () => {
+        const runtime = new Runtime();
+        await runtime.start();
+        expect(runtime.getKernel().bootstrap).toHaveBeenCalled();
+    });
+});

package/src/runtime.ts

@@ -0,0 +1,78 @@
+import { ObjectKernel, Plugin, IHttpServer, ObjectKernelConfig } from '@objectstack/core';
+import { HttpServer } from './http-server.js';
+import { createApiRegistryPlugin, ApiRegistryConfig } from './api-registry-plugin.js';
+
+export interface RuntimeConfig {
+    /**
+     * Optional existing server instance (e.g. Hono, Express app)
+     * If provided, Runtime will use it as the 'http.server' service.
+     * If not provided, Runtime expects a server plugin (like HonoServerPlugin) to be registered manually.
+     */
+    server?: IHttpServer;
+    
+    /**
+     * API Registry Configuration
+     */
+    api?: ApiRegistryConfig;
+
+    /**
+     * Kernel Configuration
+     */
+    kernel?: ObjectKernelConfig;
+}
+
+/**
+ * ObjectStack Runtime
+ * 
+ * High-level entry point for bootstrapping an ObjectStack application.
+ * Wraps ObjectKernel and provides standard orchestration for:
+ * - HTTP Server binding
+ * - API Registry (REST Routes)
+ * - Plugin Management
+ */
+export class Runtime {
+    readonly kernel: ObjectKernel;
+    
+    constructor(config: RuntimeConfig = {}) {
+        this.kernel = new ObjectKernel(config.kernel);
+        
+        // If external server provided, register it immediately
+        if (config.server) {
+             // If the provided server is not already an HttpServer wrapper, wrap it?
+             // Since IHttpServer is the interface, we assume it complies.
+             // But HttpServer class in runtime is an adapter.
+             // If user passes raw Hono, it won't work unless they wrapped it.
+             // We'll assume they pass a compliant IHttpServer.
+             this.kernel.registerService('http.server', config.server);
+        }
+        
+        // Register API Registry by default
+        // This plugin is passive (wait for services) so it's safe to add early.
+        this.kernel.use(createApiRegistryPlugin(config.api));
+    }
+    
+    /**
+     * Register a plugin
+     */
+    use(plugin: Plugin) {
+        this.kernel.use(plugin);
+        return this;
+    }
+    
+    /**
+     * Start the runtime
+     * 1. Initializes all plugins (init phase)
+     * 2. Starts all plugins (start phase)
+     */
+    async start() {
+        await this.kernel.bootstrap();
+        return this;
+    }
+    
+    /**
+     * Get the kernel instance
+     */
+    getKernel() {
+        return this.kernel;
+    }
+}