@objectstack/plugin-hono-server 1.0.1 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@objectstack/plugin-hono-server",
-  "version": "1.0.1",
+  "version": "1.0.4",
   "license": "Apache-2.0",
   "description": "Standard Hono Server Adapter for ObjectStack Runtime",
   "main": "dist/index.js",
@@ -8,9 +8,11 @@
   "dependencies": {
     "@hono/node-server": "^1.2.0",
     "hono": "^4.0.0",
-    "@objectstack/core": "1.0.1",
-    "@objectstack/spec": "1.0.1",
-    "@objectstack/types": "1.0.1"
+    "@objectstack/core": "1.0.4",
+    "@objectstack/hono": "1.0.4",
+    "@objectstack/runtime": "1.0.4",
+    "@objectstack/spec": "1.0.4",
+    "@objectstack/types": "1.0.4"
   },
   "devDependencies": {
     "@types/node": "^25.1.0",

package/src/adapter.ts

@@ -16,6 +16,7 @@ import { serveStatic } from '@hono/node-server/serve-static';
 export class HonoHttpServer implements IHttpServer {
     private app: Hono;
     private server: any;
+    private listeningPort: number | undefined;
 
     constructor(
         private port: number = 3000,
@@ -101,21 +102,35 @@ export class HonoHttpServer implements IHttpServer {
         }
     }
 
+    /**
+     * Mount a sub-application or router
+     */
+    mount(path: string, subApp: Hono) {
+        this.app.route(path, subApp);
+    }
+
+
     async listen(port: number) {
         return new Promise<void>((resolve) => {
             if (this.staticRoot) {
                 this.app.get('/*', serveStatic({ root: this.staticRoot }));
             }
             
+            const targetPort = port || this.port;
             this.server = serve({
                 fetch: this.app.fetch,
-                port: port || this.port
+                port: targetPort
             }, (info) => {
+                this.listeningPort = info.port;
                 resolve();
             });
         });
     }
 
+    getPort() {
+        return this.listeningPort || this.port;
+    }
+
     // Expose raw app for scenarios where standard interface is not enough
     getRawApp() {
         return this.app;

package/src/hono-plugin.test.ts

@@ -1,167 +1,86 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { HonoServerPlugin } from './hono-plugin';
-import { PluginContext, ApiRegistry } from '@objectstack/core';
+import { PluginContext } from '@objectstack/core';
+import { createHonoApp } from '@objectstack/hono';
+import { HonoHttpServer } from './adapter';
+
+// Mock dependencies
+vi.mock('@objectstack/hono', () => ({
+    createHonoApp: vi.fn(),
+}));
+
+vi.mock('./adapter', () => ({
+    HonoHttpServer: vi.fn(function() {
+        return {
+            mount: vi.fn(),
+            start: vi.fn(),
+            stop: vi.fn(),
+            getApp: vi.fn()
+        };
+    })
+}));
 
 describe('HonoServerPlugin', () => {
     let context: any;
     let logger: any;
-    let protocol: any;
-    let apiRegistry: any;
+    let kernel: any;
 
     beforeEach(() => {
+        vi.clearAllMocks();
+
         logger = {
             info: vi.fn(),
             debug: vi.fn(),
             warn: vi.fn(),
             error: vi.fn()
         };
-        
-        protocol = {
-            getDiscovery: vi.fn().mockResolvedValue({ version: 'v1', apiName: 'ObjectStack' }),
-            getMetaTypes: vi.fn().mockResolvedValue({ types: ['object', 'plugin'] }),
-            getMetaItems: vi.fn().mockResolvedValue({ type: 'object', items: [] }),
-            findData: vi.fn().mockResolvedValue({ object: 'test', records: [] }),
-            getData: vi.fn().mockResolvedValue({ object: 'test', id: '1', record: {} }),
-            createData: vi.fn().mockResolvedValue({ object: 'test', id: '1', record: {} }),
-            updateData: vi.fn().mockResolvedValue({ object: 'test', id: '1', record: {} }),
-            deleteData: vi.fn().mockResolvedValue({ object: 'test', id: '1', success: true }),
-            batchData: vi.fn().mockResolvedValue({ total: 0, succeeded: 0, failed: 0 }),
-            createManyData: vi.fn().mockResolvedValue({ object: 'test', records: [], count: 0 }),
-            updateManyData: vi.fn().mockResolvedValue({ total: 0, succeeded: 0, failed: 0 }),
-            deleteManyData: vi.fn().mockResolvedValue({ total: 0, succeeded: 0, failed: 0 }),
-            getMetaItemCached: vi.fn().mockResolvedValue({ data: {}, notModified: false }),
-            getUiView: vi.fn().mockResolvedValue({ object: 'test', type: 'list' })
-        };
 
-        apiRegistry = {
-            registerApi: vi.fn(),
-            getRegistry: vi.fn().mockReturnValue({
-                version: '1.0.0',
-                conflictResolution: 'error',
-                apis: [],
-                totalApis: 0,
-                totalEndpoints: 0
-            })
+        kernel = {
+            getService: vi.fn(),
         };
 
         context = {
             logger,
-            getService: vi.fn((service) => {
-                if (service === 'protocol') return protocol;
-                if (service === 'api-registry') throw new Error('Not found');
-                return null;
-            }),
+            getKernel: vi.fn().mockReturnValue(kernel),
             registerService: vi.fn(),
-            hook: vi.fn()
+            hook: vi.fn(),
+            getService: vi.fn()
         };
-    });
-
-    it('should initialize and register server', async () => {
-        const plugin = new HonoServerPlugin();
-        await plugin.init(context as PluginContext);
-        
-        expect(context.registerService).toHaveBeenCalledWith('http-server', expect.anything());
-    });
 
-    it('should register hook on start', async () => {
-        const plugin = new HonoServerPlugin();
-        await plugin.init(context as PluginContext);
-        await plugin.start(context as PluginContext);
-        
-        // Should wait for kernel:ready to start server
-        expect(context.hook).toHaveBeenCalledWith('kernel:ready', expect.any(Function));
-    });
-
-    it('should register CRUD routes in legacy mode when API Registry not available', async () => {
-        const plugin = new HonoServerPlugin();
-        await plugin.init(context as PluginContext);
-        await plugin.start(context as PluginContext);
-        
-        expect(context.getService).toHaveBeenCalledWith('protocol');
-        expect(context.getService).toHaveBeenCalledWith('api-registry');
-        expect(logger.debug).toHaveBeenCalledWith('API Registry not found, using legacy route registration');
-    });
-
-    it('should use API Registry when available', async () => {
-        context.getService = vi.fn((service) => {
-            if (service === 'protocol') return protocol;
-            if (service === 'api-registry') return apiRegistry;
-            return null;
+        (createHonoApp as any).mockReturnValue({
+            // Mock Hono App structure if needed
         });
-
-        const plugin = new HonoServerPlugin();
-        await plugin.init(context as PluginContext);
-        await plugin.start(context as PluginContext);
-        
-        expect(context.getService).toHaveBeenCalledWith('api-registry');
-        expect(apiRegistry.registerApi).toHaveBeenCalled();
     });
 
-    it('should register standard endpoints to API Registry', async () => {
-        context.getService = vi.fn((service) => {
-            if (service === 'protocol') return protocol;
-            if (service === 'api-registry') return apiRegistry;
-            return null;
-        });
-
+    it('should initialize and register server', async () => {
         const plugin = new HonoServerPlugin();
         await plugin.init(context as PluginContext);
-        await plugin.start(context as PluginContext);
         
-        expect(apiRegistry.registerApi).toHaveBeenCalledWith(
-            expect.objectContaining({
-                id: 'objectstack_core_api',
-                name: 'ObjectStack Core API',
-                type: 'rest',
-                version: 'v1'
-            })
-        );
+        expect(context.registerService).toHaveBeenCalledWith('http-server', expect.any(Object));
+        expect(HonoHttpServer).toHaveBeenCalled();
     });
 
-    it('should skip standard endpoint registration when disabled', async () => {
-        context.getService = vi.fn((service) => {
-            if (service === 'protocol') return protocol;
-            if (service === 'api-registry') return apiRegistry;
-            return null;
-        });
-
-        const plugin = new HonoServerPlugin({ registerStandardEndpoints: false });
+    it('should create and mount Hono app on start', async () => {
+        const plugin = new HonoServerPlugin();
         await plugin.init(context as PluginContext);
         await plugin.start(context as PluginContext);
         
-        expect(apiRegistry.registerApi).not.toHaveBeenCalled();
-    });
-
-    it('should use legacy routes when useApiRegistry is disabled', async () => {
-        context.getService = vi.fn((service) => {
-            if (service === 'protocol') return protocol;
-            if (service === 'api-registry') return apiRegistry;
-            return null;
-        });
-
-        const plugin = new HonoServerPlugin({ useApiRegistry: false });
-        await plugin.init(context as PluginContext);
-        await plugin.start(context as PluginContext);
+        expect(createHonoApp).toHaveBeenCalledWith(expect.objectContaining({
+            kernel: kernel,
+            prefix: '/api/v1'
+        }));
         
-        expect(apiRegistry.getRegistry).not.toHaveBeenCalled();
-        expect(logger.debug).toHaveBeenCalledWith('Using legacy route registration');
+        // Access the mocked server instance
+        const serverInstance = (HonoHttpServer as any).mock.instances[0];
+        expect(serverInstance.mount).toHaveBeenCalledWith('/', expect.anything());
     });
 
-    it('should respect REST server configuration', async () => {
-        context.getService = vi.fn((service) => {
-            if (service === 'protocol') return protocol;
-            if (service === 'api-registry') return apiRegistry;
-            return null;
-        });
-
+    it('should respect REST server configuration for prefix', async () => {
         const plugin = new HonoServerPlugin({
             restConfig: {
                 api: {
                     version: 'v2',
-                    basePath: '/custom',
-                    enableCrud: true,
-                    enableMetadata: true,
-                    enableBatch: true
+                    basePath: '/custom'
                 }
             }
         });
@@ -169,22 +88,20 @@ describe('HonoServerPlugin', () => {
         await plugin.init(context as PluginContext);
         await plugin.start(context as PluginContext);
         
-        expect(apiRegistry.registerApi).toHaveBeenCalledWith(
-            expect.objectContaining({
-                version: 'v2'
-            })
-        );
+        expect(createHonoApp).toHaveBeenCalledWith(expect.objectContaining({
+            prefix: '/custom/v2'
+        }));
     });
 
-    it('should handle protocol service not found gracefully', async () => {
-        context.getService = vi.fn(() => {
-            throw new Error('Service not found');
+    it('should handle errors during app creation', async () => {
+        (createHonoApp as any).mockImplementation(() => {
+            throw new Error('Creation failed');
         });
 
         const plugin = new HonoServerPlugin();
         await plugin.init(context as PluginContext);
         await plugin.start(context as PluginContext);
         
-        expect(logger.warn).toHaveBeenCalledWith('Protocol service not found, skipping protocol routes');
+        expect(logger.error).toHaveBeenCalledWith('Failed to create standard Hono app', expect.any(Error));
     });
 });