@objectstack/runtime 1.0.0 → 1.0.1

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @objectstack/runtime
 
+## 1.0.1
+
+### Patch Changes
+
+- Fix TypeScript error in http-dispatcher tests to resolve CI build failures.
+  - @objectstack/spec@1.0.1
+  - @objectstack/core@1.0.1
+  - @objectstack/types@1.0.1
+
 ## 1.0.0
 
 ### Major Changes

package/dist/http-dispatcher.d.ts

@@ -65,7 +65,7 @@ export declare class HttpDispatcher {
      * Standard: /metadata/:type/:name
      * Fallback for backward compat: /metadata (all objects), /metadata/:objectName (get object)
      */
-    handleMetadata(path: string, context: HttpProtocolContext): Promise<HttpDispatcherResult>;
+    handleMetadata(path: string, context: HttpProtocolContext, method?: string, body?: any): Promise<HttpDispatcherResult>;
     /**
      * Handles Data requests
      * path: sub-path after /data/ (e.g. "contacts", "contacts/123", "contacts/query")

package/dist/http-dispatcher.js

@@ -99,7 +99,7 @@ export class HttpDispatcher {
      * Standard: /metadata/:type/:name
      * Fallback for backward compat: /metadata (all objects), /metadata/:objectName (get object)
      */
-    async handleMetadata(path, context) {
+    async handleMetadata(path, context, method, body) {
         const broker = this.ensureBroker();
         const parts = path.replace(/^\/+/, '').split('/').filter(Boolean);
         // GET /metadata/types
@@ -108,9 +108,32 @@ export class HttpDispatcher {
             // For now we mock the types supported by core
             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) {
+                        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) {
+                    // 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') {

package/dist/http-dispatcher.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/http-dispatcher.test.js

@@ -0,0 +1,79 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { HttpDispatcher } from './http-dispatcher.js';
+describe('HttpDispatcher', () => {
+    let kernel;
+    let dispatcher;
+    let mockProtocol;
+    let mockBroker;
+    beforeEach(() => {
+        // Mock Kernel
+        mockProtocol = {
+            saveMetaItem: vi.fn().mockResolvedValue({ success: true, message: 'Saved' }),
+            getMetaItem: vi.fn().mockResolvedValue({ success: true, item: { foo: 'bar' } })
+        };
+        mockBroker = {
+            call: vi.fn(),
+        };
+        kernel = {
+            broker: mockBroker,
+            context: {
+                getService: (name) => {
+                    if (name === 'protocol')
+                        return mockProtocol;
+                    return null;
+                }
+            }
+        };
+        dispatcher = new HttpDispatcher(kernel);
+    });
+    describe('handleMetadata', () => {
+        it('should handle PUT /metadata/:type/:name by calling protocol.saveMetaItem', async () => {
+            const context = { request: {} };
+            const body = { label: 'New Label' };
+            const path = '/objects/my_obj';
+            const result = await dispatcher.handleMetadata(path, context, 'PUT', body);
+            expect(result.handled).toBe(true);
+            expect(result.response?.status).toBe(200);
+            expect(mockProtocol.saveMetaItem).toHaveBeenCalledWith({
+                type: 'objects',
+                name: 'my_obj',
+                item: body
+            });
+            expect(result.response?.body).toEqual({
+                success: true,
+                data: { success: true, message: 'Saved' },
+                meta: undefined
+            });
+        });
+        it('should fallback to broker call if protocol is missing saveMetaItem', async () => {
+            // Mock protocol without saveMetaItem
+            kernel.context.getService = () => ({});
+            // Mock broker success
+            mockBroker.call.mockResolvedValue({ success: true, fromBroker: true });
+            const context = { request: {} };
+            const body = { label: 'Fallback' };
+            const path = '/objects/my_obj';
+            const result = await dispatcher.handleMetadata(path, context, 'PUT', body);
+            expect(result.handled).toBe(true);
+            expect(mockBroker.call).toHaveBeenCalledWith('metadata.saveItem', { type: 'objects', name: 'my_obj', item: body }, { request: context.request });
+            expect(result.response?.body?.data).toEqual({ success: true, fromBroker: true });
+        });
+        it('should return error if save fails', async () => {
+            mockProtocol.saveMetaItem.mockRejectedValue(new Error('Save failed'));
+            const context = { request: {} };
+            const body = {};
+            const path = '/objects/bad_obj';
+            const result = await dispatcher.handleMetadata(path, context, 'PUT', body);
+            expect(result.handled).toBe(true);
+            expect(result.response?.status).toBe(400);
+            expect(result.response?.body?.error?.message).toBe('Save failed');
+        });
+        it('should handle READ operations as before', async () => {
+            mockBroker.call.mockResolvedValue({ name: 'my_obj' });
+            const context = { request: {} };
+            const result = await dispatcher.handleMetadata('/objects/my_obj', context, 'GET');
+            expect(result.handled).toBe(true);
+            expect(mockBroker.call).toHaveBeenCalledWith('metadata.getObject', { objectName: 'my_obj' }, { request: context.request });
+        });
+    });
+});

package/dist/rest-server.js

@@ -250,6 +250,34 @@ export class RestServer {
                 },
             });
         }
+        // PUT /meta/:type/:name - Save metadata item
+        // We always register this route, but return 501 if protocol doesn't support it
+        // This makes it discoverable even if not implemented
+        this.routeManager.register({
+            method: 'PUT',
+            path: `${metaPath}/:type/:name`,
+            handler: async (req, res) => {
+                try {
+                    if (!this.protocol.saveMetaItem) {
+                        res.status(501).json({ error: 'Save operation not supported by protocol implementation' });
+                        return;
+                    }
+                    const result = await this.protocol.saveMetaItem({
+                        type: req.params.type,
+                        name: req.params.name,
+                        item: req.body
+                    });
+                    res.json(result);
+                }
+                catch (error) {
+                    res.status(400).json({ error: error.message });
+                }
+            },
+            metadata: {
+                summary: 'Save specific metadata item',
+                tags: ['metadata'],
+            },
+        });
     }
     /**
      * Register CRUD endpoints for data operations

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@objectstack/runtime",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "license": "Apache-2.0",
   "description": "ObjectStack Core Runtime & Query Engine",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "dependencies": {
-    "@objectstack/core": "1.0.0",
-    "@objectstack/spec": "1.0.0",
-    "@objectstack/types": "1.0.0"
+    "@objectstack/core": "1.0.1",
+    "@objectstack/spec": "1.0.1",
+    "@objectstack/types": "1.0.1"
   },
   "devDependencies": {
     "typescript": "^5.0.0",

package/src/http-dispatcher.test.ts

@@ -0,0 +1,107 @@
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { HttpDispatcher } from './http-dispatcher.js';
+import { ObjectKernel } from '@objectstack/core';
+
+describe('HttpDispatcher', () => {
+    let kernel: ObjectKernel;
+    let dispatcher: HttpDispatcher;
+    let mockProtocol: any;
+    let mockBroker: any;
+
+    beforeEach(() => {
+        // Mock Kernel
+        mockProtocol = {
+            saveMetaItem: vi.fn().mockResolvedValue({ success: true, message: 'Saved' }),
+            getMetaItem: vi.fn().mockResolvedValue({ success: true, item: { foo: 'bar' } })
+        };
+        
+        mockBroker = {
+            call: vi.fn(),
+        };
+
+        kernel = {
+            broker: mockBroker,
+            context: {
+                getService: (name: string) => {
+                    if (name === 'protocol') return mockProtocol;
+                    return null;
+                }
+            }
+        } as any;
+
+        dispatcher = new HttpDispatcher(kernel);
+    });
+
+    describe('handleMetadata', () => {
+        it('should handle PUT /metadata/:type/:name by calling protocol.saveMetaItem', async () => {
+            const context = { request: {} };
+            const body = { label: 'New Label' };
+            const path = '/objects/my_obj';
+
+            const result = await dispatcher.handleMetadata(path, context, 'PUT', body);
+
+            expect(result.handled).toBe(true);
+            expect(result.response?.status).toBe(200);
+            expect(mockProtocol.saveMetaItem).toHaveBeenCalledWith({
+                type: 'objects',
+                name: 'my_obj',
+                item: body
+            });
+            expect(result.response?.body).toEqual({
+                success: true,
+                data: { success: true, message: 'Saved' },
+                meta: undefined
+            });
+        });
+
+        it('should fallback to broker call if protocol is missing saveMetaItem', async () => {
+             // Mock protocol without saveMetaItem
+            (kernel as any).context.getService = () => ({}); 
+            // Mock broker success
+            mockBroker.call.mockResolvedValue({ success: true, fromBroker: true });
+
+            const context = { request: {} };
+            const body = { label: 'Fallback' };
+            const path = '/objects/my_obj';
+
+            const result = await dispatcher.handleMetadata(path, context, 'PUT', body);
+
+            expect(result.handled).toBe(true);
+            expect(mockBroker.call).toHaveBeenCalledWith(
+                'metadata.saveItem',
+                { type: 'objects', name: 'my_obj', item: body },
+                { request: context.request }
+            );
+            expect(result.response?.body?.data).toEqual({ success: true, fromBroker: true });
+        });
+
+        it('should return error if save fails', async () => {
+            mockProtocol.saveMetaItem.mockRejectedValue(new Error('Save failed'));
+
+            const context = { request: {} };
+            const body = {};
+            const path = '/objects/bad_obj';
+
+            const result = await dispatcher.handleMetadata(path, context, 'PUT', body);
+
+            expect(result.handled).toBe(true);
+            expect(result.response?.status).toBe(400);
+            expect(result.response?.body?.error?.message).toBe('Save failed');
+        });
+        
+        it('should handle READ operations as before', async () => {
+             mockBroker.call.mockResolvedValue({ name: 'my_obj' });
+             
+             const context = { request: {} };
+             const result = await dispatcher.handleMetadata('/objects/my_obj', context, 'GET');
+             
+             expect(result.handled).toBe(true);
+             expect(mockBroker.call).toHaveBeenCalledWith(
+                 'metadata.getObject', 
+                 { objectName: 'my_obj' }, 
+                 { request: context.request }
+             );
+        });
+    });
+});

package/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') {

package/src/rest-server.ts

@@ -333,6 +333,35 @@ export class RestServer {
                 },
             });
         }
+
+        // PUT /meta/:type/:name - Save metadata item
+        // We always register this route, but return 501 if protocol doesn't support it
+        // This makes it discoverable even if not implemented
+        this.routeManager.register({
+            method: 'PUT',
+            path: `${metaPath}/:type/:name`,
+            handler: async (req: any, res: any) => {
+                try {
+                    if (!this.protocol.saveMetaItem) {
+                        res.status(501).json({ error: 'Save operation not supported by protocol implementation' });
+                        return;
+                    }
+
+                    const result = await this.protocol.saveMetaItem({
+                        type: req.params.type,
+                        name: req.params.name,
+                        item: req.body
+                    });
+                    res.json(result);
+                } catch (error: any) {
+                    res.status(400).json({ error: error.message });
+                }
+            },
+            metadata: {
+                summary: 'Save specific metadata item',
+                tags: ['metadata'],
+            },
+        });
     }
     
     /**