feat: add logging for intercepted requests in MSWPlugin and implement root path handling in HttpDispatcher

Author: hotlong

packages/plugins/plugin-msw/src/msw-plugin.ts

@@ -240,6 +240,11 @@ export class MSWPlugin implements Plugin {
                     path = path.slice(baseUrl.length);
                 }
 
+                if (this.options.logRequests) {
+                    // eslint-disable-next-line no-console
+                    console.log(`[MSW] Intercepted: ${request.method} ${url.pathname}`, { path });
+                }
+                
                 // Parse Body if present
                 let body: any = undefined;
                 if (request.method !== 'GET' && request.method !== 'HEAD') {

packages/runtime/src/http-dispatcher.root.test.ts

@@ -0,0 +1,58 @@
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { HttpDispatcher } from './http-dispatcher';
+import { ObjectKernel } from '@objectstack/core';
+
+describe('HttpDispatcher Root Handling', () => {
+    let kernel: ObjectKernel;
+    let dispatcher: HttpDispatcher;
+
+    beforeEach(() => {
+        // Mock minimal Kernel structure
+        kernel = {
+            services: {},
+            broker: {
+                call: vi.fn(),
+            },
+            context: {
+                getService: vi.fn(),
+            }
+        } as any;
+
+        dispatcher = new HttpDispatcher(kernel);
+    });
+
+    it('should handled GET request to root path ("") correctly', async () => {
+        const context = { request: {} };
+        const method = 'GET';
+        // MSW passes empty string when stripping base URL
+        const path = ''; 
+        const body = undefined;
+        const query = {};
+
+        const result = await dispatcher.dispatch(method, path, body, query, context);
+
+        expect(result.handled).toBe(true);
+        expect(result.response).toBeDefined();
+        expect(result.response?.status).toBe(200);
+        
+        const data = result.response?.body?.data;
+        expect(data).toBeDefined();
+        // getDiscoveryInfo returns 'name' not 'apiName'
+        expect(data.name).toBe('ObjectOS');
+        expect(data.version).toBe('1.0.0');
+        expect(data.routes).toBeDefined();
+        // Since we passed empty prefix in dispatch code (hardcoded), routes should be relative
+        expect(data.routes.metadata).toBe('/meta');
+    });
+
+    it('should NOT handle POST request to root path ("")', async () => {
+        const context = { request: {} };
+        const method = 'POST';
+        const path = '';
+        
+        const result = await dispatcher.dispatch(method, path, {}, {}, context);
+
+        expect(result.handled).toBe(false);
+    });
+});

packages/runtime/src/http-dispatcher.ts

@@ -173,12 +173,30 @@ export class HttpDispatcher {
 
             try {
                 // Try specific calls based on type
-                if (type === 'objects') {
+                if (type === 'objects' || type === 'object') {
                     const data = await broker.call('metadata.getObject', { objectName: name }, { request: context.request });
                     return { handled: true, response: this.success(data) };
                 }
-                // Generic call for other types if supported
-                const data = await broker.call(`metadata.get${this.capitalize(type.slice(0, -1))}`, { name }, { request: context.request });
+
+                // If type is singular (e.g. 'app'), use it directly
+                // If plural (e.g. 'apps'), slice it
+                const singularType = type.endsWith('s') ? type.slice(0, -1) : type;
+                
+                // Try Protocol Service First (Preferred)
+                const protocol = this.kernel?.context?.getService ? this.kernel.context.getService('protocol') : null;
+                if (protocol && typeof protocol.getMetaItem === 'function') {
+                     try {
+                        const data = await protocol.getMetaItem({ type: singularType, name });
+                        return { handled: true, response: this.success(data) };
+                     } catch (e: any) {
+                        // Protocol might throw if not found or not supported
+                        // Fallback to broker?
+                     }
+                }
+
+                // Generic call for other types if supported via Broker (Legacy)
+                const method = `metadata.get${this.capitalize(singularType)}`;
+                const data = await broker.call(method, { name }, { request: context.request });
                 return { handled: true, response: this.success(data) };
             } catch (e: any) {
                 // Fallback: treat first part as object name if only 1 part (handled below)
@@ -537,6 +555,17 @@ export class HttpDispatcher {
     async dispatch(method: string, path: string, body: any, query: any, context: HttpProtocolContext): Promise<HttpDispatcherResult> {
         const cleanPath = path.replace(/\/$/, ''); // Remove trailing slash if present, but strict on clean paths
 
+        // 0. Root Discovery Endpoint (GET /)
+        // Handles request to base URL (e.g. /api/v1) which MSW strips to empty string
+        if (cleanPath === '' && method === 'GET') {
+             // We use '' as prefix since we are internal dispatcher
+             const info = this.getDiscoveryInfo('');
+             return { 
+                 handled: true, 
+                 response: this.success(info) 
+             };
+        }
+
         // 1. System Protocols (Prefix-based)
         if (cleanPath.startsWith('/auth')) {
             return this.handleAuth(cleanPath.substring(5), method, body, context);