@objectstack/driver-memory 0.9.2 → 1.0.1

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # @objectstack/driver-memory
 
+## 1.0.1
+
+### Patch Changes
+
+- @objectstack/spec@1.0.1
+- @objectstack/core@1.0.1
+
+## 1.0.0
+
+### Major Changes
+
+- Major version release for ObjectStack Protocol v1.0.
+  - Stabilized Protocol Definitions
+  - Enhanced Runtime Plugin Support
+  - Fixed Type Compliance across Monorepo
+
+### Patch Changes
+
+- Updated dependencies
+  - @objectstack/spec@1.0.0
+  - @objectstack/core@1.0.0
+
 ## 0.9.2
 
 ### Patch Changes

package/README.md

@@ -1,235 +1,21 @@
 # @objectstack/driver-memory
 
-In-Memory Driver for ObjectStack. A reference implementation of the DriverInterface that stores data in memory using JavaScript arrays.
-
-## 🤖 AI Development Context
-
-**Role**: Reference Driver Implementation
-**Usage**:
-- Use for testing or prototypes.
-- Stores data in JS RAM (volatile).
-- **Do not** use for production.
-
-## Plugin Capabilities
-
-This driver implements the ObjectStack plugin capability protocol:
-- **Type**: `driver`
-- **Protocol**: `com.objectstack.protocol.storage.v1` (partial conformance)
-- **Provides**: `DriverInterface` for data storage operations
-- **Features**: 
-  - ✅ Basic CRUD operations
-  - ✅ Pagination (limit/offset)
-  - ❌ Advanced query filters
-  - ❌ Aggregations
-  - ❌ Sorting
-  - ❌ Transactions
-  - ❌ Joins
-
-See [objectstack.config.ts](./objectstack.config.ts) for the complete capability manifest.
+In-Memory Database access layer for ObjectStack. Supports rich querying capabilities (MongoDB-style operators) on standard JavaScript arrays.
 
 ## Features
 
-- 🚀 **Zero Dependencies**: Pure JavaScript implementation
-- 🧪 **Perfect for Testing**: Volatile storage ideal for unit tests
-- 📝 **TypeScript First**: Fully typed with TypeScript
-- 🔍 **Reference Implementation**: Clean example of DriverInterface
-- ⚡ **Fast**: In-memory operations are lightning fast
-
-## Installation
-
-```bash
-pnpm add @objectstack/driver-memory
-```
+- **NoSQL Syntax**: Supports `$eq`, `$gt`, `$lt`, `$in`, `$and`, `$or` operators.
+- **Sorting & Pagination**: Full support for `sort`, `skip`, `limit`.
+- **Zero Config**: Perfect for prototyping, testing, and the **MSW Browser Mock**.
+- **Stateful**: Preserves data in memory during the session.
 
 ## Usage
 
