@objectstack/objectql 0.6.1 → 0.7.2

package/dist/protocol.d.ts

@@ -1,43 +1,113 @@
-import { IObjectStackProtocol } from '@objectstack/spec/api';
+import { ObjectStackProtocol } from '@objectstack/spec/api';
 import { IDataEngine } from '@objectstack/core';
-export declare class ObjectStackProtocolImplementation implements IObjectStackProtocol {
+import type { BatchUpdateRequest, BatchUpdateResponse, UpdateManyDataRequest, DeleteManyDataRequest } from '@objectstack/spec/api';
+import type { MetadataCacheRequest, MetadataCacheResponse } from '@objectstack/spec/api';
+import type { CreateViewRequest, UpdateViewRequest, ListViewsRequest, ViewResponse, ListViewsResponse } from '@objectstack/spec/api';
+export declare class ObjectStackProtocolImplementation implements ObjectStackProtocol {
     private engine;
+    private viewStorage;
     constructor(engine: IDataEngine);
-    getDiscovery(): {
-        name: string;
+    getDiscovery(_request: {}): Promise<{
         version: string;
-        capabilities: {
-            metadata: boolean;
-            data: boolean;
-            ui: boolean;
-        };
-    };
-    getMetaTypes(): string[];
-    getMetaItems(type: string): unknown[];
-    getMetaItem(type: string, name: string): unknown;
-    getUiView(object: string, type: 'list' | 'form'): {
+        apiName: string;
+        capabilities: string[];
+        endpoints: {};
+    }>;
+    getMetaTypes(_request: {}): Promise<{
+        types: string[];
+    }>;
+    getMetaItems(request: {
+        type: string;
+    }): Promise<{
+        type: string;
+        items: unknown[];
+    }>;
+    getMetaItem(request: {
+        type: string;
+        name: string;
+    }): Promise<{
         type: string;
+        name: string;
+        item: unknown;
+    }>;
+    getUiView(request: {
+        object: string;
+        type: 'list' | 'form';
+    }): Promise<{
+        object: string;
+        type: "list" | "form";
+        view: any;
+    }>;
+    findData(request: {
+        object: string;
+        query?: any;
+    }): Promise<{
+        object: string;
+        value: any[];
+        records: any[];
+        total: number;
+        hasMore: boolean;
+    }>;
+    getData(request: {
         object: string;
-        columns: {
-            field: string;
-            label: string;
-        }[];
-        sections?: undefined;
-    } | {
+        id: string;
+    }): Promise<{
+        object: string;
+        id: string;
+        record: any;
+    }>;
+    createData(request: {
+        object: string;
+        data: any;
+    }): Promise<{
+        object: string;
+        id: any;
+        record: any;
+    }>;
+    updateData(request: {
+        object: string;
+        id: string;
+        data: any;
+    }): Promise<{
+        object: string;
+        id: string;
+        record: any;
+    }>;
+    deleteData(request: {
+        object: string;
+        id: string;
+    }): Promise<{
+        object: string;
+        id: string;
+        success: boolean;
+    }>;
+    getMetaItemCached(request: {
         type: string;
+        name: string;
+        cacheRequest?: MetadataCacheRequest;
+    }): Promise<MetadataCacheResponse>;
+    batchData(_request: {
+        object: string;
+        request: BatchUpdateRequest;
+    }): Promise<BatchUpdateResponse>;
+    createManyData(request: {
+        object: string;
+        records: any[];
+    }): Promise<any>;
+    updateManyData(_request: UpdateManyDataRequest): Promise<any>;
+    deleteManyData(request: DeleteManyDataRequest): Promise<any>;
+    createView(request: CreateViewRequest): Promise<ViewResponse>;
+    getView(request: {
+        id: string;
+    }): Promise<ViewResponse>;
+    listViews(request: ListViewsRequest): Promise<ListViewsResponse>;
+    updateView(request: UpdateViewRequest): Promise<ViewResponse>;
+    deleteView(request: {
+        id: string;
+    }): Promise<{
+        success: boolean;
         object: string;
-        sections: {
-            label: string;
-            fields: {
-                field: string;
-            }[];
-        }[];
-        columns?: undefined;
-    };
-    findData(object: string, query: any): Promise<any[]>;
-    getData(object: string, id: string): Promise<any>;
-    createData(object: string, data: any): Promise<any>;
-    updateData(object: string, id: string, data: any): Promise<any>;
-    deleteData(object: string, id: string): Promise<boolean>;
+        id: string;
+    }>;
 }
 //# sourceMappingURL=protocol.d.ts.map

package/dist/protocol.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../src/protocol.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAKhD,qBAAa,iCAAkC,YAAW,oBAAoB;IAC1E,OAAO,CAAC,MAAM,CAAc;gBAEhB,MAAM,EAAE,WAAW;IAI/B,YAAY;;;;;;;;;IAYZ,YAAY;IAIZ,YAAY,CAAC,IAAI,EAAE,MAAM;IAIzB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IAItC,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM;;;;;;;;;;;;;;;;;;;IA6B/C,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG;IAI7B,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM;IAsBxC,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG;IAIpC,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG;IAIhD,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM;CAGxC"}
+{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../src/protocol.ts"],"names":[],"mappings":"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"}

package/dist/protocol.js

@@ -1,37 +1,58 @@
 // We import SchemaRegistry directly since this class lives in the same package
 import { SchemaRegistry } from './registry';
+/**
+ * Simple hash function for ETag generation (browser-compatible)
+ * Uses a basic hash algorithm instead of crypto.createHash
+ */
+function simpleHash(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+        const char = str.charCodeAt(i);
+        hash = ((hash << 5) - hash) + char;
+        hash = hash & hash; // Convert to 32bit integer
+    }
+    return Math.abs(hash).toString(16);
+}
 export class ObjectStackProtocolImplementation {
     constructor(engine) {
+        this.viewStorage = new Map();
         this.engine = engine;
     }
-    getDiscovery() {
+    async getDiscovery(_request) {
         return {
-            name: 'ObjectStack API',
             version: '1.0',
-            capabilities: {
-                metadata: true,
-                data: true,
-                ui: true
-            }
+            apiName: 'ObjectStack API',
+            capabilities: ['metadata', 'data', 'ui'],
+            endpoints: {}
         };
     }
-    getMetaTypes() {
-        return SchemaRegistry.getRegisteredTypes();
+    async getMetaTypes(_request) {
+        return {
+            types: SchemaRegistry.getRegisteredTypes()
+        };
     }
-    getMetaItems(type) {
-        return SchemaRegistry.listItems(type);
+    async getMetaItems(request) {
+        return {
+            type: request.type,
+            items: SchemaRegistry.listItems(request.type)
+        };
     }
-    getMetaItem(type, name) {
-        return SchemaRegistry.getItem(type, name);
+    async getMetaItem(request) {
+        return {
+            type: request.type,
+            name: request.name,
+            item: SchemaRegistry.getItem(request.type, request.name)
+        };
     }
-    getUiView(object, type) {
-        const schema = SchemaRegistry.getObject(object);
+    async getUiView(request) {
+        const schema = SchemaRegistry.getObject(request.object);
         if (!schema)
-            throw new Error(`Object ${object} not found`);
-        if (type === 'list') {
-            return {
+            throw new Error(`Object ${request.object} not found`);
+        let view;
+        if (request.type === 'list') {
+            view = {
                 type: 'list',
-                object: object,
+                object: request.object,
                 columns: Object.keys(schema.fields || {}).slice(0, 5).map(f => ({
                     field: f,
                     label: schema.fields[f].label || f
@@ -39,9 +60,9 @@ export class ObjectStackProtocolImplementation {
             };
         }
         else {
-            return {
+            view = {
                 type: 'form',
-                object: object,
+                object: request.object,
                 sections: [
                     {
                         label: 'General',
@@ -52,36 +73,193 @@ export class ObjectStackProtocolImplementation {
                 ]
             };
         }
+        return {
+            object: request.object,
+            type: request.type,
+            view
+        };
+    }
+    async findData(request) {
+        // TODO: Normalize query from HTTP Query params (string values) to DataEngineQueryOptions (typed)
+        // For now, we assume query is partially compatible or simple enough.
+        // We should parse 'top', 'skip', 'limit' to numbers if they are strings.
+        const options = { ...request.query };
+        if (options.top)
+            options.top = Number(options.top);
+        if (options.skip)
+            options.skip = Number(options.skip);
+        if (options.limit)
+            options.limit = Number(options.limit);
+        // Handle OData style $filter if present, or flat filters
+        // This is a naive implementation, a real OData parser is needed for complex scenarios.
+        const records = await this.engine.find(request.object, options);
+        return {
+            object: request.object,
+            value: records, // OData compaibility
+            records, // Legacy
+            total: records.length,
+            hasMore: false
+        };
     }
-    findData(object, query) {
-        return this.engine.find(object, query);
-    }
-    async getData(object, id) {
-        // IDataEngine doesn't have findOne, so we simulate it with find and limit 1
-        // Assuming the ID field is named '_id' or 'id'. 
-        // For broad compatibility, we might need to know the ID field name.
-        // But traditionally it is _id in ObjectStack/mongo or id in others.
-        // Let's rely on finding by ID if the engine supports it via find?
-        // Actually, ObjectQL (the implementation) DOES have findOne.
-        // But we are programming against IDataEngine interface here.
-        // If the engine IS ObjectQL (which it practically is), we could cast it.
-        // But let's try to stick to interface.
-        const results = await this.engine.find(object, {
-            filter: { _id: id }, // Default Assumption: _id
-            limit: 1
+    async getData(request) {
+        const result = await this.engine.findOne(request.object, {
+            filter: { _id: request.id }
         });
-        if (results && results.length > 0) {
-            return results[0];
+        if (result) {
+            return {
+                object: request.object,
+                id: request.id,
+                record: result
+            };
         }
-        throw new Error(`Record ${id} not found in ${object}`);
+        throw new Error(`Record ${request.id} not found in ${request.object}`);
+    }
+    async createData(request) {
+        const result = await this.engine.insert(request.object, request.data);
+        return {
+            object: request.object,
+            id: result._id || result.id,
+            record: result
+        };
+    }
+    async updateData(request) {
+        // Adapt: update(obj, id, data) -> update(obj, data, options)
+        const result = await this.engine.update(request.object, request.data, { filter: { _id: request.id } });
+        return {
+            object: request.object,
+            id: request.id,
+            record: result
+        };
     }
-    createData(object, data) {
-        return this.engine.insert(object, data);
+    async deleteData(request) {
+        // Adapt: delete(obj, id) -> delete(obj, options)
+        await this.engine.delete(request.object, { filter: { _id: request.id } });
+        return {
+            object: request.object,
+            id: request.id,
+            success: true
+        };
+    }
+    // ==========================================
+    // Metadata Caching
+    // ==========================================
+    async getMetaItemCached(request) {
+        try {
+            const item = SchemaRegistry.getItem(request.type, request.name);
+            if (!item) {
+                throw new Error(`Metadata item ${request.type}/${request.name} not found`);
+            }
+            // Calculate ETag (simple hash of the stringified metadata)
+            const content = JSON.stringify(item);
+            const hash = simpleHash(content);
+            const etag = { value: hash, weak: false };
+            // Check If-None-Match header
+            if (request.cacheRequest?.ifNoneMatch) {
+                const clientEtag = request.cacheRequest.ifNoneMatch.replace(/^"(.*)"$/, '$1').replace(/^W\/"(.*)"$/, '$1');
+                if (clientEtag === hash) {
+                    // Return 304 Not Modified
+                    return {
+                        notModified: true,
+                        etag,
+                    };
+                }
+            }
+            // Return full metadata with cache headers
+            return {
+                data: item,
+                etag,
+                lastModified: new Date().toISOString(),
+                cacheControl: {
+                    directives: ['public', 'max-age'],
+                    maxAge: 3600, // 1 hour
+                },
+                notModified: false,
+            };
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    // ==========================================
+    // Batch Operations
+    // ==========================================
+    async batchData(_request) {
+        // Map high-level batch request to DataEngine batch if available
+        // Or implement loop here.
+        // For now, let's just fail or implement basic loop to satisfying interface
+        // since full batch mapping requires careful type handling.
+        throw new Error('Batch operations not yet fully implemented in protocol adapter');
+    }
+    async createManyData(request) {
+        const records = await this.engine.insert(request.object, request.records);
+        return {
+            object: request.object,
+            records,
+            count: records.length
+        };
+    }
+    async updateManyData(_request) {
+        // TODO: Implement proper updateMany in DataEngine
+        throw new Error('updateManyData not implemented');
+    }
+    async deleteManyData(request) {
+        // This expects deleting by IDs.
+        return this.engine.delete(request.object, {
+            filter: { _id: { $in: request.ids } },
+            ...request.options
+        });
+    }
+    // ==========================================
+    // View Storage (Mock Implementation for now)
+    // ==========================================
+    async createView(request) {
+        const id = Math.random().toString(36).substring(7);
+        // Cast to unknown then SavedView to bypass strict type checks for the mock
+        const view = {
+            id,
+            ...request,
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+            createdBy: 'system',
+            updatedBy: 'system'
+        };
+        this.viewStorage.set(id, view);
+        return { success: true, data: view };
+    }
+    async getView(request) {
+        const view = this.viewStorage.get(request.id);
+        if (!view)
+            throw new Error(`View ${request.id} not found`);
+        return { success: true, data: view };
+    }
+    async listViews(request) {
+        const views = Array.from(this.viewStorage.values())
+            .filter(v => !request?.object || v.object === request.object);
+        return {
+            success: true,
+            data: views,
+            pagination: {
+                total: views.length,
+                limit: request.limit || 50,
+                offset: request.offset || 0,
+                hasMore: false
+            }
+        };
     }
-    updateData(object, id, data) {
-        return this.engine.update(object, id, data);
+    async updateView(request) {
+        const view = this.viewStorage.get(request.id);
+        if (!view)
+            throw new Error(`View ${request.id} not found`);
+        const { id, ...updates } = request;
+        // Cast to unknown then SavedView to bypass strict type checks for the mock
+        const updated = { ...view, ...updates, updatedAt: new Date().toISOString() };
+        this.viewStorage.set(request.id, updated);
+        return { success: true, data: updated };
     }
-    deleteData(object, id) {
-        return this.engine.delete(object, id);
+    async deleteView(request) {
+        const deleted = this.viewStorage.delete(request.id);
+        if (!deleted)
+            throw new Error(`View ${request.id} not found`);
+        return { success: true, object: 'view', id: request.id };
     }
 }

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@objectstack/objectql",
-  "version": "0.6.1",
+  "version": "0.7.2",
   "description": "Isomorphic ObjectQL Engine for ObjectStack",
   "main": "src/index.ts",
   "types": "src/index.ts",
   "dependencies": {
-    "@objectstack/core": "0.6.1",
-    "@objectstack/spec": "0.6.1",
-    "@objectstack/types": "0.6.1"
+    "@objectstack/core": "0.7.2",
+    "@objectstack/spec": "0.7.2",
+    "@objectstack/types": "0.7.2"
   },
   "devDependencies": {
     "typescript": "^5.0.0",
@@ -15,6 +15,6 @@
   },
   "scripts": {
     "build": "tsc",
-    "test": "vitest"
+    "test": "echo no tests"
   }
 }