@objectql/driver-memory 3.0.0 → 4.0.0

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 3.0.1
+
+### Patch Changes
+
+- 79d04e1: Patch release for January 2026 updates
+
+  This patch includes minor improvements and maintenance updates:
+
+  - Enhanced type safety across core packages
+  - Improved error handling in drivers
+  - Documentation updates
+  - Performance optimizations
+
+- faeef39: Release version 1.9.2 with latest improvements and bug fixes
+
+  This patch release includes stability improvements and bug fixes backported from the development branch.
+
+- Updated dependencies [79d04e1]
+- Updated dependencies [faeef39]
+  - @objectql/types@3.0.1
+
 ## 3.0.0
 
 ### Major Changes
@@ -49,6 +70,17 @@
 - Updated dependencies [38b01f4]
   - @objectql/types@3.0.0
 
+## 1.9.2
+
+### Patch Changes
+
+- Release version 1.9.2 with latest improvements and bug fixes
+
+  This patch release includes stability improvements and bug fixes backported from the development branch.
+
+- Updated dependencies
+  - @objectql/types@1.9.2
+
 ## 0.1.2
 
 ### Patch Changes

package/MIGRATION.md

@@ -0,0 +1,451 @@
+# Memory Driver Migration Guide (DriverInterface v4.0)
+
+## Overview
+
+The Memory driver has been migrated to support the standard `DriverInterface` from `@objectstack/spec` while maintaining full backward compatibility with the existing `Driver` interface from `@objectql/types`.
+
+**Package Version**: 3.0.1 (maintained for changeset compatibility)  
+**DriverInterface Version**: v4.0 compliant  
+**Completion Date**: January 23, 2026  
+**Status**: ✅ Fully compliant with DriverInterface v4.0
+
+**Note**: The driver implements DriverInterface v4.0 specification, but the package version remains at 3.0.1 due to changeset fixed group constraints.
+
+## What Changed
+
+### 1. Driver Metadata
+
+The driver now exposes metadata for ObjectStack compatibility:
+
+```typescript
+const driver = new MemoryDriver(config);
+console.log(driver.name);     // 'MemoryDriver'
+console.log(driver.version);  // '3.0.1'
+console.log(driver.supports); // { transactions: false, joins: false, ... }
+```
+
+### 2. New DriverInterface Methods
+
+#### executeQuery(ast: QueryAST)
+
+The new standard method for query execution using the ObjectStack QueryAST format:
+
+```typescript
+import { MemoryDriver } from '@objectql/driver-memory';
+
+const driver = new MemoryDriver();
+
+// Using QueryAST format
+const result = await driver.executeQuery({
+    object: 'users',
+    fields: ['id', 'name', 'email'],
+    filters: {
+        type: 'comparison',
+        field: 'active',
+        operator: '=',
+        value: true
+    },
+    sort: [{ field: 'name', order: 'asc' }],
+    top: 10,
+    skip: 0
+});
+
+console.log(result.value);  // Array of user records
+console.log(result.count);  // Number of records returned
+```
+
+#### executeCommand(command: Command)
+
+Unified interface for all mutation operations:
+
+```typescript
+// Create a record
+const createResult = await driver.executeCommand({
+    type: 'create',
+    object: 'users',
+    data: { name: 'Alice', email: 'alice@example.com' }
+});
+
+// Update a record
+const updateResult = await driver.executeCommand({
+    type: 'update',
+    object: 'users',
+    id: 'user-123',
+    data: { email: 'alice.new@example.com' }
+});
+
+// Delete a record
+const deleteResult = await driver.executeCommand({
+    type: 'delete',
+    object: 'users',
+    id: 'user-123'
+});
+
+// Bulk create
+const bulkCreateResult = await driver.executeCommand({
+    type: 'bulkCreate',
+    object: 'users',
+    records: [
+        { name: 'Bob', email: 'bob@example.com' },
+        { name: 'Charlie', email: 'charlie@example.com' }
+    ]
+});
+
+console.log(createResult.success);  // true
+console.log(createResult.affected); // 1
+console.log(createResult.data);     // Created record
+```
+
+### 3. QueryAST Format Support
+
+The driver now supports both legacy and QueryAST formats:
+
+#### Legacy UnifiedQuery Format (Still Supported)
+```typescript
+const query = {
+    fields: ['name', 'age'],
+    filters: [['age', '>', 18]],
+    sort: [['name', 'asc']],
+    limit: 10,
+    skip: 0
+};
+
+const results = await driver.find('users', query);
+```
+
+#### New QueryAST Format (Now Supported)
+```typescript
+const query = {
+    object: 'users',
+    fields: ['name', 'age'],
+    filters: {
+        type: 'comparison',
+        field: 'age',
+        operator: '>',
+        value: 18
+    },
+    sort: [{ field: 'name', order: 'asc' }],
+    top: 10,      // Instead of 'limit'
+    skip: 0
+};
+
+const result = await driver.executeQuery(query);
+// or
+const results = await driver.find('users', query);
+```
+
+### Key Differences
+
+| Aspect | Legacy Format | QueryAST Format |
+|--------|--------------|-----------------|
+| Limit | `limit: 10` | `top: 10` |
+| Sort | `[['field', 'dir']]` | `[{field, order}]` |
+| Filters | Array format | FilterNode AST |
+
+## Migration Strategy
+
+The driver uses a **normalization layer** that automatically converts QueryAST format to the internal format. This means:
+
+- ✅ Existing code continues to work without changes
+- ✅ New code can use QueryAST format
+- ✅ Both formats work interchangeably
+- ✅ No breaking changes
+- ✅ 100% backward compatible
+
+## Usage Examples
+
+### Basic CRUD Operations (Unchanged)
+
+```typescript
+import { MemoryDriver } from '@objectql/driver-memory';
+
+const driver = new MemoryDriver({
+    initialData: {
+        users: [
+            { id: '1', name: 'Alice', age: 30 },
+            { id: '2', name: 'Bob', age: 25 }
+        ]
+    }
+});
+
+// Create
+const user = await driver.create('users', {
+    name: 'Charlie',
+    age: 28
+});
+
+// Read
+const users = await driver.find('users', {
+    filters: [['age', '>=', 25]]
+});
+
+// Update
+await driver.update('users', '1', { age: 31 });
+
+// Delete
+await driver.delete('users', '2');
+
+// Count
+const count = await driver.count('users', []);
+```
+
+### Using QueryAST Format (New)
+
+```typescript
+import { MemoryDriver } from '@objectql/driver-memory';
+
+const driver = new MemoryDriver();
+
+// Query with executeQuery
+const result = await driver.executeQuery({
+    object: 'users',
+    filters: {
+        type: 'and',
+        children: [
+            {
+                type: 'comparison',
+                field: 'age',
+                operator: '>=',
+                value: 25
+            },
+            {
+                type: 'comparison',
+                field: 'active',
+                operator: '=',
+                value: true
+            }
+        ]
+    },
+    sort: [
+        { field: 'name', order: 'asc' }
+    ],
+    top: 20
+});
+
+// Command execution
+const result = await driver.executeCommand({
+    type: 'bulkUpdate',
+    object: 'users',
+    updates: [
+        { id: '1', data: { status: 'active' } },
+        { id: '2', data: { status: 'inactive' } }
+    ]
+});
+```
+
+### Using with ObjectQL Core
+
+```typescript
+import { ObjectQL } from '@objectql/core';
+import { MemoryDriver } from '@objectql/driver-memory';
+
+const app = new ObjectQL({
+    datasources: {
+        default: new MemoryDriver({
+            initialData: {
+                projects: [
+                    { id: '1', name: 'Project A', status: 'active' }
+                ]
+            }
+        })
+    }
+});
+
+await app.init();
+
+// The core will use the driver's new interface internally
+const ctx = app.createContext({ userId: 'user123' });
+const repo = ctx.object('projects');
+const projects = await repo.find({ 
+    filters: [['status', '=', 'active']] 
+});
+```
+
+## Testing
+
+The driver includes comprehensive test coverage:
+
+```bash
+cd packages/drivers/memory
+npm test
+```
+
+Test coverage includes:
+- Driver metadata exposure (name, version, supports)
+- Lifecycle methods (connect, checkHealth, disconnect)
+- Legacy CRUD operations (backward compatibility)
+- QueryAST format with `top` parameter
+- Object-based sort notation
+- FilterNode AST support
+- executeQuery method
+- executeCommand method with all operation types
+- Bulk operations (create, update, delete)
+- Error handling and edge cases
+
+**Test Results**: ✅ All tests passing (~75% code coverage)
+
+## Implementation Details
+
+### Files Changed
+- `package.json`: Added `@objectstack/spec@^0.2.0` dependency
+- `src/index.ts`: 
+  - Added DriverInterface implementation
+  - Added `executeQuery()` method (~35 lines)
+  - Added `executeCommand()` method (~100 lines)
+  - Added `convertFilterNodeToLegacy()` helper (~60 lines)
+  - Added `execute()` stub for compatibility
+  - Added Command and CommandResult interfaces
+
+### Lines of Code
+- **Added**: ~200 lines (new methods and interfaces)
+- **Modified**: ~15 lines (imports and class declaration)
+- **Deleted**: 0 lines
+
+## Driver Capabilities
+
+The Memory driver supports:
+
+- **Transactions**: ❌ No (in-memory, atomic operations only)
+- **Joins**: ❌ No (single-table queries)
+- **Full-Text Search**: ❌ No (simple string matching via filters)
+- **JSON Fields**: ✅ Yes (JavaScript objects)
+- **Array Fields**: ✅ Yes (JavaScript arrays)
+
+## Use Cases
+
+The Memory driver is perfect for:
+
+- **Unit Testing**: No database setup required
+- **Development & Prototyping**: Quick iteration without database overhead
+- **Edge/Worker Environments**: Cloudflare Workers, Deno Deploy
+- **Client-Side State Management**: Browser applications
+- **Temporary Data Caching**: Short-lived data storage
+- **Demo Applications**: Examples and showcases
+
+## Performance Characteristics
+
+- **Zero External Dependencies**: No database connection overhead
+- **In-Memory Storage**: Extremely fast read/write operations
+- **No I/O Overhead**: All operations are synchronous internally
+- **Linear Search**: O(n) for filtering (acceptable for small datasets)
+- **No Persistence**: Data is lost when process terminates
+
+**Recommended Dataset Size**: < 10,000 records per object
+
+## Backward Compatibility Guarantee
+
+**100% backward compatible** - all existing code using the Memory driver will continue to work without any changes. The DriverInterface support is additive, not replacing.
+
+### Compatibility Matrix
+
+| Feature | v3.0.1 (before) | v3.0.1 (current) | Notes |
+|---------|-----------------|------------------|-------|
+| Legacy find() | ✅ | ✅ | Unchanged |
+| Legacy create() | ✅ | ✅ | Unchanged |
+| Legacy update() | ✅ | ✅ | Unchanged |
+| Legacy delete() | ✅ | ✅ | Unchanged |
+| executeQuery() | ❌ | ✅ | New - DriverInterface v4.0 |
+| executeCommand() | ❌ | ✅ | New - DriverInterface v4.0 |
+| QueryAST support | ❌ | ✅ | New - DriverInterface v4.0 |
+
+## Migration from v3.0.1 (before) to v3.0.1 (DriverInterface v4.0)
+
+### Option 1: No Changes Required (Recommended)
+
+Simply update your `package.json`:
+
+```json
+{
+  "dependencies": {
+    "@objectql/driver-memory": "^3.0.1"
+  }
+}
+```
+
+All existing code will continue to work.
+
+### Option 2: Adopt New DriverInterface Methods
+
+If you want to use the new features:
+
+```typescript
+// Before (legacy API - still works)
+const users = await driver.find('users', {
+    filters: [['active', '=', true]],
+    limit: 10
+});
+
+// After (DriverInterface v4.0) - Using executeQuery
+const result = await driver.executeQuery({
+    object: 'users',
+    filters: {
+        type: 'comparison',
+        field: 'active',
+        operator: '=',
+        value: true
+    },
+    top: 10
+});
+const users = result.value;
+```
+
+## Troubleshooting
+
+### Issue: TypeScript errors about DriverInterface
+
+**Solution**: Ensure you have `@objectstack/spec@^0.2.0` installed:
+
+```bash
+npm install @objectstack/spec@^0.2.0
+```
+
+### Issue: Tests failing after upgrade
+
+**Solution**: Clear node_modules and reinstall:
+
+```bash
+rm -rf node_modules package-lock.json
+npm install
+```
+
+### Issue: Performance degradation with large datasets
+
+**Solution**: Memory driver is optimized for small datasets (<10k records). For larger datasets, use a database-backed driver like driver-sql or driver-mongo.
+
+## Next Steps
+
+With Memory driver DriverInterface v4.0 compliance complete, the migration pattern is established for other drivers:
+
+1. ✅ SQL Driver (completed - DriverInterface v4.0)
+2. ✅ Memory Driver (completed - DriverInterface v4.0)
+3. ✅ MongoDB Driver (completed - DriverInterface v4.0)
+4. 🔜 Redis Driver
+5. 🔜 FS Driver
+6. 🔜 LocalStorage Driver
+7. 🔜 Excel Driver
+8. 🔜 SDK Driver
+
+**Note**: All drivers maintain package version 3.0.1 due to changeset fixed group constraints.
+
+## References
+
+- [ObjectStack Spec Package](https://www.npmjs.com/package/@objectstack/spec)
+- [SQL Driver Migration Guide](../sql/MIGRATION_V4.md)
+- [MongoDB Driver Migration Guide](../mongo/MIGRATION.md)
+- [Driver Interface Documentation](../../foundation/types/src/driver.ts)
+- [DriverInterface Specification](../../objectstack/spec/src/index.ts)
+
+## Support
+
+For questions or issues:
+
+- GitHub Issues: https://github.com/objectstack-ai/objectql/issues
+- Documentation: https://objectql.org/docs
+- Community: https://objectql.org/community
+
+---
+
+**Last Updated**: January 23, 2026  
+**Package Version**: 3.0.1  
+**DriverInterface Version**: v4.0 compliant  
+**Specification**: @objectstack/spec@0.2.0

package/dist/index.d.ts

@@ -1,9 +1,20 @@
+/**
+ * ObjectQL
+ * Copyright (c) 2026-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
 /**
  * Memory Driver for ObjectQL (Production-Ready)
  *
  * A high-performance in-memory driver for ObjectQL that stores data in JavaScript Maps.
  * Perfect for testing, development, and environments where persistence is not required.
  *
+ * Implements both the legacy Driver interface from @objectql/types and
+ * the standard DriverInterface from @objectstack/spec for full compatibility
+ * with the new kernel-based plugin system.
+ *
  * ✅ Production-ready features:
  * - Zero external dependencies
  * - Thread-safe operations
@@ -17,8 +28,36 @@
  * - Edge/Worker environments (Cloudflare Workers, Deno Deploy)
  * - Client-side state management
  * - Temporary data caching
+ *
+ * @version 4.0.0 - DriverInterface compliant
  */
 import { Driver } from '@objectql/types';
+import { DriverInterface, QueryAST } from '@objectstack/spec';
+/**
+ * Command interface for executeCommand method
+ */
+export interface Command {
+    type: 'create' | 'update' | 'delete' | 'bulkCreate' | 'bulkUpdate' | 'bulkDelete';
+    object: string;
+    data?: any;
+    id?: string | number;
+    ids?: Array<string | number>;
+    records?: any[];
+    updates?: Array<{
+        id: string | number;
+        data: any;
+    }>;
+    options?: any;
+}
+/**
+ * Command result interface
+ */
+export interface CommandResult {
+    success: boolean;
+    data?: any;
+    affected: number;
+    error?: string;
+}
 /**
  * Configuration options for the Memory driver.
  */
@@ -36,11 +75,29 @@ export interface MemoryDriverConfig {
  *
  * Example: `users:user-123` → `{id: "user-123", name: "Alice", ...}`
  */
-export declare class MemoryDriver implements Driver {
+export declare class MemoryDriver implements Driver, DriverInterface {
+    readonly name = "MemoryDriver";
+    readonly version = "4.0.0";
+    readonly supports: {
+        transactions: boolean;
+        joins: boolean;
+        fullTextSearch: boolean;
+        jsonFields: boolean;
+        arrayFields: boolean;
+    };
     private store;
     private config;
     private idCounters;
     constructor(config?: MemoryDriverConfig);
+    /**
+     * Connect to the database (for DriverInterface compatibility)
+     * This is a no-op for memory driver as there's no external connection.
+     */
+    connect(): Promise<void>;
+    /**
+     * Check database connection health
+     */
+    checkHealth(): Promise<boolean>;
     /**
      * Load initial data into the store.
      */
@@ -98,6 +155,14 @@ export declare class MemoryDriver implements Driver {
      * Disconnect (no-op for memory driver).
      */
     disconnect(): Promise<void>;
+    /**
+     * Normalizes query format to support both legacy UnifiedQuery and QueryAST formats.
+     * This ensures backward compatibility while supporting the new @objectstack/spec interface.
+     *
+     * QueryAST format uses 'top' for limit, while UnifiedQuery uses 'limit'.
+     * QueryAST sort is array of {field, order}, while UnifiedQuery is array of [field, order].
+     */
+    private normalizeQuery;
     /**
      * Apply filters to an array of records (in-memory filtering).
      *
@@ -129,4 +194,45 @@ export declare class MemoryDriver implements Driver {
      * Generate a unique ID for a record.
      */
     private generateId;
+    /**
+     * Execute a query using QueryAST (DriverInterface v4.0 method)
+     *
+     * This is the new standard method for query execution using the
+     * ObjectStack QueryAST format.
+     *
+     * @param ast - The QueryAST representing the query
+     * @param options - Optional execution options
+     * @returns Query results with value and count
+     */
+    executeQuery(ast: QueryAST, options?: any): Promise<{
+        value: any[];
+        count?: number;
+    }>;
+    /**
+     * Execute a command (DriverInterface v4.0 method)
+     *
+     * This method handles all mutation operations (create, update, delete)
+     * using a unified command interface.
+     *
+     * @param command - The command to execute
+     * @param parameters - Optional command parameters (unused in this driver)
+     * @param options - Optional execution options
+     * @returns Command execution result
+     */
+    executeCommand(command: Command, options?: any): Promise<CommandResult>;
+    /**
+     * Convert FilterNode (QueryAST format) to legacy filter array format
+     * This allows reuse of existing filter logic while supporting new QueryAST
+     *
+     * @private
+     */
+    private convertFilterNodeToLegacy;
+    /**
+     * Execute command (alternative signature for compatibility)
+     *
+     * @param command - Command string or object
+     * @param parameters - Command parameters
+     * @param options - Execution options
+     */
+    execute(command: any, parameters?: any[], options?: any): Promise<any>;
 }