@objectql/server 4.0.0 → 4.0.2

package/test/rest.test.ts

@@ -27,37 +27,97 @@ class MockDriver implements Driver {
     async find(objectName: string, query: any) {
         let items = this.data[objectName] || [];
         
-        // Apply filters if provided
+        // Apply filters if provided (supports FilterNode array format)
         if (query && query.filters) {
-            const filters = query.filters;
-            if (typeof filters === 'object') {
-                const filterKeys = Object.keys(filters);
-                if (filterKeys.length > 0) {
-                    items = items.filter(item => {
-                        for (const [key, value] of Object.entries(filters)) {
-                            if (item[key] !== value) {
-                                return false;
-                            }
-                        }
-                        return true;
-                    });
-                }
-            }
+            items = items.filter(item => this.matchesFilter(item, query.filters));
         }
         
-        // Apply skip and limit if provided
+        // Apply skip and top/limit if provided (QueryAST uses 'top' for limit)
         if (query) {
             if (query.skip) {
                 items = items.slice(query.skip);
             }
-            if (query.limit) {
-                items = items.slice(0, query.limit);
+            if (query.top || query.limit) {
+                items = items.slice(0, query.top || query.limit);
             }
         }
         
         return items;
     }
-    
+
+    /**
+     * Matches an item against a filter condition
+     * @param item - The data item to test
+     * @param filter - The filter in FilterNode array format or simple object format
+     *                 FilterNode format: [field, op, value] for single condition
+     *                 Complex filters: [[field, op, value], 'and', [field2, op2, value2]]
+     *                 Simple format: { field: value }
+     * @returns true if item matches the filter
+     */
+    private matchesFilter(item: any, filter: any): boolean {
+        if (!filter) return true;
+        
+        // Handle FilterNode array format: [[field, op, value]] or [[field, op, value], 'and', [field2, op2, value2]]
+        if (Array.isArray(filter)) {
+            // Single condition: [field, op, value]
+            if (filter.length === 3 && typeof filter[0] === 'string') {
+                const [field, op, value] = filter;
+                return this.evaluateCondition(item, field, op, value);
+            }
+            
+            // Multiple conditions with logical operators
+            let result = true;
+            let currentOp = 'and';
+            for (let i = 0; i < filter.length; i++) {
+                const element = filter[i];
+                if (typeof element === 'string') {
+                    currentOp = element; // 'and' or 'or'
+                } else if (Array.isArray(element)) {
+                    const conditionResult = this.matchesFilter(item, element);
+                    if (currentOp === 'and') {
+                        result = result && conditionResult;
+                    } else if (currentOp === 'or') {
+                        result = result || conditionResult;
+                    }
+                }
+            }
+            return result;
+        }
+        
+        // Handle simple object format: { field: value }
+        if (typeof filter === 'object') {
+            for (const [key, value] of Object.entries(filter)) {
+                if (item[key] !== value) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        
+        return true;
+    }
+
+    /**
+     * Evaluates a single filter condition
+     * @param item - The data item to test
+     * @param field - The field name
+     * @param op - The operator: '=', '!=', '>', '>=', '<', '<=', 'in'
+     * @param value - The value to compare against
+     * @returns true if the condition is satisfied
+     */
+    private evaluateCondition(item: any, field: string, op: string, value: any): boolean {
+        const fieldValue = item[field];
+        switch (op) {
+            case '=': return fieldValue === value;
+            case '!=': return fieldValue !== value;
+            case '>': return fieldValue > value;
+            case '>=': return fieldValue >= value;
+            case '<': return fieldValue < value;
+            case '<=': return fieldValue <= value;
+            case 'in': return Array.isArray(value) ? value.includes(fieldValue) : false;
+            default: return true;
+        }
+    }
     async findOne(objectName: string, id: string | number, query?: any, options?: any) {
         const items = this.data[objectName] || [];
         if (id !== undefined && id !== null) {
@@ -97,7 +157,13 @@ class MockDriver implements Driver {
     }
     
     async count(objectName: string, query: any) {
-        return (this.data[objectName] || []).length;
+        // Count should apply filters but not skip/limit
+        const countQuery = { ...query };
+        delete countQuery.skip;
+        delete countQuery.top;
+        delete countQuery.limit;
+        const items = await this.find(objectName, countQuery);
+        return items.length;
     }
     
     async createMany(objectName: string, data: any[]) {
@@ -201,6 +267,8 @@ describe('REST API Adapter', () => {
                 }
             }
         });
+        
+        await app.init();
 
         // Create handler and server once for all tests
         handler = createRESTHandler(app);
@@ -223,8 +291,9 @@ describe('REST API Adapter', () => {
             .set('Accept', 'application/json');
 
         expect(response.status).toBe(200);
-        expect(response.body.name).toBe('Alice');
-        expect(response.body['@type']).toBe('user');
+        expect(response.body.data).toBeDefined();
+        expect(response.body.data.name).toBe('Alice');
+        expect(response.body.data['@type']).toBe('user');
     });
 
     it('should handle POST /api/data/:object - Create record', async () => {
@@ -234,9 +303,10 @@ describe('REST API Adapter', () => {
             .set('Accept', 'application/json');
 
         expect(response.status).toBe(201);
-        expect(response.body.name).toBe('Charlie');
-        expect(response.body._id).toBeDefined();
-        expect(response.body['@type']).toBe('user');
+        expect(response.body.data).toBeDefined();
+        expect(response.body.data.name).toBe('Charlie');
+        expect(response.body.data._id).toBeDefined();
+        expect(response.body.data['@type']).toBe('user');
     });
 
     it('should handle PUT /api/data/:object/:id - Update record', async () => {
@@ -254,8 +324,9 @@ describe('REST API Adapter', () => {
             .set('Accept', 'application/json');
 
         expect(response.status).toBe(200);
-        expect(response.body.deleted).toBe(true);
-        expect(response.body['@type']).toBe('user');
+        expect(response.body.data).toBeDefined();
+        expect(response.body.data.deleted).toBe(true);
+        expect(response.body.data['@type']).toBe('user');
     });
 
     it('should return 404 for non-existent object', async () => {
@@ -442,7 +513,8 @@ describe('REST API Adapter', () => {
 
             // Should still work as single create
             expect(response.status).toBe(201);
-            expect(response.body._id).toBeDefined();
+            expect(response.body.data).toBeDefined();
+            expect(response.body.data._id).toBeDefined();
         });
     });
 });