Refactor ObjectQL and Hono server integration; add protocol implementation and update dependencies

Author: hotlong

packages/core/package.json

@@ -10,5 +10,8 @@
   },
   "devDependencies": {
     "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "@objectstack/spec": "workspace:*"
   }
 }

packages/objectql/src/plugin.ts

@@ -1,9 +1,14 @@
 import { ObjectQL } from './index';
+import { ObjectStackProtocolImplementation } from './protocol';
+// IObjectStackProtocol is used for type checking implicitly via ObjectStackProtocolImplementation contract
 
 // Minimal Context interface to avoid circular dependency on @objectstack/runtime
 export interface PluginContext {
     registerService(name: string, service: any): void;
     logger: Console;
+    // We need access to the kernel-like object to pass to protocol, 
+    // or at least expose getService on context if it's there
+    getService?: <T>(name: string) => T; 
     [key: string]: any;
 }
 
@@ -31,6 +36,15 @@ export class ObjectQLPlugin {
 
     ctx.registerService('objectql', this.ql);
     if(ctx.logger) ctx.logger.log(`[ObjectQLPlugin] ObjectQL engine registered as service`);
+
+    // Register Protocol Implementation
+    if (!this.ql) {
+        throw new Error('ObjectQL engine not initialized');
+    }
+    const protocolShim = new ObjectStackProtocolImplementation(this.ql);
+
+    ctx.registerService('protocol', protocolShim);
+    if(ctx.logger) ctx.logger.log(`[ObjectQLPlugin] Protocol service registered`);
   }
 
   async start(ctx: PluginContext) {

packages/objectql/src/protocol.ts

@@ -0,0 +1,104 @@
+import { IObjectStackProtocol } from '@objectstack/spec/api';
+import { IDataEngine } from '@objectstack/spec/system';
+
+// We import SchemaRegistry directly since this class lives in the same package
+import { SchemaRegistry } from './registry';
+
+export class ObjectStackProtocolImplementation implements IObjectStackProtocol {
+    private engine: IDataEngine;
+
+    constructor(engine: IDataEngine) {
+        this.engine = engine;
+    }
+
+    getDiscovery() {
+        return {
+            name: 'ObjectStack API',
+            version: '1.0',
+            capabilities: {
+                metadata: true,
+                data: true,
+                ui: true
+            }
+        };
+    }
+
+    getMetaTypes() {
+        return SchemaRegistry.getRegisteredTypes();
+    }
+
+    getMetaItems(type: string) {
+        return SchemaRegistry.listItems(type);
+    }
+
+    getMetaItem(type: string, name: string) {
+        return SchemaRegistry.getItem(type, name);
+    }
+
+    getUiView(object: string, type: 'list' | 'form') {
+        const schema = SchemaRegistry.getObject(object);
+        if (!schema) throw new Error(`Object ${object} not found`);
+
+        if (type === 'list') {
+            return {
+                type: 'list',
+                object: object,
+                columns: Object.keys(schema.fields || {}).slice(0, 5).map(f => ({
+                    field: f,
+                    label: schema.fields[f].label || f
+                }))
+            };
+        } else {
+             return {
+                type: 'form',
+                object: object,
+                sections: [
+                    {
+                        label: 'General',
+                        fields: Object.keys(schema.fields || {}).map(f => ({
+                            field: f
+                        }))
+                    }
+                ]
+            };
+        }
+    }
+
+    findData(object: string, query: any) {
+        return this.engine.find(object, query);
+    }
+
+    async getData(object: string, id: string) {
+        // IDataEngine doesn't have findOne, so we simulate it with find and limit 1
+        // Assuming the ID field is named '_id' or 'id'. 
+        // For broad compatibility, we might need to know the ID field name.
+        // But traditionally it is _id in ObjectStack/mongo or id in others.
+        // Let's rely on finding by ID if the engine supports it via find?
+        // Actually, ObjectQL (the implementation) DOES have findOne.
+        // But we are programming against IDataEngine interface here.
+        
+        // If the engine IS ObjectQL (which it practically is), we could cast it.
+        // But let's try to stick to interface.
+        
+        const results = await this.engine.find(object, {
+            filter: { _id: id }, // Default Assumption: _id
+            limit: 1
+        });
+        if (results && results.length > 0) {
+            return results[0];
+        }
+        throw new Error(`Record ${id} not found in ${object}`);
+    }
+
+    createData(object: string, data: any) {
+        return this.engine.insert(object, data);
+    }
+
+    updateData(object: string, id: string, data: any) {
+        return this.engine.update(object, id, data);
+    }
+
+    deleteData(object: string, id: string) {
+        return this.engine.delete(object, id);
+    }
+}

packages/plugin-hono-server/package.json

@@ -9,16 +9,13 @@
   },
   "dependencies": {
     "@hono/node-server": "^1.2.0",
+    "@objectstack/core": "workspace:*",
     "@objectstack/spec": "workspace:*",
     "@objectstack/types": "workspace:*",
-    "@objectstack/runtime": "workspace:*",
     "hono": "^4.0.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
     "typescript": "^5.0.0"
-  },
-  "peerDependencies": {
-    "@objectstack/runtime": "^0.4.2"
   }
 }

packages/plugin-hono-server/src/hono-plugin.ts

@@ -1,10 +1,5 @@
-import { 
-    Plugin, 
-    PluginContext, 
-    ObjectStackRuntimeProtocol 
-} from '@objectstack/runtime';
-// Use the new IHttpServer interface
-import { IHttpServer } from '@objectstack/spec/api';
+import { Plugin, PluginContext } from '@objectstack/core';
+import { IHttpServer, IObjectStackProtocol } from '@objectstack/spec/api';
 import { HonoHttpServer } from './adapter';
 
 export interface HonoPluginOptions {
@@ -46,24 +41,13 @@ export class HonoServerPlugin implements Plugin {
      * Start phase - Bind routes and start listening
      */
     async start(ctx: PluginContext) {
-        // Get ObjectQL directly from services
-        let protocol: ObjectStackRuntimeProtocol | null = null;
+        // Get protocol implementation instance
+        let protocol: IObjectStackProtocol | null = null;
 
         try {
-            const objectql = ctx.getService<any>('objectql');
-            
-            // Create Protocol Instance with faked Kernel
-            // This is necessary because Protocol expects full Kernel but we only have Context
-            protocol = new ObjectStackRuntimeProtocol({
-                getService: (name: string) => {
-                    if (name === 'objectql') return objectql;
-                    throw new Error(`[HonoPlugin] Service ${name} not found`);
-                },
-                getAllPlugins: () => [] // Mock
-            } as any);
-
+            protocol = ctx.getService<IObjectStackProtocol>('protocol');
         } catch (e) {
-            ctx.logger.log('[HonoServerPlugin] ObjectQL service not found, skipping protocol routes');
+            ctx.logger.log('[HonoServerPlugin] Protocol service not found, skipping protocol routes');
         }
 
         // Register protocol routes if available

packages/runtime/src/index.ts

@@ -10,7 +10,7 @@ export { DriverPlugin } from './driver-plugin.js';
 export { AppManifestPlugin } from './app-manifest-plugin.js';
 
 // Export Protocol
-export { ObjectStackRuntimeProtocol } from './protocol.js';
+// export { ObjectStackRuntimeProtocol } from './protocol.js';
 
 // Export Types
 export * from '@objectstack/core';

packages/runtime/src/protocol.ts

@@ -15,3 +15,5 @@ export * from './router.zod';
 export * from './odata.zod';
 
 export * from './http-server';
+export * from './protocol';
+