feat: enhance metadata handling in Hono, NestJS, and NextJS adapters to support PUT and POST requests with body parsing

Author: hotlong

packages/adapters/hono/src/index.ts

@@ -76,7 +76,20 @@ export function createHonoApp(options: ObjectStackHonoOptions) {
   app.all(`${prefix}/metadata*`, async (c) => {
     try {
       const path = c.req.path.substring(c.req.path.indexOf('/metadata') + 9);
-      const result = await dispatcher.handleMetadata(path, { request: c.req.raw });
+      const method = c.req.method;
+      let body = undefined;
+      
+      if (method === 'PUT' || method === 'POST') {
+          // Attempt to parse JSON body
+          try {
+            body = await c.req.json();
+          } catch (e) {
+            // Ignore parse errors, body remains undefined or empty
+            body = {};
+          }
+      }
+
+      const result = await dispatcher.handleMetadata(path, { request: c.req.raw }, method, body);
       return normalizeResponse(c, result);
     } catch (err: any) {
       return c.json({ success: false, error: { message: err.message, code: err.statusCode || 500 } }, err.statusCode || 500);

packages/adapters/nestjs/src/index.ts

@@ -114,14 +114,18 @@ export class ObjectStackController {
 
   // Metadata
   @All('metadata*')
-  async metadata(@Req() req: any, @Res() res: any) {
+  async metadata(@Req() req: any, @Res() res: any, @Body() body?: any) {
       try {
           // /api/metadata/objects -> objects
           let path = req.params[0] || ''; 
           if (req.url.includes('/metadata')) {
              path = req.url.split('/metadata')[1].split('?')[0];
           }
-          const result = await this.service.dispatcher.handleMetadata(path, { request: req });
+          
+          // Use injected body or fallback to req.body
+          const payload = body || req.body;
+          
+          const result = await this.service.dispatcher.handleMetadata(path, { request: req }, req.method, payload);
           return this.normalizeResponse(result, res);
       } catch (err) {
           return this.handleError(err, res);

packages/adapters/nextjs/src/index.ts

@@ -75,7 +75,13 @@ export function createRouteHandler(options: NextAdapterOptions) {
         // --- 3. Metadata ---
         if (segments[0] === 'metadata') {
             const subPath = segments.slice(1).join('/');
-            const result = await dispatcher.handleMetadata(subPath, { request: rawRequest });
+            
+            let body: any = undefined;
+            if (method === 'PUT' || method === 'POST') {
+                body = await req.json().catch(() => ({}));
+            }
+
+            const result = await dispatcher.handleMetadata(subPath, { request: rawRequest }, method, body);
             return toResponse(result);
         }
 

packages/runtime/src/http-dispatcher.ts

@@ -131,7 +131,7 @@ export class HttpDispatcher {
      * Standard: /metadata/:type/:name
      * Fallback for backward compat: /metadata (all objects), /metadata/:objectName (get object)
      */
-    async handleMetadata(path: string, context: HttpProtocolContext): Promise<HttpDispatcherResult> {
+    async handleMetadata(path: string, context: HttpProtocolContext, method?: string, body?: any): Promise<HttpDispatcherResult> {
         const broker = this.ensureBroker();
         const parts = path.replace(/^\/+/, '').split('/').filter(Boolean);
 
@@ -142,9 +142,34 @@ export class HttpDispatcher {
             return { handled: true, response: this.success({ types: ['objects', 'apps', 'plugins'] }) };
         }
 
-        // GET /metadata/:type/:name
+        // /metadata/:type/:name
         if (parts.length === 2) {
             const [type, name] = parts;
+
+            // PUT /metadata/:type/:name (Save)
+            if (method === 'PUT' && body) {
+                // Try to get the protocol service directly
+                const protocol = this.kernel?.context?.getService ? this.kernel.context.getService('protocol') : null;
+                
+                if (protocol && typeof protocol.saveMetaItem === 'function') {
+                    try {
+                        const result = await protocol.saveMetaItem({ type, name, item: body });
+                        return { handled: true, response: this.success(result) };
+                    } catch (e: any) {
+                        return { handled: true, response: this.error(e.message, 400) };
+                    }
+                }
+                
+                // Fallback to broker if protocol not available (legacy)
+                try {
+                     const data = await broker.call('metadata.saveItem', { type, name, item: body }, { request: context.request });
+                     return { handled: true, response: this.success(data) };
+                } catch (e: any) {
+                     // If broker doesn't support it either
+                     return { handled: true, response: this.error(e.message || 'Save not supported', 501) };
+                }
+            }
+
             try {
                 // Try specific calls based on type
                 if (type === 'objects') {