@objectstack/plugin-msw 1.0.0 → 1.0.2

package/src/msw-plugin.ts

@@ -4,11 +4,12 @@ import {
     Plugin, 
     PluginContext, 
     ObjectKernel,
-    IDataEngine
+    HttpDispatcher,
+    HttpDispatcherResult
 } from '@objectstack/runtime';
 // import { ObjectStackProtocolImplementation } from '@objectstack/objectql';
 import { ObjectStackProtocol } from '@objectstack/spec/api';
-// import { IDataEngine } from '@objectstack/core';
+import { IDataEngine } from '@objectstack/core';
 
 // Helper for parsing query parameters
 function parseQueryParams(url: URL): Record<string, any> {
@@ -54,33 +55,6 @@ function parseQueryParams(url: URL): Record<string, any> {
     return params;
 }
 
-// Helper to normalize flat parameters into 'where' clause
-function normalizeQuery(params: Record<string, any>): Record<string, any> {
-    // If 'where' is already present, trust it
-    if (params.where) return params;
-
-    const reserved = ['select', 'order', 'orderBy', 'sort', 'limit', 'skip', 'offset', 'top', 'page', 'pageSize', 'count'];
-    const where: Record<string, any> = {};
-    let hasWhere = false;
-
-    for (const key in params) {
-        if (!reserved.includes(key)) {
-            where[key] = params[key];
-            hasWhere = true;
-        }
-    }
-
-    if (hasWhere) {
-        // Keep original params but add where. 
-        // This allows protocols that look at root properties to still work, 
-        // while providing 'where' for strict drivers.
-        return { ...params, where };
-    }
-    
-    return params;
-}
-
-
 export interface MSWPluginOptions {
     /**
      * Enable MSW in the browser environment
@@ -103,210 +77,9 @@ export interface MSWPluginOptions {
     logRequests?: boolean;
 }
 
-/**
- * ObjectStack Server Mock - Provides mock database functionality
- */
-export class ObjectStackServer {
-    private static protocol: ObjectStackProtocol | null = null;
-    private static logger: any | null = null;
-
-    static init(protocol: ObjectStackProtocol, logger?: any) {
-        this.protocol = protocol;
-        this.logger = logger || { 
-            info: console.log, 
-            debug: console.debug, 
-            warn: console.warn, 
-            error: console.error 
-        };
-    }
-
-    static async findData(object: string, params?: any) {
-        if (!this.protocol) {
-            throw new Error('ObjectStackServer not initialized. Call ObjectStackServer.init() first.');
-        }
-        
-        this.logger?.debug?.('MSW: Finding records', { object, params });
-        const result = await this.protocol.findData({ object, query: params || {} });
-        this.logger?.debug?.('MSW: Find completed', { object, count: result?.records?.length ?? 0 });
-        return {
-            status: 200,
-            data: result
-        };
-    }
-
-    static async getData(object: string, id: string) {
-        if (!this.protocol) {
-            throw new Error('ObjectStackServer not initialized. Call ObjectStackServer.init() first.');
-        }
-        
-        this.logger?.debug?.('MSW: Getting record', { object, id });
-        try {
-            const result = await this.protocol.getData({ object, id });
-            this.logger?.debug?.('MSW: Get completed', { object, id });
-            return {
-                status: 200,
-                data: result
-            };
-        } catch (error) {
-            this.logger?.warn?.('MSW: Get failed - not found', { object, id });
-            const message = error instanceof Error ? error.message : 'Unknown error';
-            return {
-                status: 404,
-                data: { error: message }
-            };
-        }
-    }
-
-    static async createData(object: string, data: any) {
-        if (!this.protocol) {
-            throw new Error('ObjectStackServer not initialized. Call ObjectStackServer.init() first.');
-        }
-        
-        this.logger?.debug?.('MSW: Creating record', { object });
-        try {
-            const result = await this.protocol.createData({ object, data });
-            this.logger?.info?.('MSW: Record created', { object, id: result?.id });
-            return {
-                status: 201,
-                data: result
-            };
-        } catch (error) {
-            this.logger?.error?.('MSW: Create failed', error, { object });
-            const message = error instanceof Error ? error.message : 'Unknown error';
-            return {
-                status: 400,
-                data: { error: message }
-            };
-        }
-    }
-
-    static async updateData(object: string, id: string, data: any) {
-        if (!this.protocol) {
-            throw new Error('ObjectStackServer not initialized. Call ObjectStackServer.init() first.');
-        }
-        
-        this.logger?.debug?.('MSW: Updating record', { object, id });
-        try {
-            const result = await this.protocol.updateData({ object, id, data });
-            this.logger?.info?.('MSW: Record updated', { object, id });
-            return {
-                status: 200,
-                data: result
-            };
-        } catch (error) {
-            this.logger?.error?.('MSW: Update failed', error, { object, id });
-            const message = error instanceof Error ? error.message : 'Unknown error';
-            return {
-                status: 400,
-                data: { error: message }
-            };
-        }
-    }
-
-    static async deleteData(object: string, id: string) {
-        if (!this.protocol) {
-            throw new Error('ObjectStackServer not initialized. Call ObjectStackServer.init() first.');
-        }
-        
-        this.logger?.debug?.('MSW: Deleting record', { object, id });
-        try {
-            const result = await this.protocol.deleteData({ object, id });
-            this.logger?.info?.('MSW: Record deleted', { object, id, success: result?.success });
-            return {
-                status: 200,
-                data: result
-            };
-        } catch (error) {
-            this.logger?.error?.('MSW: Delete failed', error, { object, id });
-            const message = error instanceof Error ? error.message : 'Unknown error';
-            return {
-                status: 400,
-                data: { error: message }
-            };
-        }
-    }
-
-    static async analyticsQuery(request: any) {
-        if (!this.protocol) {
-            throw new Error('ObjectStackServer not initialized. Call ObjectStackServer.init() first.');
-        }
-
-        this.logger?.debug?.('MSW: Executing analytics query', { request });
-        try {
-            const result = await this.protocol.analyticsQuery(request);
-            this.logger?.debug?.('MSW: Analytics query completed', { result });
-            return {
-                status: 200,
-                data: result
-            };
-        } catch (error) {
-            this.logger?.error?.('MSW: Analytics query failed', error);
-            const message = error instanceof Error ? error.message : 'Unknown error';
-            return {
-                status: 400,
-                data: { error: message }
-            };
-        }
-    }
-
-    static async getAnalyticsMeta(request: any) {
-        if (!this.protocol) {
-            throw new Error('ObjectStackServer not initialized. Call ObjectStackServer.init() first.');
-        }
-
-        this.logger?.debug?.('MSW: Getting analytics metadata', { request });
-        try {
-            const result = await this.protocol.getAnalyticsMeta(request);
-            this.logger?.debug?.('MSW: Analytics metadata retrieved', { result });
-            return {
-                status: 200,
-                data: result
-            };
-        } catch (error) {
-            this.logger?.error?.('MSW: Analytics metadata failed', error);
-            const message = error instanceof Error ? error.message : 'Unknown error';
-            return {
-                status: 400,
-                data: { error: message }
-            };
-        }
-    }
-
-    static async triggerAutomation(request: any) {
-        if (!this.protocol) {
-            throw new Error('ObjectStackServer not initialized. Call ObjectStackServer.init() first.');
-        }
-
-        this.logger?.debug?.('MSW: Triggering automation', { request });
-        try {
-            const result = await this.protocol.triggerAutomation(request);
-            this.logger?.info?.('MSW: Automation triggered', { result });
-            return {
-                status: 200,
-                data: result
-            };
-        } catch (error) {
-            this.logger?.error?.('MSW: Automation trigger failed', error);
-            const message = error instanceof Error ? error.message : 'Unknown error';
-            return {
-                status: 400,
-                data: { error: message }
-            };
-        }
-    }
-
-    // Legacy method names for compatibility
-    static async getUser(id: string) {
-        return this.getData('user', id);
-    }
-
-    static async createUser(data: any) {
-        return this.createData('user', data);
-    }
-}
-
 /**
  * MSW Plugin for ObjectStack
+
  * 
  * This plugin enables Mock Service Worker integration for testing and development.
  * It automatically mocks API endpoints using the ObjectStack runtime protocol.
@@ -331,6 +104,7 @@ export class MSWPlugin implements Plugin {
     private worker: any;
     private handlers: Array<any> = [];
     private protocol?: ObjectStackProtocol;
+    private dispatcher?: HttpDispatcher;
 
     constructor(options: MSWPluginOptions = {}) {
         this.options = {
@@ -411,299 +185,94 @@ export class MSWPlugin implements Plugin {
      * Setup MSW handlers
      */
     private setupHandlers(ctx: PluginContext) {
-        if (!this.protocol) {
-            ctx.logger.warn('[MSWPlugin] Protocol not initialized. Skipping default API handlers.');
-            this.handlers = [
-                ...(this.options.customHandlers || [])
-            ];
-            return;
+        // Initialize HttpDispatcher
+        try {
+            this.dispatcher = new HttpDispatcher(ctx.getKernel());
+        } catch (e) {
+            ctx.logger.warn('[MSWPlugin] Could not initialize HttpDispatcher via Kernel. Falling back to simple handlers.');
         }
 
-        const protocol = this.protocol;
-        
-        // Initialize ObjectStackServer with structured logger
-        ObjectStackServer.init(
-            protocol,
-            this.options.logRequests ? ctx.logger : undefined
-        );
-
-        ctx.logger.debug('Initialized ObjectStackServer', { logRequests: this.options.logRequests });
-
         const baseUrl = this.options.baseUrl || '/api/v1';
 
-        // Define standard ObjectStack API handlers
+        // Custom handlers have priority
         this.handlers = [
-            // Discovery endpoint
-            http.get(`${baseUrl}`, async () => {
-                const discovery = await protocol.getDiscovery({});
-                return HttpResponse.json({
-                    ...discovery,
-                    routes: {
-                        data: `${baseUrl}/data`,
-                        metadata: `${baseUrl}/meta`,
-                        ui: `${baseUrl}/ui`,
-                        auth: `${baseUrl}/auth`
-                    }
-                });
-            }),
-
-            // Meta endpoints
-            http.get(`${baseUrl}/meta`, async ({ request }) => {
-                const url = new URL(request.url);
-                const query = parseQueryParams(url);
-                return HttpResponse.json(await protocol.getMetaTypes({ query }));
-            }),
+            ...(this.options.customHandlers || [])
+        ];
 
-            http.get(`${baseUrl}/meta/:type`, async ({ params, request }) => {
+        if (this.dispatcher) {
+            const dispatcher = this.dispatcher;
+            
+            // Catch-all handler for ObjectStack Runtime
+            // We use a wildcard to capture all methods and paths under baseUrl
+            const catchAll = async ({ request, params }: any) => {
                 const url = new URL(request.url);
-                const query = parseQueryParams(url);
-                return HttpResponse.json(await protocol.getMetaItems({ type: params.type as string, query } as any));
-            }),
-
-            http.get(`${baseUrl}/meta/:type/:name`, async ({ params }) => {
-                try {
-                    return HttpResponse.json(
-                        await protocol.getMetaItem({ type: params.type as string, name: params.name as string } as any)
-                    );
-                } catch (error) {
-                    const message = error instanceof Error ? error.message : 'Unknown error';
-                    return HttpResponse.json({ error: message }, { status: 404 });
-                }
-            }),
-
-            // Data endpoints
-            http.get(`${baseUrl}/data/:object`, async ({ params, request }) => {
-                try {
-                    const url = new URL(request.url);
-                    
-                    // Use helper to parse properly (handle multiple values, JSON strings, numbers)
-                    const rawParams = parseQueryParams(url);
-                    
-                    // Normalize to standard query object (move flats to 'where')
-                    const queryParams = normalizeQuery(rawParams);
-                    
-                    const result = await ObjectStackServer.findData(
-                        params.object as string,
-                        queryParams
-                    );
-                    return HttpResponse.json(result.data, { 
-                        status: result.status,
-                        headers: { 'Cache-Control': 'no-store' }
-                    });
-                } catch (error) {
-                    const message = error instanceof Error ? error.message : 'Unknown error';
-                    return HttpResponse.json({ error: message }, { status: 404 });
-                }
-            }),
-
-            http.get(`${baseUrl}/data/:object/:id`, async ({ params }) => {
-                try {
-                    const result = await ObjectStackServer.getData(
-                        params.object as string,
-                        params.id as string
-                    );
-                    return HttpResponse.json(result.data, { 
-                        status: result.status,
-                        headers: { 'Cache-Control': 'no-store' }
-                    });
-                } catch (error) {
-                    const message = error instanceof Error ? error.message : 'Unknown error';
-                    return HttpResponse.json({ error: message }, { status: 404 });
-                }
-            }),
-
-            http.post(`${baseUrl}/data/:object`, async ({ params, request }) => {
-                try {
-                    const body = await request.json();
-                    const result = await ObjectStackServer.createData(
-                        params.object as string,
-                        body
-                    );
-                    return HttpResponse.json(result.data, { status: result.status });
-                } catch (error) {
-                    const message = error instanceof Error ? error.message : 'Unknown error';
-                    return HttpResponse.json({ error: message }, { status: 400 });
-                }
-            }),
-
-            http.patch(`${baseUrl}/data/:object/:id`, async ({ params, request }) => {
-                try {
-                    const body = await request.json();
-                    const result = await ObjectStackServer.updateData(
-                        params.object as string,
-                        params.id as string,
-                        body
-                    );
-                    return HttpResponse.json(result.data, { status: result.status });
-                } catch (error) {
-                    const message = error instanceof Error ? error.message : 'Unknown error';
-                    return HttpResponse.json({ error: message }, { status: 400 });
-                }
-            }),
-
-            http.delete(`${baseUrl}/data/:object/:id`, async ({ params }) => {
-                try {
-                    const result = await ObjectStackServer.deleteData(
-                        params.object as string,
-                        params.id as string
-                    );
-                    return HttpResponse.json(result.data, { status: result.status });
-                } catch (error) {
-                    const message = error instanceof Error ? error.message : 'Unknown error';
-                    return HttpResponse.json({ error: message }, { status: 400 });
+                // Calculate path relative to API prefix
+                // e.g. /api/v1/data/contacts -> /data/contacts
+                let path = url.pathname;
+                if (path.startsWith(baseUrl)) {
+                    path = path.slice(baseUrl.length);
                 }
-            }),
-
-            // Batch Operations
-            http.post(`${baseUrl}/data/:object/batch`, async ({ params, request }) => {
-                try {
-                    const body = await request.json();
-                    const result = await protocol.batchData({ object: params.object as string, request: body as any });
-                    return HttpResponse.json(result);
-                } catch (error) {
-                    const message = error instanceof Error ? error.message : 'Unknown error';
-                    return HttpResponse.json({ error: message }, { status: 400 });
-                }
-            }),
-
-            http.post(`${baseUrl}/data/:object/createMany`, async ({ params, request }) => {
-                try {
-                    const body = await request.json();
-                    const records = Array.isArray(body) ? body : [];
-                    const result = await protocol.createManyData({ object: params.object as string, records });
-                    return HttpResponse.json(result, { status: 201 });
-                } catch (error) {
-                    const message = error instanceof Error ? error.message : 'Unknown error';
-                    return HttpResponse.json({ error: message }, { status: 400 });
-                }
-            }),
-
-            http.post(`${baseUrl}/data/:object/updateMany`, async ({ params, request }) => {
-                try {
-                    const body = await request.json() as any;
-                    const result = await protocol.updateManyData({ 
-                        object: params.object as string, 
-                        records: body?.records || [], 
-                        options: body?.options 
-                    });
-                    return HttpResponse.json(result);
-                } catch (error) {
-                    const message = error instanceof Error ? error.message : 'Unknown error';
-                    return HttpResponse.json({ error: message }, { status: 400 });
-                }
-            }),
-
-            http.post(`${baseUrl}/data/:object/deleteMany`, async ({ params, request }) => {
-                try {
-                    const body = await request.json() as any;
-                    const result = await protocol.deleteManyData({ 
-                        object: params.object as string, 
-                        ids: body?.ids || [], 
-                        options: body?.options 
-                    });
-                    return HttpResponse.json(result);
-                } catch (error) {
-                    const message = error instanceof Error ? error.message : 'Unknown error';
-                    return HttpResponse.json({ error: message }, { status: 400 });
+                
+                // Parse Body if present
+                let body: any = undefined;
+                if (request.method !== 'GET' && request.method !== 'HEAD') {
+                    try {
+                        body = await request.clone().json();
+                    } catch (e) {
+                        try {
+                            // Try form data if json fails? 
+                            // Dispatcher expects objects usually.
+                            // For file upload, body might be FormData logic needed?
+                            // For now assume JSON or text
+                        } catch (e2) {}
+                    }
                 }
-            }),
 
-            // Enhanced Metadata with Cache Support
-            http.get(`${baseUrl}/meta/:type/:name`, async ({ params, request }) => {
-                try {
-                    const cacheRequest = {
-                        ifNoneMatch: request.headers.get('if-none-match') || undefined,
-                        ifModifiedSince: request.headers.get('if-modified-since') || undefined,
-                    };
-                    
-                    const result = await protocol.getMetaItemCached({ 
-                        type: params.type as string, 
-                        name: params.name as string, 
-                        cacheRequest 
-                    } as any);
-                    
-                    if (result.notModified) {
-                        return new HttpResponse(null, { status: 304 });
-                    }
-                    
-                    // Build response headers
-                    const headers: Record<string, string> = {};
-                    if (result.etag) {
-                        const etagValue = result.etag.weak ? `W/"${result.etag.value}"` : `"${result.etag.value}"`;
-                        headers['ETag'] = etagValue;
-                    }
-                    if (result.lastModified) {
-                        headers['Last-Modified'] = new Date(result.lastModified).toUTCString();
+                // Parse Query
+                const query = parseQueryParams(url);
+                
+                // Dispatch
+                const result = await dispatcher.dispatch(
+                    request.method, 
+                    path, 
+                    body, 
+                    query, 
+                    { request }
+                );
+
+                if (result.handled) {
+                    if (result.response) {
+                        return HttpResponse.json(result.response.body, { 
+                            status: result.response.status,
+                            headers: result.response.headers as any
+                        });
                     }
-                    if (result.cacheControl) {
-                        const directives = result.cacheControl.directives.join(', ');
-                        const maxAge = result.cacheControl.maxAge ? `, max-age=${result.cacheControl.maxAge}` : '';
-                        headers['Cache-Control'] = directives + maxAge;
+                    if (result.result) {
+                        // Handle special results (streams/redirects - unlikely in MSW but possible)
+                         if (result.result.type === 'redirect') {
+                             return HttpResponse.redirect(result.result.url);
+                         }
+                         // Fallback for others
+                         return HttpResponse.json(result.result);
                     }
-                    
-                    return HttpResponse.json(result.data, { headers });
-                } catch (error) {
-                    const message = error instanceof Error ? error.message : 'Unknown error';
-                    return HttpResponse.json({ error: message }, { status: 404 });
-                }
-            }),
-
-            // UI Protocol endpoint
-            http.get(`${baseUrl}/ui/view/:object`, async ({ params, request }) => {
-                try {
-                    const url = new URL(request.url);
-                    const viewType = url.searchParams.get('type') || 'list';
-                    const view = await protocol.getUiView({ object: params.object as string, type: viewType as 'list' | 'form' });
-                    return HttpResponse.json(view);
-                } catch (error) {
-                    const message = error instanceof Error ? error.message : 'Unknown error';
-                    return HttpResponse.json({ error: message }, { status: 404 });
-                }
-            }),
-
-            // Analytics Operations
-            http.post(`${baseUrl}/analytics/query`, async ({ request }) => {
-                try {
-                    const body = await request.json();
-                    const result = await ObjectStackServer.analyticsQuery(body);
-                    return HttpResponse.json(result.data, { status: result.status });
-                } catch (error) {
-                    const message = error instanceof Error ? error.message : 'Unknown error';
-                    return HttpResponse.json({ error: message }, { status: 400 });
-                }
-            }),
-
-            http.get(`${baseUrl}/analytics/meta`, async ({ request }) => {
-                try {
-                    const url = new URL(request.url);
-                    const query = parseQueryParams(url);
-                    const result = await ObjectStackServer.getAnalyticsMeta(query);
-                    return HttpResponse.json(result.data, { status: result.status });
-                } catch (error) {
-                    const message = error instanceof Error ? error.message : 'Unknown error';
-                    return HttpResponse.json({ error: message }, { status: 400 });
                 }
-            }),
-
-            // Automation Operations
-            http.post(`${baseUrl}/automation/trigger`, async ({ request }) => {
-                try {
-                    const body = await request.json();
-                    const result = await ObjectStackServer.triggerAutomation(body);
-                    return HttpResponse.json(result.data, { status: result.status });
-                } catch (error) {
-                    const message = error instanceof Error ? error.message : 'Unknown error';
-                    return HttpResponse.json({ error: message }, { status: 400 });
-                }
-            }),
-
-            // Add custom handlers
-            ...(this.options.customHandlers || [])
-        ];
+                
+                // Not handled by dispatcher (404 for this route subset)
+                return undefined; // Let MSW pass through or handle next
+            };
 
-        ctx.logger.info('MSW request handlers installed', { count: this.handlers.length, baseUrl });
+            this.handlers.push(
+                http.all(`${baseUrl}/*`, catchAll),
+                http.all(`${baseUrl}`, catchAll) // Handle root if needed
+            );
+            
+            ctx.logger.info('MSW handlers set up using HttpDispatcher', { baseUrl });
+        } else {
+             ctx.logger.warn('[MSWPlugin] No dispatcher available. No API routes registered.');
+        }
     }
 
+
     /**
      * Start the MSW worker
      */
@@ -745,3 +314,46 @@ export class MSWPlugin implements Plugin {
         return this.handlers;
     }
 }
+
+/**
+ * Static helper for interacting with ObjectStack protocol in MSW handlers
+ */
+export class ObjectStackServer {
+    private static protocol: ObjectStackProtocol;
+
+    static init(protocol: ObjectStackProtocol) {
+        this.protocol = protocol;
+    }
+
+    private static getProtocol(): ObjectStackProtocol {
+        if (!this.protocol) {
+            throw new Error('ObjectStackServer not initialized. Call ObjectStackServer.init(protocol) first.');
+        }
+        return this.protocol;
+    }
+
+    static async findData(objectName: string, query?: any) {
+        const body = await this.getProtocol().findData({ object: objectName, query });
+        return { data: body, status: 200 };
+    }
+
+    static async getData(objectName: string, id: string) {
+        const body = await this.getProtocol().getData({ object: objectName, id });
+        return { data: body, status: 200 };
+    }
+
+    static async createData(objectName: string, data: any) {
+        const body = await this.getProtocol().createData({ object: objectName, data });
+        return { data: body, status: 201 };
+    }
+
+    static async updateData(objectName: string, id: string, data: any) {
+        const body = await this.getProtocol().updateData({ object: objectName, id, data });
+        return { data: body, status: 200 };
+    }
+
+    static async deleteData(objectName: string, id: string) {
+        const body = await this.getProtocol().deleteData({ object: objectName, id });
+        return { data: body, status: 200 };
+    }
+}