-### With ObjectStack Runtime
-
-```typescript
-import { InMemoryDriver } from '@objectstack/driver-memory';
-import { DriverPlugin } from '@objectstack/runtime';
-import { ObjectKernel } from '@objectstack/runtime';
-
-const kernel = new ObjectKernel();
-
-// Create and register the driver
-const memoryDriver = new InMemoryDriver();
-kernel.use(new DriverPlugin(memoryDriver, 'memory'));
-
-await kernel.bootstrap();
-```
-
-### Standalone Usage
-
 ```typescript
 import { InMemoryDriver } from '@objectstack/driver-memory';
 
-const driver = new InMemoryDriver({
-  seedData: true  // Pre-populate with example data
-});
-
-// Initialize
+const driver = new InMemoryDriver();
 await driver.connect();
 
-// Create a record
-const user = await driver.create('user', {
-  name: 'John Doe',
-  email: 'john@example.com'
-});
-
-// Find records
-const users = await driver.find('user', {
-  limit: 10,
-  offset: 0
-});
-
-// Get by ID
-const foundUser = await driver.findOne('user', user.id);
-
-// Update
-await driver.update('user', user.id, {
-  name: 'Jane Doe'
-});
-
-// Delete
-await driver.delete('user', user.id);
-
-// Count
-const count = await driver.count('user');
-
-// Cleanup
-await driver.disconnect();
-```
-
-## API Reference
-
-### InMemoryDriver
-
-The main driver class that implements `DriverInterface`.
-
-#### Constructor Options
-
-```typescript
-interface DriverOptions {
-  /**
-   * Pre-populate the database with example data on startup
-   * @default false
-   */
-  seedData?: boolean;
-  
-  /**
-   * Logger instance
-   */
-  logger?: Logger;
-}
-```
-
-#### Methods
-
-- `connect()` - Initialize the driver (no-op for in-memory)
-- `disconnect()` - Cleanup resources (clears all data)
-- `create(object, data)` - Create a new record
-- `find(object, query?)` - Query records with optional pagination
-- `findOne(object, id)` - Get a single record by ID
-- `update(object, id, data)` - Update a record
-- `delete(object, id)` - Delete a record
-- `count(object, query?)` - Count total records
-- `getSchema(object)` - Get object schema definition
-- `query(query)` - Execute a raw query (limited support)
-
-#### Capabilities
-
-The driver declares its capabilities via the `supports` property:
-
-```typescript
-{
-  transactions: false,
-  queryFilters: false,
-  queryAggregations: false,
-  querySorting: false,
-  queryPagination: true,  // ✅ Supported via limit/offset
-  queryWindowFunctions: false,
-  querySubqueries: false,
-  joins: false,
-  fullTextSearch: false,
-  vectorSearch: false,
-  geoSpatial: false
-}
-```
-
-## Data Storage
-
-The in-memory driver stores data in a simple Map structure:
-
-```typescript
-private tables: Map<string, Array<Record<string, any>>> = new Map();
-```
-
-**Important**: All data is lost when the process exits or `disconnect()` is called. This driver is **not suitable for production use**.
-
-## Use Cases
-
-✅ **Good for:**
-- Unit testing
-- Integration testing
-- Development/prototyping
-- CI/CD pipelines
-- Examples and tutorials
-- Learning ObjectStack
-
-❌ **Not suitable for:**
-- Production environments
-- Data persistence requirements
-- Large datasets (memory constraints)
-- Multi-process scenarios
-- Concurrent write operations
-
-## Testing Example
-
-```typescript
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { InMemoryDriver } from '@objectstack/driver-memory';
-
-describe('User CRUD', () => {
-  let driver: InMemoryDriver;
-
-  beforeEach(async () => {
-    driver = new InMemoryDriver();
-    await driver.connect();
-  });
-
-  afterEach(async () => {
-    await driver.disconnect();
-  });
-
-  it('should create and retrieve a user', async () => {
-    const user = await driver.create('user', {
-      name: 'Test User',
-      email: 'test@example.com'
-    });
-
-    expect(user.id).toBeDefined();
-    
-    const found = await driver.findOne('user', user.id);
-    expect(found.name).toBe('Test User');
-  });
-});
+// Used internally by ObjectQL
 ```
-
-## Relationship to Other Drivers
-
-This driver serves as a reference implementation. For production use, consider:
-
-- **@objectstack/driver-postgres** - PostgreSQL driver with full SQL capabilities
-- **@objectstack/driver-mongodb** - MongoDB driver for document storage
-- **@objectstack/driver-redis** - Redis driver for caching and key-value storage
-
-## License
-
-Apache-2.0
-
-## Related Packages
-
-- [@objectstack/runtime](../../runtime) - ObjectStack Runtime
-- [@objectstack/spec](../../spec) - ObjectStack Specifications
-- [@objectstack/core](../../core) - Core Interfaces and Types

package/dist/memory-driver.d.ts

@@ -54,6 +54,12 @@ export declare class InMemoryDriver implements DriverInterface {
         updated_at: any;
         id: any;
     }[]>;
