添加 HonoServerPlugin，支持 API 路由和中间件；重构 DataEngine 以支持运行时插件的安装和启动；创建 types.ts 定义 RuntimePlugin 接口

Author: hotlong

packages/driver-memory/src/memory-driver.ts

@@ -14,6 +14,13 @@ import {
 export class InMemoryDriver implements DriverInterface {
   name = 'in-memory-driver';
   version = '0.0.1';
+
+  // Duck-typed RuntimePlugin hook
+  install(ctx: any) {
+    if (ctx.engine && ctx.engine.ql && typeof ctx.engine.ql.registerDriver === 'function') {
+        ctx.engine.ql.registerDriver(this);
+    }
+  }
 
   supports = {
     transactions: false, 

packages/runtime/src/data-engine.ts

@@ -26,8 +26,16 @@ export class DataEngine {
     console.log('[DataEngine] Starting...');
 
     // 0. Register Provided Plugins
-    this.plugins.forEach(p => {
-        console.log(`[DataEngine] Loading Plugin: ${p.id || p.name}`);
+    for (const p of this.plugins) {
+        // Check if it is a Runtime Plugin (System Capability)
+        if ('onStart' in p || 'install' in p) {
+             console.log(`[DataEngine] Loading Runtime Plugin: ${p.name}`);
+             if (p.install) await p.install({ engine: this });
+             continue;
+        }
+        
+        // Otherwise treat as App Manifest
+        console.log(`[DataEngine] Loading App Manifest: ${p.id || p.name}`);
         SchemaRegistry.registerPlugin(p);
 
         // Register Objects from App/Plugin
@@ -37,7 +45,7 @@ export class DataEngine {
                 console.log(`[DataEngine] Registered Object: ${obj.name}`);
             }
         }
-    });
+    }
 
     // 1. Load Drivers (Default to Memory if none provided in plugins)
     // TODO: Detect driver from plugins. For now, we still hard load memory driver if needed?
@@ -60,6 +68,14 @@ export class DataEngine {
 
     // 3. Seed Data
     await this.seed();
+
+    // 4. Start Runtime Plugins
+    for (const p of this.plugins) {
+        if (('onStart' in p) && typeof p.onStart === 'function') {
+            console.log(`[DataEngine] Starting Plugin: ${p.name}`);
+            await p.onStart({ engine: this });
+        }
+    }
   }
 
   async seed() {

packages/runtime/src/index.ts

@@ -8,3 +8,6 @@ export { ObjectStackRuntimeProtocol } from './protocol';
 
 // Re-export common types from spec for convenience
 export type { DriverInterface, DriverOptions, QueryAST } from '@objectstack/spec';
+
+export * from './types';
+

packages/runtime/src/types.ts

@@ -0,0 +1,11 @@
+import { DataEngine } from './data-engine';
+
+export interface RuntimeContext {
+    engine: DataEngine;
+}
+
+export interface RuntimePlugin {
+    name: string;
+    install?: (ctx: RuntimeContext) => void | Promise<void>;
+    onStart?: (ctx: RuntimeContext) => void | Promise<void>;
+}

packages/server/src/hono-plugin.ts

@@ -0,0 +1,128 @@
+import { serve } from '@hono/node-server';
+import { serveStatic } from '@hono/node-server/serve-static';
+import { Hono } from 'hono';
+import { cors } from 'hono/cors';
+import { logger } from 'hono/logger';
+import { RuntimePlugin, RuntimeContext, ObjectStackRuntimeProtocol } from '@objectstack/runtime';
+
+export interface HonoPluginOptions {
+    port?: number;
+    staticRoot?: string;
+}
+
+export class HonoServerPlugin implements RuntimePlugin {
+    name = 'hono-server';
+    private options: HonoPluginOptions;
+    private app: Hono;
+
+    constructor(options: HonoPluginOptions = {}) {
+        this.options = { 
+            port: 3000,
+            ...options
+        };
+        this.app = new Hono();
+    }
+
+    install(ctx: RuntimeContext) {
+        const { engine } = ctx;
+        const protocol = new ObjectStackRuntimeProtocol(engine);
+
+        // Middleware
+        this.app.use('*', logger());
+        this.app.use('*', cors());
+
+        // --- Bind Protocol to Hono ---
+        
+        // 1. Discovery
+        this.app.get('/api/v1', (c) => c.json(protocol.getDiscovery()));
+
+        // 2. Meta
+        this.app.get('/api/v1/meta', (c) => c.json(protocol.getMetaTypes()));
+        this.app.get('/api/v1/meta/:type', (c) => c.json(protocol.getMetaItems(c.req.param('type'))));
+        this.app.get('/api/v1/meta/:type/:name', (c) => {
+             try {
+                 return c.json(protocol.getMetaItem(c.req.param('type'), c.req.param('name')));
+             } catch (e: any) {
+                 return c.json({ error: e.message }, 404);
+             }
+        });
+
+        // 3. Data
+        this.app.get('/api/v1/data/:object', async (c) => {
+            try {
+                const result = await protocol.findData(c.req.param('object'), c.req.query());
+                return c.json(result);
+            } catch (e: any) {
+                return c.json({ error: e.message }, 404);
+            }
+        });
+
+        this.app.get('/api/v1/data/:object/:id', async (c) => {
+            try {
+                const result = await protocol.getData(c.req.param('object'), c.req.param('id'));
+                return c.json(result);
+            } catch (e: any) {
+                return c.json({ error: e.message }, 404);
+            }
+        });
+
+        this.app.post('/api/v1/data/:object', async (c) => {
+            try {
+                const body = await c.req.json();
+                const result = await protocol.createData(c.req.param('object'), body);
+                return c.json(result, 201);
+            } catch (e: any) {
+                return c.json({ error: e.message }, 400);
+            }
+        });
+
+        this.app.patch('/api/v1/data/:object/:id', async (c) => {
+            try {
+                const body = await c.req.json();
+                const result = await protocol.updateData(c.req.param('object'), c.req.param('id'), body);
+                return c.json(result);
+            } catch (e: any) {
+                return c.json({ error: e.message }, 400);
+            }
+        });
+
+        this.app.delete('/api/v1/data/:object/:id', async (c) => {
+            try {
+                const result = await protocol.deleteData(c.req.param('object'), c.req.param('id'));
+                return c.json(result);
+            } catch (e: any) {
+                return c.json({ error: e.message }, 400);
+            }
+        });
+        
+        // 4. UI Protocol
+        this.app.get('/api/v1/ui/view/:object', (c) => {
+            try {
+                // @ts-ignore
+                const view = protocol.getUiView(c.req.param('object'), c.req.query('type') || 'list');
+                return c.json(view);
+            } catch (e: any) {
+                return c.json({ error: e.message }, 404);
+            }
+        });
+
+        // Static Files
+        if (this.options.staticRoot) {
+            this.app.get('/', serveStatic({ root: this.options.staticRoot, path: 'index.html' }));
+            this.app.get('/*', serveStatic({ root: this.options.staticRoot }));
+        }
+
+        console.log(`[HonoPlugin] Installed routes and middleware.`);
+    }
+
+    async onStart(ctx: RuntimeContext) {
+        const port = this.options.port;
+        console.log(`[HonoPlugin] Starting server...`);
+        console.log(`✅ Server is running on http://localhost:${port}`);
+        
+        serve({
+            fetch: this.app.fetch,
+            port
+        });
+    }
+}

packages/server/src/index.ts

@@ -9,6 +9,7 @@ import { CoreRestApiPlugin } from './plugins/rest-api';
 
 export * from './plugin';
 export { CoreRestApiPlugin };
+export { HonoServerPlugin } from './hono-plugin';
 
 export interface ServerConfig {
   port?: number;