@objectql/driver-memory 4.0.1 → 4.0.3

package/.turbo/turbo-build.log

@@ -0,0 +1,4 @@
+
+> @objectql/driver-memory@4.0.3 build /home/runner/work/objectql/objectql/packages/drivers/memory
+> tsc
+

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## 4.0.3
+
+### Patch Changes
+
+- **Patch Release v4.0.3**
+
+  This patch release includes infrastructure improvements and development experience enhancements:
+  - Refactored dev server setup for improved configuration handling
+  - Enhanced example scripts and development workflow
+  - Updated build and test infrastructure
+  - Improved documentation and developer tools
+  - Bug fixes and stability improvements
+
+- Updated dependencies
+  - @objectql/types@4.0.3
+
+## 4.0.2
+
+### Patch Changes
+
+- **Patch Release v4.0.2**
+
+  This patch release includes:
+  - Infrastructure improvements and maintenance updates
+  - Enhanced stability and reliability
+  - Bug fixes and performance optimizations
+
+- Updated dependencies
+  - @objectql/types@4.0.2
+
 ## 4.0.1
 
 ### Patch Changes

package/dist/index.d.ts

@@ -67,6 +67,27 @@ export interface MemoryDriverConfig {
     initialData?: Record<string, any[]>;
     /** Optional: Enable strict mode (throw on missing objects) */
     strictMode?: boolean;
+    /** Optional: Enable persistence to file system */
+    persistence?: {
+        /** File path to persist data */
+        filePath: string;
+        /** Auto-save interval in milliseconds (default: 5000) */
+        autoSaveInterval?: number;
+    };
+    /** Optional: Fields to index for faster queries */
+    indexes?: Record<string, string[]>;
+}
+/**
+ * In-memory transaction
+ */
+interface MemoryTransaction {
+    id: string;
+    snapshot: Map<string, any>;
+    operations: Array<{
+        type: 'set' | 'delete';
+        key: string;
+        value?: any;
+    }>;
 }
 /**
  * Memory Driver Implementation
@@ -92,9 +113,12 @@ export declare class MemoryDriver implements Driver {
         queryWindowFunctions: boolean;
         querySubqueries: boolean;
     };
-    private store;
-    private config;
-    private idCounters;
+    protected store: Map<string, any>;
+    protected config: MemoryDriverConfig;
+    protected idCounters: Map<string, number>;
+    protected transactions: Map<string, MemoryTransaction>;
+    protected indexes: Map<string, Map<string, Set<string>>>;
+    protected persistenceTimer?: NodeJS.Timeout;
     constructor(config?: MemoryDriverConfig);
     /**
      * Connect to the database (for DriverInterface compatibility)
@@ -108,7 +132,7 @@ export declare class MemoryDriver implements Driver {
     /**
      * Load initial data into the store.
      */
-    private loadInitialData;
+    protected loadInitialData(data: Record<string, any[]>): void;
     /**
      * Find multiple records matching the query criteria.
      * Supports filtering, sorting, pagination, and field projection using Mingo.
@@ -159,9 +183,71 @@ export declare class MemoryDriver implements Driver {
      */
     getSize(): number;
     /**
-     * Disconnect (no-op for memory driver).
+     * Disconnect and cleanup resources.
      */
     disconnect(): Promise<void>;
