@objectstack/plugin-msw 0.9.2 → 1.0.1

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # @objectstack/plugin-msw
 
+## 1.0.1
+
+### Patch Changes
+
+- Updated dependencies
+  - @objectstack/runtime@1.0.1
+  - @objectstack/spec@1.0.1
+  - @objectstack/types@1.0.1
+  - @objectstack/objectql@1.0.1
+
+## 1.0.0
+
+### Major Changes
+
+- Major version release for ObjectStack Protocol v1.0.
+  - Stabilized Protocol Definitions
+  - Enhanced Runtime Plugin Support
+  - Fixed Type Compliance across Monorepo
+
+### Patch Changes
+
+- Updated dependencies
+  - @objectstack/spec@1.0.0
+  - @objectstack/runtime@1.0.0
+  - @objectstack/objectql@1.0.0
+  - @objectstack/types@1.0.0
+
 ## 0.9.2
 
 ### Patch Changes

package/dist/msw-plugin.d.ts

@@ -38,8 +38,8 @@ export declare class ObjectStackServer {
         status: number;
         data: {
             object: string;
-            id: string;
             record: Record<string, any>;
+            id: string;
         };
     } | {
         status: number;
@@ -51,8 +51,8 @@ export declare class ObjectStackServer {
         status: number;
         data: {
             object: string;
-            id: string;
             record: Record<string, any>;
+            id: string;
         };
     } | {
         status: number;
@@ -64,8 +64,8 @@ export declare class ObjectStackServer {
         status: number;
         data: {
             object: string;
-            id: string;
             record: Record<string, any>;
+            id: string;
         };
     } | {
         status: number;
@@ -86,12 +86,118 @@ export declare class ObjectStackServer {
             error: string;
         };
     }>;
+    static analyticsQuery(request: any): Promise<{
+        status: number;
+        data: {
+            data: {
+                fields: {
+                    type: string;
+                    name: string;
+                }[];
+                rows: Record<string, any>[];
+                sql?: string | undefined;
+            };
+            success: boolean;
+            error?: {
+                message: string;
+                code: string;
+                category?: string | undefined;
+                requestId?: string | undefined;
+                details?: any;
+            } | undefined;
+            meta?: {
+                timestamp: string;
+                duration?: number | undefined;
+                requestId?: string | undefined;
+                traceId?: string | undefined;
+            } | undefined;
+        };
+    } | {
+        status: number;
+        data: {
+            error: string;
+        };
+    }>;
+    static getAnalyticsMeta(request: any): Promise<{
+        status: number;
+        data: {
+            data: {
+                cubes: {
+                    dimensions: Record<string, {
+                        type: "string" | "number" | "boolean" | "time" | "geo";
+                        label: string;
+                        name: string;
+                        sql: string;
+                        description?: string | undefined;
+                        granularities?: ("second" | "minute" | "hour" | "day" | "week" | "month" | "quarter" | "year")[] | undefined;
+                    }>;
+                    name: string;
+                    sql: string;
+                    measures: Record<string, {
+                        type: "string" | "number" | "boolean" | "count" | "sum" | "avg" | "min" | "max" | "count_distinct";
+                        label: string;
+                        name: string;
+                        sql: string;
+                        description?: string | undefined;
+                        format?: string | undefined;
+                        filters?: {
+                            sql: string;
+                        }[] | undefined;
+                    }>;
+                    public: boolean;
+                    joins?: Record<string, {
+                        name: string;
+                        sql: string;
+                        relationship: "one_to_one" | "one_to_many" | "many_to_one";
+                    }> | undefined;
+                    description?: string | undefined;
+                    title?: string | undefined;
+                    refreshKey?: {
+                        every?: string | undefined;
+                        sql?: string | undefined;
+                    } | undefined;
+                }[];
+            };
+            success: boolean;
+            error?: {
+                message: string;
+                code: string;
+                category?: string | undefined;
+                requestId?: string | undefined;
+                details?: any;
+            } | undefined;
+            meta?: {
+                timestamp: string;
+                duration?: number | undefined;
+                requestId?: string | undefined;
+                traceId?: string | undefined;
+            } | undefined;
+        };
+    } | {
+        status: number;
+        data: {
+            error: string;
+        };
+    }>;
+    static triggerAutomation(request: any): Promise<{
+        status: number;
+        data: {
+            success: boolean;
+            result?: any;
+            jobId?: string | undefined;
+        };
+    } | {
+        status: number;
+        data: {
+            error: string;
+        };
+    }>;
     static getUser(id: string): Promise<{
         status: number;
         data: {
             object: string;
-            id: string;
             record: Record<string, any>;
+            id: string;
         };
     } | {
         status: number;
@@ -103,8 +209,20 @@ export declare class ObjectStackServer {
         status: number;
         data: {
             object: string;
-            id: string;
             record: Record<string, any>;
+            id: string;
+        };
+    } | {
+        status: number;
+        data: {
+            error: string;
+        };
+    }>;
+    static saveMetaItem(type: string, name: string, item: any): Promise<{
+        status: number;
+        data: {
+            success: boolean;
+            message?: string | undefined;
         };
     } | {
         status: number;

package/dist/msw-plugin.js

@@ -1,5 +1,70 @@
-import { http, HttpResponse, passthrough } from 'msw';
+import { http, HttpResponse } from 'msw';
 import { setupWorker } from 'msw/browser';
+// import { IDataEngine } from '@objectstack/core';
+// Helper for parsing query parameters
+function parseQueryParams(url) {
+    const params = {};
+    const keys = Array.from(new Set(url.searchParams.keys()));
+    for (const key of keys) {
+        const values = url.searchParams.getAll(key);
+        // If single value, use it directly. If multiple, keep as array.
+        const rawValue = values.length === 1 ? values[0] : values;
+        // Helper to parse individual value
+        const parseValue = (val) => {
+            if (val === 'true')
+                return true;
+            if (val === 'false')
+                return false;
+            if (val === 'null')
+                return null;
+            if (val === 'undefined')
+                return undefined;
+            // Try number (integers only or floats)
+            // Safety check: Don't convert if it loses information (like leading zeros)
+            const num = Number(val);
+            if (!isNaN(num) && val.trim() !== '' && String(num) === val) {
+                return num;
+            }
+            // Try JSON
+            if ((val.startsWith('{') && val.endsWith('}')) || (val.startsWith('[') && val.endsWith(']'))) {
+                try {
+                    return JSON.parse(val);
+                }
+                catch { }
+            }
+            return val;
+        };
+        if (Array.isArray(rawValue)) {
+            params[key] = rawValue.map(parseValue);
+        }
+        else {
+            params[key] = parseValue(rawValue);
+        }
+    }
+    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
  */
@@ -113,6 +178,72 @@ export class ObjectStackServer {
             };
         }
     }
+    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);
@@ -120,6 +251,32 @@ export class ObjectStackServer {
     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;
@@ -233,9 +390,6 @@ export class MSWPlugin {
         const baseUrl = this.options.baseUrl || '/api/v1';
         // Define standard ObjectStack API handlers
         this.handlers = [
-            // Passthrough for external resources
-            http.get('https://fonts.googleapis.com/*', () => passthrough()),
-            http.get('https://fonts.gstatic.com/*', () => passthrough()),
             // Discovery endpoint
             http.get(`${baseUrl}`, async () => {
                 const discovery = await protocol.getDiscovery({});
@@ -250,11 +404,15 @@ export class MSWPlugin {
                 });
             }),
             // Meta endpoints
-            http.get(`${baseUrl}/meta`, async () => {
-                return HttpResponse.json(await protocol.getMetaTypes({}));
+            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 }) => {
-                return HttpResponse.json(await protocol.getMetaItems({ type: params.type }));
+            http.get(`${baseUrl}/meta/:type`, async ({ params, request }) => {
+                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 {
@@ -265,14 +423,26 @@ export class MSWPlugin {
                     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);
-                    const queryParams = {};
-                    url.searchParams.forEach((value, key) => {
-                        queryParams[key] = value;
-                    });
+                    // 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,
@@ -432,6 +602,42 @@ export class MSWPlugin {
                     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 || [])
         ];

package/package.json

@@ -1,23 +1,24 @@
 {
   "name": "@objectstack/plugin-msw",
-  "version": "0.9.2",
+  "version": "1.0.1",
   "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"
+  },
   "dependencies": {
     "msw": "^2.0.0",
-    "@objectstack/spec": "0.9.2",
-    "@objectstack/types": "0.9.2",
-    "@objectstack/objectql": "0.9.2"
+    "@objectstack/spec": "1.0.1",
+    "@objectstack/types": "1.0.1",
+    "@objectstack/objectql": "1.0.1"
   },
   "devDependencies": {
     "@types/node": "^25.1.0",
     "typescript": "^5.0.0",
     "vitest": "^4.0.18",
-    "@objectstack/runtime": "0.9.2"
-  },
-  "peerDependencies": {
-    "@objectstack/runtime": "^0.9.2"
+    "@objectstack/runtime": "1.0.1"
   },
   "scripts": {
     "build": "tsc",

package/src/msw-plugin.ts

@@ -10,6 +10,77 @@ import {
 import { ObjectStackProtocol } from '@objectstack/spec/api';
 // import { IDataEngine } from '@objectstack/core';
 
+// Helper for parsing query parameters
+function parseQueryParams(url: URL): Record<string, any> {
+    const params: Record<string, any> = {};
+    const keys = Array.from(new Set(url.searchParams.keys()));
+
+    for (const key of keys) {
+        const values = url.searchParams.getAll(key);
+        // If single value, use it directly. If multiple, keep as array.
+        const rawValue = values.length === 1 ? values[0] : values;
+        
+        // Helper to parse individual value
+        const parseValue = (val: string) => {
+            if (val === 'true') return true;
+            if (val === 'false') return false;
+            if (val === 'null') return null;
+            if (val === 'undefined') return undefined;
+            
+            // Try number (integers only or floats)
+            // Safety check: Don't convert if it loses information (like leading zeros)
+            const num = Number(val);
+            if (!isNaN(num) && val.trim() !== '' && String(num) === val) {
+                return num;
+            }
+            
+            // Try JSON
+            if ((val.startsWith('{') && val.endsWith('}')) || (val.startsWith('[') && val.endsWith(']'))) {
+                try {
+                    return JSON.parse(val);
+                } catch {}
+            }
+            
+            return val;
+        };
+
+        if (Array.isArray(rawValue)) {
+            params[key] = rawValue.map(parseValue);
+        } else {
+            params[key] = parseValue(rawValue as string);
+        }
+    }
+    
+    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
@@ -155,6 +226,75 @@ export class ObjectStackServer {
         }
     }
 
+    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);
@@ -163,6 +303,33 @@ export class ObjectStackServer {
     static async createUser(data: any) {
         return this.createData('user', data);
     }
+    static async saveMetaItem(type: string, name: string, item: any) {
+        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 }
+            };
+        }
+    }
 }
 
 /**
@@ -293,10 +460,6 @@ export class MSWPlugin implements Plugin {
 
         // Define standard ObjectStack API handlers
         this.handlers = [
-            // Passthrough for external resources
-            http.get('https://fonts.googleapis.com/*', () => passthrough()),
-            http.get('https://fonts.gstatic.com/*', () => passthrough()),
-            
             // Discovery endpoint
             http.get(`${baseUrl}`, async () => {
                 const discovery = await protocol.getDiscovery({});
@@ -312,18 +475,22 @@ export class MSWPlugin implements Plugin {
             }),
 
             // Meta endpoints
-            http.get(`${baseUrl}/meta`, async () => {
-                return HttpResponse.json(await protocol.getMetaTypes({}));
+            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 }) => {
-                return HttpResponse.json(await protocol.getMetaItems({ type: params.type as string }));
+            http.get(`${baseUrl}/meta/:type`, async ({ params, request }) => {
+                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 })
+                        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';
@@ -331,14 +498,32 @@ export class MSWPlugin implements Plugin {
                 }
             }),
 
+            // Save Metadata
+            http.put(`${baseUrl}/meta/:type/:name`, async ({ params, request }) => {
+                try {
+                    const body = await request.json();
+                    const result = await ObjectStackServer.saveMetaItem(
+                        params.type as string, 
+                        params.name 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 });
+                }
+            }),
+
             // Data endpoints
             http.get(`${baseUrl}/data/:object`, async ({ params, request }) => {
                 try {
                     const url = new URL(request.url);
-                    const queryParams: Record<string, any> = {};
-                    url.searchParams.forEach((value, key) => {
-                        queryParams[key] = value;
-                    });
+                    
+                    // 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,
@@ -478,7 +663,7 @@ export class MSWPlugin implements Plugin {
                         type: params.type as string, 
                         name: params.name as string, 
                         cacheRequest 
-                    });
+                    } as any);
                     
                     if (result.notModified) {
                         return new HttpResponse(null, { status: 304 });
@@ -519,6 +704,42 @@ export class MSWPlugin implements Plugin {
                 }
             }),
 
+            // 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 || [])
         ];