@objectstack/plugin-hono-server 0.6.1 → 0.7.1

package/dist/hono-plugin.js

@@ -24,97 +24,349 @@ class HonoServerPlugin {
      * Init phase - Setup HTTP server and register as service
      */
     async init(ctx) {
+        ctx.logger.debug('Initializing Hono server plugin', {
+            port: this.options.port,
+            staticRoot: this.options.staticRoot
+        });
         // Register HTTP server service as IHttpServer
         ctx.registerService('http-server', this.server);
-        ctx.logger.log('[HonoServerPlugin] HTTP server service registered');
+        ctx.logger.info('HTTP server service registered', { serviceName: 'http-server' });
     }
     /**
      * Start phase - Bind routes and start listening
      */
     async start(ctx) {
+        ctx.logger.debug('Starting Hono server plugin');
         // Get protocol implementation instance
         let protocol = null;
         try {
             protocol = ctx.getService('protocol');
+            ctx.logger.debug('Protocol service found, registering protocol routes');
         }
         catch (e) {
-            ctx.logger.log('[HonoServerPlugin] Protocol service not found, skipping protocol routes');
+            ctx.logger.warn('Protocol service not found, skipping protocol routes');
         }
         // Register protocol routes if available
         if (protocol) {
             const p = protocol;
-            this.server.get('/api/v1', (req, res) => res.json(p.getDiscovery()));
+            ctx.logger.debug('Registering API routes');
+            this.server.get('/api/v1', async (req, res) => {
+                ctx.logger.debug('API discovery request');
+                res.json(await p.getDiscovery({}));
+            });
             // Meta Protocol
-            this.server.get('/api/v1/meta', (req, res) => res.json(p.getMetaTypes()));
-            this.server.get('/api/v1/meta/:type', (req, res) => res.json(p.getMetaItems(req.params.type)));
-            this.server.get('/api/v1/meta/:type/:name', (req, res) => {
-                try {
-                    res.json(p.getMetaItem(req.params.type, req.params.name));
-                }
-                catch (e) {
-                    res.status(404).json({ error: e.message });
-                }
+            this.server.get('/api/v1/meta', async (req, res) => {
+                ctx.logger.debug('Meta types request');
+                res.json(await p.getMetaTypes({}));
+            });
+            this.server.get('/api/v1/meta/:type', async (req, res) => {
+                ctx.logger.debug('Meta items request', { type: req.params.type });
+                res.json(await p.getMetaItems({ type: req.params.type }));
             });
             // Data Protocol
             this.server.get('/api/v1/data/:object', async (req, res) => {
+                ctx.logger.debug('Data find request', { object: req.params.object, query: req.query });
                 try {
-                    res.json(await p.findData(req.params.object, req.query));
+                    const result = await p.findData({ object: req.params.object, query: req.query });
+                    ctx.logger.debug('Data find completed', { object: req.params.object, count: result?.records?.length ?? 0 });
+                    res.json(result);
                 }
                 catch (e) {
+                    ctx.logger.error('Data find failed', e, { object: req.params.object });
                     res.status(400).json({ error: e.message });
                 }
             });
             this.server.get('/api/v1/data/:object/:id', async (req, res) => {
+                ctx.logger.debug('Data get request', { object: req.params.object, id: req.params.id });
                 try {
-                    res.json(await p.getData(req.params.object, req.params.id));
+                    const result = await p.getData({ object: req.params.object, id: req.params.id });
+                    ctx.logger.debug('Data get completed', { object: req.params.object, id: req.params.id });
+                    res.json(result);
                 }
                 catch (e) {
+                    ctx.logger.warn('Data get failed - not found', { object: req.params.object, id: req.params.id });
                     res.status(404).json({ error: e.message });
                 }
             });
             this.server.post('/api/v1/data/:object', async (req, res) => {
+                ctx.logger.debug('Data create request', { object: req.params.object });
                 try {
-                    res.status(201).json(await p.createData(req.params.object, req.body));
+                    const result = await p.createData({ object: req.params.object, data: req.body });
+                    ctx.logger.info('Data created', { object: req.params.object, id: result?.id });
+                    res.status(201).json(result);
                 }
                 catch (e) {
+                    ctx.logger.error('Data create failed', e, { object: req.params.object });
                     res.status(400).json({ error: e.message });
                 }
             });
             this.server.patch('/api/v1/data/:object/:id', async (req, res) => {
+                ctx.logger.debug('Data update request', { object: req.params.object, id: req.params.id });
                 try {
-                    res.json(await p.updateData(req.params.object, req.params.id, req.body));
+                    const result = await p.updateData({ object: req.params.object, id: req.params.id, data: req.body });
+                    ctx.logger.info('Data updated', { object: req.params.object, id: req.params.id });
+                    res.json(result);
                 }
                 catch (e) {
+                    ctx.logger.error('Data update failed', e, { object: req.params.object, id: req.params.id });
                     res.status(400).json({ error: e.message });
                 }
             });
             this.server.delete('/api/v1/data/:object/:id', async (req, res) => {
+                ctx.logger.debug('Data delete request', { object: req.params.object, id: req.params.id });
                 try {
-                    res.json(await p.deleteData(req.params.object, req.params.id));
+                    const result = await p.deleteData({ object: req.params.object, id: req.params.id });
+                    ctx.logger.info('Data deleted', { object: req.params.object, id: req.params.id, success: result?.success });
+                    res.json(result);
                 }
                 catch (e) {
+                    ctx.logger.error('Data delete failed', e, { object: req.params.object, id: req.params.id });
                     res.status(400).json({ error: e.message });
                 }
             });
             // UI Protocol
-            // @ts-ignore
-            this.server.get('/api/v1/ui/view/:object', (req, res) => {
+            this.server.get('/api/v1/ui/view/:object', async (req, res) => {
+                const viewType = (req.query.type) || 'list';
+                const qt = Array.isArray(viewType) ? viewType[0] : viewType;
+                ctx.logger.debug('UI view request', { object: req.params.object, viewType: qt });
+                try {
+                    res.json(await p.getUiView({ object: req.params.object, type: qt }));
+                }
+                catch (e) {
+                    ctx.logger.warn('UI view not found', { object: req.params.object, viewType: qt });
+                    res.status(404).json({ error: e.message });
+                }
+            });
+            // Batch Operations
+            this.server.post('/api/v1/data/:object/batch', async (req, res) => {
+                ctx.logger.info('Batch operation request', {
+                    object: req.params.object,
+                    operation: req.body?.operation,
+                    hasBody: !!req.body,
+                    bodyType: typeof req.body,
+                    bodyKeys: req.body ? Object.keys(req.body) : []
+                });
+                try {
+                    const result = await p.batchData({ object: req.params.object, request: req.body });
+                    ctx.logger.info('Batch operation completed', {
+                        object: req.params.object,
+                        operation: req.body?.operation,
+                        total: result.total,
+                        succeeded: result.succeeded,
+                        failed: result.failed
+                    });
+                    res.json(result);
+                }
+                catch (e) {
+                    ctx.logger.error('Batch operation failed', e, { object: req.params.object });
+                    res.status(400).json({ error: e.message });
+                }
+            });
+            this.server.post('/api/v1/data/:object/createMany', async (req, res) => {
+                ctx.logger.debug('Create many request', { object: req.params.object, count: req.body?.length });
+                try {
+                    const result = await p.createManyData({ object: req.params.object, records: req.body || [] });
+                    ctx.logger.info('Create many completed', { object: req.params.object, count: result.records?.length ?? 0 });
+                    res.status(201).json(result);
+                }
+                catch (e) {
+                    ctx.logger.error('Create many failed', e, { object: req.params.object });
+                    res.status(400).json({ error: e.message });
+                }
+            });
+            this.server.post('/api/v1/data/:object/updateMany', async (req, res) => {
+                ctx.logger.debug('Update many request', { object: req.params.object, count: req.body?.records?.length });
+                try {
+                    const result = await p.updateManyData({ object: req.params.object, records: req.body?.records, options: req.body?.options });
+                    ctx.logger.info('Update many completed', {
+                        object: req.params.object,
+                        total: result.total,
+                        succeeded: result.succeeded,
+                        failed: result.failed
+                    });
+                    res.json(result);
+                }
+                catch (e) {
+                    ctx.logger.error('Update many failed', e, { object: req.params.object });
+                    res.status(400).json({ error: e.message });
+                }
+            });
+            this.server.post('/api/v1/data/:object/deleteMany', async (req, res) => {
+                ctx.logger.debug('Delete many request', { object: req.params.object, count: req.body?.ids?.length });
                 try {
-                    const viewType = (req.query.type) || 'list';
-                    const qt = Array.isArray(viewType) ? viewType[0] : viewType;
-                    res.json(p.getUiView(req.params.object, qt));
+                    const result = await p.deleteManyData({ object: req.params.object, ids: req.body?.ids, options: req.body?.options });
+                    ctx.logger.info('Delete many completed', {
+                        object: req.params.object,
+                        total: result.total,
+                        succeeded: result.succeeded,
+                        failed: result.failed
+                    });
+                    res.json(result);
                 }
                 catch (e) {
+                    ctx.logger.error('Delete many failed', e, { object: req.params.object });
+                    res.status(400).json({ error: e.message });
+                }
+            });
+            // Enhanced Metadata Route with ETag Support
+            this.server.get('/api/v1/meta/:type/:name', async (req, res) => {
+                ctx.logger.debug('Meta item request with cache support', {
+                    type: req.params.type,
+                    name: req.params.name,
+                    ifNoneMatch: req.headers['if-none-match']
+                });
+                try {
+                    const cacheRequest = {
+                        ifNoneMatch: req.headers['if-none-match'],
+                        ifModifiedSince: req.headers['if-modified-since'],
+                    };
+                    const result = await p.getMetaItemCached({
+                        type: req.params.type,
+                        name: req.params.name,
+                        cacheRequest
+                    });
+                    if (result.notModified) {
+                        ctx.logger.debug('Meta item not modified (304)', { type: req.params.type, name: req.params.name });
+                        res.status(304).json({});
+                    }
+                    else {
+                        // Set cache headers
+                        if (result.etag) {
+                            const etagValue = result.etag.weak ? `W/"${result.etag.value}"` : `"${result.etag.value}"`;
+                            res.header('ETag', etagValue);
+                        }
+                        if (result.lastModified) {
+                            res.header('Last-Modified', new Date(result.lastModified).toUTCString());
+                        }
+                        if (result.cacheControl) {
+                            const directives = result.cacheControl.directives.join(', ');
+                            const maxAge = result.cacheControl.maxAge ? `, max-age=${result.cacheControl.maxAge}` : '';
+                            res.header('Cache-Control', directives + maxAge);
+                        }
+                        ctx.logger.debug('Meta item returned with cache headers', {
+                            type: req.params.type,
+                            name: req.params.name,
+                            etag: result.etag?.value
+                        });
+                        res.json(result.data);
+                    }
+                }
+                catch (e) {
+                    ctx.logger.warn('Meta item not found', { type: req.params.type, name: req.params.name });
                     res.status(404).json({ error: e.message });
                 }
             });
+            // View Storage Routes
+            this.server.post('/api/v1/ui/views', async (req, res) => {
+                ctx.logger.debug('Create view request', { name: req.body?.name, object: req.body?.object });
+                try {
+                    const result = await p.createView(req.body);
+                    if (result.success) {
+                        ctx.logger.info('View created', { id: result.data?.id, name: result.data?.name });
+                        res.status(201).json(result);
+                    }
+                    else {
+                        ctx.logger.warn('View creation failed', { error: result.error });
+                        res.status(400).json(result);
+                    }
+                }
+                catch (e) {
+                    ctx.logger.error('View creation error', e);
+                    res.status(500).json({ success: false, error: { code: 'internal_error', message: e.message } });
+                }
+            });
+            this.server.get('/api/v1/ui/views/:id', async (req, res) => {
+                ctx.logger.debug('Get view request', { id: req.params.id });
+                try {
+                    const result = await p.getView({ id: req.params.id });
+                    if (result.success) {
+                        ctx.logger.debug('View retrieved', { id: req.params.id });
+                        res.json(result);
+                    }
+                    else {
+                        ctx.logger.warn('View not found', { id: req.params.id });
+                        res.status(404).json(result);
+                    }
+                }
+                catch (e) {
+                    ctx.logger.error('Get view error', e, { id: req.params.id });
+                    res.status(500).json({ success: false, error: { code: 'internal_error', message: e.message } });
+                }
+            });
+            this.server.get('/api/v1/ui/views', async (req, res) => {
+                ctx.logger.debug('List views request', { query: req.query });
+                try {
+                    const request = {};
+                    if (req.query.object)
+                        request.object = req.query.object;
+                    if (req.query.type)
+                        request.type = req.query.type;
+                    if (req.query.visibility)
+                        request.visibility = req.query.visibility;
+                    if (req.query.createdBy)
+                        request.createdBy = req.query.createdBy;
+                    if (req.query.isDefault !== undefined)
+                        request.isDefault = req.query.isDefault === 'true';
+                    if (req.query.limit)
+                        request.limit = parseInt(req.query.limit);
+                    if (req.query.offset)
+                        request.offset = parseInt(req.query.offset);
+                    const result = await p.listViews(request);
+                    ctx.logger.debug('Views listed', { count: result.data?.length, total: result.pagination?.total });
+                    res.json(result);
+                }
+                catch (e) {
+                    ctx.logger.error('List views error', e);
+                    res.status(500).json({ success: false, error: { code: 'internal_error', message: e.message } });
+                }
+            });
+            this.server.patch('/api/v1/ui/views/:id', async (req, res) => {
+                ctx.logger.debug('Update view request', { id: req.params.id });
+                try {
+                    const result = await p.updateView({ ...req.body, id: req.params.id });
+                    if (result.success) {
+                        ctx.logger.info('View updated', { id: req.params.id });
+                        res.json(result);
+                    }
+                    else {
+                        ctx.logger.warn('View update failed', { id: req.params.id, error: result.error });
+                        res.status(result.error?.code === 'resource_not_found' ? 404 : 400).json(result);
+                    }
+                }
+                catch (e) {
+                    ctx.logger.error('Update view error', e, { id: req.params.id });
+                    res.status(500).json({ success: false, error: { code: 'internal_error', message: e.message } });
+                }
+            });
+            this.server.delete('/api/v1/ui/views/:id', async (req, res) => {
+                ctx.logger.debug('Delete view request', { id: req.params.id });
+                try {
+                    const result = await p.deleteView({ id: req.params.id });
+                    if (result.success) {
+                        ctx.logger.info('View deleted', { id: req.params.id });
+                        res.json(result);
+                    }
+                    else {
+                        ctx.logger.warn('View deletion failed', { id: req.params.id });
+                        res.status(404).json(result);
+                    }
+                }
+                catch (e) {
+                    ctx.logger.error('Delete view error', e, { id: req.params.id });
+                    res.status(500).json({ success: false, error: { code: 'internal_error', message: e.message } });
+                }
+            });
+            ctx.logger.info('All API routes registered');
         }
         // Start server on kernel:ready hook
         ctx.hook('kernel:ready', async () => {
             const port = this.options.port || 3000;
-            ctx.logger.log('[HonoServerPlugin] Starting server...');
+            ctx.logger.info('Starting HTTP server', { port });
             await this.server.listen(port);
-            ctx.logger.log(`✅ Server is running on http://localhost:${port}`);
+            ctx.logger.info('HTTP server started successfully', {
+                port,
+                url: `http://localhost:${port}`
+            });
         });
     }
     /**
@@ -122,6 +374,7 @@ class HonoServerPlugin {
      */
     async destroy() {
         this.server.close();
+        // Note: Can't use ctx.logger here since we're in destroy
         console.log('[HonoServerPlugin] Server stopped');
     }
 }

package/objectstack.config.ts

@@ -0,0 +1,238 @@
+import { ObjectStackManifest } from '@objectstack/spec/system';
+
+/**
+ * Hono Server Plugin Manifest
+ * 
+ * HTTP server adapter plugin using the Hono framework.
+ * Provides northbound HTTP/REST API gateway capabilities.
+ */
+const HonoServerPlugin: ObjectStackManifest = {
+  id: 'com.objectstack.server.hono',
+  name: 'Hono Server Adapter',
+  version: '1.0.0',
+  type: 'adapter',
+  description: 'HTTP server adapter using Hono framework. Exposes ObjectStack Runtime Protocol via REST API endpoints.',
+  
+  configuration: {
+    title: 'Hono Server Configuration',
+    properties: {
+      port: {
+        type: 'number',
+        default: 3000,
+        description: 'HTTP server port',
+      },
+      staticRoot: {
+        type: 'string',
+        description: 'Path to static files directory (optional)',
+      },
+    },
+  },
+
+  // Plugin Capability Declaration
+  capabilities: {
+    // Protocols This Plugin Implements
+    implements: [
+      {
+        protocol: {
+          id: 'com.objectstack.protocol.http.v1',
+          label: 'HTTP Server Protocol v1',
+          version: { major: 1, minor: 0, patch: 0 },
+          description: 'Standard HTTP server capabilities',
+        },
+        conformance: 'full',
+        certified: false,
+      },
+      {
+        protocol: {
+          id: 'com.objectstack.protocol.api.rest.v1',
+          label: 'REST API Protocol v1',
+          version: { major: 1, minor: 0, patch: 0 },
+          description: 'RESTful API endpoint implementation',
+        },
+        conformance: 'full',
+        features: [
+          {
+            name: 'meta_protocol',
+            enabled: true,
+            description: 'Metadata discovery endpoints',
+          },
+          {
+            name: 'data_protocol',
+            enabled: true,
+            description: 'CRUD data operations',
+          },
+          {
+            name: 'ui_protocol',
+            enabled: true,
+            description: 'UI view metadata endpoints',
+          },
+        ],
+        certified: false,
+      },
+    ],
+
+    // Interfaces This Plugin Provides
+    provides: [
+      {
+        id: 'com.objectstack.server.hono.interface.http_server',
+        name: 'IHttpServer',
+        description: 'HTTP server service interface',
+        version: { major: 1, minor: 0, patch: 0 },
+        stability: 'stable',
+        methods: [
+          {
+            name: 'get',
+            description: 'Register GET route handler',
+            parameters: [
+              {
+                name: 'path',
+                type: 'string',
+                required: true,
+                description: 'Route path pattern',
+              },
+              {
+                name: 'handler',
+                type: 'Function',
+                required: true,
+                description: 'Route handler function',
+              },
+            ],
+            returnType: 'void',
+            async: false,
+          },
+          {
+            name: 'post',
+            description: 'Register POST route handler',
+            parameters: [
+              {
+                name: 'path',
+                type: 'string',
+                required: true,
+                description: 'Route path pattern',
+              },
+              {
+                name: 'handler',
+                type: 'Function',
+                required: true,
+                description: 'Route handler function',
+              },
+            ],
+            returnType: 'void',
+            async: false,
+          },
+          {
+            name: 'patch',
+            description: 'Register PATCH route handler',
+            parameters: [
+              {
+                name: 'path',
+                type: 'string',
+                required: true,
+                description: 'Route path pattern',
+              },
+              {
+                name: 'handler',
+                type: 'Function',
+                required: true,
+                description: 'Route handler function',
+              },
+            ],
+            returnType: 'void',
+            async: false,
+          },
+          {
+            name: 'delete',
+            description: 'Register DELETE route handler',
+            parameters: [
+              {
+                name: 'path',
+                type: 'string',
+                required: true,
+                description: 'Route path pattern',
+              },
+              {
+                name: 'handler',
+                type: 'Function',
+                required: true,
+                description: 'Route handler function',
+              },
+            ],
+            returnType: 'void',
+            async: false,
+          },
+          {
+            name: 'listen',
+            description: 'Start the HTTP server',
+            parameters: [
+              {
+                name: 'port',
+                type: 'number',
+                required: true,
+                description: 'Port number',
+              },
+            ],
+            returnType: 'Promise<void>',
+            async: true,
+          },
+          {
+            name: 'close',
+            description: 'Stop the HTTP server',
+            parameters: [],
+            returnType: 'void',
+            async: false,
+          },
+        ],
+      },
+    ],
+
+    // Dependencies on Other Plugins/Services
+    requires: [
+      {
+        pluginId: 'com.objectstack.engine.objectql',
+        version: '^0.6.0',
+        optional: true,
+        reason: 'ObjectStack Runtime Protocol implementation service',
+        requiredCapabilities: [
+          'com.objectstack.protocol.runtime.v1',
+        ],
+      },
+    ],
+
+    // Extension Points This Plugin Defines
+    extensionPoints: [
+      {
+        id: 'com.objectstack.server.hono.extension.middleware',
+        name: 'HTTP Middleware',
+        description: 'Register custom HTTP middleware',
+        type: 'hook',
+        cardinality: 'multiple',
+        contract: {
+          signature: '(req: Request, res: Response, next: Function) => void | Promise<void>',
+        },
+      },
+      {
+        id: 'com.objectstack.server.hono.extension.route',
+        name: 'Custom Routes',
+        description: 'Register custom API routes',
+        type: 'action',
+        cardinality: 'multiple',
+        contract: {
+          input: 'RouteDefinition',
+          signature: '(app: HonoApp) => void',
+        },
+      },
+    ],
+
+    // No extensions contributed to other plugins
+    extensions: [],
+  },
+
+  contributes: {
+    // System Events
+    events: [
+      'kernel:ready',
+    ],
+  },
+};
+
+export default HonoServerPlugin;

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@objectstack/plugin-hono-server",
-  "version": "0.6.1",
+  "version": "0.7.1",
   "description": "Standard Hono Server Adapter for ObjectStack Runtime",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "dependencies": {
     "@hono/node-server": "^1.2.0",
     "hono": "^4.0.0",
-    "@objectstack/core": "0.6.1",
-    "@objectstack/spec": "0.6.1",
-    "@objectstack/types": "0.6.1"
+    "@objectstack/core": "0.7.1",
+    "@objectstack/spec": "0.7.1",
+    "@objectstack/types": "0.7.1"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",

package/src/adapter.ts

@@ -27,19 +27,33 @@ export class HonoHttpServer implements IHttpServer {
     // internal helper to convert standard handler to Hono handler
     private wrap(handler: RouteHandler) {
         return async (c: any) => {
+            let body: any = {};
+            
+            // Try to parse JSON body first if content-type is JSON
+            if (c.req.header('content-type')?.includes('application/json')) {
+                try { 
+                    body = await c.req.json(); 
+                } catch(e) {
+                    // If JSON parsing fails, try parseBody
+                    try { 
+                        body = await c.req.parseBody(); 
+                    } catch(e2) {}
+                }
+            } else {
+                // For non-JSON content types, use parseBody
+                try { 
+                    body = await c.req.parseBody(); 
+                } catch(e) {}
+            }
+            
             const req = {
                 params: c.req.param(),
                 query: c.req.query(),
-                body: await c.req.parseBody().catch(() => {}), // fallback
+                body,
                 headers: c.req.header(),
                 method: c.req.method,
                 path: c.req.path
             };
-            
-            // Try to parse JSON body if possible
-            if (c.req.header('content-type')?.includes('application/json')) {
-                try { req.body = await c.req.json(); } catch(e) {}
-            }
 
             let capturedResponse: any;