@objectstack/runtime 0.9.2 → 1.0.0

package/dist/runtime.test.js

@@ -0,0 +1,57 @@
+import { describe, it, expect, vi } from 'vitest';
+import { Runtime } from './runtime';
+// Mock ObjectKernel to isolate Runtime logic
+vi.mock('@objectstack/core', async () => {
+    const actual = await vi.importActual('@objectstack/core');
+    return {
+        ...actual,
+        ObjectKernel: class {
+            constructor() {
+                this.use = vi.fn();
+                this.registerService = vi.fn();
+                this.bootstrap = vi.fn().mockResolvedValue(undefined);
+                this.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 = {
+            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/package.json

@@ -1,20 +1,23 @@
 {
   "name": "@objectstack/runtime",
-  "version": "0.9.2",
+  "version": "1.0.0",
+  "license": "Apache-2.0",
   "description": "ObjectStack Core Runtime & Query Engine",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "dependencies": {
-    "@objectstack/core": "0.9.2",
-    "@objectstack/spec": "0.9.2",
-    "@objectstack/types": "0.9.2"
+    "@objectstack/core": "1.0.0",
+    "@objectstack/spec": "1.0.0",
+    "@objectstack/types": "1.0.0"
   },
   "devDependencies": {
-    "typescript": "^5.0.0"
+    "typescript": "^5.0.0",
+    "vitest": "^4.0.18"
   },
   "scripts": {
     "build": "tsc",
-    "dev": "tsc -w"
+    "dev": "tsc -w",
+    "test": "vitest run"
   }
 }

package/src/api-registry-plugin.ts

@@ -0,0 +1,58 @@
+import { Plugin, PluginContext, IHttpServer } from '@objectstack/core';
+import { RestServer } from './rest-server.js';
+import { ObjectStackProtocol, RestServerConfig } from '@objectstack/spec/api';
+
+export interface ApiRegistryConfig {
+    serverServiceName?: string;
+    protocolServiceName?: string;
+    api?: RestServerConfig;
+}
+
+/**
+ * ApiRegistryPlugin
+ * 
+ * Responsibilities:
+ * 1. Consumes 'http.server' (or configured service)
+ * 2. Consumes 'protocol' (ObjectStackProtocol)
+ * 3. Instantiates RestServer to auto-generate routes
+ */
+export function createApiRegistryPlugin(config: ApiRegistryConfig = {}): Plugin {
+    return {
+        name: 'com.objectstack.runtime.api-registry',
+        version: '1.0.0',
+        
+        init: async (ctx: PluginContext) => {
+            // No service registration, this is a consumer plugin
+        },
+        
+        start: async (ctx: PluginContext) => {
+            const serverService = config.serverServiceName || 'http.server';
+            const protocolService = config.protocolServiceName || 'protocol';
+            
+            const server = ctx.getService<IHttpServer>(serverService);
+            const protocol = ctx.getService<ObjectStackProtocol>(protocolService);
+            
+            if (!server) {
+                ctx.logger.warn(`ApiRegistryPlugin: HTTP Server service '${serverService}' not found. REST routes skipped.`);
+                return;
+            }
+            
+            if (!protocol) {
+                ctx.logger.warn(`ApiRegistryPlugin: Protocol service '${protocolService}' not found. REST routes skipped.`);
+                return;
+            }
+            
+            ctx.logger.info('Hydrating REST API from Protocol...');
+            
+            try {
+                const restServer = new RestServer(server, protocol, config.api as any);
+                restServer.registerRoutes();
+                
+                ctx.logger.info('REST API successfully registered');
+            } catch (err: any) {
+                ctx.logger.error('Failed to register REST API routes', { error: err.message } as any);
+                throw err;
+            }
+        }
+    };
+}

package/src/app-plugin.test.ts

@@ -0,0 +1,102 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { AppPlugin } from './app-plugin';
+import { PluginContext } from '@objectstack/core';
+
+describe('AppPlugin', () => {
+    let mockContext: PluginContext;
+
+    beforeEach(() => {
+        mockContext = {
+            logger: { 
+                info: vi.fn(), 
+                error: vi.fn(),
+                warn: vi.fn(),
+                debug: vi.fn()
+            },
+            registerService: vi.fn(),
+            getService: vi.fn(),
+            getServices: vi.fn()
+        } as unknown as PluginContext;
+    });
+
+    it('should initialize with manifest info', () => {
+        const bundle = {
+            id: 'com.test.app',
+            name: 'Test App',
+            version: '1.0.0'
+        };
+        const plugin = new AppPlugin(bundle);
+        expect(plugin.name).toBe('plugin.app.com.test.app');
+        expect(plugin.version).toBe('1.0.0');
+    });
+
+    it('should handle nested stack definition manifest', () => {
+        const bundle = {
+            manifest: {
+                id: 'com.test.stack',
+                version: '2.0.0'
+            },
+            objects: []
+        };
+        const plugin = new AppPlugin(bundle);
+        expect(plugin.name).toBe('plugin.app.com.test.stack');
+        expect(plugin.version).toBe('2.0.0');
+    });
+
+    it('registerService should register raw manifest in init phase', async () => {
+        const bundle = {
+            id: 'com.test.simple',
+            objects: []
+        };
+        const plugin = new AppPlugin(bundle);
+        
+        await plugin.init(mockContext);
+        
+        expect(mockContext.registerService).toHaveBeenCalledWith('app.com.test.simple', bundle);
+    });
+
+    it('start should do nothing if no runtime hooks', async () => {
+        const bundle = { id: 'com.test.static' };
+        const plugin = new AppPlugin(bundle);
+        
+        vi.mocked(mockContext.getService).mockReturnValue({}); // Mock ObjectQL exists
+        
+        await plugin.start!(mockContext);
+        // Only logs, no errors
+        expect(mockContext.logger.debug).toHaveBeenCalled();
+    });
+
+    it('start should invoke onEnable if present', async () => {
+        const onEnableSpy = vi.fn();
+        const bundle = { 
+            id: 'com.test.code',
+            onEnable: onEnableSpy
+        };
+        const plugin = new AppPlugin(bundle);
+        
+        // Mock ObjectQL engine
+        const mockQL = { registry: {} };
+        vi.mocked(mockContext.getService).mockReturnValue(mockQL);
+        
+        await plugin.start!(mockContext);
+        
+        expect(onEnableSpy).toHaveBeenCalled();
+        // Check context passed to onEnable
+        const callArg = onEnableSpy.mock.calls[0][0];
+        expect(callArg.ql).toBe(mockQL);
+    });
+
+    it('start should warn if objectql not found', async () => {
+        const bundle = { id: 'com.test.warn' };
+        const plugin = new AppPlugin(bundle);
+        
+        vi.mocked(mockContext.getService).mockReturnValue(undefined); // No ObjectQL
+        
+        await plugin.start!(mockContext);
+        
+        expect(mockContext.logger.warn).toHaveBeenCalledWith(
+            expect.stringContaining('ObjectQL engine service not found'), 
+            expect.any(Object)
+        );
+    });
+});

package/src/app-plugin.ts

@@ -25,7 +25,7 @@ export class AppPlugin implements Plugin {
         this.version = sys.version;
     }
 
-    async init(ctx: PluginContext) {
+    init = async (ctx: PluginContext) => {
         const sys = this.bundle.manifest || this.bundle;
         const appId = sys.id || sys.name;
 
@@ -48,7 +48,7 @@ export class AppPlugin implements Plugin {
         ctx.registerService(serviceName, servicePayload);
     }
 
-    async start(ctx: PluginContext) {
+    start = async (ctx: PluginContext) => {
         const sys = this.bundle.manifest || this.bundle;
         const appId = sys.id || sys.name;
         

package/src/driver-plugin.ts

@@ -26,7 +26,7 @@ export class DriverPlugin implements Plugin {
         this.name = `com.objectstack.driver.${driverName || driver.name || 'unknown'}`;
     }
 
-    async init(ctx: PluginContext) {
+    init = async (ctx: PluginContext) => {
         // Register driver as a service instead of directly to objectql
         const serviceName = `driver.${this.driver.name || 'unknown'}`;
         ctx.registerService(serviceName, this.driver);
@@ -37,7 +37,7 @@ export class DriverPlugin implements Plugin {
         });
     }
 
-    async start(ctx: PluginContext) {
+    start = async (ctx: PluginContext) => {
         // Drivers don't need start phase, initialization happens in init
         ctx.logger.debug('Driver plugin started', { driverName: this.driver.name || 'unknown' });
     }