@objectstack/plugin-msw 1.0.1 → 1.0.4

package/dist/msw-plugin.js

@@ -1,6 +1,6 @@
 import { http, HttpResponse } from 'msw';
 import { setupWorker } from 'msw/browser';
-// import { IDataEngine } from '@objectstack/core';
+import { HttpDispatcher } from '@objectstack/runtime';
 // Helper for parsing query parameters
 function parseQueryParams(url) {
     const params = {};
@@ -43,245 +43,9 @@ function parseQueryParams(url) {
     }
     return params;
 }
-// Helper to normalize flat parameters into 'where' clause
-function normalizeQuery(params) {
-    // 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 = {};
-    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;
-}
-/**
- * ObjectStack Server Mock - Provides mock database functionality
- */
-export class ObjectStackServer {
-    static init(protocol, logger) {
-        this.protocol = protocol;
-        this.logger = logger || {
-            info: console.log,
-            debug: console.debug,
-            warn: console.warn,
-            error: console.error
-        };
-    }
-    static async findData(object, params) {
-        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, id) {
-        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, data) {
-        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, id, data) {
-        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, id) {
-        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) {
-        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) {
-        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) {
-        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) {
-        return this.getData('user', id);
-    }
-    static async createUser(data) {
-        return this.createData('user', data);
-    }
-    static async saveMetaItem(type, name, item) {
-        if (!this.protocol) {
-            throw new Error('ObjectStackServer not initialized. Call ObjectStackServer.init() first.');
-        }
-        this.logger?.debug?.('MSW: Saving metadata', { type, name });
-        try {
-            // Check if protocol supports saveMetaItem (it might be added recently)
-            if (!this.protocol.saveMetaItem) {
-                throw new Error('Protocol does not support saveMetaItem');
-            }
-            const result = await this.protocol.saveMetaItem({ type, name, item });
-            this.logger?.info?.('MSW: Metadata saved', { type, name });
-            return {
-                status: 200,
-                data: result
-            };
-        }
-        catch (error) {
-            this.logger?.error?.('MSW: Save metadata failed', error, { type, name });
-            const message = error instanceof Error ? error.message : 'Unknown error';
-            return {
-                status: 400,
-                data: { error: message }
-            };
-        }
-    }
-}
-ObjectStackServer.protocol = null;
-ObjectStackServer.logger = null;
 /**
  * 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.
@@ -376,272 +140,76 @@ export class MSWPlugin {
      * Setup MSW handlers
      */
     setupHandlers(ctx) {
-        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 }));
-            }),
-            http.get(`${baseUrl}/meta/:type`, async ({ params, request }) => {
+            ...(this.options.customHandlers || [])
+        ];
+        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 }) => {
                 const url = new URL(request.url);
-                const query = parseQueryParams(url);
-                return HttpResponse.json(await protocol.getMetaItems({ type: params.type, query }));
-            }),
-            http.get(`${baseUrl}/meta/:type/:name`, async ({ params }) => {
-                try {
-                    return HttpResponse.json(await protocol.getMetaItem({ type: params.type, name: params.name }));
-                }
-                catch (error) {
-                    const message = error instanceof Error ? error.message : 'Unknown error';
-                    return HttpResponse.json({ error: message }, { status: 404 });
-                }
-            }),
-            // Save Metadata
-            http.put(`${baseUrl}/meta/:type/:name`, async ({ params, request }) => {
-                try {
-                    const body = await request.json();
-                    const result = await ObjectStackServer.saveMetaItem(params.type, params.name, 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 });
-                }
-            }),
-            // 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, 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, params.id);
-                    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, 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, params.id, 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, params.id);
-                    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 });
-                }
-            }),
-            // 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, request: body });
-                    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, 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();
-                    const result = await protocol.updateManyData({
-                        object: params.object,
-                        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();
-                    const result = await protocol.deleteManyData({
-                        object: params.object,
-                        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 });
-                }
-            }),
-            // 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,
-                        name: params.name,
-                        cacheRequest
-                    });
-                    if (result.notModified) {
-                        return new HttpResponse(null, { status: 304 });
+                // 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);
+                }
+                // Parse Body if present
+                let body = undefined;
+                if (request.method !== 'GET' && request.method !== 'HEAD') {
+                    try {
+                        body = await request.clone().json();
                     }
-                    // Build response headers
-                    const headers = {};
-                    if (result.etag) {
-                        const etagValue = result.etag.weak ? `W/"${result.etag.value}"` : `"${result.etag.value}"`;
-                        headers['ETag'] = etagValue;
+                    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) { }
                     }
-                    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
+                        });
                     }
-                    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, type: viewType });
-                    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 || [])
-        ];
-        ctx.logger.info('MSW request handlers installed', { count: this.handlers.length, baseUrl });
+                // Not handled by dispatcher (404 for this route subset)
+                return undefined; // Let MSW pass through or handle next
+            };
+            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
@@ -682,3 +250,37 @@ export class MSWPlugin {
         return this.handlers;
     }
 }
+/**
+ * Static helper for interacting with ObjectStack protocol in MSW handlers
+ */
+export class ObjectStackServer {
+    static init(protocol) {
+        this.protocol = protocol;
+    }
+    static getProtocol() {
+        if (!this.protocol) {
+            throw new Error('ObjectStackServer not initialized. Call ObjectStackServer.init(protocol) first.');
+        }
+        return this.protocol;
+    }
+    static async findData(objectName, query) {
+        const body = await this.getProtocol().findData({ object: objectName, query });
+        return { data: body, status: 200 };
+    }
+    static async getData(objectName, id) {
+        const body = await this.getProtocol().getData({ object: objectName, id });
+        return { data: body, status: 200 };
+    }
+    static async createData(objectName, data) {
+        const body = await this.getProtocol().createData({ object: objectName, data });
+        return { data: body, status: 201 };
+    }
+    static async updateData(objectName, id, data) {
+        const body = await this.getProtocol().updateData({ object: objectName, id, data });
+        return { data: body, status: 200 };
+    }
+    static async deleteData(objectName, id) {
+        const body = await this.getProtocol().deleteData({ object: objectName, id });
+        return { data: body, status: 200 };
+    }
+}

package/package.json

@@ -1,24 +1,25 @@
 {
   "name": "@objectstack/plugin-msw",
-  "version": "1.0.1",
+  "version": "1.0.4",
   "description": "MSW (Mock Service Worker) Plugin for ObjectStack Runtime",
   "license": "Apache-2.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "peerDependencies": {
-    "@objectstack/runtime": "^1.0.1"
+    "@objectstack/runtime": "^1.0.4"
   },
   "dependencies": {
     "msw": "^2.0.0",
-    "@objectstack/spec": "1.0.1",
-    "@objectstack/types": "1.0.1",
-    "@objectstack/objectql": "1.0.1"
+    "@objectstack/core": "1.0.4",
+    "@objectstack/objectql": "1.0.4",
+    "@objectstack/spec": "1.0.4",
+    "@objectstack/types": "1.0.4"
   },
   "devDependencies": {
     "@types/node": "^25.1.0",
     "typescript": "^5.0.0",
     "vitest": "^4.0.18",
-    "@objectstack/runtime": "1.0.1"
+    "@objectstack/runtime": "1.0.4"
   },
   "scripts": {
     "build": "tsc",