@objectstack/driver-memory 0.9.2 → 1.0.1

package/dist/memory-matcher.js

@@ -0,0 +1,160 @@
+/**
+ * Simple In-Memory Query Matcher
+ *
+ * Implements a subset of the ObjectStack Filter Protocol (MongoDB-compatible)
+ * for evaluating conditions against in-memory JavaScript objects.
+ */
+/**
+ * matches - Check if a record matches a filter criteria
+ * @param record The data record to check
+ * @param filter The filter condition (where clause)
+ */
+export function match(record, filter) {
+    if (!filter || Object.keys(filter).length === 0)
+        return true;
+    // 1. Handle Top-Level Logical Operators ($and, $or, $not)
+    // These usually appear at the root or nested.
+    // $and: [ { ... }, { ... } ]
+    if (Array.isArray(filter.$and)) {
+        if (!filter.$and.every((f) => match(record, f))) {
+            return false;
+        }
+    }
+    // $or: [ { ... }, { ... } ]
+    if (Array.isArray(filter.$or)) {
+        if (!filter.$or.some((f) => match(record, f))) {
+            return false;
+        }
+    }
+    // $not: { ... }
+    if (filter.$not) {
+        if (match(record, filter.$not)) {
+            return false;
+        }
+    }
+    // 2. Iterate over field constraints
+    for (const key of Object.keys(filter)) {
+        // Skip logical operators we already handled (or future ones)
+        if (key.startsWith('$'))
+            continue;
+        const condition = filter[key];
+        const value = getValueByPath(record, key);
+        if (!checkCondition(value, condition)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Access nested properties via dot-notation (e.g. "user.name")
+ */
+export function getValueByPath(obj, path) {
+    if (!path.includes('.'))
+        return obj[path];
+    return path.split('.').reduce((o, i) => (o ? o[i] : undefined), obj);
+}
+/**
+ * Evaluate a specific condition against a value
+ */
+function checkCondition(value, condition) {
+    // Case A: Implicit Equality (e.g. status: 'active')
+    // If condition is a primitive or Date/Array (exact match), treat as equality.
+    if (typeof condition !== 'object' ||
+        condition === null ||
+        condition instanceof Date ||
+        Array.isArray(condition)) {
+        // Loose equality to handle undefined/null mismatch or string/number coercion if desired.
+        // But stick to == for JS loose equality which is often convenient in weakly typed queries.
+        return value == condition;
+    }
+    // Case B: Operator Object (e.g. { $gt: 10, $lt: 20 })
+    const keys = Object.keys(condition);
+    const isOperatorObject = keys.some(k => k.startsWith('$'));
+    if (!isOperatorObject) {
+        // It's just a nested object comparison or implicit equality against an object
+        // Simplistic check:
+        return JSON.stringify(value) === JSON.stringify(condition);
+    }
+    // Iterate operators
+    for (const op of keys) {
+        const target = condition[op];
+        // Handle undefined values
+        if (value === undefined && op !== '$exists' && op !== '$ne') {
+            return false;
+        }
+        switch (op) {
+            case '$eq':
+                if (value != target)
+                    return false;
+                break;
+            case '$ne':
+                if (value == target)
+                    return false;
+                break;
+            // Numeric / Date
+            case '$gt':
+                if (!(value > target))
+                    return false;
+                break;
+            case '$gte':
+                if (!(value >= target))
+                    return false;
+                break;
+            case '$lt':
+                if (!(value < target))
+                    return false;
+                break;
+            case '$lte':
+                if (!(value <= target))
+                    return false;
+                break;
+            case '$between':
+                // target should be [min, max]
+                if (Array.isArray(target) && (value < target[0] || value > target[1]))
+                    return false;
+                break;
+            // Sets
+            case '$in':
+                if (!Array.isArray(target) || !target.includes(value))
+                    return false;
+                break;
+            case '$nin':
+                if (Array.isArray(target) && target.includes(value))
+                    return false;
+                break;
+            // Existence
+            case '$exists':
+                const exists = value !== undefined && value !== null;
+                if (exists !== !!target)
+                    return false;
+                break;
+            // Strings
+            case '$contains':
+                if (typeof value !== 'string' || !value.includes(target))
+                    return false;
+                break;
+            case '$startsWith':
+                if (typeof value !== 'string' || !value.startsWith(target))
+                    return false;
+                break;
+            case '$endsWith':
+                if (typeof value !== 'string' || !value.endsWith(target))
+                    return false;
+                break;
+            case '$regex':
+                try {
+                    const re = new RegExp(target, condition.$options || '');
+                    if (!re.test(String(value)))
+                        return false;
+                }
+                catch (e) {
+                    return false;
+                }
+                break;
+            default:
+                // Unknown operator, ignore or fail. Ignoring safe for optional features.
+                break;
+        }
+    }
+    return true;
+}

package/package.json

@@ -1,18 +1,22 @@
 {
   "name": "@objectstack/driver-memory",
-  "version": "0.9.2",
+  "version": "1.0.1",
+  "license": "Apache-2.0",
   "description": "In-Memory Driver for ObjectStack (Reference Implementation)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "dependencies": {
-    "@objectstack/core": "0.9.2",
-    "@objectstack/spec": "0.9.2"
+    "@objectstack/core": "1.0.1",
+    "@objectstack/spec": "1.0.1"
   },
   "devDependencies": {
-    "typescript": "^5.0.0"
+    "typescript": "^5.0.0",
+    "vitest": "^4.0.18",
+    "@types/node": "^25.1.0"
   },
   "scripts": {
     "build": "tsc",
-    "dev": "tsc -w"
+    "dev": "tsc -w",
+    "test": "vitest run"
   }
 }

package/src/memory-driver.test.ts

@@ -0,0 +1,120 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { InMemoryDriver } from './memory-driver.js';
+
+describe('InMemoryDriver', () => {
+  let driver: InMemoryDriver;
+  const testTable = 'test_table';
+
+  beforeEach(async () => {
+    driver = new InMemoryDriver();
+    await driver.connect();
+    // No explicit clear DB method exposed, but new instance is clean.
+  });
+
+  describe('Lifecycle', () => {
+    it('should connect successfully', async () => {
+      expect(driver.checkHealth()).resolves.toBe(true);
+    });
+
+    it('should clear data on disconnect', async () => {
+      await driver.create(testTable, { id: '1', name: 'test' });
+      await driver.disconnect();
+      const results = await driver.find(testTable, { fields: ['id'], object: testTable });
+      expect(results).toHaveLength(0);
+    });
+  });
+
+  describe('Plugin Installation', () => {
+      it('should register driver with engine', () => {
+          const registerDriverFn = vi.fn();
+          const mockEngine = {
+              ql: {
+                  registerDriver: registerDriverFn
+              }
+          };
+          
+          driver.install({ engine: mockEngine });
+          expect(registerDriverFn).toHaveBeenCalledWith(driver);
+      });
+      
+       it('should handle missing engine gracefully', () => {
+          const mockCtx = {}; // No engine
+          // Should not throw
+          driver.install(mockCtx);
+      });
+  });
+
+  describe('CRUD Operations', () => {
+    it('should create and find records', async () => {
+      const data = { id: '1', name: 'Alice', age: 30 };
+      const created = await driver.create(testTable, data);
+      expect(created.id).toBe('1');
+
+      const results = await driver.find(testTable, { 
+          fields: ['id', 'name', 'age'],
+          object: testTable
+      });
+      
+      expect(results).toHaveLength(1);
+      expect(results[0].id).toBe('1');
+      expect(results[0].name).toBe('Alice');
+    });
+
+    it('should support updating records by ID', async () => {
+      await driver.create(testTable, { id: '1', name: 'Bob', active: true });
+      
+      const updateResult = await driver.update(
+          testTable, 
+          '1', 
+          { active: false }
+      );
+      
+      expect(updateResult.active).toBe(false);
+      
+      const results = await driver.find(testTable, { fields: ['active'], object: testTable });
+      expect(results[0].active).toBe(false);
+    });
+
+    it('should support deleting records by ID', async () => {
+       await driver.create(testTable, { id: '1', name: 'Charlie' });
+       await driver.create(testTable, { id: '2', name: 'David' });
+       
+       const deleteResult = await driver.delete(testTable, '1');
+       expect(deleteResult).toBe(true);
+       
+       const results = await driver.find(testTable, { fields: ['name'], object: testTable });
+       expect(results).toHaveLength(1);
+       expect(results[0].name).toBe('David');
+    });
+  });
+  
+  describe('Query Capability', () => {
+      it('should filter results', async () => {
+          await driver.create(testTable, { id: '1', role: 'admin' });
+          await driver.create(testTable, { id: '2', role: 'user' });
+          await driver.create(testTable, { id: '3', role: 'user' });
+          
+          const results = await driver.find(testTable, {
+              fields: ['id'],
+              object: testTable,
+              where: { role: 'user' }
+          });
+          
+          expect(results).toHaveLength(2);
+      });
+
+      it('should limit results', async () => {
+           await driver.create(testTable, { id: '1' });
+           await driver.create(testTable, { id: '2' });
+           await driver.create(testTable, { id: '3' });
+          
+          const results = await driver.find(testTable, {
+              fields: ['id'],
+              object: testTable,
+              limit: 2
+          });
+          
+          expect(results).toHaveLength(2);
+      });
+  });
+});

package/src/memory-driver.ts

@@ -1,6 +1,7 @@
 import { QueryAST, QueryInput } from '@objectstack/spec/data';
 import { DriverOptions } from '@objectstack/spec/data';
 import { DriverInterface, Logger, createLogger } from '@objectstack/core';
+import { match, getValueByPath } from './memory-matcher.js';
 
 /**
  * Example: In-Memory Driver
@@ -36,10 +37,10 @@ export class InMemoryDriver implements DriverInterface {
     transactions: false, 
     
     // Query Operations
-    queryFilters: false,         // TODO: Not implemented - basic find() doesn't handle filters
-    queryAggregations: false,    // TODO: Not implemented - count() only returns total
-    querySorting: false,         // TODO: Not implemented - find() doesn't handle sorting
-    queryPagination: true,       // Basic pagination via 'limit' is implemented
+    queryFilters: true,          // Implemented via memory-matcher
+    queryAggregations: true,    // Implemented
+    querySorting: true,          // Implemented via JS sort
+    queryPagination: true,       // Implemented
     queryWindowFunctions: false, // TODO: Not implemented
     querySubqueries: false,      // TODO: Not implemented
     joins: false,                // TODO: Not implemented
@@ -101,11 +102,43 @@ export class InMemoryDriver implements DriverInterface {
     this.logger.debug('Find operation', { object, query });
     
     const table = this.getTable(object);
-    
-    // 💡 Naive Implementation
-    let results = [...table];
+    let results = table;
+
+    // 1. Filter
+    if (query.where) {
+        results = results.filter(record => match(record, query.where));
+    }
+
+    // 1.5 Aggregation & Grouping
+    if (query.groupBy || (query.aggregations && query.aggregations.length > 0)) {
+        results = this.performAggregation(results, query);
+    }
+
+    // 2. Sort
+    if (query.orderBy) {
+        // Normalize sort to array
+        const sortFields = Array.isArray(query.orderBy) ? query.orderBy : [query.orderBy];
+        
+        results.sort((a, b) => {
+            for (const { field, order } of sortFields) {
+                const valA = getValueByPath(a, field);
+                const valB = getValueByPath(b, field);
+                
+                if (valA === valB) continue;
+                
+                const comparison = valA > valB ? 1 : -1;
+                return order === 'desc' ? -comparison : comparison;
+            }
+            return 0;
+        });
+    }
 
-    // Simple limiting for demonstration
+    // 3. Pagination (Offset)
+    if (query.offset) {
+        results = results.slice(query.offset);
+    }
+
+    // 4. Pagination (Limit)
     if (query.limit) {
       results = results.slice(0, query.limit);
     }
@@ -211,7 +244,11 @@ export class InMemoryDriver implements DriverInterface {
   }
 
   async count(object: string, query?: QueryInput, options?: DriverOptions) {
-    const count = this.getTable(object).length;
+    let results = this.getTable(object);
+    if (query?.where) {
+        results = results.filter(record => match(record, query.where));
+    }
+    const count = results.length;
     this.logger.debug('Count operation', { object, count });
     return count;
   }
@@ -226,7 +263,62 @@ export class InMemoryDriver implements DriverInterface {
     this.logger.debug('BulkCreate completed', { object, count: results.length });
     return results;
   }
+  
+  async updateMany(object: string, query: QueryInput, data: Record<string, any>, options?: DriverOptions) {
+      this.logger.debug('UpdateMany operation', { object, query });
+      
+      const table = this.getTable(object);
+      let targetRecords = table;
+      
+      if (query && query.where) {
+          targetRecords = targetRecords.filter(r => match(r, query.where));
+      }
+      
+      const count = targetRecords.length;
+      
+      // Update each record
+      for (const record of targetRecords) {
+          // Find index in original table
+          const index = table.findIndex(r => r.id === record.id);
+          if (index !== -1) {
+              const updated = {
+                  ...table[index],
+                  ...data,
+                  updated_at: new Date()
+              };
+              table[index] = updated;
+          }
+      }
+      
+      this.logger.debug('UpdateMany completed', { object, count });
+      return { count };
+  }
 
+  async deleteMany(object: string, query: QueryInput, options?: DriverOptions) {
+      this.logger.debug('DeleteMany operation', { object, query });
+      
+      const table = this.getTable(object);
+      const initialLength = table.length;
+      
+      // Filter IN PLACE or create new array?
+      // Creating new array is safer for now.
+      
+      const remaining = table.filter(r => {
+          if (!query || !query.where) return false; // Delete all? No, standard safety implies explicit empty filter for delete all.
+          // Wait, normally deleteMany({}) deletes all.
+          // Let's assume if query passed, use it.
+          const matches = match(r, query.where);
+          return !matches; // Keep if it DOES NOT match
+      });
+      
+      this.db[object] = remaining;
+      const count = initialLength - remaining.length;
+      
+      this.logger.debug('DeleteMany completed', { object, count });
+      return { count };
+  }
+
+  // Compatibility aliases
   async bulkUpdate(object: string, updates: { id: string | number, data: Record<string, any> }[], options?: DriverOptions) {
     this.logger.debug('BulkUpdate operation', { object, count: updates.length });
     const results = await Promise.all(updates.map(u => this.update(object, u.id, u.data, options)));
@@ -266,6 +358,118 @@ export class InMemoryDriver implements DriverInterface {
   async commit() { /* No-op */ }
   async rollback() { /* No-op */ }
 
+  // ===================================
+  // Aggregation Logic
+  // ===================================
+
+  private performAggregation(records: any[], query: QueryInput): any[] {
+    const { groupBy, aggregations } = query;
+    const groups: Map<string, any[]> = new Map();
+
+    // 1. Group records
+    if (groupBy && groupBy.length > 0) {
+        for (const record of records) {
+            // Create a composite key from group values
+            const keyParts = groupBy.map(field => {
+                const val = getValueByPath(record, field);
+                return val === undefined || val === null ? 'null' : String(val);
+            });
+            const key = JSON.stringify(keyParts);
+            
+            if (!groups.has(key)) {
+                groups.set(key, []);
+            }
+            groups.get(key)!.push(record);
+        }
+    } else {
+        // No grouping -> Single group containing all records
+        // If aggregation is requested without group by, it runs on whole set (even if empty)
+        if (aggregations && aggregations.length > 0) {
+             groups.set('all', records);
+        } else {
+             // Should not be here if performAggregation called correctly
+             groups.set('all', records);
+        }
+    }
+
+    // 2. Compute aggregates for each group
+    const resultRows: any[] = [];
+    
+    for (const [key, groupRecords] of groups.entries()) {
+        const row: any = {};
+        
+        // A. Add Group fields to row (if groupBy exists)
+        if (groupBy && groupBy.length > 0) {
+             if (groupRecords.length > 0) {
+                const firstRecord = groupRecords[0];
+                for (const field of groupBy) {
+                     this.setValueByPath(row, field, getValueByPath(firstRecord, field));
+                }
+             }
+        }
+        
+        // B. Compute Aggregations
+        if (aggregations) {
+            for (const agg of aggregations) {
+                 const value = this.computeAggregate(groupRecords, agg);
+                 row[agg.alias] = value;
+            }
+        }
+        
+        resultRows.push(row);
+    }
+    
+    return resultRows;
+  }
+  
+  private computeAggregate(records: any[], agg: any): any {
+      const { function: func, field } = agg;
+      
+      const values = field ? records.map(r => getValueByPath(r, field)) : [];
+      
+      switch (func) {
+          case 'count':
+              if (!field || field === '*') return records.length;
+              return values.filter(v => v !== null && v !== undefined).length;
+              
+          case 'sum':
+          case 'avg': {
+              const nums = values.filter(v => typeof v === 'number');
+              const sum = nums.reduce((a, b) => a + b, 0);
+              if (func === 'sum') return sum;
+              return nums.length > 0 ? sum / nums.length : null;
+          }
+              
+          case 'min': {
+              // Handle comparable values
+              const valid = values.filter(v => v !== null && v !== undefined);
+              if (valid.length === 0) return null;
+              // Works for numbers and strings
+              return valid.reduce((min, v) => (v < min ? v : min), valid[0]);
+          }
+
+          case 'max': {
+              const valid = values.filter(v => v !== null && v !== undefined);
+              if (valid.length === 0) return null;
+              return valid.reduce((max, v) => (v > max ? v : max), valid[0]);
+          }
+
+          default:
+              return null;
+      }
+  }
+
+  private setValueByPath(obj: any, path: string, value: any) {
+      const parts = path.split('.');
+      let current = obj;
+      for (let i = 0; i < parts.length - 1; i++) {
+          const part = parts[i];
+          if (!current[part]) current[part] = {};
+          current = current[part];
+      }
+      current[parts[parts.length - 1]] = value;
+  }
+
   // ===================================
   // Helpers
   // ===================================