@objectstack/plugin-msw 0.6.1 → 0.7.2

package/src/msw-plugin.ts

@@ -1,4 +1,4 @@
-import { http, HttpResponse } from 'msw';
+import { http, HttpResponse, passthrough } from 'msw';
 import { setupWorker } from 'msw/browser';
 import { 
     Plugin, 
@@ -7,7 +7,7 @@ import {
     IDataEngine
 } from '@objectstack/runtime';
 import { ObjectStackProtocolImplementation } from '@objectstack/objectql';
-import { IObjectStackProtocol } from '@objectstack/spec/api';
+import { ObjectStackProtocol } from '@objectstack/spec/api';
 // import { IDataEngine } from '@objectstack/core';
 
 export interface MSWPluginOptions {
@@ -36,12 +36,17 @@ export interface MSWPluginOptions {
  * ObjectStack Server Mock - Provides mock database functionality
  */
 export class ObjectStackServer {
-    private static protocol: IObjectStackProtocol | null = null;
-    private static logger: ((message: string, ...meta: any[]) => void) | null = null;
+    private static protocol: ObjectStackProtocol | null = null;
+    private static logger: any | null = null;
 
-    static init(protocol: IObjectStackProtocol, logger?: (message: string, ...meta: any[]) => void) {
+    static init(protocol: ObjectStackProtocol, logger?: any) {
         this.protocol = protocol;
-        this.logger = logger || console.log;
+        this.logger = logger || { 
+            info: console.log, 
+            debug: console.debug, 
+            warn: console.warn, 
+            error: console.error 
+        };
     }
 
     static async findData(object: string, params?: any) {
@@ -49,8 +54,9 @@ export class ObjectStackServer {
             throw new Error('ObjectStackServer not initialized. Call ObjectStackServer.init() first.');
         }
         
-        this.logger?.(`[MSW] Finding ${object} records`, params);
-        const result = await this.protocol.findData(object, params || {});
+        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
@@ -62,14 +68,16 @@ export class ObjectStackServer {
             throw new Error('ObjectStackServer not initialized. Call ObjectStackServer.init() first.');
         }
         
-        this.logger?.(`[MSW] Getting ${object} record:`, id);
+        this.logger?.debug?.('MSW: Getting record', { object, id });
         try {
-            const result = await this.protocol.getData(object, id);
+            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,
@@ -83,14 +91,16 @@ export class ObjectStackServer {
             throw new Error('ObjectStackServer not initialized. Call ObjectStackServer.init() first.');
         }
         
-        this.logger?.(`[MSW] Creating ${object} record:`, data);
+        this.logger?.debug?.('MSW: Creating record', { object });
         try {
-            const result = await this.protocol.createData(object, data);
+            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,
@@ -104,14 +114,16 @@ export class ObjectStackServer {
             throw new Error('ObjectStackServer not initialized. Call ObjectStackServer.init() first.');
         }
         
-        this.logger?.(`[MSW] Updating ${object} record ${id}:`, data);
+        this.logger?.debug?.('MSW: Updating record', { object, id });
         try {
-            const result = await this.protocol.updateData(object, id, data);
+            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,
@@ -125,14 +137,16 @@ export class ObjectStackServer {
             throw new Error('ObjectStackServer not initialized. Call ObjectStackServer.init() first.');
         }
         
-        this.logger?.(`[MSW] Deleting ${object} record:`, id);
+        this.logger?.debug?.('MSW: Deleting record', { object, id });
         try {
-            const result = await this.protocol.deleteData(object, id);
+            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,
@@ -176,7 +190,7 @@ export class MSWPlugin implements Plugin {
     private options: MSWPluginOptions;
     private worker: any;
     private handlers: Array<any> = [];
-    private protocol?: IObjectStackProtocol;
+    private protocol?: ObjectStackProtocol;
 
     constructor(options: MSWPluginOptions = {}) {
         this.options = {
@@ -191,24 +205,32 @@ export class MSWPlugin implements Plugin {
      * Init phase
      */
     async init(ctx: PluginContext) {
+        ctx.logger.debug('Initializing MSW plugin', { 
+            enableBrowser: this.options.enableBrowser,
+            baseUrl: this.options.baseUrl,
+            logRequests: this.options.logRequests
+        });
         // Protocol will be created in start phase
-        ctx.logger.log('[MSWPlugin] Initialized');
+        ctx.logger.info('MSW plugin initialized');
     }
 
     /**
      * Start phase
      */
     async start(ctx: PluginContext) {
+        ctx.logger.debug('Starting MSW plugin');
+        
         try {
             const dataEngine = ctx.getService<IDataEngine>('objectql');
             this.protocol = new ObjectStackProtocolImplementation(dataEngine);
+            ctx.logger.debug('Protocol implementation created');
         } catch (e) {
-            console.error('[MSWPlugin] Failed to initialize protocol', e);
+            ctx.logger.error('Failed to initialize protocol', e as Error);
             throw new Error('[MSWPlugin] Failed to initialize protocol (missing objectql service?)');
         }
         
-        this.setupHandlers();
-        await this.startWorker();
+        this.setupHandlers(ctx);
+        await this.startWorker(ctx);
     }
 
     /**
@@ -221,41 +243,56 @@ export class MSWPlugin implements Plugin {
     /**
      * Setup MSW handlers
      */
-    private setupHandlers() {
+    private setupHandlers(ctx: PluginContext) {
         if (!this.protocol) {
             throw new Error('[MSWPlugin] Protocol not initialized');
         }
 
         const protocol = this.protocol;
         
-        // Initialize ObjectStackServer
+        // Initialize ObjectStackServer with structured logger
         ObjectStackServer.init(
             protocol,
-            this.options.logRequests ? console.log : undefined
+            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
         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}`, () => {
-                return HttpResponse.json(protocol.getDiscovery());
+            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`, () => {
-                return HttpResponse.json(protocol.getMetaTypes());
+            http.get(`${baseUrl}/meta`, async () => {
+                return HttpResponse.json(await protocol.getMetaTypes({}));
             }),
 
-            http.get(`${baseUrl}/meta/:type`, ({ params }) => {
-                return HttpResponse.json(protocol.getMetaItems(params.type as string));
+            http.get(`${baseUrl}/meta/:type`, async ({ params }) => {
+                return HttpResponse.json(await protocol.getMetaItems({ type: params.type as string }));
             }),
 
-            http.get(`${baseUrl}/meta/:type/:name`, ({ params }) => {
+            http.get(`${baseUrl}/meta/:type/:name`, async ({ params }) => {
                 try {
                     return HttpResponse.json(
-                        protocol.getMetaItem(params.type as string, params.name as string)
+                        await protocol.getMetaItem({ type: params.type as string, name: params.name as string })
                     );
                 } catch (error) {
                     const message = error instanceof Error ? error.message : 'Unknown error';
@@ -276,7 +313,10 @@ export class MSWPlugin implements Plugin {
                         params.object as string,
                         queryParams
                     );
-                    return HttpResponse.json(result.data, { status: result.status });
+                    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 });
@@ -289,7 +329,10 @@ export class MSWPlugin implements Plugin {
                         params.object as string,
                         params.id as string
                     );
-                    return HttpResponse.json(result.data, { status: result.status });
+                    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 });
@@ -338,12 +381,106 @@ export class MSWPlugin implements Plugin {
                 }
             }),
 
+            // 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 });
+                }
+            }),
+
+            // 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 
+                    });
+                    
+                    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();
+                    }
+                    if (result.cacheControl) {
+                        const directives = result.cacheControl.directives.join(', ');
+                        const maxAge = result.cacheControl.maxAge ? `, max-age=${result.cacheControl.maxAge}` : '';
+                        headers['Cache-Control'] = directives + maxAge;
+                    }
+                    
+                    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`, ({ params, request }) => {
+            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 = protocol.getUiView(params.object as string, viewType as 'list' | 'form');
+                    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';
@@ -351,26 +488,122 @@ export class MSWPlugin implements Plugin {
                 }
             }),
 
+            // View Storage Operations
+            http.post(`${baseUrl}/ui/views`, async ({ request }) => {
+                try {
+                    const body = await request.json();
+                    const result = await protocol.createView(body as any);
+                    if (result.success) {
+                        return HttpResponse.json(result, { status: 201 });
+                    } else {
+                        return HttpResponse.json(result, { status: 400 });
+                    }
+                } catch (error) {
+                    const message = error instanceof Error ? error.message : 'Unknown error';
+                    return HttpResponse.json({ success: false, error: { code: 'internal_error', message } }, { status: 500 });
+                }
+            }),
+
+            http.get(`${baseUrl}/ui/views/:id`, async ({ params }) => {
+                try {
+                    const result = await protocol.getView({ id: params.id as string });
+                    if (result.success) {
+                        return HttpResponse.json(result);
+                    } else {
+                        return HttpResponse.json(result, { status: 404 });
+                    }
+                } catch (error) {
+                    const message = error instanceof Error ? error.message : 'Unknown error';
+                    return HttpResponse.json({ success: false, error: { code: 'internal_error', message } }, { status: 500 });
+                }
+            }),
+
+            http.get(`${baseUrl}/ui/views`, async ({ request }) => {
+                try {
+                    const url = new URL(request.url);
+                    const queryRequest: any = {};
+                    if (url.searchParams.get('object')) queryRequest.object = url.searchParams.get('object');
+                    if (url.searchParams.get('type')) queryRequest.type = url.searchParams.get('type');
+                    if (url.searchParams.get('visibility')) queryRequest.visibility = url.searchParams.get('visibility');
+                    if (url.searchParams.get('createdBy')) queryRequest.createdBy = url.searchParams.get('createdBy');
+                    if (url.searchParams.get('isDefault')) queryRequest.isDefault = url.searchParams.get('isDefault') === 'true';
+                    
+                    // Parse numeric parameters with validation
+                    const limitParam = url.searchParams.get('limit');
+                    const offsetParam = url.searchParams.get('offset');
+                    if (limitParam) {
+                        const limit = parseInt(limitParam, 10);
+                        if (!isNaN(limit) && limit > 0) queryRequest.limit = limit;
+                    }
+                    if (offsetParam) {
+                        const offset = parseInt(offsetParam, 10);
+                        if (!isNaN(offset) && offset >= 0) queryRequest.offset = offset;
+                    }
+                    
+                    const result = await protocol.listViews(queryRequest);
+                    return HttpResponse.json(result);
+                } catch (error) {
+                    const message = error instanceof Error ? error.message : 'Unknown error';
+                    return HttpResponse.json({ success: false, error: { code: 'internal_error', message } }, { status: 500 });
+                }
+            }),
+
+            http.patch(`${baseUrl}/ui/views/:id`, async ({ params, request }) => {
+                try {
+                    const body = await request.json() as any;
+                    // Merge body with id parameter, ensuring body is an object
+                    const updateData = (typeof body === 'object' && body !== null) 
+                        ? { ...body, id: params.id as string } 
+                        : { id: params.id as string };
+                    
+                    const result = await protocol.updateView(updateData as any);
+                    if (result.success) {
+                        return HttpResponse.json(result);
+                    } else {
+                        const statusCode = result.error?.code === 'resource_not_found' ? 404 : 400;
+                        return HttpResponse.json(result, { status: statusCode });
+                    }
+                } catch (error) {
+                    const message = error instanceof Error ? error.message : 'Unknown error';
+                    return HttpResponse.json({ success: false, error: { code: 'internal_error', message } }, { status: 500 });
+                }
+            }),
+
+            http.delete(`${baseUrl}/ui/views/:id`, async ({ params }) => {
+                try {
+                    const result = await protocol.deleteView({ id: params.id as string });
+                    if (result.success) {
+                        return HttpResponse.json(result);
+                    } else {
+                        return HttpResponse.json(result, { status: 404 });
+                    }
+                } catch (error) {
+                    const message = error instanceof Error ? error.message : 'Unknown error';
+                    return HttpResponse.json({ success: false, error: { code: 'internal_error', message } }, { status: 500 });
+                }
+            }),
+
             // Add custom handlers
             ...(this.options.customHandlers || [])
         ];
 
-        console.log(`[MSWPlugin] Installed ${this.handlers.length} request handlers.`);
+        ctx.logger.info('MSW request handlers installed', { count: this.handlers.length, baseUrl });
     }
 
     /**
      * Start the MSW worker
      */
-    private async startWorker() {
+    private async startWorker(ctx: PluginContext) {
         if (this.options.enableBrowser && typeof window !== 'undefined') {
             // Browser environment
+            ctx.logger.debug('Starting MSW in browser mode');
             this.worker = setupWorker(...this.handlers);
             await this.worker.start({
                 onUnhandledRequest: 'bypass',
             });
-            console.log(`[MSWPlugin] Started MSW in browser mode.`);
+            ctx.logger.info('MSW started in browser mode');
         } else {
-            console.log(`[MSWPlugin] Browser mode disabled or not in browser environment.`);
+            ctx.logger.debug('MSW browser mode disabled or not in browser environment');
         }
     }
 
@@ -380,7 +613,7 @@ export class MSWPlugin implements Plugin {
     private async stopWorker() {
         if (this.worker) {
             this.worker.stop();
-            console.log(`[MSWPlugin] Stopped MSW worker.`);
+            console.log('[MSWPlugin] Stopped MSW worker');
         }
     }