@push.rocks/smartmongo 2.0.14 → 2.2.0

package/ts/congodb/engine/QueryEngine.ts

@@ -0,0 +1,301 @@
+import * as plugins from '../congodb.plugins.js';
+import type { Document, IStoredDocument, ISortSpecification, ISortDirection } from '../types/interfaces.js';
+
+// Import mingo Query class
+import { Query } from 'mingo';
+
+/**
+ * Query engine using mingo for MongoDB-compatible query matching
+ */
+export class QueryEngine {
+  /**
+   * Filter documents by a MongoDB query filter
+   */
+  static filter(documents: IStoredDocument[], filter: Document): IStoredDocument[] {
+    if (!filter || Object.keys(filter).length === 0) {
+      return documents;
+    }
+
+    const query = new Query(filter);
+    return documents.filter(doc => query.test(doc));
+  }
+
+  /**
+   * Test if a single document matches a filter
+   */
+  static matches(document: Document, filter: Document): boolean {
+    if (!filter || Object.keys(filter).length === 0) {
+      return true;
+    }
+
+    const query = new Query(filter);
+    return query.test(document);
+  }
+
+  /**
+   * Find a single document matching the filter
+   */
+  static findOne(documents: IStoredDocument[], filter: Document): IStoredDocument | null {
+    if (!filter || Object.keys(filter).length === 0) {
+      return documents[0] || null;
+    }
+
+    const query = new Query(filter);
+    for (const doc of documents) {
+      if (query.test(doc)) {
+        return doc;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Sort documents by a sort specification
+   */
+  static sort(documents: IStoredDocument[], sort: ISortSpecification): IStoredDocument[] {
+    if (!sort) {
+      return documents;
+    }
+
+    // Normalize sort specification to array of [field, direction] pairs
+    const sortFields: Array<[string, number]> = [];
+
+    if (Array.isArray(sort)) {
+      for (const [field, direction] of sort) {
+        sortFields.push([field, this.normalizeDirection(direction)]);
+      }
+    } else {
+      for (const [field, direction] of Object.entries(sort)) {
+        sortFields.push([field, this.normalizeDirection(direction)]);
+      }
+    }
+
+    return [...documents].sort((a, b) => {
+      for (const [field, direction] of sortFields) {
+        const aVal = this.getNestedValue(a, field);
+        const bVal = this.getNestedValue(b, field);
+
+        const comparison = this.compareValues(aVal, bVal);
+        if (comparison !== 0) {
+          return comparison * direction;
+        }
+      }
+      return 0;
+    });
+  }
+
+  /**
+   * Apply projection to documents
+   */
+  static project(documents: IStoredDocument[], projection: Document): Document[] {
+    if (!projection || Object.keys(projection).length === 0) {
+      return documents;
+    }
+
+    // Determine if this is inclusion or exclusion projection
+    const keys = Object.keys(projection);
+    const hasInclusion = keys.some(k => k !== '_id' && projection[k] === 1);
+    const hasExclusion = keys.some(k => k !== '_id' && projection[k] === 0);
+
+    // Can't mix inclusion and exclusion (except for _id)
+    if (hasInclusion && hasExclusion) {
+      throw new Error('Cannot mix inclusion and exclusion in projection');
+    }
+
+    return documents.map(doc => {
+      if (hasInclusion) {
+        // Inclusion projection
+        const result: Document = {};
+
+        // Handle _id
+        if (projection._id !== 0 && projection._id !== false) {
+          result._id = doc._id;
+        }
+
+        for (const key of keys) {
+          if (key === '_id') continue;
+          if (projection[key] === 1 || projection[key] === true) {
+            const value = this.getNestedValue(doc, key);
+            if (value !== undefined) {
+              this.setNestedValue(result, key, value);
+            }
+          }
+        }
+
+        return result;
+      } else {
+        // Exclusion projection - start with copy and remove fields
+        const result = { ...doc };
+
+        for (const key of keys) {
+          if (projection[key] === 0 || projection[key] === false) {
+            this.deleteNestedValue(result, key);
+          }
+        }
+
+        return result;
+      }
+    });
+  }
+
+  /**
+   * Get distinct values for a field
+   */
+  static distinct(documents: IStoredDocument[], field: string, filter?: Document): any[] {
+    let docs = documents;
+    if (filter && Object.keys(filter).length > 0) {
+      docs = this.filter(documents, filter);
+    }
+
+    const values = new Set<any>();
+    for (const doc of docs) {
+      const value = this.getNestedValue(doc, field);
+      if (value !== undefined) {
+        if (Array.isArray(value)) {
+          // For arrays, add each element
+          for (const v of value) {
+            values.add(this.toComparable(v));
+          }
+        } else {
+          values.add(this.toComparable(value));
+        }
+      }
+    }
+
+    return Array.from(values);
+  }
+
+  /**
+   * Normalize sort direction to 1 or -1
+   */
+  private static normalizeDirection(direction: ISortDirection): number {
+    if (typeof direction === 'number') {
+      return direction > 0 ? 1 : -1;
+    }
+    if (direction === 'asc' || direction === 'ascending') {
+      return 1;
+    }
+    return -1;
+  }
+
+  /**
+   * Get a nested value from an object using dot notation
+   */
+  static getNestedValue(obj: any, path: string): any {
+    const parts = path.split('.');
+    let current = obj;
+
+    for (const part of parts) {
+      if (current === null || current === undefined) {
+        return undefined;
+      }
+      if (Array.isArray(current)) {
+        // Handle array access
+        const index = parseInt(part, 10);
+        if (!isNaN(index)) {
+          current = current[index];
+        } else {
+          // Get the field from all array elements
+          return current.map(item => this.getNestedValue(item, part)).flat();
+        }
+      } else {
+        current = current[part];
+      }
+    }
+
+    return current;
+  }
+
+  /**
+   * Set a nested value in an object using dot notation
+   */
+  private static setNestedValue(obj: any, path: string, value: any): void {
+    const parts = path.split('.');
+    let current = obj;
+
+    for (let i = 0; i < parts.length - 1; i++) {
+      const part = parts[i];
+      if (!(part in current)) {
+        current[part] = {};
+      }
+      current = current[part];
+    }
+
+    current[parts[parts.length - 1]] = value;
+  }
+
+  /**
+   * Delete a nested value from an object using dot notation
+   */
+  private static deleteNestedValue(obj: any, path: string): void {
+    const parts = path.split('.');
+    let current = obj;
+
+    for (let i = 0; i < parts.length - 1; i++) {
+      const part = parts[i];
+      if (!(part in current)) {
+        return;
+      }
+      current = current[part];
+    }
+
+    delete current[parts[parts.length - 1]];
+  }
+
+  /**
+   * Compare two values for sorting
+   */
+  private static compareValues(a: any, b: any): number {
+    // Handle undefined/null
+    if (a === undefined && b === undefined) return 0;
+    if (a === undefined) return -1;
+    if (b === undefined) return 1;
+    if (a === null && b === null) return 0;
+    if (a === null) return -1;
+    if (b === null) return 1;
+
+    // Handle ObjectId
+    if (a instanceof plugins.bson.ObjectId && b instanceof plugins.bson.ObjectId) {
+      return a.toHexString().localeCompare(b.toHexString());
+    }
+
+    // Handle dates
+    if (a instanceof Date && b instanceof Date) {
+      return a.getTime() - b.getTime();
+    }
+
+    // Handle numbers
+    if (typeof a === 'number' && typeof b === 'number') {
+      return a - b;
+    }
+
+    // Handle strings
+    if (typeof a === 'string' && typeof b === 'string') {
+      return a.localeCompare(b);
+    }
+
+    // Handle booleans
+    if (typeof a === 'boolean' && typeof b === 'boolean') {
+      return (a ? 1 : 0) - (b ? 1 : 0);
+    }
+
+    // Fall back to string comparison
+    return String(a).localeCompare(String(b));
+  }
+
+  /**
+   * Convert a value to a comparable form (for distinct)
+   */
+  private static toComparable(value: any): any {
+    if (value instanceof plugins.bson.ObjectId) {
+      return value.toHexString();
+    }
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    if (typeof value === 'object' && value !== null) {
+      return JSON.stringify(value);
+    }
+    return value;
+  }
+}

package/ts/congodb/engine/TransactionEngine.ts

@@ -0,0 +1,351 @@
+import * as plugins from '../congodb.plugins.js';
+import type { IStorageAdapter } from '../storage/IStorageAdapter.js';
+import type { Document, IStoredDocument, ITransactionOptions } from '../types/interfaces.js';
+import { CongoTransactionError, CongoWriteConflictError } from '../errors/CongoErrors.js';
+
+/**
+ * Transaction state
+ */
+export interface ITransactionState {
+  id: string;
+  sessionId: string;
+  startTime: plugins.bson.Timestamp;
+  status: 'active' | 'committed' | 'aborted';
+  readSet: Map<string, Set<string>>; // ns -> document _ids read
+  writeSet: Map<string, Map<string, { op: 'insert' | 'update' | 'delete'; doc?: IStoredDocument; originalDoc?: IStoredDocument }>>; // ns -> _id -> operation
+  snapshots: Map<string, IStoredDocument[]>; // ns -> snapshot of documents
+}
+
+/**
+ * Transaction engine for ACID transaction support
+ */
+export class TransactionEngine {
+  private storage: IStorageAdapter;
+  private transactions: Map<string, ITransactionState> = new Map();
+  private txnCounter = 0;
+
+  constructor(storage: IStorageAdapter) {
+    this.storage = storage;
+  }
+
+  /**
+   * Start a new transaction
+   */
+  startTransaction(sessionId: string, options?: ITransactionOptions): string {
+    this.txnCounter++;
+    const txnId = `txn_${sessionId}_${this.txnCounter}`;
+
+    const transaction: ITransactionState = {
+      id: txnId,
+      sessionId,
+      startTime: new plugins.bson.Timestamp({ t: Math.floor(Date.now() / 1000), i: this.txnCounter }),
+      status: 'active',
+      readSet: new Map(),
+      writeSet: new Map(),
+      snapshots: new Map(),
+    };
+
+    this.transactions.set(txnId, transaction);
+    return txnId;
+  }
+
+  /**
+   * Get a transaction by ID
+   */
+  getTransaction(txnId: string): ITransactionState | undefined {
+    return this.transactions.get(txnId);
+  }
+
+  /**
+   * Check if a transaction is active
+   */
+  isActive(txnId: string): boolean {
+    const txn = this.transactions.get(txnId);
+    return txn?.status === 'active';
+  }
+
+  /**
+   * Get or create a snapshot for a namespace
+   */
+  async getSnapshot(txnId: string, dbName: string, collName: string): Promise<IStoredDocument[]> {
+    const txn = this.transactions.get(txnId);
+    if (!txn || txn.status !== 'active') {
+      throw new CongoTransactionError('Transaction is not active');
+    }
+
+    const ns = `${dbName}.${collName}`;
+    if (!txn.snapshots.has(ns)) {
+      const snapshot = await this.storage.createSnapshot(dbName, collName);
+      txn.snapshots.set(ns, snapshot);
+    }
+
+    // Apply transaction writes to snapshot
+    const snapshot = txn.snapshots.get(ns)!;
+    const writes = txn.writeSet.get(ns);
+
+    if (!writes) {
+      return snapshot;
+    }
+
+    // Create a modified view of the snapshot
+    const result: IStoredDocument[] = [];
+    const deletedIds = new Set<string>();
+    const modifiedDocs = new Map<string, IStoredDocument>();
+
+    for (const [idStr, write] of writes) {
+      if (write.op === 'delete') {
+        deletedIds.add(idStr);
+      } else if (write.op === 'update' || write.op === 'insert') {
+        if (write.doc) {
+          modifiedDocs.set(idStr, write.doc);
+        }
+      }
+    }
+
+    // Add existing documents (not deleted, possibly modified)
+    for (const doc of snapshot) {
+      const idStr = doc._id.toHexString();
+      if (deletedIds.has(idStr)) {
+        continue;
+      }
+      if (modifiedDocs.has(idStr)) {
+        result.push(modifiedDocs.get(idStr)!);
+        modifiedDocs.delete(idStr);
+      } else {
+        result.push(doc);
+      }
+    }
+
+    // Add new documents (inserts)
+    for (const doc of modifiedDocs.values()) {
+      result.push(doc);
+    }
+
+    return result;
+  }
+
+  /**
+   * Record a read operation
+   */
+  recordRead(txnId: string, dbName: string, collName: string, docIds: string[]): void {
+    const txn = this.transactions.get(txnId);
+    if (!txn || txn.status !== 'active') return;
+
+    const ns = `${dbName}.${collName}`;
+    if (!txn.readSet.has(ns)) {
+      txn.readSet.set(ns, new Set());
+    }
+
+    const readSet = txn.readSet.get(ns)!;
+    for (const id of docIds) {
+      readSet.add(id);
+    }
+  }
+
+  /**
+   * Record a write operation (insert)
+   */
+  recordInsert(txnId: string, dbName: string, collName: string, doc: IStoredDocument): void {
+    const txn = this.transactions.get(txnId);
+    if (!txn || txn.status !== 'active') {
+      throw new CongoTransactionError('Transaction is not active');
+    }
+
+    const ns = `${dbName}.${collName}`;
+    if (!txn.writeSet.has(ns)) {
+      txn.writeSet.set(ns, new Map());
+    }
+
+    txn.writeSet.get(ns)!.set(doc._id.toHexString(), {
+      op: 'insert',
+      doc,
+    });
+  }
+
+  /**
+   * Record a write operation (update)
+   */
+  recordUpdate(
+    txnId: string,
+    dbName: string,
+    collName: string,
+    originalDoc: IStoredDocument,
+    updatedDoc: IStoredDocument
+  ): void {
+    const txn = this.transactions.get(txnId);
+    if (!txn || txn.status !== 'active') {
+      throw new CongoTransactionError('Transaction is not active');
+    }
+
+    const ns = `${dbName}.${collName}`;
+    if (!txn.writeSet.has(ns)) {
+      txn.writeSet.set(ns, new Map());
+    }
+
+    const idStr = originalDoc._id.toHexString();
+    const existing = txn.writeSet.get(ns)!.get(idStr);
+
+    // If we already have a write for this document, update it
+    if (existing) {
+      existing.doc = updatedDoc;
+    } else {
+      txn.writeSet.get(ns)!.set(idStr, {
+        op: 'update',
+        doc: updatedDoc,
+        originalDoc,
+      });
+    }
+  }
+
+  /**
+   * Record a write operation (delete)
+   */
+  recordDelete(txnId: string, dbName: string, collName: string, doc: IStoredDocument): void {
+    const txn = this.transactions.get(txnId);
+    if (!txn || txn.status !== 'active') {
+      throw new CongoTransactionError('Transaction is not active');
+    }
+
+    const ns = `${dbName}.${collName}`;
+    if (!txn.writeSet.has(ns)) {
+      txn.writeSet.set(ns, new Map());
+    }
+
+    const idStr = doc._id.toHexString();
+    const existing = txn.writeSet.get(ns)!.get(idStr);
+
+    if (existing && existing.op === 'insert') {
+      // If we inserted and then deleted, just remove the write
+      txn.writeSet.get(ns)!.delete(idStr);
+    } else {
+      txn.writeSet.get(ns)!.set(idStr, {
+        op: 'delete',
+        originalDoc: doc,
+      });
+    }
+  }
+
+  /**
+   * Commit a transaction
+   */
+  async commitTransaction(txnId: string): Promise<void> {
+    const txn = this.transactions.get(txnId);
+    if (!txn) {
+      throw new CongoTransactionError('Transaction not found');
+    }
+    if (txn.status !== 'active') {
+      throw new CongoTransactionError(`Cannot commit transaction in state: ${txn.status}`);
+    }
+
+    // Check for write conflicts
+    for (const [ns, writes] of txn.writeSet) {
+      const [dbName, collName] = ns.split('.');
+      const ids = Array.from(writes.keys()).map(id => new plugins.bson.ObjectId(id));
+
+      const hasConflicts = await this.storage.hasConflicts(dbName, collName, ids, txn.startTime);
+      if (hasConflicts) {
+        txn.status = 'aborted';
+        throw new CongoWriteConflictError();
+      }
+    }
+
+    // Apply all writes
+    for (const [ns, writes] of txn.writeSet) {
+      const [dbName, collName] = ns.split('.');
+
+      for (const [idStr, write] of writes) {
+        switch (write.op) {
+          case 'insert':
+            if (write.doc) {
+              await this.storage.insertOne(dbName, collName, write.doc);
+            }
+            break;
+          case 'update':
+            if (write.doc) {
+              await this.storage.updateById(dbName, collName, new plugins.bson.ObjectId(idStr), write.doc);
+            }
+            break;
+          case 'delete':
+            await this.storage.deleteById(dbName, collName, new plugins.bson.ObjectId(idStr));
+            break;
+        }
+      }
+    }
+
+    txn.status = 'committed';
+  }
+
+  /**
+   * Abort a transaction
+   */
+  async abortTransaction(txnId: string): Promise<void> {
+    const txn = this.transactions.get(txnId);
+    if (!txn) {
+      throw new CongoTransactionError('Transaction not found');
+    }
+    if (txn.status !== 'active') {
+      // Already committed or aborted, just return
+      return;
+    }
+
+    // Simply discard all buffered writes
+    txn.writeSet.clear();
+    txn.readSet.clear();
+    txn.snapshots.clear();
+    txn.status = 'aborted';
+  }
+
+  /**
+   * End a transaction (cleanup)
+   */
+  endTransaction(txnId: string): void {
+    this.transactions.delete(txnId);
+  }
+
+  /**
+   * Get all pending writes for a namespace
+   */
+  getPendingWrites(txnId: string, dbName: string, collName: string): Map<string, { op: 'insert' | 'update' | 'delete'; doc?: IStoredDocument }> | undefined {
+    const txn = this.transactions.get(txnId);
+    if (!txn) return undefined;
+
+    const ns = `${dbName}.${collName}`;
+    return txn.writeSet.get(ns);
+  }
+
+  /**
+   * Execute a callback within a transaction, with automatic retry on conflict
+   */
+  async withTransaction<T>(
+    sessionId: string,
+    callback: (txnId: string) => Promise<T>,
+    options?: ITransactionOptions & { maxRetries?: number }
+  ): Promise<T> {
+    const maxRetries = options?.maxRetries ?? 3;
+    let lastError: Error | undefined;
+
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+      const txnId = this.startTransaction(sessionId, options);
+
+      try {
+        const result = await callback(txnId);
+        await this.commitTransaction(txnId);
+        this.endTransaction(txnId);
+        return result;
+      } catch (error: any) {
+        await this.abortTransaction(txnId);
+        this.endTransaction(txnId);
+
+        if (error instanceof CongoWriteConflictError && attempt < maxRetries - 1) {
+          // Retry on write conflict
+          lastError = error;
+          continue;
+        }
+
+        throw error;
+      }
+    }
+
+    throw lastError || new CongoTransactionError('Transaction failed after max retries');
+  }
+}