@push.rocks/smartmongo 2.2.0 → 3.0.0

package/dist_ts/{congodb → tsmdb}/types/interfaces.d.ts

@@ -1,9 +1,9 @@
-import type * as plugins from '../congodb.plugins.js';
+import type * as plugins from '../tsmdb.plugins.js';
 export type Document = Record<string, any>;
 export interface WithId<TSchema> {
     _id: plugins.bson.ObjectId;
 }
-export interface ICongoClientOptions {
+export interface ITsmdbClientOptions {
     /** Storage adapter type: 'memory' or 'file' */
     storageType?: 'memory' | 'file';
     /** Path for file-based storage */
@@ -14,7 +14,7 @@ export interface ICongoClientOptions {
     persistPath?: string;
 }
 export interface IParsedConnectionString {
-    protocol: 'congo';
+    protocol: 'tsmdb';
     storageType: 'memory' | 'file';
     options: {
         persist?: string;

package/dist_ts/{congodb → tsmdb}/types/interfaces.js

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RzL2NvbmdvZGIvdHlwZXMvaW50ZXJmYWNlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RzL3RzbWRiL3R5cGVzL2ludGVyZmFjZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartmongo",
-  "version": "2.2.0",
+  "version": "3.0.0",
   "private": false,
   "description": "A module for creating and managing a local MongoDB instance for testing purposes.",
   "main": "dist_ts/index.js",

package/readme.hints.md

@@ -9,21 +9,21 @@
 - **Why:** Deno wraps CommonJS exports in a `default` property, so default imports are required
 - Fixed in version 2.0.13 (changed from `import * as mongoPlugin`)
 
-## CongoDB - MongoDB Wire Protocol Server
+## TsmDB - MongoDB Wire Protocol Server
 
 ### Architecture
-CongoDB implements the MongoDB binary wire protocol (OP_MSG, OP_QUERY) allowing official MongoDB drivers to connect directly.
+TsmDB implements the MongoDB binary wire protocol (OP_MSG, OP_QUERY) allowing official MongoDB drivers to connect directly.
 
 ```
-Official MongoClient  →  TCP (wire protocol)  →  CongoServer  →  Engines  →  Storage
+Official MongoClient  →  TCP (wire protocol)  →  TsmdbServer  →  Engines  →  Storage
      (mongodb npm)           OP_MSG/BSON            (port)
 ```
 
 ### Module Structure
 ```
-ts/congodb/
+ts/tsmdb/
 ├── server/                   # Wire protocol server
-│   ├── CongoServer.ts        # TCP server, connection handling
+│   ├── TsmdbServer.ts        # TCP server, connection handling
 │   ├── WireProtocol.ts       # OP_MSG/OP_QUERY parsing & encoding
 │   ├── CommandRouter.ts      # Route commands to handlers
 │   └── handlers/             # Command implementations
@@ -53,11 +53,11 @@ ts/congodb/
 
 ### Usage Example
 ```typescript
-import { CongoServer } from '@push.rocks/smartmongo/congodb';
+import { TsmdbServer } from '@push.rocks/smartmongo/tsmdb';
 import { MongoClient } from 'mongodb';
 
 // Start server
-const server = new CongoServer({ port: 27117 });
+const server = new TsmdbServer({ port: 27117 });
 await server.start();
 
 // Connect with official MongoDB driver
@@ -82,8 +82,3 @@ await server.stop();
 - **Aggregation**: aggregate, count, distinct
 - **Indexes**: createIndexes, dropIndexes, listIndexes
 - **Admin**: ping, listDatabases, listCollections, drop, dropDatabase, create, serverStatus, buildInfo
-
-### Notes
-- The old CongoClient/CongoDb/CongoCollection classes have been removed
-- Use the official `mongodb` npm package's MongoClient instead
-- Server supports MongoDB wire protocol versions 0-21 (MongoDB 3.6 through 7.0 compatible)

package/readme.md

@@ -1,6 +1,6 @@
 # @push.rocks/smartmongo
 
-A powerful MongoDB toolkit for testing and development — featuring both a real MongoDB memory server (**SmartMongo**) and an ultra-fast, lightweight wire-protocol-compatible in-memory database server (**CongoDB**). 🚀
+A powerful MongoDB toolkit for testing and development — featuring both a real MongoDB memory server (**SmartMongo**) and an ultra-fast, lightweight wire-protocol-compatible in-memory database server (**TsmDB**). 🚀
 
 ## Install
 
@@ -18,7 +18,7 @@ For reporting bugs, issues, or security vulnerabilities, please visit [community
 
 `@push.rocks/smartmongo` provides two powerful approaches for MongoDB in testing and development:
 
-| Feature | SmartMongo | CongoDB |
+| Feature | SmartMongo | TsmDB |
 |---------|------------|---------|
 | **Type** | Real MongoDB (memory server) | Pure TypeScript wire protocol server |
 | **Speed** | ~2-5s startup | ⚡ Instant startup (~5ms) |
@@ -51,16 +51,16 @@ console.log(descriptor.mongoDbUrl); // mongodb://127.0.0.1:xxxxx/...
 await mongo.stop();
 ```
 
-### Option 2: CongoDB (Wire Protocol Server)
+### Option 2: TsmDB (Wire Protocol Server)
 
 A lightweight, pure TypeScript MongoDB-compatible server that speaks the wire protocol — use the official `mongodb` driver directly!
 
 ```typescript
-import { congodb } from '@push.rocks/smartmongo';
+import { tsmdb } from '@push.rocks/smartmongo';
 import { MongoClient } from 'mongodb';
 
-// Start CongoDB server
-const server = new congodb.CongoServer({ port: 27017 });
+// Start TsmDB server
+const server = new tsmdb.TsmdbServer({ port: 27017 });
 await server.start();
 
 // Connect with the official MongoDB driver!
@@ -116,14 +116,14 @@ await mongo.stopAndDumpToDir('./test-data');
 await mongo.stopAndDumpToDir('./test-data', (doc) => `${doc.collection}-${doc._id}.bson`);
 ```
 
-## 🔧 CongoDB API
+## 🔧 TsmDB API
 
 ### Server Configuration
 
 ```typescript
-import { congodb } from '@push.rocks/smartmongo';
+import { tsmdb } from '@push.rocks/smartmongo';
 
-const server = new congodb.CongoServer({
+const server = new tsmdb.TsmdbServer({
   port: 27017,           // Default MongoDB port
   host: '127.0.0.1',     // Bind address
   storage: 'memory',     // 'memory' or 'file'
@@ -143,7 +143,7 @@ await server.stop();
 
 ### Supported MongoDB Operations
 
-CongoDB supports the core MongoDB operations via the wire protocol:
+TsmDB supports the core MongoDB operations via the wire protocol:
 
 #### 🔹 CRUD Operations
 ```typescript
@@ -279,23 +279,23 @@ console.log(result.deletedCount);   // 1
 
 ### Storage Adapters
 
-CongoDB supports pluggable storage:
+TsmDB supports pluggable storage:
 
 ```typescript
 // In-memory (default) - fast, data lost on stop
-const server = new congodb.CongoServer({ storage: 'memory' });
+const server = new tsmdb.TsmdbServer({ storage: 'memory' });
 
 // In-memory with persistence - periodic snapshots to disk
-const server = new congodb.CongoServer({
+const server = new tsmdb.TsmdbServer({
   storage: 'memory',
   persistPath: './data/snapshot.json',
   persistIntervalMs: 30000  // Save every 30 seconds
 });
 
 // File-based - persistent storage
-const server = new congodb.CongoServer({
+const server = new tsmdb.TsmdbServer({
   storage: 'file',
-  storagePath: './data/congodb'
+  storagePath: './data/tsmdb'
 });
 ```
 
@@ -309,22 +309,22 @@ const server = new congodb.CongoServer({
 | **Indexes** | `createIndexes`, `dropIndexes`, `listIndexes` |
 | **Admin** | `ping`, `listDatabases`, `listCollections`, `drop`, `dropDatabase`, `create`, `serverStatus`, `buildInfo` |
 
-CongoDB supports MongoDB wire protocol versions 0-21, compatible with MongoDB 3.6 through 7.0 drivers.
+TsmDB supports MongoDB wire protocol versions 0-21, compatible with MongoDB 3.6 through 7.0 drivers.
 
 ## 🧪 Testing Examples
 
-### Jest/Mocha with CongoDB
+### Jest/Mocha with TsmDB
 
 ```typescript
-import { congodb } from '@push.rocks/smartmongo';
+import { tsmdb } from '@push.rocks/smartmongo';
 import { MongoClient } from 'mongodb';
 
-let server: congodb.CongoServer;
+let server: tsmdb.TsmdbServer;
 let client: MongoClient;
 let db: Db;
 
 beforeAll(async () => {
-  server = new congodb.CongoServer({ port: 27117 });
+  server = new tsmdb.TsmdbServer({ port: 27117 });
   await server.start();
 
   client = new MongoClient('mongodb://127.0.0.1:27117');
@@ -355,14 +355,14 @@ test('should insert and find user', async () => {
 
 ```typescript
 import { expect, tap } from '@git.zone/tstest/tapbundle';
-import { congodb } from '@push.rocks/smartmongo';
+import { tsmdb } from '@push.rocks/smartmongo';
 import { MongoClient } from 'mongodb';
 
-let server: congodb.CongoServer;
+let server: tsmdb.TsmdbServer;
 let client: MongoClient;
 
 tap.test('setup', async () => {
-  server = new congodb.CongoServer({ port: 27117 });
+  server = new tsmdb.TsmdbServer({ port: 27117 });
   await server.start();
   client = new MongoClient('mongodb://127.0.0.1:27117');
   await client.connect();
@@ -401,7 +401,7 @@ export default tap.start();
 
 ## 🏗️ Architecture
 
-### CongoDB Wire Protocol Stack
+### TsmDB Wire Protocol Stack
 
 ```
 ┌─────────────────────────────────────────────────────────────┐
@@ -411,7 +411,7 @@ export default tap.start();
                           │ TCP + OP_MSG/BSON
                           ▼
 ┌─────────────────────────────────────────────────────────────┐
-│                      CongoServer                            │
+│                      TsmdbServer                            │
 │  ┌──────────────┐  ┌──────────────┐  ┌──────────────────┐  │
 │  │ WireProtocol │→ │CommandRouter │→ │     Handlers     │  │
 │  │  (OP_MSG)    │  │              │  │ (Find, Insert..) │  │

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartmongo',
-  version: '2.2.0',
+  version: '3.0.0',
   description: 'A module for creating and managing a local MongoDB instance for testing purposes.'
 }

package/ts/index.ts

@@ -1,8 +1,8 @@
 import { commitinfo } from './00_commitinfo_data.js';
 import * as plugins from './smartmongo.plugins.js';
 
-// Export CongoDB module
-export * as congodb from './congodb/index.js';
+// Export TsmDB module
+export * as tsmdb from './tsmdb/index.js';
 
 export class SmartMongo {
   // STATIC

package/ts/{congodb → tsmdb}/engine/AggregationEngine.ts

@@ -1,4 +1,4 @@
-import * as plugins from '../congodb.plugins.js';
+import * as plugins from '../tsmdb.plugins.js';
 import type { Document, IStoredDocument, IAggregateOptions } from '../types/interfaces.js';
 
 // Import mingo Aggregator

package/ts/{congodb → tsmdb}/engine/IndexEngine.ts

@@ -1,4 +1,4 @@
-import * as plugins from '../congodb.plugins.js';
+import * as plugins from '../tsmdb.plugins.js';
 import type { IStorageAdapter } from '../storage/IStorageAdapter.js';
 import type {
   Document,
@@ -7,7 +7,7 @@ import type {
   IIndexInfo,
   ICreateIndexOptions,
 } from '../types/interfaces.js';
-import { CongoDuplicateKeyError, CongoIndexError } from '../errors/CongoErrors.js';
+import { TsmdbDuplicateKeyError, TsmdbIndexError } from '../errors/TsmdbErrors.js';
 import { QueryEngine } from './QueryEngine.js';
 
 /**
@@ -116,7 +116,7 @@ export class IndexEngine {
       const keyStr = JSON.stringify(keyValue);
 
       if (indexData.unique && indexData.entries.has(keyStr)) {
-        throw new CongoDuplicateKeyError(
+        throw new TsmdbDuplicateKeyError(
           `E11000 duplicate key error index: ${this.dbName}.${this.collName}.$${name}`,
           key as Record<string, 1>,
           keyValue
@@ -148,11 +148,11 @@ export class IndexEngine {
     await this.initialize();
 
     if (name === '_id_') {
-      throw new CongoIndexError('cannot drop _id index');
+      throw new TsmdbIndexError('cannot drop _id index');
     }
 
     if (!this.indexes.has(name)) {
-      throw new CongoIndexError(`index not found: ${name}`);
+      throw new TsmdbIndexError(`index not found: ${name}`);
     }
 
     this.indexes.delete(name);
@@ -215,7 +215,7 @@ export class IndexEngine {
       if (indexData.unique) {
         const existing = indexData.entries.get(keyStr);
         if (existing && existing.size > 0) {
-          throw new CongoDuplicateKeyError(
+          throw new TsmdbDuplicateKeyError(
             `E11000 duplicate key error collection: ${this.dbName}.${this.collName} index: ${name}`,
             indexData.key as Record<string, 1>,
             keyValue
@@ -260,7 +260,7 @@ export class IndexEngine {
           if (indexData.unique) {
             const existing = indexData.entries.get(newKeyStr);
             if (existing && existing.size > 0) {
-              throw new CongoDuplicateKeyError(
+              throw new TsmdbDuplicateKeyError(
                 `E11000 duplicate key error collection: ${this.dbName}.${this.collName} index: ${name}`,
                 indexData.key as Record<string, 1>,
                 newKeyValue

package/ts/{congodb → tsmdb}/engine/QueryEngine.ts

@@ -1,4 +1,4 @@
-import * as plugins from '../congodb.plugins.js';
+import * as plugins from '../tsmdb.plugins.js';
 import type { Document, IStoredDocument, ISortSpecification, ISortDirection } from '../types/interfaces.js';
 
 // Import mingo Query class

package/ts/{congodb → tsmdb}/engine/TransactionEngine.ts

@@ -1,7 +1,7 @@
-import * as plugins from '../congodb.plugins.js';
+import * as plugins from '../tsmdb.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';
+import { TsmdbTransactionError, TsmdbWriteConflictError } from '../errors/TsmdbErrors.js';
 
 /**
  * Transaction state
@@ -70,7 +70,7 @@ export class TransactionEngine {
   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');
+      throw new TsmdbTransactionError('Transaction is not active');
     }
 
     const ns = `${dbName}.${collName}`;
@@ -148,7 +148,7 @@ export class TransactionEngine {
   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');
+      throw new TsmdbTransactionError('Transaction is not active');
     }
 
     const ns = `${dbName}.${collName}`;
@@ -174,7 +174,7 @@ export class TransactionEngine {
   ): void {
     const txn = this.transactions.get(txnId);
     if (!txn || txn.status !== 'active') {
-      throw new CongoTransactionError('Transaction is not active');
+      throw new TsmdbTransactionError('Transaction is not active');
     }
 
     const ns = `${dbName}.${collName}`;
@@ -203,7 +203,7 @@ export class TransactionEngine {
   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');
+      throw new TsmdbTransactionError('Transaction is not active');
     }
 
     const ns = `${dbName}.${collName}`;
@@ -231,10 +231,10 @@ export class TransactionEngine {
   async commitTransaction(txnId: string): Promise<void> {
     const txn = this.transactions.get(txnId);
     if (!txn) {
-      throw new CongoTransactionError('Transaction not found');
+      throw new TsmdbTransactionError('Transaction not found');
     }
     if (txn.status !== 'active') {
-      throw new CongoTransactionError(`Cannot commit transaction in state: ${txn.status}`);
+      throw new TsmdbTransactionError(`Cannot commit transaction in state: ${txn.status}`);
     }
 
     // Check for write conflicts
@@ -245,7 +245,7 @@ export class TransactionEngine {
       const hasConflicts = await this.storage.hasConflicts(dbName, collName, ids, txn.startTime);
       if (hasConflicts) {
         txn.status = 'aborted';
-        throw new CongoWriteConflictError();
+        throw new TsmdbWriteConflictError();
       }
     }
 
@@ -281,7 +281,7 @@ export class TransactionEngine {
   async abortTransaction(txnId: string): Promise<void> {
     const txn = this.transactions.get(txnId);
     if (!txn) {
-      throw new CongoTransactionError('Transaction not found');
+      throw new TsmdbTransactionError('Transaction not found');
     }
     if (txn.status !== 'active') {
       // Already committed or aborted, just return
@@ -336,7 +336,7 @@ export class TransactionEngine {
         await this.abortTransaction(txnId);
         this.endTransaction(txnId);
 
-        if (error instanceof CongoWriteConflictError && attempt < maxRetries - 1) {
+        if (error instanceof TsmdbWriteConflictError && attempt < maxRetries - 1) {
           // Retry on write conflict
           lastError = error;
           continue;
@@ -346,6 +346,6 @@ export class TransactionEngine {
       }
     }
 
-    throw lastError || new CongoTransactionError('Transaction failed after max retries');
+    throw lastError || new TsmdbTransactionError('Transaction failed after max retries');
   }
 }

package/ts/{congodb → tsmdb}/engine/UpdateEngine.ts

@@ -1,4 +1,4 @@
-import * as plugins from '../congodb.plugins.js';
+import * as plugins from '../tsmdb.plugins.js';
 import type { Document, IStoredDocument } from '../types/interfaces.js';
 import { QueryEngine } from './QueryEngine.js';
 

package/ts/{congodb/errors/CongoErrors.ts → tsmdb/errors/TsmdbErrors.ts}

@@ -1,14 +1,14 @@
 /**
- * Base error class for all CongoDB errors
+ * Base error class for all TsmDB errors
  * Mirrors MongoDB driver error hierarchy
  */
-export class CongoError extends Error {
+export class TsmdbError extends Error {
   public code?: number;
   public codeName?: string;
 
   constructor(message: string, code?: number, codeName?: string) {
     super(message);
-    this.name = 'CongoError';
+    this.name = 'TsmdbError';
     this.code = code;
     this.codeName = codeName;
     Object.setPrototypeOf(this, new.target.prototype);
@@ -18,33 +18,33 @@ export class CongoError extends Error {
 /**
  * Error thrown during connection issues
  */
-export class CongoConnectionError extends CongoError {
+export class TsmdbConnectionError extends TsmdbError {
   constructor(message: string) {
     super(message);
-    this.name = 'CongoConnectionError';
+    this.name = 'TsmdbConnectionError';
   }
 }
 
 /**
  * Error thrown when an operation times out
  */
-export class CongoTimeoutError extends CongoError {
+export class TsmdbTimeoutError extends TsmdbError {
   constructor(message: string) {
     super(message, 50, 'MaxTimeMSExpired');
-    this.name = 'CongoTimeoutError';
+    this.name = 'TsmdbTimeoutError';
   }
 }
 
 /**
  * Error thrown during write operations
  */
-export class CongoWriteError extends CongoError {
+export class TsmdbWriteError extends TsmdbError {
   public writeErrors?: IWriteError[];
   public result?: any;
 
   constructor(message: string, code?: number, writeErrors?: IWriteError[]) {
     super(message, code);
-    this.name = 'CongoWriteError';
+    this.name = 'TsmdbWriteError';
     this.writeErrors = writeErrors;
   }
 }
@@ -52,13 +52,13 @@ export class CongoWriteError extends CongoError {
 /**
  * Error thrown for duplicate key violations
  */
-export class CongoDuplicateKeyError extends CongoWriteError {
+export class TsmdbDuplicateKeyError extends TsmdbWriteError {
   public keyPattern?: Record<string, 1>;
   public keyValue?: Record<string, any>;
 
   constructor(message: string, keyPattern?: Record<string, 1>, keyValue?: Record<string, any>) {
     super(message, 11000);
-    this.name = 'CongoDuplicateKeyError';
+    this.name = 'TsmdbDuplicateKeyError';
     this.codeName = 'DuplicateKey';
     this.keyPattern = keyPattern;
     this.keyValue = keyValue;
@@ -68,13 +68,13 @@ export class CongoDuplicateKeyError extends CongoWriteError {
 /**
  * Error thrown for bulk write failures
  */
-export class CongoBulkWriteError extends CongoError {
+export class TsmdbBulkWriteError extends TsmdbError {
   public writeErrors: IWriteError[];
   public result: any;
 
   constructor(message: string, writeErrors: IWriteError[], result: any) {
     super(message, 65);
-    this.name = 'CongoBulkWriteError';
+    this.name = 'TsmdbBulkWriteError';
     this.writeErrors = writeErrors;
     this.result = result;
   }
@@ -83,20 +83,20 @@ export class CongoBulkWriteError extends CongoError {
 /**
  * Error thrown during transaction operations
  */
-export class CongoTransactionError extends CongoError {
+export class TsmdbTransactionError extends TsmdbError {
   constructor(message: string, code?: number) {
     super(message, code);
-    this.name = 'CongoTransactionError';
+    this.name = 'TsmdbTransactionError';
   }
 }
 
 /**
  * Error thrown when a transaction is aborted due to conflict
  */
-export class CongoWriteConflictError extends CongoTransactionError {
+export class TsmdbWriteConflictError extends TsmdbTransactionError {
   constructor(message: string = 'Write conflict during transaction') {
     super(message, 112);
-    this.name = 'CongoWriteConflictError';
+    this.name = 'TsmdbWriteConflictError';
     this.codeName = 'WriteConflict';
   }
 }
@@ -104,20 +104,20 @@ export class CongoWriteConflictError extends CongoTransactionError {
 /**
  * Error thrown for invalid arguments
  */
-export class CongoArgumentError extends CongoError {
+export class TsmdbArgumentError extends TsmdbError {
   constructor(message: string) {
     super(message);
-    this.name = 'CongoArgumentError';
+    this.name = 'TsmdbArgumentError';
   }
 }
 
 /**
  * Error thrown when an operation is not supported
  */
-export class CongoNotSupportedError extends CongoError {
+export class TsmdbNotSupportedError extends TsmdbError {
   constructor(message: string) {
     super(message, 115);
-    this.name = 'CongoNotSupportedError';
+    this.name = 'TsmdbNotSupportedError';
     this.codeName = 'CommandNotSupported';
   }
 }
@@ -125,20 +125,20 @@ export class CongoNotSupportedError extends CongoError {
 /**
  * Error thrown when cursor is exhausted or closed
  */
-export class CongoCursorError extends CongoError {
+export class TsmdbCursorError extends TsmdbError {
   constructor(message: string) {
     super(message);
-    this.name = 'CongoCursorError';
+    this.name = 'TsmdbCursorError';
   }
 }
 
 /**
  * Error thrown when a namespace (database.collection) is invalid
  */
-export class CongoNamespaceError extends CongoError {
+export class TsmdbNamespaceError extends TsmdbError {
   constructor(message: string) {
     super(message, 73);
-    this.name = 'CongoNamespaceError';
+    this.name = 'TsmdbNamespaceError';
     this.codeName = 'InvalidNamespace';
   }
 }
@@ -146,10 +146,10 @@ export class CongoNamespaceError extends CongoError {
 /**
  * Error thrown when an index operation fails
  */
-export class CongoIndexError extends CongoError {
+export class TsmdbIndexError extends TsmdbError {
   constructor(message: string, code?: number) {
     super(message, code || 86);
-    this.name = 'CongoIndexError';
+    this.name = 'TsmdbIndexError';
   }
 }
 
@@ -164,18 +164,18 @@ export interface IWriteError {
 }
 
 /**
- * Convert any error to a CongoError
+ * Convert any error to a TsmdbError
  */
-export function toCongoError(error: any): CongoError {
-  if (error instanceof CongoError) {
+export function toTsmdbError(error: any): TsmdbError {
+  if (error instanceof TsmdbError) {
     return error;
   }
-  const congoError = new CongoError(error.message || String(error));
+  const tsmdbError = new TsmdbError(error.message || String(error));
   if (error.code) {
-    congoError.code = error.code;
+    tsmdbError.code = error.code;
   }
   if (error.codeName) {
-    congoError.codeName = error.codeName;
+    tsmdbError.codeName = error.codeName;
   }
-  return congoError;
+  return tsmdbError;
 }

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

@@ -1,8 +1,8 @@
-// CongoDB - MongoDB Wire Protocol compatible in-memory database server
-// Use the official MongoDB driver to connect to CongoServer
+// TsmDB - MongoDB Wire Protocol compatible in-memory database server
+// Use the official MongoDB driver to connect to TsmdbServer
 
 // Re-export plugins for external use
-import * as plugins from './congodb.plugins.js';
+import * as plugins from './tsmdb.plugins.js';
 export { plugins };
 
 // Export BSON types for convenience
@@ -12,7 +12,7 @@ export { ObjectId, Binary, Timestamp, Long, Decimal128, UUID } from 'bson';
 export * from './types/interfaces.js';
 
 // Export errors
-export * from './errors/CongoErrors.js';
+export * from './errors/TsmdbErrors.js';
 
 // Export storage adapters
 export type { IStorageAdapter } from './storage/IStorageAdapter.js';
@@ -27,9 +27,9 @@ export { AggregationEngine } from './engine/AggregationEngine.js';
 export { IndexEngine } from './engine/IndexEngine.js';
 export { TransactionEngine } from './engine/TransactionEngine.js';
 
-// Export server (the main entry point for using CongoDB)
-export { CongoServer } from './server/CongoServer.js';
-export type { ICongoServerOptions } from './server/CongoServer.js';
+// Export server (the main entry point for using TsmDB)
+export { TsmdbServer } from './server/TsmdbServer.js';
+export type { ITsmdbServerOptions } from './server/TsmdbServer.js';
 
 // Export wire protocol utilities (for advanced usage)
 export { WireProtocol } from './server/WireProtocol.js';