@objectstack/plugin-msw 0.6.1 → 0.7.2

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # @objectstack/plugin-msw
 
+## 0.7.2
+
+### Patch Changes
+
+- fb41cc0: Patch release: Updated documentation and JSON schemas
+- Updated dependencies [fb41cc0]
+  - @objectstack/spec@0.7.2
+  - @objectstack/types@0.7.2
+  - @objectstack/objectql@0.7.2
+  - @objectstack/runtime@0.7.2
+
+## 0.7.1
+
+### Patch Changes
+
+- Patch release for maintenance and stability improvements
+- Updated dependencies
+  - @objectstack/spec@0.7.1
+  - @objectstack/objectql@0.7.1
+  - @objectstack/runtime@0.7.1
+  - @objectstack/types@0.7.1
+
 ## 0.6.1
 
 ### Patch Changes

package/README.md

@@ -2,6 +2,16 @@
 
 MSW (Mock Service Worker) Plugin for ObjectStack Runtime. This plugin enables seamless integration with [Mock Service Worker](https://mswjs.io/) for testing and development environments.
 
+## Plugin Capabilities
+
+This plugin implements the ObjectStack plugin capability protocol:
+- **Protocol**: `com.objectstack.protocol.testing.mock.v1` (full conformance)
+- **Protocol**: `com.objectstack.protocol.api.rest.v1` (full conformance)
+- **Provides**: `ObjectStackServer` interface for mock API operations
+- **Requires**: `com.objectstack.engine.objectql` for data operations
+
+See [objectstack.config.ts](./objectstack.config.ts) for the complete capability manifest.
+
 ## Features
 
 - 🎯 **Automatic API Mocking**: Automatically generates MSW handlers for all ObjectStack API endpoints

package/dist/msw-plugin.d.ts

@@ -1,5 +1,5 @@
 import { Plugin, PluginContext } from '@objectstack/runtime';
-import { IObjectStackProtocol } from '@objectstack/spec/api';
+import { ObjectStackProtocol } from '@objectstack/spec/api';
 export interface MSWPluginOptions {
     /**
      * Enable MSW in the browser environment
@@ -24,34 +24,93 @@ export interface MSWPluginOptions {
 export declare class ObjectStackServer {
     private static protocol;
     private static logger;
-    static init(protocol: IObjectStackProtocol, logger?: (message: string, ...meta: any[]) => void): void;
+    static init(protocol: ObjectStackProtocol, logger?: any): void;
     static findData(object: string, params?: any): Promise<{
         status: number;
-        data: any;
+        data: {
+            object: string;
+            records: Record<string, any>[];
+            total?: number | undefined;
+            hasMore?: boolean | undefined;
+        };
     }>;
     static getData(object: string, id: string): Promise<{
         status: number;
-        data: any;
+        data: {
+            object: string;
+            record: Record<string, any>;
+            id: string;
+        };
+    } | {
+        status: number;
+        data: {
+            error: string;
+        };
     }>;
     static createData(object: string, data: any): Promise<{
         status: number;
-        data: any;
+        data: {
+            object: string;
+            record: Record<string, any>;
+            id: string;
+        };
+    } | {
+        status: number;
+        data: {
+            error: string;
+        };
     }>;
     static updateData(object: string, id: string, data: any): Promise<{
         status: number;
-        data: any;
+        data: {
+            object: string;
+            record: Record<string, any>;
+            id: string;
+        };
+    } | {
+        status: number;
+        data: {
+            error: string;
+        };
     }>;
     static deleteData(object: string, id: string): Promise<{
         status: number;
-        data: any;
+        data: {
+            object: string;
+            id: string;
+            success: boolean;
+        };
+    } | {
+        status: number;
+        data: {
+            error: string;
+        };
     }>;
     static getUser(id: string): Promise<{
         status: number;
-        data: any;
+        data: {
+            object: string;
+            record: Record<string, any>;
+            id: string;
+        };
+    } | {
+        status: number;
+        data: {
+            error: string;
+        };
     }>;
     static createUser(data: any): Promise<{
         status: number;
-        data: any;
+        data: {
+            object: string;
+            record: Record<string, any>;
+            id: string;
+        };
+    } | {
+        status: number;
+        data: {
+            error: string;
+        };
     }>;
 }
 /**

package/dist/msw-plugin.js

@@ -1,4 +1,4 @@
-import { http, HttpResponse } from 'msw';
+import { http, HttpResponse, passthrough } from 'msw';
 import { setupWorker } from 'msw/browser';
 import { ObjectStackProtocolImplementation } from '@objectstack/objectql';
 /**
@@ -7,14 +7,20 @@ import { ObjectStackProtocolImplementation } from '@objectstack/objectql';
 export class ObjectStackServer {
     static init(protocol, logger) {
         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, params) {
         if (!this.protocol) {
             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
@@ -24,15 +30,17 @@ export class ObjectStackServer {
         if (!this.protocol) {
             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,
@@ -44,15 +52,17 @@ export class ObjectStackServer {
         if (!this.protocol) {
             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,
@@ -64,15 +74,17 @@ export class ObjectStackServer {
         if (!this.protocol) {
             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,
@@ -84,15 +96,17 @@ export class ObjectStackServer {
         if (!this.protocol) {
             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,
@@ -144,23 +158,30 @@ export class MSWPlugin {
      * Init phase
      */
     async init(ctx) {
+        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) {
+        ctx.logger.debug('Starting MSW plugin');
         try {
             const dataEngine = ctx.getService('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);
             throw new Error('[MSWPlugin] Failed to initialize protocol (missing objectql service?)');
         }
-        this.setupHandlers();
-        await this.startWorker();
+        this.setupHandlers(ctx);
+        await this.startWorker(ctx);
     }
     /**
      * Destroy phase
@@ -171,30 +192,43 @@ export class MSWPlugin {
     /**
      * Setup MSW handlers
      */
-    setupHandlers() {
+    setupHandlers(ctx) {
         if (!this.protocol) {
             throw new Error('[MSWPlugin] Protocol not initialized');
         }
         const protocol = this.protocol;
-        // Initialize ObjectStackServer
-        ObjectStackServer.init(protocol, this.options.logRequests ? console.log : undefined);
+        // 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
         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));
+            http.get(`${baseUrl}/meta/:type`, async ({ params }) => {
+                return HttpResponse.json(await protocol.getMetaItems({ type: params.type }));
             }),
-            http.get(`${baseUrl}/meta/:type/:name`, ({ params }) => {
+            http.get(`${baseUrl}/meta/:type/:name`, async ({ params }) => {
                 try {
-                    return HttpResponse.json(protocol.getMetaItem(params.type, params.name));
+                    return HttpResponse.json(await protocol.getMetaItem({ type: params.type, name: params.name }));
                 }
                 catch (error) {
                     const message = error instanceof Error ? error.message : 'Unknown error';
@@ -210,7 +244,10 @@ export class MSWPlugin {
                         queryParams[key] = value;
                     });
                     const result = await ObjectStackServer.findData(params.object, 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';
@@ -220,7 +257,10 @@ export class MSWPlugin {
             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 });
+                    return HttpResponse.json(result.data, {
+                        status: result.status,
+                        headers: { 'Cache-Control': 'no-store' }
+                    });
                 }
                 catch (error) {
                     const message = error instanceof Error ? error.message : 'Unknown error';
@@ -259,12 +299,102 @@ export class MSWPlugin {
                     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 });
+                    }
+                    // Build response headers
+                    const headers = {};
+                    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, viewType);
+                    const view = await protocol.getUiView({ object: params.object, type: viewType });
                     return HttpResponse.json(view);
                 }
                 catch (error) {
@@ -272,25 +402,129 @@ export class MSWPlugin {
                     return HttpResponse.json({ error: message }, { status: 404 });
                 }
             }),
+            // View Storage Operations
+            http.post(`${baseUrl}/ui/views`, async ({ request }) => {
+                try {
+                    const body = await request.json();
+                    const result = await protocol.createView(body);
+                    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 });
+                    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 = {};
+                    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();
+                    // Merge body with id parameter, ensuring body is an object
+                    const updateData = (typeof body === 'object' && body !== null)
+                        ? { ...body, id: params.id }
+                        : { id: params.id };
+                    const result = await protocol.updateView(updateData);
+                    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 });
+                    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
      */
-    async startWorker() {
+    async startWorker(ctx) {
         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');
         }
     }
     /**
@@ -299,7 +533,7 @@ export class MSWPlugin {
     async stopWorker() {
         if (this.worker) {
             this.worker.stop();
-            console.log(`[MSWPlugin] Stopped MSW worker.`);
+            console.log('[MSWPlugin] Stopped MSW worker');
         }
     }
     /**