@trust0/ridb-mongodb 0.0.1 → 0.0.3

package/CHANGELOG.md

@@ -1,3 +1,33 @@
+## 0.0.3 (2025-07-22)
+
+### 🩹 Fixes
+
+- current structure doesn't manage examples very well will figure out later ([bcb8934](https://github.com/trust0-project/RIDB/commit/bcb8934))
+- specify packages ([b49617b](https://github.com/trust0-project/RIDB/commit/b49617b))
+- mongodb improvement ([3f89e54](https://github.com/trust0-project/RIDB/commit/3f89e54))
+
+### 🧱 Updated Dependencies
+
+- Updated @trust0/ridb to 1.5.36
+
+### ❤️ Thank You
+
+- Javier Ribó
+
+## 0.0.2 (2025-07-22)
+
+### 🩹 Fixes
+
+- change exports ([70cabaa](https://github.com/trust0-project/RIDB/commit/70cabaa))
+
+### 🧱 Updated Dependencies
+
+- Updated @trust0/ridb to 1.5.35
+
+### ❤️ Thank You
+
+- Javier Ribó
+
 ## 0.0.1 (2025-07-21)
 
 ### 🩹 Fixes

package/build/index.d.ts

@@ -1,4 +1,4 @@
-import { SchemaTypeRecord, BaseStorage, BaseStorageOptions, Doc, Operation, QueryType, QueryOptions } from '@trust0/ridb-core';
+import { BaseStorageOptions, SchemaTypeRecord, BaseStorage } from '@trust0/ridb-core';
 
 /**
  * @packageDocumentation
@@ -32,49 +32,6 @@ interface MongoDBConfig {
     mongoOptions?: Record<string, any>;
 }
 type MongoDBStorageOptions = BaseStorageOptions & MongoDBConfig;
-/**
- * MongoDB storage implementation class
- * @public
- */
-declare class MongoDBStorage<T extends SchemaTypeRecord> extends BaseStorage<T> {
-    private client?;
-    private db?;
-    private mongoConfig;
-    constructor(name: string, schemas: T, options?: MongoDBStorageOptions);
-    /**
-     * Utility method to recursively convert ObjectId values to strings throughout an object
-     * This ensures that MongoDB's ObjectId instances are never returned to the application layer,
-     * maintaining consistency with RIDB's string-based approach and preventing serialization issues.
-     * Also removes MongoDB's automatic _id field entirely from results.
-     * @private
-     */
-    private convertObjectIdsToStrings;
-    /**
-     * Create a new MongoDB storage instance
-     * @param name - Database name
-     * @param schemas - Collection schemas
-     * @param options - Storage options including MongoDB connection details
-     * @returns A new Instance of MongoDB storage
-     * @public
-     */
-    static create<SchemasCreate extends SchemaTypeRecord>(name: string, schemas: SchemasCreate, options?: MongoDBStorageOptions): Promise<MongoDBStorage<SchemasCreate>>;
-    /** Start the database connection */
-    start(): Promise<void>;
-    /** Close the database connection */
-    close(): Promise<void>;
-    /** Get MongoDB collection for a given collection name */
-    private getCollection;
-    /** Find a document by its ID */
-    findDocumentById(collectionName: keyof T, id: string): Promise<Doc<T[keyof T]> | null>;
-    /** Write an operation (insert, update, delete) */
-    write(op: Operation<T[keyof T]>): Promise<Doc<T[keyof T]>>;
-    /** Convert RIDB query to MongoDB filter */
-    private convertQueryToMongoFilter;
-    /** Count documents matching a query (supports offset & limit) */
-    count(collectionName: keyof T, query: QueryType<T[keyof T]>, options?: QueryOptions): Promise<number>;
-    /** Find documents matching a query with pagination */
-    find(collectionName: keyof T, query: QueryType<T[keyof T]>, options?: QueryOptions): Promise<Doc<T[keyof T]>[]>;
-}
 /**
  * Create a MongoDB storage instance
  * @public
@@ -82,4 +39,4 @@ declare class MongoDBStorage<T extends SchemaTypeRecord> extends BaseStorage<T>
  */
 declare function createMongoDB<T extends SchemaTypeRecord>(): Promise<typeof BaseStorage<T>>;
 
-export { type MongoDBConfig, MongoDBStorage, type MongoDBStorageOptions, createMongoDB as default };
+export { type MongoDBConfig, type MongoDBStorageOptions, createMongoDB };

package/build/index.js

@@ -76,7 +76,7 @@ var require_ridb_core = __commonJS({
     var ridb_core_exports = {};
     __export2(ridb_core_exports, {
       BasePlugin: () => BasePlugin,
-      BaseStorage: () => BaseStorage2,
+      BaseStorage: () => BaseStorage,
       Collection: () => Collection,
       CoreStorage: () => CoreStorage,
       Database: () => Database,
@@ -531,7 +531,7 @@ ${val.stack}`;
     var BaseStorageFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
     }, unregister: () => {
     } } : new FinalizationRegistry((ptr) => wasm.__wbg_basestorage_free(ptr >>> 0));
-    var BaseStorage2 = class {
+    var BaseStorage = class {
       __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
@@ -3150,219 +3150,228 @@ ${val.stack}`;
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  MongoDBStorage: () => MongoDBStorage,
-  default: () => createMongoDB
+  createMongoDB: () => createMongoDB
 });
 module.exports = __toCommonJS(index_exports);
 var import_ridb_core = __toESM(require_ridb_core());
 var import_ridb = require("@trust0/ridb");
-var MongoDBStorage = class _MongoDBStorage extends import_ridb_core.BaseStorage {
-  client;
-  db;
-  mongoConfig;
-  constructor(name, schemas, options = {}) {
-    super(name, schemas, options);
-    this.mongoConfig = options;
-  }
-  /**
-   * Utility method to recursively convert ObjectId values to strings throughout an object
-   * This ensures that MongoDB's ObjectId instances are never returned to the application layer,
-   * maintaining consistency with RIDB's string-based approach and preventing serialization issues.
-   * Also removes MongoDB's automatic _id field entirely from results.
-   * @private
-   */
-  convertObjectIdsToStrings(obj) {
-    if (!obj || typeof obj !== "object") {
-      return obj;
-    }
-    if (obj.constructor?.name === "ObjectId" || obj._bsontype && obj._bsontype === "ObjectId") {
-      const stringValue = obj.toString();
-      return stringValue;
-    }
-    if (Array.isArray(obj)) {
-      return obj.map((item) => this.convertObjectIdsToStrings(item));
+async function createMongoDB() {
+  const { BaseStorage } = await (0, import_ridb.WasmInternal)();
+  class MongoDBStorage extends BaseStorage {
+    client;
+    db;
+    mongoConfig;
+    constructor(name, schemas, options = {}) {
+      super(name, schemas, options);
+      this.mongoConfig = options;
     }
-    const converted = {};
-    for (const [key, value] of Object.entries(obj)) {
-      if (key === "_id") {
-        continue;
+    /**
+     * Utility method to recursively convert ObjectId values to strings throughout an object
+     * This ensures that MongoDB's ObjectId instances are never returned to the application layer,
+     * maintaining consistency with RIDB's string-based approach and preventing serialization issues.
+     * Also removes MongoDB's automatic _id field entirely from results.
+     * @private
+     */
+    convertObjectIdsToStrings(obj) {
+      if (!obj || typeof obj !== "object") {
+        return obj;
+      }
+      if (obj.constructor?.name === "ObjectId" || obj._bsontype && obj._bsontype === "ObjectId") {
+        const stringValue = obj.toString();
+        return stringValue;
+      }
+      if (Array.isArray(obj)) {
+        return obj.map((item) => this.convertObjectIdsToStrings(item));
+      }
+      const converted = {};
+      for (const [key, value] of Object.entries(obj)) {
+        if (key === "_id") {
+          continue;
+        }
+        converted[key] = this.convertObjectIdsToStrings(value);
       }
-      converted[key] = this.convertObjectIdsToStrings(value);
+      return converted;
     }
-    return converted;
-  }
-  /**
-   * Create a new MongoDB storage instance
-   * @param name - Database name
-   * @param schemas - Collection schemas
-   * @param options - Storage options including MongoDB connection details
-   * @returns A new Instance of MongoDB storage
-   * @public
-   */
-  static async create(name, schemas, options = {}) {
-    const db = new _MongoDBStorage(name, schemas, options);
-    return db;
-  }
-  /** Start the database connection */
-  async start() {
-    const { MongoClient } = await import("mongodb");
-    const url = this.mongoConfig.url || process.env.MONGODB_URL || "mongodb://localhost:27017";
-    const dbName = this.mongoConfig.dbName || this.name;
-    this.client = new MongoClient(url, this.mongoConfig.mongoOptions || {});
-    await this.client.connect();
-    this.db = this.client.db(dbName);
-  }
-  /** Close the database connection */
-  async close() {
-    if (this.client) {
-      await this.client.close();
-      this.client = void 0;
-      this.db = void 0;
+    /**
+     * Create a new MongoDB storage instance
+     * @param name - Database name
+     * @param schemas - Collection schemas
+     * @param options - Storage options including MongoDB connection details
+     * @returns A new Instance of MongoDB storage
+     * @public
+     */
+    static async create(name, schemas, options = {}) {
+      const db = new MongoDBStorage(name, schemas, options);
+      return db;
     }
-  }
-  /** Get MongoDB collection for a given collection name */
-  getCollection(collectionName) {
-    if (!this.db) {
-      throw new Error("Database not started. Call start() first.");
+    /** Start the database connection */
+    async start() {
+      const { MongoClient } = await import("mongodb");
+      const url = this.mongoConfig.url || process.env.MONGODB_URL;
+      if (!url) {
+        throw new Error("MONGODB_URL is required");
+      }
+      const dbName = this.mongoConfig.dbName || this.name;
+      this.client = new MongoClient(url, {
+        connectTimeoutMS: 5e3,
+        serverSelectionTimeoutMS: 5e3,
+        socketTimeoutMS: 5e3,
+        maxPoolSize: 10,
+        minPoolSize: 5,
+        maxIdleTimeMS: 5e3,
+        maxConnecting: 5
+      });
+      await this.client.connect();
+      this.db = this.client.db(dbName);
     }
-    const collection = this.db.collection(collectionName);
-    return collection;
-  }
-  /** Find a document by its ID */
-  async findDocumentById(collectionName, id) {
-    const collection = this.getCollection(String(collectionName));
-    const schema = this.getSchema(String(collectionName));
-    const primaryKey = schema.primaryKey;
-    const query = { [primaryKey]: id };
-    const doc = await collection.findOne(query);
-    if (!doc) {
-      return null;
+    /** Close the database connection */
+    async close() {
+      if (this.client) {
+        await this.client.close();
+        this.client = void 0;
+        this.db = void 0;
+      }
     }
-    const converted = this.convertObjectIdsToStrings(doc);
-    return converted;
-  }
-  /** Write an operation (insert, update, delete) */
-  async write(op) {
-    const collectionName = String(op.collection);
-    const collection = this.getCollection(collectionName);
-    const { primaryKey } = this.getSchema(collectionName);
-    switch (op.opType) {
-      case import_ridb_core.OpType.CREATE: {
-        const id = primaryKey in op.data ? op.data[primaryKey] : null;
-        if (!id) {
-          throw new Error("Document ID is required");
-        }
-        const existQuery = { [primaryKey]: id };
-        const existing = await collection.findOne(existQuery);
-        if (existing) {
-          throw new Error(`Document with ${primaryKey} '${id}' already exists`);
-        }
-        const docToInsert = { ...op.data };
-        const insertResult = await collection.insertOne(docToInsert);
-        const result = this.convertObjectIdsToStrings(op.data);
-        return result;
-      }
-      case import_ridb_core.OpType.UPDATE: {
-        const id = primaryKey in op.data ? op.data[primaryKey] : null;
-        if (!id) {
-          throw new Error("Document ID is required");
-        }
-        const updateQuery = { [primaryKey]: id };
-        const updateData = { $set: op.data };
-        const result = await collection.updateOne(updateQuery, updateData);
-        if (result.matchedCount === 0) {
-          throw new Error("Document ID not found");
-        }
-        const convertedResult = this.convertObjectIdsToStrings(op.data);
-        return convertedResult;
-      }
-      case import_ridb_core.OpType.DELETE: {
-        const id = op.data;
-        const deleteQuery = { [primaryKey]: id };
-        const result = await collection.deleteOne(deleteQuery);
-        if (result.deletedCount === 0) {
-          throw new Error("Document ID not found");
-        }
-        const convertedResult = this.convertObjectIdsToStrings(op.data);
-        return convertedResult;
-      }
-      default:
-        throw new Error(`Unknown operation type: ${op.opType}`);
+    /** Get MongoDB collection for a given collection name */
+    getCollection(collectionName) {
+      if (!this.db) {
+        throw new Error("Database not started. Call start() first.");
+      }
+      const collection = this.db.collection(collectionName);
+      return collection;
     }
-  }
-  /** Convert RIDB query to MongoDB filter */
-  convertQueryToMongoFilter(query, schema) {
-    if (!query || typeof query !== "object") {
-      return {};
+    /** Find a document by its ID */
+    async findDocumentById(collectionName, id) {
+      const collection = this.getCollection(String(collectionName));
+      const schema = this.getSchema(String(collectionName));
+      const primaryKey = schema.primaryKey;
+      const query = { [primaryKey]: id };
+      const doc = await collection.findOne(query);
+      if (!doc) {
+        return null;
+      }
+      const converted = this.convertObjectIdsToStrings(doc);
+      return converted;
     }
-    const filter = {};
-    for (const [key, value] of Object.entries(query)) {
-      if (value === null || value === void 0) {
-        filter[key] = { $exists: false };
-      } else if (typeof value === "object" && value !== null) {
-        if ("$in" in value) {
-          filter[key] = { $in: this.convertObjectIdsToStrings(value.$in) };
-        } else if ("$nin" in value) {
-          filter[key] = { $nin: this.convertObjectIdsToStrings(value.$nin) };
-        } else if ("$gt" in value) {
-          filter[key] = { $gt: this.convertObjectIdsToStrings(value.$gt) };
-        } else if ("$gte" in value) {
-          filter[key] = { $gte: this.convertObjectIdsToStrings(value.$gte) };
-        } else if ("$lt" in value) {
-          filter[key] = { $lt: this.convertObjectIdsToStrings(value.$lt) };
-        } else if ("$lte" in value) {
-          filter[key] = { $lte: this.convertObjectIdsToStrings(value.$lte) };
-        } else if ("$ne" in value) {
-          filter[key] = { $ne: this.convertObjectIdsToStrings(value.$ne) };
-        } else if ("$regex" in value) {
-          filter[key] = { $regex: value.$regex };
+    /** Write an operation (insert, update, delete) */
+    async write(op) {
+      const collectionName = String(op.collection);
+      const collection = this.getCollection(collectionName);
+      const { primaryKey } = this.getSchema(collectionName);
+      switch (op.opType) {
+        case import_ridb_core.OpType.CREATE: {
+          const id = primaryKey in op.data ? op.data[primaryKey] : null;
+          if (!id) {
+            throw new Error("Document ID is required");
+          }
+          const existQuery = { [primaryKey]: id };
+          const existing = await collection.findOne(existQuery);
+          if (existing) {
+            throw new Error(`Document with ${primaryKey} '${id}' already exists`);
+          }
+          const docToInsert = { ...op.data };
+          const insertResult = await collection.insertOne(docToInsert);
+          const result = this.convertObjectIdsToStrings(op.data);
+          return result;
+        }
+        case import_ridb_core.OpType.UPDATE: {
+          const id = primaryKey in op.data ? op.data[primaryKey] : null;
+          if (!id) {
+            throw new Error("Document ID is required");
+          }
+          const updateQuery = { [primaryKey]: id };
+          const updateData = { $set: op.data };
+          const result = await collection.updateOne(updateQuery, updateData);
+          if (result.matchedCount === 0) {
+            throw new Error("Document ID not found");
+          }
+          const convertedResult = this.convertObjectIdsToStrings(op.data);
+          return convertedResult;
+        }
+        case import_ridb_core.OpType.DELETE: {
+          const id = op.data;
+          const deleteQuery = { [primaryKey]: id };
+          const result = await collection.deleteOne(deleteQuery);
+          if (result.deletedCount === 0) {
+            throw new Error("Document ID not found");
+          }
+          const convertedResult = this.convertObjectIdsToStrings(op.data);
+          return convertedResult;
+        }
+        default:
+          throw new Error(`Unknown operation type: ${op.opType}`);
+      }
+    }
+    /** Convert RIDB query to MongoDB filter */
+    convertQueryToMongoFilter(query, schema) {
+      if (!query || typeof query !== "object") {
+        return {};
+      }
+      const filter = {};
+      for (const [key, value] of Object.entries(query)) {
+        if (value === null || value === void 0) {
+          filter[key] = { $exists: false };
+        } else if (typeof value === "object" && value !== null) {
+          if ("$in" in value) {
+            filter[key] = { $in: this.convertObjectIdsToStrings(value.$in) };
+          } else if ("$nin" in value) {
+            filter[key] = { $nin: this.convertObjectIdsToStrings(value.$nin) };
+          } else if ("$gt" in value) {
+            filter[key] = { $gt: this.convertObjectIdsToStrings(value.$gt) };
+          } else if ("$gte" in value) {
+            filter[key] = { $gte: this.convertObjectIdsToStrings(value.$gte) };
+          } else if ("$lt" in value) {
+            filter[key] = { $lt: this.convertObjectIdsToStrings(value.$lt) };
+          } else if ("$lte" in value) {
+            filter[key] = { $lte: this.convertObjectIdsToStrings(value.$lte) };
+          } else if ("$ne" in value) {
+            filter[key] = { $ne: this.convertObjectIdsToStrings(value.$ne) };
+          } else if ("$regex" in value) {
+            filter[key] = { $regex: value.$regex };
+          } else {
+            filter[key] = this.convertObjectIdsToStrings(value);
+          }
         } else {
           filter[key] = this.convertObjectIdsToStrings(value);
         }
-      } else {
-        filter[key] = this.convertObjectIdsToStrings(value);
       }
+      return filter;
     }
-    return filter;
-  }
-  /** Count documents matching a query (supports offset & limit) */
-  async count(collectionName, query, options) {
-    const collection = this.getCollection(String(collectionName));
-    const schema = this.getSchema(String(collectionName));
-    const filter = this.convertQueryToMongoFilter(query, schema);
-    let countOptions = {};
-    if (options?.offset) {
-      countOptions.skip = options.offset;
-    }
-    if (options?.limit) {
-      countOptions.limit = options.limit;
+    /** Count documents matching a query (supports offset & limit) */
+    async count(collectionName, query, options) {
+      const collection = this.getCollection(String(collectionName));
+      const schema = this.getSchema(String(collectionName));
+      const filter = this.convertQueryToMongoFilter(query, schema);
+      let countOptions = {};
+      if (options?.offset) {
+        countOptions.skip = options.offset;
+      }
+      if (options?.limit) {
+        countOptions.limit = options.limit;
+      }
+      const count = await collection.countDocuments(filter, Object.keys(countOptions).length > 0 ? countOptions : void 0);
+      return count;
     }
-    const count = await collection.countDocuments(filter, Object.keys(countOptions).length > 0 ? countOptions : void 0);
-    return count;
-  }
-  /** Find documents matching a query with pagination */
-  async find(collectionName, query, options) {
-    const collection = this.getCollection(String(collectionName));
-    const schema = this.getSchema(String(collectionName));
-    const filter = this.convertQueryToMongoFilter(query, schema);
-    let findQuery = collection.find(filter);
-    if (options?.offset) {
-      findQuery = findQuery.skip(options.offset);
-    }
-    if (options?.limit) {
-      findQuery = findQuery.limit(options.limit);
+    /** Find documents matching a query with pagination */
+    async find(collectionName, query, options) {
+      const collection = this.getCollection(String(collectionName));
+      const schema = this.getSchema(String(collectionName));
+      const filter = this.convertQueryToMongoFilter(query, schema);
+      let findQuery = collection.find(filter);
+      if (options?.offset) {
+        findQuery = findQuery.skip(options.offset);
+      }
+      if (options?.limit) {
+        findQuery = findQuery.limit(options.limit);
+      }
+      const docs = await findQuery.toArray();
+      const convertedDocs = docs.map((doc) => this.convertObjectIdsToStrings(doc));
+      return convertedDocs;
     }
-    const docs = await findQuery.toArray();
-    const convertedDocs = docs.map((doc) => this.convertObjectIdsToStrings(doc));
-    return convertedDocs;
   }
-};
-async function createMongoDB() {
-  const { BaseStorage: base } = await (0, import_ridb.WasmInternal)();
-  Object.setPrototypeOf(MongoDBStorage.prototype, base.prototype);
   return MongoDBStorage;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  MongoDBStorage
+  createMongoDB
 });

package/build/index.mjs

@@ -70,7 +70,7 @@ var require_ridb_core = __commonJS({
     var ridb_core_exports = {};
     __export(ridb_core_exports, {
       BasePlugin: () => BasePlugin,
-      BaseStorage: () => BaseStorage2,
+      BaseStorage: () => BaseStorage,
       Collection: () => Collection,
       CoreStorage: () => CoreStorage,
       Database: () => Database,
@@ -525,7 +525,7 @@ ${val.stack}`;
     var BaseStorageFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
     }, unregister: () => {
     } } : new FinalizationRegistry((ptr) => wasm.__wbg_basestorage_free(ptr >>> 0));
-    var BaseStorage2 = class {
+    var BaseStorage = class {
       __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
@@ -3146,213 +3146,222 @@ var import_ridb_core = __toESM(require_ridb_core());
 import {
   WasmInternal
 } from "@trust0/ridb";
-var MongoDBStorage = class _MongoDBStorage extends import_ridb_core.BaseStorage {
-  client;
-  db;
-  mongoConfig;
-  constructor(name, schemas, options = {}) {
-    super(name, schemas, options);
-    this.mongoConfig = options;
-  }
-  /**
-   * Utility method to recursively convert ObjectId values to strings throughout an object
-   * This ensures that MongoDB's ObjectId instances are never returned to the application layer,
-   * maintaining consistency with RIDB's string-based approach and preventing serialization issues.
-   * Also removes MongoDB's automatic _id field entirely from results.
-   * @private
-   */
-  convertObjectIdsToStrings(obj) {
-    if (!obj || typeof obj !== "object") {
-      return obj;
-    }
-    if (obj.constructor?.name === "ObjectId" || obj._bsontype && obj._bsontype === "ObjectId") {
-      const stringValue = obj.toString();
-      return stringValue;
-    }
-    if (Array.isArray(obj)) {
-      return obj.map((item) => this.convertObjectIdsToStrings(item));
+async function createMongoDB() {
+  const { BaseStorage } = await WasmInternal();
+  class MongoDBStorage extends BaseStorage {
+    client;
+    db;
+    mongoConfig;
+    constructor(name, schemas, options = {}) {
+      super(name, schemas, options);
+      this.mongoConfig = options;
     }
-    const converted = {};
-    for (const [key, value] of Object.entries(obj)) {
-      if (key === "_id") {
-        continue;
+    /**
+     * Utility method to recursively convert ObjectId values to strings throughout an object
+     * This ensures that MongoDB's ObjectId instances are never returned to the application layer,
+     * maintaining consistency with RIDB's string-based approach and preventing serialization issues.
+     * Also removes MongoDB's automatic _id field entirely from results.
+     * @private
+     */
+    convertObjectIdsToStrings(obj) {
+      if (!obj || typeof obj !== "object") {
+        return obj;
+      }
+      if (obj.constructor?.name === "ObjectId" || obj._bsontype && obj._bsontype === "ObjectId") {
+        const stringValue = obj.toString();
+        return stringValue;
+      }
+      if (Array.isArray(obj)) {
+        return obj.map((item) => this.convertObjectIdsToStrings(item));
+      }
+      const converted = {};
+      for (const [key, value] of Object.entries(obj)) {
+        if (key === "_id") {
+          continue;
+        }
+        converted[key] = this.convertObjectIdsToStrings(value);
       }
-      converted[key] = this.convertObjectIdsToStrings(value);
+      return converted;
     }
-    return converted;
-  }
-  /**
-   * Create a new MongoDB storage instance
-   * @param name - Database name
-   * @param schemas - Collection schemas
-   * @param options - Storage options including MongoDB connection details
-   * @returns A new Instance of MongoDB storage
-   * @public
-   */
-  static async create(name, schemas, options = {}) {
-    const db = new _MongoDBStorage(name, schemas, options);
-    return db;
-  }
-  /** Start the database connection */
-  async start() {
-    const { MongoClient } = await import("mongodb");
-    const url = this.mongoConfig.url || process.env.MONGODB_URL || "mongodb://localhost:27017";
-    const dbName = this.mongoConfig.dbName || this.name;
-    this.client = new MongoClient(url, this.mongoConfig.mongoOptions || {});
-    await this.client.connect();
-    this.db = this.client.db(dbName);
-  }
-  /** Close the database connection */
-  async close() {
-    if (this.client) {
-      await this.client.close();
-      this.client = void 0;
-      this.db = void 0;
+    /**
+     * Create a new MongoDB storage instance
+     * @param name - Database name
+     * @param schemas - Collection schemas
+     * @param options - Storage options including MongoDB connection details
+     * @returns A new Instance of MongoDB storage
+     * @public
+     */
+    static async create(name, schemas, options = {}) {
+      const db = new MongoDBStorage(name, schemas, options);
+      return db;
     }
-  }
-  /** Get MongoDB collection for a given collection name */
-  getCollection(collectionName) {
-    if (!this.db) {
-      throw new Error("Database not started. Call start() first.");
+    /** Start the database connection */
+    async start() {
+      const { MongoClient } = await import("mongodb");
+      const url = this.mongoConfig.url || process.env.MONGODB_URL;
+      if (!url) {
+        throw new Error("MONGODB_URL is required");
+      }
+      const dbName = this.mongoConfig.dbName || this.name;
+      this.client = new MongoClient(url, {
+        connectTimeoutMS: 5e3,
+        serverSelectionTimeoutMS: 5e3,
+        socketTimeoutMS: 5e3,
+        maxPoolSize: 10,
+        minPoolSize: 5,
+        maxIdleTimeMS: 5e3,
+        maxConnecting: 5
+      });
+      await this.client.connect();
+      this.db = this.client.db(dbName);
     }
-    const collection = this.db.collection(collectionName);
-    return collection;
-  }
-  /** Find a document by its ID */
-  async findDocumentById(collectionName, id) {
-    const collection = this.getCollection(String(collectionName));
-    const schema = this.getSchema(String(collectionName));
-    const primaryKey = schema.primaryKey;
-    const query = { [primaryKey]: id };
-    const doc = await collection.findOne(query);
-    if (!doc) {
-      return null;
+    /** Close the database connection */
+    async close() {
+      if (this.client) {
+        await this.client.close();
+        this.client = void 0;
+        this.db = void 0;
+      }
     }
-    const converted = this.convertObjectIdsToStrings(doc);
-    return converted;
-  }
-  /** Write an operation (insert, update, delete) */
-  async write(op) {
-    const collectionName = String(op.collection);
-    const collection = this.getCollection(collectionName);
-    const { primaryKey } = this.getSchema(collectionName);
-    switch (op.opType) {
-      case import_ridb_core.OpType.CREATE: {
-        const id = primaryKey in op.data ? op.data[primaryKey] : null;
-        if (!id) {
-          throw new Error("Document ID is required");
-        }
-        const existQuery = { [primaryKey]: id };
-        const existing = await collection.findOne(existQuery);
-        if (existing) {
-          throw new Error(`Document with ${primaryKey} '${id}' already exists`);
-        }
-        const docToInsert = { ...op.data };
-        const insertResult = await collection.insertOne(docToInsert);
-        const result = this.convertObjectIdsToStrings(op.data);
-        return result;
-      }
-      case import_ridb_core.OpType.UPDATE: {
-        const id = primaryKey in op.data ? op.data[primaryKey] : null;
-        if (!id) {
-          throw new Error("Document ID is required");
-        }
-        const updateQuery = { [primaryKey]: id };
-        const updateData = { $set: op.data };
-        const result = await collection.updateOne(updateQuery, updateData);
-        if (result.matchedCount === 0) {
-          throw new Error("Document ID not found");
-        }
-        const convertedResult = this.convertObjectIdsToStrings(op.data);
-        return convertedResult;
-      }
-      case import_ridb_core.OpType.DELETE: {
-        const id = op.data;
-        const deleteQuery = { [primaryKey]: id };
-        const result = await collection.deleteOne(deleteQuery);
-        if (result.deletedCount === 0) {
-          throw new Error("Document ID not found");
-        }
-        const convertedResult = this.convertObjectIdsToStrings(op.data);
-        return convertedResult;
-      }
-      default:
-        throw new Error(`Unknown operation type: ${op.opType}`);
+    /** Get MongoDB collection for a given collection name */
+    getCollection(collectionName) {
+      if (!this.db) {
+        throw new Error("Database not started. Call start() first.");
+      }
+      const collection = this.db.collection(collectionName);
+      return collection;
     }
-  }
-  /** Convert RIDB query to MongoDB filter */
-  convertQueryToMongoFilter(query, schema) {
-    if (!query || typeof query !== "object") {
-      return {};
+    /** Find a document by its ID */
+    async findDocumentById(collectionName, id) {
+      const collection = this.getCollection(String(collectionName));
+      const schema = this.getSchema(String(collectionName));
+      const primaryKey = schema.primaryKey;
+      const query = { [primaryKey]: id };
+      const doc = await collection.findOne(query);
+      if (!doc) {
+        return null;
+      }
+      const converted = this.convertObjectIdsToStrings(doc);
+      return converted;
     }
-    const filter = {};
-    for (const [key, value] of Object.entries(query)) {
-      if (value === null || value === void 0) {
-        filter[key] = { $exists: false };
-      } else if (typeof value === "object" && value !== null) {
-        if ("$in" in value) {
-          filter[key] = { $in: this.convertObjectIdsToStrings(value.$in) };
-        } else if ("$nin" in value) {
-          filter[key] = { $nin: this.convertObjectIdsToStrings(value.$nin) };
-        } else if ("$gt" in value) {
-          filter[key] = { $gt: this.convertObjectIdsToStrings(value.$gt) };
-        } else if ("$gte" in value) {
-          filter[key] = { $gte: this.convertObjectIdsToStrings(value.$gte) };
-        } else if ("$lt" in value) {
-          filter[key] = { $lt: this.convertObjectIdsToStrings(value.$lt) };
-        } else if ("$lte" in value) {
-          filter[key] = { $lte: this.convertObjectIdsToStrings(value.$lte) };
-        } else if ("$ne" in value) {
-          filter[key] = { $ne: this.convertObjectIdsToStrings(value.$ne) };
-        } else if ("$regex" in value) {
-          filter[key] = { $regex: value.$regex };
+    /** Write an operation (insert, update, delete) */
+    async write(op) {
+      const collectionName = String(op.collection);
+      const collection = this.getCollection(collectionName);
+      const { primaryKey } = this.getSchema(collectionName);
+      switch (op.opType) {
+        case import_ridb_core.OpType.CREATE: {
+          const id = primaryKey in op.data ? op.data[primaryKey] : null;
+          if (!id) {
+            throw new Error("Document ID is required");
+          }
+          const existQuery = { [primaryKey]: id };
+          const existing = await collection.findOne(existQuery);
+          if (existing) {
+            throw new Error(`Document with ${primaryKey} '${id}' already exists`);
+          }
+          const docToInsert = { ...op.data };
+          const insertResult = await collection.insertOne(docToInsert);
+          const result = this.convertObjectIdsToStrings(op.data);
+          return result;
+        }
+        case import_ridb_core.OpType.UPDATE: {
+          const id = primaryKey in op.data ? op.data[primaryKey] : null;
+          if (!id) {
+            throw new Error("Document ID is required");
+          }
+          const updateQuery = { [primaryKey]: id };
+          const updateData = { $set: op.data };
+          const result = await collection.updateOne(updateQuery, updateData);
+          if (result.matchedCount === 0) {
+            throw new Error("Document ID not found");
+          }
+          const convertedResult = this.convertObjectIdsToStrings(op.data);
+          return convertedResult;
+        }
+        case import_ridb_core.OpType.DELETE: {
+          const id = op.data;
+          const deleteQuery = { [primaryKey]: id };
+          const result = await collection.deleteOne(deleteQuery);
+          if (result.deletedCount === 0) {
+            throw new Error("Document ID not found");
+          }
+          const convertedResult = this.convertObjectIdsToStrings(op.data);
+          return convertedResult;
+        }
+        default:
+          throw new Error(`Unknown operation type: ${op.opType}`);
+      }
+    }
+    /** Convert RIDB query to MongoDB filter */
+    convertQueryToMongoFilter(query, schema) {
+      if (!query || typeof query !== "object") {
+        return {};
+      }
+      const filter = {};
+      for (const [key, value] of Object.entries(query)) {
+        if (value === null || value === void 0) {
+          filter[key] = { $exists: false };
+        } else if (typeof value === "object" && value !== null) {
+          if ("$in" in value) {
+            filter[key] = { $in: this.convertObjectIdsToStrings(value.$in) };
+          } else if ("$nin" in value) {
+            filter[key] = { $nin: this.convertObjectIdsToStrings(value.$nin) };
+          } else if ("$gt" in value) {
+            filter[key] = { $gt: this.convertObjectIdsToStrings(value.$gt) };
+          } else if ("$gte" in value) {
+            filter[key] = { $gte: this.convertObjectIdsToStrings(value.$gte) };
+          } else if ("$lt" in value) {
+            filter[key] = { $lt: this.convertObjectIdsToStrings(value.$lt) };
+          } else if ("$lte" in value) {
+            filter[key] = { $lte: this.convertObjectIdsToStrings(value.$lte) };
+          } else if ("$ne" in value) {
+            filter[key] = { $ne: this.convertObjectIdsToStrings(value.$ne) };
+          } else if ("$regex" in value) {
+            filter[key] = { $regex: value.$regex };
+          } else {
+            filter[key] = this.convertObjectIdsToStrings(value);
+          }
         } else {
           filter[key] = this.convertObjectIdsToStrings(value);
         }
-      } else {
-        filter[key] = this.convertObjectIdsToStrings(value);
       }
+      return filter;
     }
-    return filter;
-  }
-  /** Count documents matching a query (supports offset & limit) */
-  async count(collectionName, query, options) {
-    const collection = this.getCollection(String(collectionName));
-    const schema = this.getSchema(String(collectionName));
-    const filter = this.convertQueryToMongoFilter(query, schema);
-    let countOptions = {};
-    if (options?.offset) {
-      countOptions.skip = options.offset;
-    }
-    if (options?.limit) {
-      countOptions.limit = options.limit;
+    /** Count documents matching a query (supports offset & limit) */
+    async count(collectionName, query, options) {
+      const collection = this.getCollection(String(collectionName));
+      const schema = this.getSchema(String(collectionName));
+      const filter = this.convertQueryToMongoFilter(query, schema);
+      let countOptions = {};
+      if (options?.offset) {
+        countOptions.skip = options.offset;
+      }
+      if (options?.limit) {
+        countOptions.limit = options.limit;
+      }
+      const count = await collection.countDocuments(filter, Object.keys(countOptions).length > 0 ? countOptions : void 0);
+      return count;
     }
-    const count = await collection.countDocuments(filter, Object.keys(countOptions).length > 0 ? countOptions : void 0);
-    return count;
-  }
-  /** Find documents matching a query with pagination */
-  async find(collectionName, query, options) {
-    const collection = this.getCollection(String(collectionName));
-    const schema = this.getSchema(String(collectionName));
-    const filter = this.convertQueryToMongoFilter(query, schema);
-    let findQuery = collection.find(filter);
-    if (options?.offset) {
-      findQuery = findQuery.skip(options.offset);
-    }
-    if (options?.limit) {
-      findQuery = findQuery.limit(options.limit);
+    /** Find documents matching a query with pagination */
+    async find(collectionName, query, options) {
+      const collection = this.getCollection(String(collectionName));
+      const schema = this.getSchema(String(collectionName));
+      const filter = this.convertQueryToMongoFilter(query, schema);
+      let findQuery = collection.find(filter);
+      if (options?.offset) {
+        findQuery = findQuery.skip(options.offset);
+      }
+      if (options?.limit) {
+        findQuery = findQuery.limit(options.limit);
+      }
+      const docs = await findQuery.toArray();
+      const convertedDocs = docs.map((doc) => this.convertObjectIdsToStrings(doc));
+      return convertedDocs;
     }
-    const docs = await findQuery.toArray();
-    const convertedDocs = docs.map((doc) => this.convertObjectIdsToStrings(doc));
-    return convertedDocs;
   }
-};
-async function createMongoDB() {
-  const { BaseStorage: base } = await WasmInternal();
-  Object.setPrototypeOf(MongoDBStorage.prototype, base.prototype);
   return MongoDBStorage;
 }
 export {
-  MongoDBStorage,
-  createMongoDB as default
+  createMongoDB
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@trust0/ridb-mongodb",
-  "version": "0.0.1",
-  "description": "MongoDB storage for @trust0/ridb.",
+  "version": "0.0.3",
+  "description": "MongoDB storage for @trust0/ridb",
   "main": "./build/index.js",
   "module": "./build/index.mjs",
   "types": "./build/index.d.ts",
@@ -31,7 +31,7 @@
     "types:default": "npx tsc"
   },
   "devDependencies": {
-    "@trust0/ridb": "^1.5.34",
+    "@trust0/ridb": "^1.5.36",
     "@trust0/ridb-build": "^0.0.16",
     "jsdom": "^24.1.3",
     "mongodb": "^6.0.0",