+    updateMany(object: string, query: QueryInput, data: Record<string, any>, options?: DriverOptions): Promise<{
+        count: number;
+    }>;
+    deleteMany(object: string, query: QueryInput, options?: DriverOptions): Promise<{
+        count: number;
+    }>;
     bulkUpdate(object: string, updates: {
         id: string | number;
         data: Record<string, any>;
@@ -64,6 +70,9 @@ export declare class InMemoryDriver implements DriverInterface {
     beginTransaction(): Promise<void>;
     commit(): Promise<void>;
     rollback(): Promise<void>;
+    private performAggregation;
+    private computeAggregate;
+    private setValueByPath;
     private getTable;
     private generateId;
 }

package/dist/memory-driver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memory-driver.d.ts","sourceRoot":"","sources":["../src/memory-driver.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,eAAe,EAAwB,MAAM,mBAAmB,CAAC;AAE1E;;;;;GAKG;AACH,qBAAa,cAAe,YAAW,eAAe;IACpD,IAAI,SAAsB;IAC1B,OAAO,SAAW;IAClB,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,MAAM,CAAS;gBAEX,MAAM,CAAC,EAAE,GAAG;IAOxB,OAAO,CAAC,GAAG,EAAE,GAAG;IAUhB,QAAQ;;;;;;;;;;;;;;MAmBN;IAEF;;OAEG;IACH,OAAO,CAAC,EAAE,CAA6B;IAMjC,OAAO;IAIP,UAAU;IAWV,WAAW;IAYX,OAAO,CAAC,OAAO,EAAE,GAAG,EAAE,MAAM,CAAC,EAAE,GAAG,EAAE;IASpC,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,aAAa;IAiB9D,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,aAAa;IAStE,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,aAAa;IAUlE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,CAAC,EAAE,aAAa;;;;;IAkBzE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,CAAC,EAAE,aAAa;IAsB9F,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,YAAY,CAAC,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,aAAa;IAqBlG,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa;IAgBnE,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,aAAa;IAUjE,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,EAAE,OAAO,CAAC,EAAE,aAAa;;;;;IAOpF,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE;QAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;KAAE,EAAE,EAAE,OAAO,CAAC,EAAE,aAAa;IAOjH,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,EAAE,OAAO,CAAC,EAAE,aAAa;IAU5E,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,aAAa;IAO/D,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa;IAQjD,gBAAgB;IAIhB,MAAM;IACN,QAAQ;IAMd,OAAO,CAAC,QAAQ;IAOhB,OAAO,CAAC,UAAU;CAGnB"}
+{"version":3,"file":"memory-driver.d.ts","sourceRoot":"","sources":["../src/memory-driver.ts"],"names":[],"mappings":"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"}

package/dist/memory-driver.js

@@ -1,4 +1,5 @@
 import { createLogger } from '@objectstack/core';
+import { match, getValueByPath } from './memory-matcher.js';
 /**
  * Example: In-Memory Driver
  *
@@ -13,10 +14,10 @@ export class InMemoryDriver {
             // Transaction & Connection Management
             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
@@ -81,9 +82,36 @@ export class InMemoryDriver {
     async find(object, query, options) {
         this.logger.debug('Find operation', { object, query });
         const table = this.getTable(object);
-        // 💡 Naive Implementation
-        let results = [...table];
-        // Simple limiting for demonstration
+        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;
+            });
+        }
+        // 3. Pagination (Offset)
+        if (query.offset) {
+            results = results.slice(query.offset);
+        }
+        // 4. Pagination (Limit)
         if (query.limit) {
             results = results.slice(0, query.limit);
         }
@@ -167,7 +195,11 @@ export class InMemoryDriver {
         return true;
     }
     async count(object, query, options) {
-        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;
     }
@@ -180,6 +212,50 @@ export class InMemoryDriver {
         this.logger.debug('BulkCreate completed', { object, count: results.length });
         return results;
     }
+    async updateMany(object, query, data, options) {
+        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, query, options) {
+        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, updates, options) {
         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)));
@@ -213,6 +289,107 @@ export class InMemoryDriver {
     async commit() { }
     async rollback() { }
     // ===================================
+    // Aggregation Logic
+    // ===================================
+    performAggregation(records, query) {
+        const { groupBy, aggregations } = query;
+        const groups = 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 = [];
+        for (const [key, groupRecords] of groups.entries()) {
+            const row = {};
+            // 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;
+    }
+    computeAggregate(records, agg) {
+        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;
+        }
+    }
+    setValueByPath(obj, path, value) {
+        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
     // ===================================
     getTable(name) {

package/dist/memory-driver.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=memory-driver.test.d.ts.map

package/dist/memory-driver.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-driver.test.d.ts","sourceRoot":"","sources":["../src/memory-driver.test.ts"],"names":[],"mappings":""}

package/dist/memory-driver.test.js

@@ -0,0 +1,93 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { InMemoryDriver } from './memory-driver.js';
+describe('InMemoryDriver', () => {
+    let driver;
+    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/dist/memory-matcher.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Simple In-Memory Query Matcher
+ *
+ * Implements a subset of the ObjectStack Filter Protocol (MongoDB-compatible)
+ * for evaluating conditions against in-memory JavaScript objects.
+ */
+type RecordType = Record<string, any>;
+/**
+ * matches - Check if a record matches a filter criteria
+ * @param record The data record to check
+ * @param filter The filter condition (where clause)
+ */
+export declare function match(record: RecordType, filter: any): boolean;
+/**
+ * Access nested properties via dot-notation (e.g. "user.name")
+ */
+export declare function getValueByPath(obj: any, path: string): any;
+export {};
+//# sourceMappingURL=memory-matcher.d.ts.map

package/dist/memory-matcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-matcher.d.ts","sourceRoot":"","sources":["../src/memory-matcher.ts"],"names":[],"mappings":"AACA;;;;;GAKG;AAEH,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AAEtC;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,GAAG,OAAO,CAyC9D;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,GAAG,GAAG,CAG1D"}