@push.rocks/smartmongo 2.2.0 → 4.0.0

package/ts/{congodb → tsmdb}/server/handlers/AdminHandler.ts

@@ -1,5 +1,6 @@
-import * as plugins from '../../congodb.plugins.js';
+import * as plugins from '../../tsmdb.plugins.js';
 import type { ICommandHandler, IHandlerContext } from '../CommandRouter.js';
+import { SessionEngine } from '../../engine/SessionEngine.js';
 
 /**
  * AdminHandler - Handles administrative commands
@@ -237,16 +238,18 @@ export class AdminHandler implements ICommandHandler {
    * Handle serverStatus command
    */
   private async handleServerStatus(context: IHandlerContext): Promise<plugins.bson.Document> {
-    const { server } = context;
+    const { server, sessionEngine } = context;
 
     const uptime = server.getUptime();
     const connections = server.getConnectionCount();
+    const sessions = sessionEngine.listSessions();
+    const sessionsWithTxn = sessionEngine.getSessionsWithTransactions();
 
     return {
       ok: 1,
       host: `${server.host}:${server.port}`,
       version: '7.0.0',
-      process: 'congodb',
+      process: 'tsmdb',
       pid: process.pid,
       uptime,
       uptimeMillis: uptime * 1000,
@@ -263,13 +266,33 @@ export class AdminHandler implements ICommandHandler {
         totalCreated: connections,
         active: connections,
       },
+      logicalSessionRecordCache: {
+        activeSessionsCount: sessions.length,
+        sessionsCollectionJobCount: 0,
+        lastSessionsCollectionJobDurationMillis: 0,
+        lastSessionsCollectionJobTimestamp: new Date(),
+        transactionReaperJobCount: 0,
+        lastTransactionReaperJobDurationMillis: 0,
+        lastTransactionReaperJobTimestamp: new Date(),
+      },
+      transactions: {
+        retriedCommandsCount: 0,
+        retriedStatementsCount: 0,
+        transactionsCollectionWriteCount: 0,
+        currentActive: sessionsWithTxn.length,
+        currentInactive: 0,
+        currentOpen: sessionsWithTxn.length,
+        totalStarted: sessionsWithTxn.length,
+        totalCommitted: 0,
+        totalAborted: 0,
+      },
       network: {
         bytesIn: 0,
         bytesOut: 0,
         numRequests: 0,
       },
       storageEngine: {
-        name: 'congodb',
+        name: 'tsmdb',
         supportsCommittedReads: true,
         persistent: false,
       },
@@ -283,7 +306,7 @@ export class AdminHandler implements ICommandHandler {
     return {
       ok: 1,
       version: '7.0.0',
-      gitVersion: 'congodb',
+      gitVersion: 'tsmdb',
       modules: [],
       allocator: 'system',
       javascriptEngine: 'none',
@@ -294,7 +317,7 @@ export class AdminHandler implements ICommandHandler {
         compiled: 'disabled',
       },
       buildEnvironment: {
-        distmod: 'congodb',
+        distmod: 'tsmdb',
         distarch: process.arch,
         cc: '',
         ccflags: '',
@@ -307,7 +330,7 @@ export class AdminHandler implements ICommandHandler {
       bits: 64,
       debug: false,
       maxBsonObjectSize: 16777216,
-      storageEngines: ['congodb'],
+      storageEngines: ['tsmdb'],
     };
   }
 
@@ -409,6 +432,17 @@ export class AdminHandler implements ICommandHandler {
    * Handle endSessions command
    */
   private async handleEndSessions(context: IHandlerContext): Promise<plugins.bson.Document> {
+    const { command, sessionEngine } = context;
+
+    // End each session in the array
+    const sessions = command.endSessions || [];
+    for (const sessionSpec of sessions) {
+      const sessionId = SessionEngine.extractSessionId(sessionSpec);
+      if (sessionId) {
+        await sessionEngine.endSession(sessionId);
+      }
+    }
+
     return { ok: 1 };
   }
 
@@ -416,16 +450,87 @@ export class AdminHandler implements ICommandHandler {
    * Handle abortTransaction command
    */
   private async handleAbortTransaction(context: IHandlerContext): Promise<plugins.bson.Document> {
-    // Transactions are not fully supported, but acknowledge the command
-    return { ok: 1 };
+    const { transactionEngine, sessionEngine, txnId, sessionId } = context;
+
+    if (!txnId) {
+      return {
+        ok: 0,
+        errmsg: 'No transaction started',
+        code: 251,
+        codeName: 'NoSuchTransaction',
+      };
+    }
+
+    try {
+      await transactionEngine.abortTransaction(txnId);
+      transactionEngine.endTransaction(txnId);
+      // Update session state
+      if (sessionId) {
+        sessionEngine.endTransaction(sessionId);
+      }
+      return { ok: 1 };
+    } catch (error: any) {
+      return {
+        ok: 0,
+        errmsg: error.message || 'Abort transaction failed',
+        code: error.code || 1,
+        codeName: error.codeName || 'UnknownError',
+      };
+    }
   }
 
   /**
    * Handle commitTransaction command
    */
   private async handleCommitTransaction(context: IHandlerContext): Promise<plugins.bson.Document> {
-    // Transactions are not fully supported, but acknowledge the command
-    return { ok: 1 };
+    const { transactionEngine, sessionEngine, txnId, sessionId } = context;
+
+    if (!txnId) {
+      return {
+        ok: 0,
+        errmsg: 'No transaction started',
+        code: 251,
+        codeName: 'NoSuchTransaction',
+      };
+    }
+
+    try {
+      await transactionEngine.commitTransaction(txnId);
+      transactionEngine.endTransaction(txnId);
+      // Update session state
+      if (sessionId) {
+        sessionEngine.endTransaction(sessionId);
+      }
+      return { ok: 1 };
+    } catch (error: any) {
+      // If commit fails, transaction should be aborted
+      try {
+        await transactionEngine.abortTransaction(txnId);
+        transactionEngine.endTransaction(txnId);
+        if (sessionId) {
+          sessionEngine.endTransaction(sessionId);
+        }
+      } catch {
+        // Ignore abort errors
+      }
+
+      if (error.code === 112) {
+        // Write conflict
+        return {
+          ok: 0,
+          errmsg: error.message || 'Write conflict during commit',
+          code: 112,
+          codeName: 'WriteConflict',
+        };
+      }
+
+      return {
+        ok: 0,
+        errmsg: error.message || 'Commit transaction failed',
+        code: error.code || 1,
+        codeName: error.codeName || 'UnknownError',
+      };
+    }
   }
 
   /**

package/ts/{congodb → tsmdb}/server/handlers/AggregateHandler.ts

@@ -1,4 +1,4 @@
-import * as plugins from '../../congodb.plugins.js';
+import * as plugins from '../../tsmdb.plugins.js';
 import type { ICommandHandler, IHandlerContext, ICursorState } from '../CommandRouter.js';
 import { AggregationEngine } from '../../engine/AggregationEngine.js';
 

package/ts/{congodb → tsmdb}/server/handlers/DeleteHandler.ts

@@ -1,5 +1,6 @@
-import * as plugins from '../../congodb.plugins.js';
+import * as plugins from '../../tsmdb.plugins.js';
 import type { ICommandHandler, IHandlerContext } from '../CommandRouter.js';
+import type { IStoredDocument } from '../../types/interfaces.js';
 import { QueryEngine } from '../../engine/QueryEngine.js';
 
 /**
@@ -47,6 +48,8 @@ export class DeleteHandler implements ICommandHandler {
       return { ok: 1, n: 0 };
     }
 
+    const indexEngine = context.getIndexEngine(collection);
+
     for (let i = 0; i < deletes.length; i++) {
       const deleteSpec = deletes[i];
       const filter = deleteSpec.q || deleteSpec.filter || {};
@@ -56,8 +59,15 @@ export class DeleteHandler implements ICommandHandler {
       const deleteAll = limit === 0;
 
       try {
-        // Get all documents
-        const documents = await storage.findAll(database, collection);
+        // Try to use index-accelerated query
+        const candidateIds = await indexEngine.findCandidateIds(filter);
+
+        let documents: IStoredDocument[];
+        if (candidateIds !== null) {
+          documents = await storage.findByIds(database, collection, candidateIds);
+        } else {
+          documents = await storage.findAll(database, collection);
+        }
 
         // Apply filter
         const matchingDocs = QueryEngine.filter(documents, filter);
@@ -69,6 +79,11 @@ export class DeleteHandler implements ICommandHandler {
         // Determine which documents to delete
         const docsToDelete = deleteAll ? matchingDocs : matchingDocs.slice(0, 1);
 
+        // Update indexes for deleted documents
+        for (const doc of docsToDelete) {
+          await indexEngine.onDelete(doc as any);
+        }
+
         // Delete the documents
         const idsToDelete = docsToDelete.map(doc => doc._id);
         const deleted = await storage.deleteByIds(database, collection, idsToDelete);

package/ts/{congodb → tsmdb}/server/handlers/FindHandler.ts

@@ -1,5 +1,6 @@
-import * as plugins from '../../congodb.plugins.js';
+import * as plugins from '../../tsmdb.plugins.js';
 import type { ICommandHandler, IHandlerContext, ICursorState } from '../CommandRouter.js';
+import type { IStoredDocument } from '../../types/interfaces.js';
 import { QueryEngine } from '../../engine/QueryEngine.js';
 
 /**
@@ -45,7 +46,7 @@ export class FindHandler implements ICommandHandler {
    * Handle find command
    */
   private async handleFind(context: IHandlerContext): Promise<plugins.bson.Document> {
-    const { storage, database, command } = context;
+    const { storage, database, command, getIndexEngine } = context;
 
     const collection = command.find;
     const filter = command.filter || {};
@@ -70,11 +71,22 @@ export class FindHandler implements ICommandHandler {
       };
     }
 
-    // Get all documents
-    let documents = await storage.findAll(database, collection);
+    // Try to use index-accelerated query
+    const indexEngine = getIndexEngine(collection);
+    const candidateIds = await indexEngine.findCandidateIds(filter);
 
-    // Apply filter
-    documents = QueryEngine.filter(documents, filter);
+    let documents: IStoredDocument[];
+    if (candidateIds !== null) {
+      // Index hit - fetch only candidate documents
+      documents = await storage.findByIds(database, collection, candidateIds);
+      // Still apply filter for any conditions the index couldn't fully satisfy
+      documents = QueryEngine.filter(documents, filter);
+    } else {
+      // No suitable index - full collection scan
+      documents = await storage.findAll(database, collection);
+      // Apply filter
+      documents = QueryEngine.filter(documents, filter);
+    }
 
     // Apply sort
     if (sort) {
@@ -233,7 +245,7 @@ export class FindHandler implements ICommandHandler {
    * Handle count command
    */
   private async handleCount(context: IHandlerContext): Promise<plugins.bson.Document> {
-    const { storage, database, command } = context;
+    const { storage, database, command, getIndexEngine } = context;
 
     const collection = command.count;
     const query = command.query || {};
@@ -246,11 +258,20 @@ export class FindHandler implements ICommandHandler {
       return { ok: 1, n: 0 };
     }
 
-    // Get all documents
-    let documents = await storage.findAll(database, collection);
+    // Try to use index-accelerated query
+    const indexEngine = getIndexEngine(collection);
+    const candidateIds = await indexEngine.findCandidateIds(query);
 
-    // Apply filter
-    documents = QueryEngine.filter(documents, query);
+    let documents: IStoredDocument[];
+    if (candidateIds !== null) {
+      // Index hit - fetch only candidate documents
+      documents = await storage.findByIds(database, collection, candidateIds);
+      documents = QueryEngine.filter(documents, query);
+    } else {
+      // No suitable index - full collection scan
+      documents = await storage.findAll(database, collection);
+      documents = QueryEngine.filter(documents, query);
+    }
 
     // Apply skip
     if (skip > 0) {
@@ -269,7 +290,7 @@ export class FindHandler implements ICommandHandler {
    * Handle distinct command
    */
   private async handleDistinct(context: IHandlerContext): Promise<plugins.bson.Document> {
-    const { storage, database, command } = context;
+    const { storage, database, command, getIndexEngine } = context;
 
     const collection = command.distinct;
     const key = command.key;
@@ -290,8 +311,16 @@ export class FindHandler implements ICommandHandler {
       return { ok: 1, values: [] };
     }
 
-    // Get all documents
-    const documents = await storage.findAll(database, collection);
+    // Try to use index-accelerated query
+    const indexEngine = getIndexEngine(collection);
+    const candidateIds = await indexEngine.findCandidateIds(query);
+
+    let documents: IStoredDocument[];
+    if (candidateIds !== null) {
+      documents = await storage.findByIds(database, collection, candidateIds);
+    } else {
+      documents = await storage.findAll(database, collection);
+    }
 
     // Get distinct values
     const values = QueryEngine.distinct(documents, key, query);

package/ts/{congodb → tsmdb}/server/handlers/HelloHandler.ts

@@ -1,4 +1,4 @@
-import * as plugins from '../../congodb.plugins.js';
+import * as plugins from '../../tsmdb.plugins.js';
 import type { ICommandHandler, IHandlerContext } from '../CommandRouter.js';
 
 /**

package/ts/{congodb → tsmdb}/server/handlers/IndexHandler.ts

@@ -1,4 +1,4 @@
-import * as plugins from '../../congodb.plugins.js';
+import * as plugins from '../../tsmdb.plugins.js';
 import type { ICommandHandler, IHandlerContext } from '../CommandRouter.js';
 import { IndexEngine } from '../../engine/IndexEngine.js';
 

package/ts/{congodb → tsmdb}/server/handlers/InsertHandler.ts

@@ -1,5 +1,6 @@
-import * as plugins from '../../congodb.plugins.js';
+import * as plugins from '../../tsmdb.plugins.js';
 import type { ICommandHandler, IHandlerContext } from '../CommandRouter.js';
+import type { IStoredDocument } from '../../types/interfaces.js';
 
 /**
  * InsertHandler - Handles insert commands
@@ -42,6 +43,8 @@ export class InsertHandler implements ICommandHandler {
     // Ensure collection exists
     await storage.createCollection(database, collection);
 
+    const indexEngine = context.getIndexEngine(collection);
+
     // Insert documents
     for (let i = 0; i < documents.length; i++) {
       const doc = documents[i];
@@ -52,6 +55,9 @@ export class InsertHandler implements ICommandHandler {
           doc._id = new plugins.bson.ObjectId();
         }
 
+        // Check index constraints before insert (doc now has _id)
+        await indexEngine.onInsert(doc as IStoredDocument);
+
         await storage.insertOne(database, collection, doc);
         insertedCount++;
       } catch (error: any) {

package/ts/{congodb → tsmdb}/server/handlers/UpdateHandler.ts

@@ -1,5 +1,6 @@
-import * as plugins from '../../congodb.plugins.js';
+import * as plugins from '../../tsmdb.plugins.js';
 import type { ICommandHandler, IHandlerContext } from '../CommandRouter.js';
+import type { IStoredDocument } from '../../types/interfaces.js';
 import { QueryEngine } from '../../engine/QueryEngine.js';
 import { UpdateEngine } from '../../engine/UpdateEngine.js';
 
@@ -69,6 +70,8 @@ export class UpdateHandler implements ICommandHandler {
     // Ensure collection exists
     await storage.createCollection(database, collection);
 
+    const indexEngine = context.getIndexEngine(collection);
+
     for (let i = 0; i < updates.length; i++) {
       const updateSpec = updates[i];
       const filter = updateSpec.q || updateSpec.filter || {};
@@ -78,8 +81,15 @@ export class UpdateHandler implements ICommandHandler {
       const arrayFilters = updateSpec.arrayFilters;
 
       try {
-        // Get all documents
-        let documents = await storage.findAll(database, collection);
+        // Try to use index-accelerated query
+        const candidateIds = await indexEngine.findCandidateIds(filter);
+
+        let documents: IStoredDocument[];
+        if (candidateIds !== null) {
+          documents = await storage.findByIds(database, collection, candidateIds);
+        } else {
+          documents = await storage.findAll(database, collection);
+        }
 
         // Apply filter
         let matchingDocs = QueryEngine.filter(documents, filter);
@@ -99,6 +109,8 @@ export class UpdateHandler implements ICommandHandler {
             Object.assign(updatedDoc, update.$setOnInsert);
           }
 
+          // Update index for the new document
+          await indexEngine.onInsert(updatedDoc);
           await storage.insertOne(database, collection, updatedDoc);
           totalUpserted++;
           upserted.push({ index: i, _id: updatedDoc._id });
@@ -113,6 +125,8 @@ export class UpdateHandler implements ICommandHandler {
             // Check if document actually changed
             const changed = JSON.stringify(doc) !== JSON.stringify(updatedDoc);
             if (changed) {
+              // Update index
+              await indexEngine.onUpdate(doc as any, updatedDoc);
               await storage.updateById(database, collection, doc._id, updatedDoc);
               totalModified++;
             }
@@ -186,8 +200,17 @@ export class UpdateHandler implements ICommandHandler {
     // Ensure collection exists
     await storage.createCollection(database, collection);
 
-    // Get matching documents
-    let documents = await storage.findAll(database, collection);
+    // Try to use index-accelerated query
+    const indexEngine = context.getIndexEngine(collection);
+    const candidateIds = await indexEngine.findCandidateIds(query);
+
+    let documents: IStoredDocument[];
+    if (candidateIds !== null) {
+      documents = await storage.findByIds(database, collection, candidateIds);
+    } else {
+      documents = await storage.findAll(database, collection);
+    }
+
     let matchingDocs = QueryEngine.filter(documents, query);
 
     // Apply sort if specified
@@ -203,6 +226,8 @@ export class UpdateHandler implements ICommandHandler {
         return { ok: 1, value: null };
       }
 
+      // Update index for delete
+      await indexEngine.onDelete(doc as any);
       await storage.deleteById(database, collection, doc._id);
 
       let result = doc;
@@ -231,6 +256,8 @@ export class UpdateHandler implements ICommandHandler {
         // Update existing
         originalDoc = { ...doc };
         resultDoc = UpdateEngine.applyUpdate(doc, update, arrayFilters);
+        // Update index
+        await indexEngine.onUpdate(doc as any, resultDoc as any);
         await storage.updateById(database, collection, doc._id, resultDoc as any);
       } else {
         // Upsert
@@ -243,6 +270,8 @@ export class UpdateHandler implements ICommandHandler {
           Object.assign(resultDoc, update.$setOnInsert);
         }
 
+        // Update index for insert
+        await indexEngine.onInsert(resultDoc as any);
         await storage.insertOne(database, collection, resultDoc);
       }
 

package/ts/{congodb → tsmdb}/server/index.ts

@@ -1,7 +1,7 @@
 // Server module exports
 
-export { CongoServer } from './CongoServer.js';
-export type { ICongoServerOptions } from './CongoServer.js';
+export { TsmdbServer } from './TsmdbServer.js';
+export type { ITsmdbServerOptions } from './TsmdbServer.js';
 export { WireProtocol } from './WireProtocol.js';
 export { CommandRouter } from './CommandRouter.js';
 export type { ICommandHandler, IHandlerContext, ICursorState } from './CommandRouter.js';

package/ts/{congodb → tsmdb}/storage/FileStorageAdapter.ts

@@ -1,9 +1,20 @@
-import * as plugins from '../congodb.plugins.js';
+import * as plugins from '../tsmdb.plugins.js';
 import type { IStorageAdapter } from './IStorageAdapter.js';
 import type { IStoredDocument, IOpLogEntry, Document } from '../types/interfaces.js';
+import { calculateDocumentChecksum, verifyChecksum } from '../utils/checksum.js';
 
 /**
- * File-based storage adapter for CongoDB
+ * File storage adapter options
+ */
+export interface IFileStorageAdapterOptions {
+  /** Enable checksum verification for data integrity */
+  enableChecksums?: boolean;
+  /** Throw error on checksum mismatch (default: false, just log warning) */
+  strictChecksums?: boolean;
+}
+
+/**
+ * File-based storage adapter for TsmDB
  * Stores data in JSON files on disk for persistence
  */
 export class FileStorageAdapter implements IStorageAdapter {
@@ -11,9 +22,13 @@ export class FileStorageAdapter implements IStorageAdapter {
   private opLogCounter = 0;
   private initialized = false;
   private fs = new plugins.smartfs.SmartFs(new plugins.smartfs.SmartFsProviderNode());
+  private enableChecksums: boolean;
+  private strictChecksums: boolean;
 
-  constructor(basePath: string) {
+  constructor(basePath: string, options?: IFileStorageAdapterOptions) {
     this.basePath = basePath;
+    this.enableChecksums = options?.enableChecksums ?? false;
+    this.strictChecksums = options?.strictChecksums ?? false;
   }
 
   // ============================================================================
@@ -68,6 +83,45 @@ export class FileStorageAdapter implements IStorageAdapter {
     return doc;
   }
 
+  /**
+   * Verify document checksum and handle errors
+   */
+  private verifyDocumentChecksum(doc: any): boolean {
+    if (!this.enableChecksums || !doc._checksum) {
+      return true;
+    }
+
+    const isValid = verifyChecksum(doc);
+    if (!isValid) {
+      const errorMsg = `Checksum mismatch for document ${doc._id}`;
+      if (this.strictChecksums) {
+        throw new Error(errorMsg);
+      } else {
+        console.warn(`WARNING: ${errorMsg}`);
+      }
+    }
+    return isValid;
+  }
+
+  /**
+   * Add checksum to document before storing
+   */
+  private prepareDocumentForStorage(doc: any): any {
+    if (!this.enableChecksums) {
+      return doc;
+    }
+    const checksum = calculateDocumentChecksum(doc);
+    return { ...doc, _checksum: checksum };
+  }
+
+  /**
+   * Remove internal checksum field before returning to user
+   */
+  private cleanDocumentForReturn(doc: any): IStoredDocument {
+    const { _checksum, ...cleanDoc } = doc;
+    return this.restoreObjectIds(cleanDoc);
+  }
+
   // ============================================================================
   // Initialization
   // ============================================================================
@@ -233,7 +287,9 @@ export class FileStorageAdapter implements IStorageAdapter {
       throw new Error(`Duplicate key error: _id ${idStr}`);
     }
 
-    docs.push(storedDoc);
+    // Add checksum if enabled
+    const docToStore = this.prepareDocumentForStorage(storedDoc);
+    docs.push(docToStore);
     await this.writeJsonFile(collPath, docs);
     return storedDoc;
   }
@@ -258,7 +314,9 @@ export class FileStorageAdapter implements IStorageAdapter {
       }
 
       existingIds.add(idStr);
-      docs.push(storedDoc);
+      // Add checksum if enabled
+      const docToStore = this.prepareDocumentForStorage(storedDoc);
+      docs.push(docToStore);
       results.push(storedDoc);
     }
 
@@ -270,10 +328,33 @@ export class FileStorageAdapter implements IStorageAdapter {
     await this.createCollection(dbName, collName);
     const collPath = this.getCollectionPath(dbName, collName);
     const docs = await this.readJsonFile<any[]>(collPath, []);
-    return docs.map(doc => this.restoreObjectIds(doc));
+    return docs.map(doc => {
+      // Verify checksum if enabled
+      this.verifyDocumentChecksum(doc);
+      // Clean and return document without internal checksum field
+      return this.cleanDocumentForReturn(doc);
+    });
+  }
+
+  async findByIds(dbName: string, collName: string, ids: Set<string>): Promise<IStoredDocument[]> {
+    await this.createCollection(dbName, collName);
+    const collPath = this.getCollectionPath(dbName, collName);
+    const docs = await this.readJsonFile<any[]>(collPath, []);
+    const results: IStoredDocument[] = [];
+    for (const doc of docs) {
+      // Verify checksum if enabled
+      this.verifyDocumentChecksum(doc);
+      // Clean and restore document
+      const cleaned = this.cleanDocumentForReturn(doc);
+      if (ids.has(cleaned._id.toHexString())) {
+        results.push(cleaned);
+      }
+    }
+    return results;
   }
 
   async findById(dbName: string, collName: string, id: plugins.bson.ObjectId): Promise<IStoredDocument | null> {
+    // Use findAll which already handles checksum verification
     const docs = await this.findAll(dbName, collName);
     const idStr = id.toHexString();
     return docs.find(d => d._id.toHexString() === idStr) || null;
@@ -291,7 +372,9 @@ export class FileStorageAdapter implements IStorageAdapter {
 
     if (idx === -1) return false;
 
-    docs[idx] = doc;
+    // Add checksum if enabled
+    const docToStore = this.prepareDocumentForStorage(doc);
+    docs[idx] = docToStore;
     await this.writeJsonFile(collPath, docs);
     return true;
   }

package/ts/{congodb → tsmdb}/storage/IStorageAdapter.ts

@@ -1,8 +1,8 @@
-import type * as plugins from '../congodb.plugins.js';
+import type * as plugins from '../tsmdb.plugins.js';
 import type { IStoredDocument, IOpLogEntry, Document } from '../types/interfaces.js';
 
 /**
- * Storage adapter interface for CongoDB
+ * Storage adapter interface for TsmDB
  * Implementations can provide different storage backends (memory, file, etc.)
  */
 export interface IStorageAdapter {
@@ -90,6 +90,12 @@ export interface IStorageAdapter {
    */
   findAll(dbName: string, collName: string): Promise<IStoredDocument[]>;
 
+  /**
+   * Find documents by a set of _id strings (hex format)
+   * Used for index-accelerated queries
+   */
+  findByIds(dbName: string, collName: string, ids: Set<string>): Promise<IStoredDocument[]>;
+
   /**
    * Find a document by _id
    */