+    /**
+     * Perform aggregation operations using Mingo
+     * @param objectName - The object type to aggregate
+     * @param pipeline - MongoDB-style aggregation pipeline
+     * @param options - Optional query options
+     * @returns Aggregation results
+     *
+     * @example
+     * // Group by status and count
+     * const results = await driver.aggregate('orders', [
+     *   { $match: { status: 'completed' } },
+     *   { $group: { _id: '$customer', totalAmount: { $sum: '$amount' } } }
+     * ]);
+     *
+     * @example
+     * // Calculate average with filter
+     * const results = await driver.aggregate('products', [
+     *   { $match: { category: 'electronics' } },
+     *   { $group: { _id: null, avgPrice: { $avg: '$price' } } }
+     * ]);
+     */
+    aggregate(objectName: string, pipeline: any[], options?: any): Promise<any[]>;
+    /**
+     * Begin a new transaction
+     * @returns Transaction object that can be passed to other methods
+     */
+    beginTransaction(): Promise<any>;
+    /**
+     * Commit a transaction
+     * @param transaction - Transaction object returned by beginTransaction()
+     */
+    commitTransaction(transaction: any): Promise<void>;
+    /**
+     * Rollback a transaction
+     * @param transaction - Transaction object returned by beginTransaction()
+     */
+    rollbackTransaction(transaction: any): Promise<void>;
+    /**
+     * Set up persistence to file system
+     * @private
+     */
+    protected setupPersistence(): void;
+    /**
+     * Save current state to disk
+     * @private
+     */
+    protected saveToDisk(): void;
+    /**
+     * Build indexes for faster queries
+     * @private
+     */
+    protected buildIndexes(indexConfig: Record<string, string[]>): void;
+    /**
+     * Update index when a record is created or updated
+     * @private
+     */
+    protected updateIndex(objectName: string, recordId: string, record: any): void;
+    /**
+     * Remove record from indexes
+     * @private
+     */
+    protected removeFromIndex(objectName: string, recordId: string): void;
     /**
      * Normalizes query format to support both legacy UnifiedQuery and QueryAST formats.
      * This ensures backward compatibility while supporting the new @objectstack/spec interface.
@@ -169,43 +255,53 @@ export declare class MemoryDriver implements Driver {
      * 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;
     /**
      * Convert ObjectQL filters to MongoDB query format for Mingo.
      *
-     * Supports ObjectQL filter format:
-     * [
-     *   ['field', 'operator', value],
-     *   'or',
-     *   ['field2', 'operator', value2]
-     * ]
+     * Supports both:
+     * 1. Legacy ObjectQL filter format (array):
+     *    [['field', 'operator', value], 'or', ['field2', 'operator', value2']]
+     * 2. New FilterCondition format (object - already MongoDB-like):
+     *    { $and: [{ field: { $eq: value }}, { field2: { $gt: value2 }}] }
      *
      * Converts to MongoDB query format:
      * { $or: [{ field: { $operator: value }}, { field2: { $operator: value2 }}] }
      */
-    private convertToMongoQuery;
+    /**
+     * Convert ObjectQL filter format to MongoDB query format.
+     * Supports three input formats:
+     *
+     * 1. AST Comparison Node: { type: 'comparison', field: string, operator: string, value: any }
+     * 2. AST Logical Node: { type: 'logical', operator: 'and' | 'or', conditions: Node[] }
+     * 3. Legacy Array Format: [field, operator, value, 'and', field2, operator2, value2]
+     * 4. MongoDB Format: { field: value } or { field: { $eq: value } } (passthrough)
+     *
+     * @param filters - Filter in any supported format
+     * @returns MongoDB query object
+     */
+    protected convertToMongoQuery(filters?: any[] | Record<string, any>): Record<string, any>;
     /**
      * Convert a single ObjectQL condition to MongoDB operator format.
      */
-    private convertConditionToMongo;
+    protected convertConditionToMongo(field: string, operator: string, value: any): Record<string, any> | null;
     /**
      * Escape special regex characters to prevent ReDoS and ensure literal matching.
      * This is crucial for security when using user input in regex patterns.
      */
-    private escapeRegex;
+    protected escapeRegex(str: string): string;
     /**
      * Apply manual sorting to an array of records.
      * This is used instead of Mingo's sort to avoid CJS build issues.
      */
-    private applyManualSort;
+    protected applyManualSort(records: any[], sort: any[]): any[];
     /**
      * Project specific fields from a document.
      */
-    private projectFields;
+    protected projectFields(doc: any, fields: string[]): any;
     /**
      * Generate a unique ID for a record.
      */
-    private generateId;
+    protected generateId(objectName: string): string;
     /**
      * Execute a query using QueryAST (DriverInterface v4.0 method)
      *
@@ -232,13 +328,6 @@ export declare class MemoryDriver implements Driver {
      * @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)
      *