blackcat.js-database 1.0.0-test → 1.0.1

package/dist/index.mjs

@@ -110,170 +110,192 @@ import { EventEmitter } from "events";
 
 // src/Database.ts
 var _Database = class _Database {
+  /**
+   * Khởi tạo Database instance.
+   *
+   * @param options Cấu hình database.
+   * @param options.driver Driver lưu trữ dữ liệu.
+   *
+   * @example
+   * ```ts
+   * const db = new Database({
+   *   driver: new JSONDriver({ filePath: "./database.json" }),
+   * })
+   * ```
+   *
+   * Ví dụ với MongoDB:
+   *
+   * ```ts
+   * const db = new Database({
+   *   driver: new MongoDriver({
+   *     uri: "mongodb://localhost:27017",
+   *     databaseName: "mydb"
+   *   })
+   * });
+   * ```
+   */
   constructor(options) {
     /**
-     * The low-level database driver handling basic operations.
+     * Storage driver được sử dụng để đọc và ghi dữ liệu database.
+     *
+     * Driver phải implement interface `DatabaseDriver`.
+     *
+     * Ví dụ:
+     * ```ts
+     * const db = new Database({
+     *   driver: new JSONDriver({ filePath: "./database.json" }),
+     * })
+     * ```
      */
     __publicField(this, "driver");
     this.driver = options.driver;
   }
   /**
-   * Gets all the database contents from the cache.
+   * Lấy toàn bộ dữ liệu từ database thông qua driver.
    *
-   * Type parameters:
+   * @template T Kiểu dữ liệu object database trả về.
    *
-   * - `T` (`object`, defaults to `Record<string, any>`) - The type of object of all the database object to be returned.
-   *
-   * @returns {T} Cached database contents.
-   *
-   * @template T (object, defaults to `Record<string, any>`) -
-   * The type of object of all the database object to be returned.
+   * @returns Promise chứa toàn bộ dữ liệu database.
    *
    * @example
-   * const databaseContents = await database.all();
-   * console.log(databaseContents); // -> { ... (the object of all the data stored in database) }
+   * ```ts
+   * const data = await db.all();
+   * console.log(data.users);
+   * ```
    */
   async all() {
-    const allDatabase = await this.driver.all();
-    return allDatabase;
+    return await this.driver.all();
   }
   /**
-   * Retrieves a value from database by a key.
+   * Lấy giá trị từ database theo key-path.
    *
-   * @param {AutocompletableString<P>} key The key to access the target in database by.
-   * @returns {Maybe<ObjectValue<V, P>>} The value of the target in database.
+   * Key có thể là chuỗi dạng path:
    *
-   * @example
-   * const simpleValue = await database.get("simpleValue");
-   * console.log(simpleValue); // -> 123
+   * ```
+   * user.profile.name
+   * economy.users.123.balance
+   * ```
+   *
+   * Nếu không truyền `key`, method sẽ trả về **toàn bộ database**.
+   *
+   * @template {AutocompletableString<ObjectPath<V>>} P Key path trong database.
    *
-   * const databaseObjectPropertyAccessed = await database.get("youCanAlso.accessDatabaseObjectProperties.likeThat");
-   * console.log(databaseObjectPropertyAccessed); // -> "hello world!"
+   * @param {AutocompletableString<P>} key Đường dẫn dữ liệu cần lấy.
    *
-   * // Assuming that the initial database object for this example is:
-   * // {
-   * //    simpleValue: 123,
-   * //    youCanAlso: {
-   * //        accessDatabaseObjectProperties: {
-   * //            likeThat: "hello world!"
-   * //        }
-   * //    }
-   * // }
+   * @returns Giá trị tại key hoặc `null` nếu không tồn tại.
+   *
+   * @example
+   * ```ts
+   * const name = await db.get("user.profile.name");
+   * ```
+   *
+   * @example
+   * ```ts
+   * const all = await db.get();
+   * ```
    */
   async get(key) {
-    if (key !== void 0) {
-      if (typeof key !== "string") {
-        throw new BlackCatError("INVALID_TYPE", "key", "string", typeOf(key));
-      }
-      return this.driver.get(key);
-    } else {
-      return this.all();
+    const data = await this.all();
+    if (key === void 0) return data;
+    if (typeof key !== "string") {
+      throw new BlackCatError("INVALID_TYPE", "key", "string", typeOf(key));
     }
-    ;
+    const keys = key.split(".");
+    let result = data;
+    for (const k of keys) {
+      if (!isObject(result) && !Array.isArray(result)) return null;
+      result = result[k];
+      if (result === void 0) return null;
+    }
+    return result;
   }
   /**
-   * Retrieves a value from database by a key.
-   *
-   * - This method is an alias for {@link Database.get()} method.
+   * Tìm và trả về một bản ghi đầu tiên khớp với điều kiện trong database.
    *
-   * @param {AutocompletableString<P>} key The key to access the target in database by.
-   * @returns {Maybe<ObjectValue<V, P>>} The value from database.
+   * Hàm này có hai cách sử dụng:
    *
-   * @example
-   * const simpleValue = await database.fetch("simpleValue");
-   * console.log(simpleValue); // -> 123
+   * 1. **Chỉ truyền `key`**
+   *    → Trả về toàn bộ dữ liệu của key (tương tự `get()`).
    *
-   * // You can use the dot notation to access the database object properties:
-   * const playerInventory = await database.fetch("player.inventory");
-   * console.log(playerInventory); // -> []
+   * 2. **Truyền `key` và `query`**
+   *    → Tìm phần tử đầu tiên trong mảng dữ liệu của key khớp với điều kiện.
    *
-   * // Assuming that the initial database object for this example is:
-   * // {
-   * //    simpleValue: 123,
-   * //    player: {
-   * //        inventory: []
-   * //    }
-   * // }
-   */
-  async fetch(key) {
-    return this.get(key);
-  }
-  /**
-   * Determines if the data is stored in database.
-   * @param {AutocompletableString<P>} key The key to access the target in database by.
-   * @returns {boolean} Whether the data is stored in database.
+   * @template V - Kiểu dữ liệu của database.
+   * @template P - Đường dẫn key trong object (`ObjectPath<V>`).
    *
-   * @example
-   * const isSimpleValueInDatabase = await database.has("simpleValue");
-   * console.log(isSimpleValueInDatabase); // -> true
+   * @param key - Key hoặc đường dẫn đến dữ liệu cần truy vấn.
+   * @param query - Đối tượng điều kiện để tìm bản ghi phù hợp.
    *
-   * const somethingElse = await database.has("somethingElse");
-   * console.log(somethingElse); // -> false
+   * @returns
+   * - Nếu chỉ có `key`: trả về toàn bộ dữ liệu của key.
+   * - Nếu có `query`: trả về bản ghi đầu tiên khớp điều kiện.
+   * - Nếu không tìm thấy: trả về `null`.
    *
-   * // You can use the dot notation to check the database object properties:
-   * const isObjectInDatabase = await database.has("youCanAlso.accessObjectProperties.likeThat");
-   * console.log(isObjectInDatabase); // -> true
+   * @example
+   * Chỉ lấy dữ liệu theo key
+   * ```ts
+   * const users = await db.findOne("user");
+   * ```
    *
-   * // Assuming that the initial database object for this example is:
-   * // {
-   * //    simpleValue: 123,
-   * //    player: {
-   * //        inventory: []
-   * //    },
-   * //    youCanAlso: {
-   * //        accessObjectProperties: {
-   * //            likeThat: "hello world!"
-   * //        }
-   * //    }
-   * // }
+   * @example
+   * Tìm một bản ghi theo điều kiện
+   * ```ts
+   * const user = await db.findOne("user", {
+   *   guild: 1234566
+   * });
+   * ```
    */
-  async has(key) {
-    return this.get(key) !== null && this.get(key) !== void 0;
+  async findOne(key, query) {
+    const data = await this.get(key);
+    if (!query) return data;
+    if (!Array.isArray(data)) return null;
+    const result = data.find((item) => {
+      return Object.entries(query).every(([k, v]) => item[k] == v);
+    });
+    return result ?? null;
   }
   /**
-   * Writes the specified value into database under the specified key.
+   * Kiểm tra một key-path có tồn tại trong database hay không.
    *
-   * @param {AutocompletableString<P>} key The key to write in the target.
-   * @param {ObjectValue<V, P>} value The value to write.
+   * Method này sử dụng `get()` để xác định giá trị có tồn tại.
    *
-   * @returns {Promise<If<IsObject<V>, FirstObjectKey<P>, V>>}
-   * - If the `value` parameter's type is not an object (string, number, boolean, etc), then the specified
-   * `value` parameter (type of `ObjectValue<V, P>`) will be returned.
+   * @template {AutocompletableString<ObjectPath<V>>} P Key path trong database.
    *
-   * - If an object is specified in the `value` parameter, then the object of the first key will be returned.
-   * (type of `FirstObjectKey<P>` - first object key (e.g. in key `member.user.id`, the first key will be `member`))
+   * @param {AutocompletableString<P>} key Đường dẫn dữ liệu cần kiểm tra.
    *
-   * @example
-   * // Assuming that the initial database object for this example is empty.
+   * @returns `true` nếu key tồn tại, ngược lại `false`.
    *
-   * await database.set("something", "hello");
-   * const hello = await database.get("something");
+   * @example
+   * ```ts
+   * const exists = await db.has("users.123");
+   * ```
+   */
+  async has(key) {
+    const value = await this.get(key);
+    return value !== null && value !== void 0;
+  }
+  /**
+   * Gán giá trị cho một key-path trong database.
    *
-   * console.log(hello); // -> "hello"
+   * Nếu key-path chưa tồn tại, các object trung gian
+   * sẽ được tự động tạo.
    *
-   * // You can use the dot notation to write data in objects:
-   * const dotNotationSetResult = await database.set("member.user.id", 2000);
-   * console.log(dotNotationSetResult); // -> 2000
+   * @template {AutocompletableString<ObjectPath<V>>} P Key path trong database.
    *
-   * await database.set("member.inventory", []);
-   * const inventory = await database.get("member.inventory");
+   * @param {AutocompletableString<P>} key Đường dẫn dữ liệu cần gán giá trị.
+   * @param {ObjectValue<V, P>} value Giá trị mới.
    *
-   * console.log(inventory); // -> []
+   * @returns {Promise<If<IsObject<V>, ObjectValue<V, FirstObjectKey<P>>, V>>} Giá trị vừa được set hoặc object root nếu value là object.
    *
-   * // Using objects as value will return the object of key `thats`:
-   * await database.set("member.user", { name: "Jerry" }); // -> { member: { user: { name: "Jerry" } } }
+   * @example
+   * ```ts
+   * await db.set("users.123.name", "Alice");
+   * ```
    *
-   * // After these manipulations, the database object will look like this:
-   * // {
-   * //     "something": "hello",
-   * //     "member": {
-   * //       "inventory": [],
-   * //       "user": { 
-   * //          "name": "Jerry",
-   * //          "id": 2000 
-   * //       }
-   * //     }
-   * // }
+   * @example
+   * ```ts
+   * await db.set("config.prefix", "!");
+   * ```
    */
   async set(key, value) {
     const allDatabase = await this.all();
@@ -297,21 +319,134 @@ var _Database = class _Database {
       ;
     }
     ;
-    await this.driver.set(keys[0], allDatabase);
+    await this.driver.set(allDatabase);
     return typeof value == "object" && value !== null ? await this.get(keys[0]) : value;
   }
   /**
-   * Update the specified value into database under the specified key.
+   * Xóa một key khỏi database.
+   *
+   * Hỗ trợ nested path bằng dot notation.
+   *
+   * @typeParam P - Path của object.
+   *
+   * @param key - Đường dẫn key cần xóa.
+   *
+   * @returns
+   * - `true` nếu xóa thành công
+   * - `false` nếu key không tồn tại
+   *
+   * @throws BlackCatError
+   * - INVALID_TYPE nếu key không phải string
+   *
+   * @example
+   * await db.delete("user.name");
+   */
+  async delete(key) {
+    if (typeof key !== "string") {
+      throw new BlackCatError("INVALID_TYPE", "key", "string", typeof key);
+    }
+    const allDatabase = await this.all();
+    const keys = key.split(".");
+    const lastKey = keys.pop();
+    let currentObj = allDatabase;
+    for (const k of keys) {
+      if (!isObject(currentObj[k])) {
+        return false;
+      }
+      currentObj = currentObj[k];
+    }
+    if (!(lastKey in currentObj)) return false;
+    delete currentObj[lastKey];
+    await this.driver.set(allDatabase);
+    return true;
+  }
+  /**
+   * Xóa toàn bộ dữ liệu trong database.
+   *
+   * Method này gọi trực tiếp `driver.delete()` để reset storage.
+   *
+   * @returns `true` sau khi dữ liệu đã được xóa.
+   *
+   * @example
+   * await db.deleteAll();
+   */
+  async deleteAll() {
+    await this.driver.delete();
+    return true;
+  }
+  /**
+   * Xóa nhiều bản ghi trong một mảng dữ liệu dựa trên điều kiện truy vấn.
+   *
+   * ⚠️ Method này **chỉ hoạt động với dữ liệu dạng mảng (array)**.
+   * Nếu dữ liệu tại `key` không phải là mảng, method sẽ **không thực hiện xóa**
+   * và trả về `0`.
    *
-   * @param {AutocompletableString<P>} key The key to update the target.
-   * @param {ObjectValue<V, P>} value The value to update.
+   * Method sẽ duyệt qua toàn bộ phần tử trong mảng và xóa những phần tử
+   * khớp với điều kiện `query`.
    *
-   * @returns {Promise<If<IsObject<V>, FirstObjectKey<P>, V>>}
-   * - If the `value` parameter's type is not an object (string, number, boolean, etc), then the specified
-   * `value` parameter (type of `ObjectValue<V, P>`) will be returned.
+   * @template V - Kiểu dữ liệu của database.
+   * @template P - Đường dẫn key trong object (`ObjectPath<V>`).
    *
-   * - If an object is specified in the `value` parameter, then the object of the first key will be returned.
-   * (type of `FirstObjectKey<P>` - first object key (e.g. in key `member.user.id`, the first key will be `member`))
+   * @param key - Đường dẫn đến mảng dữ liệu cần thao tác.
+   * @param query - Điều kiện để xác định các phần tử cần xóa.
+   * Có thể truyền:
+   * - Một object điều kiện
+   *
+   * @returns Số lượng phần tử đã bị xóa khỏi mảng.
+   *
+   * @example
+   * Database mẫu:
+   * ```json
+   * {
+   *   "member": {
+   *     "user": {
+   *       "database": [
+   *         { "guild": "123", "username": "vinh" },
+   *         { "guild": "456", "username": "test" }
+   *       ]
+   *     }
+   *   }
+   * }
+   * ```
+   *
+   * @example
+   * Xóa tất cả user có guild = "123"
+   * ```ts
+   * await db.deleteMany("member.user.database", {
+   *   guild: "123"
+   * });
+   * ```
+   */
+  async deleteMany(key, query) {
+    const data = await this.get(key);
+    if (!Array.isArray(data)) return 0;
+    const originalLength = data.length;
+    const filtered = data.filter((item) => {
+      return !Object.entries(query).every(([k, v]) => item[k] == v);
+    });
+    await this.set(key, filtered);
+    return originalLength - filtered.length;
+  }
+  /**
+   * Cập nhật giá trị của một key-path trong database.
+   *
+   * Khác với `set()`, method này chỉ ghi đè giá trị của key cuối cùng
+   * trong path mà không thay đổi cấu trúc object phía trên.
+   *
+   * Nếu các object trung gian trong path chưa tồn tại
+   * thì chúng sẽ được tự động tạo.
+   *
+   * @template P Key path trong database.
+   *
+   * @param key Đường dẫn dữ liệu cần cập nhật.
+   * @param value Giá trị mới.
+   *
+   * @returns Object cha của key vừa cập nhật.
+   *
+   * @example
+   * ```ts
+   * await db.update("users.123.name", "Alice");
+   * ```
    */
   async update(key, value) {
     const allDatabase = await this.all();
@@ -326,34 +461,25 @@ var _Database = class _Database {
     }
     const lastKey = keys[keys.length - 1];
     current[lastKey] = value;
-    await this.driver.set(keys[0], allDatabase);
+    await this.driver.set(allDatabase);
     return current;
   }
   /**
-   * Performs an arithmetical addition on a target number in database.
+   * Cộng thêm giá trị vào một key dạng number.
    *
-   * [!!!] The type of target value must be a number.
+   * Nếu key chưa tồn tại, giá trị mặc định sẽ là `0`.
    *
-   * @param {AutocompletableString<P>} key The key to access the target in database by.
-   * @param {number} numberToAdd The number to add to the target number in database.
-   * @returns {Promise<number>} Addition operation result.
+   * @template P Key path trong database.
    *
-   * @example
-   * const additionResult = await database.add("points", 5);
-   * console.log(additionResult); // -> 10 (5 + 5 = 10)
+   * @param key Đường dẫn dữ liệu dạng number.
+   * @param numberToAdd Số cần cộng thêm.
    *
-   * // Notice that we don't need to assign a value to unexistent properties in database
-   * // before performing an addition since the initial target value is 0 and will be used
-   * // as the value of the unexistent property:
-   * const unexistentAdditionResult = await database.add("somethingElse", 3);
+   * @returns Giá trị mới sau khi cộng.
    *
-   * console.log(unexistentAdditionResult); // -> 3 (0 + 3 = 3)
-   * // the property didn't exist in database, that's why 0 is added to 3
-   *
-   * // Assuming that the initial database object for this example is:
-   * // {
-   * //    points: 5
-   * // }
+   * @example
+   * ```ts
+   * await db.add("economy.users.123.balance", 50);
+   * ```
    */
   async add(key, numberToAdd) {
     const targetNumber = await this.get(key) ?? 0;
@@ -369,30 +495,21 @@ var _Database = class _Database {
     return await this.set(key, targetNumber + numberToAdd);
   }
   /**
-   * Performs an arithmetical subtraction on a target number in database.
+   * Trừ giá trị khỏi một key dạng number.
    *
-   * [!!!] The type of target value must be a number.
+   * Nếu key chưa tồn tại, giá trị mặc định sẽ là `0`.
    *
-   * @param {AutocompletableString<P>} key The key to access the target in database by.
-   * @param {number} numberToSubtract The number to subtract from the target number in database.
-   * @returns {Promise<number>} Subtraction operation result.
+   * @template P Key path trong database.
    *
-   * @example
-   * const subtractionResult = await database.subtract("points", 5)
-   * console.log(subtractionResult) // -> 5 (10 - 5 = 5)
+   * @param key Đường dẫn dữ liệu dạng number.
+   * @param numberToSubtract Số cần trừ.
    *
-   * // Notice that we don't need to assign a value to unexistent properties in database
-   * // before performing a subtraction since the initial target value is 0 and will be used
-   * // as the value of the unexistent property:
-   * const unexistentSubtractionitionResult = await database.subtract("somethingElse", 3)
+   * @returns Giá trị mới sau khi trừ.
    *
-   * console.log(unexistentSubtractionitionResult) // -> 3 (0 - 3 = -3)
-   * // the property didn't exist in database, so 3 is subtracted from 0
-   *
-   * // Assuming that the initial database object for this example is:
-   * // {
-   * //    points: 10
-   * // }
+   * @example
+   * ```ts
+   * await db.subtract("economy.users.123.balance", 20);
+   * ```
    */
   async subtract(key, numberToSubtract) {
     const targetNumber = await this.get(key) ?? 0;
@@ -408,27 +525,31 @@ var _Database = class _Database {
     return await this.set(key, targetNumber - numberToSubtract);
   }
   /**
-   * Pushes the specified value(s) into the target array in database.
+   * Thêm một hoặc nhiều phần tử vào cuối array tại key-path.
    *
-   * [!!!] The type of target value must be an array.
-   * [!!!] get only values ​​not stored in the database.
+   * Method này sẽ:
+   * - kiểm tra target có phải array không
+   * - chỉ thêm các giá trị **chưa tồn tại** trong array
    *
-   * @param {AutocompletableString<P>} key The key to access the target in database by.
-   * @param {RestOrArray<ExtractFromArray<ObjectValue<V, P>>>} values
-   * The value(s) to be pushed into the target array in database.
+   * ⚠️ Nếu key không tồn tại hoặc target không phải array
+   * thì sẽ ném lỗi.
    *
-   * @returns {Promise<Array<ExtractFromArray<ObjectValue<V, P>>>>} Updated target array from database.
+   * @template P Key path trong database.
+   *
+   * @param key Đường dẫn tới array cần thêm phần tử.
+   * @param values Một hoặc nhiều giá trị cần thêm.
+   *
+   * @returns Array sau khi thêm phần tử.
    *
    * @example
-   * console.log(await database.push("members", "Jerry")); // -> ["Tom", "Jerry"]
-   * // You can also pass in multiple values to push into the target array:
-   * console.log(await database.push("currencies", "VND")); // -> ["USD", "VND"]
+   * ```ts
+   * await db.push("users.123.roles", "admin");
+   * ```
    *
-   * // Assuming that the initial database object for this example is:
-   * // {
-   * //    members: ["Tom"],
-   * //    currencies: ["USD"]
-   * // }
+   * @example
+   * ```ts
+   * await db.push("queue.songs", song1, song2);
+   * ```
    */
   async push(key, ...values) {
     if (!values.length) {
@@ -458,23 +579,25 @@ var _Database = class _Database {
     return target[pathParts[pathParts.length - 1]];
   }
   /**
-  * Replaces the specified element in target array with the specified value in the target array in database.
-  *
-  * [!!!] The type of target value must be an array.
-  *
-  * @param {AutocompletableString<P>} key The key to access the target in database by.
-  * @param {number} targetArrayElementIndex The index to find the element in target array by.
-  * @param {V} value The value to be pushed into the target array in database.
-  * @returns {Promise<Array<ExtractFromArray<ObjectValue<V, P>>>>} Updated target array from database.
-  *
-  * @example
-  * console.log(await database.pull("members", 1, "James")); // -> ["Jerry", "James", "Tom"]
-  *
-  * // Assuming that the initial database object for this example is:
-  * // {
-  * //    members: ["Jerry", "William", "Tom"]
-  * // }
-  */
+   * Thay thế phần tử trong array theo index.
+   *
+   * @typeParam P - Path trỏ đến array.
+   *
+   * @param key - Đường dẫn array.
+   * @param targetArrayElementIndex - Index cần thay.
+   * @param value - Giá trị mới.
+   *
+   * @returns Array sau khi thay thế.
+   *
+   * @throws BlackCatError
+   * - INVALID_TYPE nếu index không phải number
+   * - REQUIRED_PARAMETER_MISSING nếu thiếu value
+   * - INVALID_KEY nếu path không tồn tại
+   * - INVALID_TARGET nếu target không phải array
+   *
+   * @example
+   * await db.pull("users", 0, { id: 2 });
+   */
   async pull(key, targetArrayElementIndex, value) {
     if (!isNumber(targetArrayElementIndex)) {
       throw new BlackCatError("INVALID_TYPE", "targetArrayElementIndex", "number", typeOf(targetArrayElementIndex));
@@ -514,26 +637,25 @@ var _Database = class _Database {
     return target[pathParts[pathParts.length - 1]];
   }
   /**
-   * Removes the specified element(s) from the target array in database.
+   * Xóa phần tử khỏi array theo index.
    *
-   * [!!!] The type of target value must be an array.
+   * Có thể truyền nhiều index hoặc một array index.
    *
-   * @param {AutocompletableString<P>} key The key to access the target in database by.
-   * @param {RestOrArray<ExtractFromArray<number>>} targetArrayElementIndexes
-   * The index(es) to find the element(s) in target array by.
+   * @typeParam P - Path trỏ đến array.
    *
-   * @returns {Promise<Array<ExtractFromArray<ObjectValue<V, P>>>>} Updated target array from database.
+   * @param key - Đường dẫn array.
+   * @param targetArrayElementIndexes - Các index cần xóa.
    *
-   * @example
-   * console.log(await database.pop("members", 1)); // -> ["Jerry", "Tom"]
+   * @returns Danh sách phần tử đã bị xóa.
    *
-   * console.log(await database.pop("currencies", 1)); // -> ["VND", "Euro"]
+   * @throws BlackCatError
+   * - INVALID_TARGET nếu target không phải array
+   * - REQUIRED_PARAMETER_MISSING nếu thiếu index
+   * - ONE_OR_MORE_ARRAY_TYPES_INVALID nếu index không phải number
    *
-   * // Assuming that the initial database object for this example is:
-   * // {
-   * //    members: ["Jerry", "William", "Tom"],
-   * //    currencies: ["VND", "USD", "Euro"]
-   * // }
+   * @example
+   * await db.pop("users", 0);
+   * await db.pop("numbers", [1, 2, 3]);
    */
   async pop(key, ...targetArrayElementIndexes) {
     const targetArray = await this.get(key) ?? [];
@@ -570,87 +692,52 @@ var _Database = class _Database {
     return removedElements;
   }
   /**
-   * Determines whether the specified target is an array.
+   * Kiểm tra xem giá trị tại key có phải là Array hay không.
    *
-   * @param {AutocompletableString<P>} key The key to access the target in database by.
-   * @returns {Promise<boolean>} Whether the target is an array.
+   * @typeParam P - Path của object trong database.
+   * @param key - Đường dẫn key cần kiểm tra.
    *
-   * @example
-   * console.log(await databse.isTargetArray("array")); // => true
-   * console.log(await databse.isTargetArray("notArray")); // => false
+   * @returns `true` nếu giá trị là Array, ngược lại `false`.
    *
-   * // Assuming that the initial database object for this example is:
-   * // {
-   * //    array: [],
-   * //    notArray: 123
-   * // }
+   * @example
+   * const result = await db.isTargetArray("users");
+   * console.log(result);
    */
   async isTargetArray(key) {
     const target = await this.get(key);
     return Array.isArray(target);
   }
   /**
-   * Determines whether the specified target is a number.
+   * Kiểm tra xem giá trị tại key có phải là Number hay không.
    *
-   * @param {AutocompletableString<P>} key The key to access the target in database by.
-   * @returns {Promise<boolean>} Whether the target is a number.
+   * @typeParam P - Path của object trong database.
    *
-   * @example
-   * console.log(await database.isTargetNumber("number")); // -> true
-   * console.log(await database.isTargetNumber("notNumber")); // -> false
+   * @param key - Đường dẫn key cần kiểm tra.
    *
-   * // Assuming that the initial database object for this example is:
-   * // {
-   * //    number: 123,
-   * //    notNumber: []
-   * // }
+   * @returns `true` nếu giá trị là Number, ngược lại `false`.
+   *
+   * @example
+   * const result = await db.isTargetNumber("stats.score");
+   * console.log(result);
    */
   async isTargetNumber(key) {
     const target = await this.get(key);
     return isNumber(target);
   }
   /**
-   * Returns an array of object keys by specified database key.
+   * Lấy danh sách các key của object trong database.
    *
-   * If `key` parameter is omitted, then an array of object keys of database root object will be returned.
+   * Nếu không truyền `key` → trả về các key cấp cao nhất của database.
    *
-   * Type parameters:
+   * @typeParam P - Path của object.
    *
-   * - `TKeys` (`TupleOrArray<string>`, defaults to `K[]`) - The tuple or array of a type of keys to be returned.
+   * @param key - Path của object cần lấy danh sách key.
    *
-   * @param {P} [key] The key to access the target in database by.
-   * @returns {Array<ObjectPath<P>>} Database object keys array.
+   * @returns Mảng các key tồn tại (không bao gồm `null` hoặc `undefined`).
    *
    * @example
-   * const prop3Keys = await database.keys("prop3");
-   * console.log(prop3Keys) // -> ["prop4", "prop5"]
-   *
-   * const prop5Keys = await database.keys("prop3.prop5");
-   * console.log(prop5Keys) // -> ["prop6"]
-   *
-   * const prop6Keys = await database.keys("prop3.prop5.prop6");
-   * console.log(prop6Keys)
-   * // -> [] (empty since the value in `prop6`, 111, is a primitive value and not an actual object)
-   *
-   * const databaseKeys = await database.keys();
-   * // in this example, `key` parameter is omitted - object keys of database object are being returned
-   *
-   * console.log(databaseKeys) // -> ["prop1", "prop2", "prop3"]
-   *
-   * const unexistentKeys = await database.keys("somethingElse");
-   * console.log(unexistentKeys) // -> [] (empty since the key `somethingElse` does not exist in database)
-   *
-   * // Assuming that the initial database object for this example is:
-   * // {
-   * //    prop1: 123,
-   * //    prop2: 456,
-   * //    prop3: { 
-   * //       prop4: 789, 
-   * //       prop5: { 
-   * //          prop6: 111 
-   * //       } 
-   * //    }
-   * // }
+   * const rootKeys = await db.keys();
+   * const userKeys = await db.keys("user");
    */
   async keys(key) {
     if (!key) return TypedObject.keys(await this.all());
@@ -658,51 +745,33 @@ var _Database = class _Database {
     return TypedObject.keys(data).filter((key2) => data[key2] !== void 0 && data[key2] !== null);
   }
   /**
-   * Determines the number of keys in the root of the database.
-   * @type {Promise<number>} amount of data.
+   * Lấy số lượng key cấp cao nhất trong database.
+   *
+   * @returns Tổng số key ở root level.
+   *
+   * @example
+   * const count = await db.size();
    */
   async size() {
     const keys = await this.keys();
     return keys.length;
   }
   /**
-   * Returns an array of object values by specified database key.
-   *
-   * If `key` parameter is omitted, then an array of object values of database root object will be returned.
-   *
-   * @param {P} [key] The key to access the target in database by.
-   * @returns {Array<ObjectValue<V, P>>} Database object values array.
-   *
-   * @example
-   * const prop3Values = await database.values("prop3");
-   * console.log(prop3Values); // -> [789, { prop6: 111 }]
+   * Lấy danh sách các giá trị từ database.
    *
-   * const prop5Values = await database.values("prop3.prop5");
-   * console.log(prop5Values); // -> []
+   * Nếu không truyền `key` → trả về toàn bộ values ở root level.
+   * Nếu truyền `key` → trả về values của object tại path đó.
    *
-   * const prop6Values = await database.values("prop3.prop5.prop6");
-   * console.log(prop6Values);
-   * // -> [] (empty since the value in `prop6`, 111, is a primitive value and not an actual object)
+   * @typeParam P - Path của object trong database.
    *
-   * const databaseValues = await database.values();
-   * // in this example, `key` parameter is omitted - object values of database object are being returned
+   * @param key - Đường dẫn object cần lấy values.
    *
-   * console.log(databaseValues); // -> [123, 456, { prop4: 789, prop5: { prop6: 111 } }]
+   * @returns Mảng các giá trị.
    *
-   * const unexistentValues = await database.values("somethingElse");
-   * console.log(unexistentValues); // -> [] (empty since the key `somethingElse` does not exist in database)
+   * @example
+   * const allValues = await db.values();
    *
-   * // Assuming that the initial database object for this example is:
-   * // {
-   * //    prop1: 123,
-   * //    prop2: 456,
-   * //    prop3: { 
-   * //       prop4: 789, 
-   * //       prop5: { 
-   * //          prop6: 111 
-   * //       } 
-   * //    }
-   * // }
+   * const userValues = await db.values("users");
    */
   async values(key) {
     if (!key) return TypedObject.values(await this.all());
@@ -710,160 +779,125 @@ var _Database = class _Database {
     return TypedObject.values(data);
   }
   /**
-   * This method works the same way as `Array.find()`.
+   * Lấy ngẫu nhiên một phần tử từ array tại path được chỉ định.
+   *
+   * @typeParam P - Path trỏ đến array trong database.
+   *
+   * @param key - Đường dẫn đến array.
+   *
+   * @returns Một phần tử ngẫu nhiên trong array hoặc `null` nếu array rỗng.
+   *
+   * @throws BlackCatError
+   * - INVALID_TARGET nếu giá trị tại key không phải array
+   *
+   * @example
+   * const randomUser = await db.random("users");
+   */
+  async random(key) {
+    const array = await this.get(key);
+    if (!Array.isArray(array)) {
+      throw new BlackCatError("INVALID_TARGET", "array", typeOf(array));
+    }
+    return array[Math.floor(Math.random() * array.length)] ?? null;
+  }
+  /**
+   * Tìm phần tử đầu tiên thỏa điều kiện.
+   *
+   * Hoạt động tương tự `Array.prototype.find`.
    *
-   * Iterates over root database values, finds the element in database values array
-   * by specified condition in the callback function and returns the result.
+   * @param queryFunction - Hàm kiểm tra điều kiện.
    *
-   * @param {QueryFunction<V>} queryFunction
-   * A function that accepts up to three arguments.
-   * The `find` method calls the `queryFunction` once for each element in database object values array.
+   * @returns Phần tử đầu tiên thỏa điều kiện hoặc `null` nếu không tìm thấy.
    *
-   * @returns {Promise<Maybe<V>>} The search
+   * @example
+   * const user = await db.find(u => u.id === 1);
    */
   async find(queryFunction) {
     const values = await this.values();
     return values.find(queryFunction) ?? null;
   }
   /**
-   * This method works the same way as `Array.map()`.
+   * Biến đổi tất cả giá trị trong database thành một mảng mới.
+   *
+   * Hoạt động giống `Array.prototype.map`.
    *
-   * Calls a defined callback function on each element of an array,
-   * and returns an array that contains the results.
+   * @typeParam TReturnType - Kiểu dữ liệu của phần tử trả về.
    *
-   * @param {QueryFunction<V, TReturnType>} queryFunction
-   * A function that accepts up to three arguments.
-   * The `map` method calls the `queryFunction` once for each element in database object values array.
+   * @param queryFunction - Hàm transform từng phần tử.
    *
-   * @returns {Promise<TReturnType[]>}
+   * @returns Mảng kết quả sau khi transform.
+   *
+   * @example
+   * const names = await db.map(user => user.name);
    */
   async map(queryFunction) {
     const values = await this.values();
     return values.map(queryFunction);
   }
   /**
-   * This method works the same way as `Array.findIndex()`.
+   * Tìm index của phần tử đầu tiên thỏa điều kiện.
+   *
+   * Hoạt động giống `Array.prototype.findIndex`.
    *
-   * Iterates over root database values, finds the index of the element in database values array
-   * by specified condition in the callback function and returns the result.
+   * @param queryFunction - Hàm kiểm tra điều kiện.
    *
-   * @param {QueryFunction<V>} queryFunction
-   * A function that accepts up to three arguments.
-   * The `findIndex` method calls the `queryFunction` once for each element in database object values array.
+   * @returns Index của phần tử hoặc `-1` nếu không tìm thấy.
    *
-   * @returns {Promise<number>}
+   * @example
+   * const index = await db.findIndex(user => user.id === 1);
    */
   async findIndex(queryFunction) {
     const values = await this.values();
     return values.findIndex(queryFunction);
   }
   /**
-   * This method works the same way as `Array.filter()`.
+   * Lọc các phần tử thỏa điều kiện.
+   *
+   * Hoạt động giống `Array.prototype.filter`.
    *
-   * Iterates over root database values, finds all the element that match the
-   * specified condition in the callback function and returns the result.
+   * @param queryFunction - Hàm kiểm tra điều kiện.
    *
-   * @param {QueryFunction<V>} queryFunction
-   * A function that accepts up to three arguments.
-   * The `filter` method calls the `queryFunction` once for each element in database object values array.
+   * @returns Mảng các phần tử thỏa điều kiện.
    *
-   * @returns {Promise<V[]>}
+   * @example
+   * const admins = await db.filter(user => user.role === "admin");
    */
   async filter(queryFunction) {
     const values = await this.values();
     return values.filter(queryFunction);
   }
   /**
-   * This method works the same way as `Array.some()`.
+   * Kiểm tra có ít nhất một phần tử thỏa điều kiện hay không.
+   *
+   * Hoạt động giống `Array.prototype.some`.
    *
-   * Iterates over root database values and checks if the
-   * specified condition in the callback function returns `true`
-   * for **any** of the elements of the database object values array.
+   * @param queryFunction - Hàm kiểm tra điều kiện.
    *
-   * @param {QueryFunction<V>} queryFunction
-   * A function that accepts up to three arguments.
-   * The `some` method calls the `queryFunction` once for each element in database object values array.
+   * @returns `true` nếu tồn tại phần tử thỏa điều kiện.
    *
-   * @returns {Promise<boolean>}
+   * @example
+   * const hasAdmin = await db.some(user => user.role === "admin");
    */
   async some(queryFunction) {
     const values = await this.values();
     return values.some(queryFunction);
   }
   /**
-   * This method works the same way as `Array.every()`.
+   * Kiểm tra tất cả phần tử có thỏa điều kiện hay không.
    *
-   * Iterates over root database values and checks if the
-   * specified condition in the callback function returns `true`
-   * for **all** of the elements of the database object values array.
+   * Hoạt động giống `Array.prototype.every`.
    *
-   * @param {QueryFunction<V>} queryFunction
-   * A function that accepts up to three arguments.
-   * The `every` method calls the `queryFunction` once for each element in database object values array.
+   * @param queryFunction - Hàm kiểm tra điều kiện.
    *
-   * @returns {Promise<boolean>}
+   * @returns `true` nếu tất cả phần tử đều thỏa điều kiện.
+   *
+   * @example
+   * const allActive = await db.every(user => user.active === true);
    */
   async every(queryFunction) {
     const values = await this.values();
     return values.every(queryFunction);
   }
-  /**
-   * Picks a random element of array in database and returns the picked array element.
-   *
-   * [!!!] The type of target value must be an array.
-   *
-   * @param {AutocompletableString<P>} key The key to access the target in database by.
-   * @returns {Promise<Maybe<ObjectValue<V, P>>>} The randomly picked element in the database array.
-   *
-   * @example
-   * const array = await database.get("array"); // assuming that the array is ['example1', 'example2', 'example3']
-   * console.log(array); // -> ['example1', 'example2', 'example3']
-   *
-   * const randomArrayElement = await database.random("exampleArray");
-   * console.log(randomArrayElement); // -> randomly picked array element: either 'example1', 'example2', or 'example3'
-   */
-  async random(key) {
-    const array = await this.get(key);
-    if (!Array.isArray(array)) {
-      throw new BlackCatError("INVALID_TARGET", "array", typeOf(array));
-    }
-    return array[Math.floor(Math.random() * array.length)] ?? null;
-  }
-  /**
-   * Deletes the data from database by key.
-   * @param {AutocompletableString<P>} key The key to access the target in database by.
-   * @returns {Promise<boolean>} Whether the deletion was successful.
-   */
-  async delete(key) {
-    if (typeof key !== "string") {
-      throw new BlackCatError("INVALID_TYPE", "key", "string", typeof key);
-    }
-    ;
-    const allDatabase = await this.all();
-    const keys = key.split(".");
-    const lastKey = keys.pop();
-    let currentObj = allDatabase;
-    for (const k of keys) {
-      if (!isObject(currentObj[k])) {
-        return false;
-      }
-      currentObj = currentObj[k];
-    }
-    if (!(lastKey in currentObj)) return false;
-    delete currentObj[lastKey];
-    await this.driver.delete(allDatabase);
-    return true;
-  }
-  /**
-   * Deletes everything from the database.
-   *
-   * - This method is an alias for {@link QuickMongo.clear()} method.
-   * @returns {Promise<boolean>} `true` if cleared successfully, `false` otherwise.
-   */
-  async deleteAll() {
-    await this.driver.delete();
-    return true;
-  }
 };
 __name(_Database, "Database");
 var Database = _Database;
@@ -872,98 +906,337 @@ var Database = _Database;
 import { promises as fs } from "fs";
 var _JSONDriver = class _JSONDriver {
   /**
-   * JSONDriver class.
-   * @param options.filePath Json database file path.
-   * @param options.minifyJSON Minifies the JSON content in database file to save some space.
+   * Khởi tạo một instance mới của {@link JSONDriver}.
+   *
+   * @param options - Cấu hình driver
+   *
+   * @param options.filePath
+   * Đường dẫn tới file JSON dùng làm database.
+   *
+   * @param options.minifyJSON
+   * Nếu `true`, nội dung JSON sẽ được minify khi ghi ra file để giảm dung lượng.
+   *
+   * @example
+   * ```ts
+   * const database = new Database({
+   *      driver: db = new JSONDriver({
+   *          filePath: "./database.json"
+   *      })
+   * });
+   * ```
    */
   constructor(options) {
     /**
-     * JSON database file path.
-     * @type {string}
+     * Đường dẫn tới file database JSON.
      */
     __publicField(this, "filePath");
     /**
-     * Minifies the JSON content in database file to save some space.
-     * @type {boolean}
+     * Cho biết có minify JSON khi ghi file hay không.
      */
     __publicField(this, "minifyJSON");
     this.filePath = options.filePath || "database.json";
     this.minifyJSON = options.minifyJSON || false;
   }
   /**
-   * Returns all data from JSON database.
-   * 
-   * @returns {Promise<any>} All data from JSON database.
-   * 
-   * @template V The type of data being returned.
+   * Đảm bảo file database tồn tại.
+   * Nếu file chưa tồn tại sẽ tự động tạo file `{}`.
+   */
+  async ensureFile() {
+    try {
+      await fs.access(this.filePath);
+    } catch {
+      await fs.writeFile(this.filePath, "{}");
+    }
+  }
+  /**
+   * Đọc toàn bộ dữ liệu từ file database JSON.
+   *
+   * Nếu file không tồn tại hoặc lỗi parse,
+   * method sẽ trả về object rỗng.
+   *
+   * @template V Kiểu dữ liệu database.
+   * @returns Promise chứa toàn bộ dữ liệu database.
    */
   async all() {
+    await this.ensureFile();
     return fs.readFile(this.filePath, "utf-8").then((content) => JSON.parse(content)).catch((error) => {
-      console.error(`Failed to load database file: ${this.filePath}`, error);
+      console.error(`Kh\xF4ng th\u1EC3 \u0111\u1ECDc file database: ${this.filePath}`, error);
       return {};
     });
   }
   /**
-   * Parses the key and fetches the value from JSON database.
+   * Ghi toàn bộ dữ liệu database xuống file JSON.
    *
-   * Type parameters:
+   * Method này **không xử lý key path**.
+   * Logic cập nhật dữ liệu sẽ được xử lý ở class `Database`
+   * trước khi truyền object hoàn chỉnh vào đây.
+   *
+   * @param data Toàn bộ dữ liệu database sau khi đã được cập nhật.
    *
-   * - `V` - The type of data being returned.
+   * @template R Kiểu dữ liệu database.
+   * @returns Promise chứa dữ liệu đã ghi.
+   */
+  async set(data) {
+    await this.ensureFile();
+    await fs.writeFile(this.filePath, JSON.stringify(data, null, this.minifyJSON ? void 0 : "	"));
+    return data;
+  }
+  /**
+   * Xóa toàn bộ database.
    *
-   * @param {string} key The key in JSON database.
-   * @returns {Promise<V>} The data from JSON database.
+   * Method này chỉ reset file JSON về `{}`.
    *
-   * @template V The type of data being returned.
+   * @returns `true` nếu reset thành công.
    */
-  async get(key) {
-    const data = await this.all();
-    const keys = key.split(".");
-    let result = data;
-    for (const k of keys) {
-      if (result === null || typeof result !== "object") return null;
-      result = result[k];
-    }
-    return result;
+  async delete() {
+    await this.ensureFile();
+    await fs.writeFile(this.filePath, "{}");
+    return true;
   }
+};
+__name(_JSONDriver, "JSONDriver");
+var JSONDriver = _JSONDriver;
+
+// src/drivers/MemoryDriver.ts
+var _MemoryDriver = class _MemoryDriver {
   /**
-   * Parses the key and sets the value in JSON database.
+   * Khởi tạo MemoryDriver.
+   *
+   * @param initialData Dữ liệu khởi tạo ban đầu.
+   * * @example
+   * ```ts
+   * const database = new Database({
+   *      driver: new MemoryDriver({
+   *          users: {},
+   *          guilds: {},
+   *          settings: {
+   *              prefix: "!"
+   *          }
+   *      })
+   * });
+   * ```
+   * 
+   *  hoặc 
+   * 
+   * ```ts
+   * const database = new Database({
+   *     driver: new MemoryDriver()
+   * });
+   * ```
+   */
+  constructor(initialData = {}) {
+    /**
+     * Object chứa toàn bộ dữ liệu database trong RAM.
+     */
+    __publicField(this, "store");
+    this.store = initialData;
+  }
+  /**
+   * Trả về toàn bộ dữ liệu database.
    *
-   * Type parameters:
+   * @template T Kiểu dữ liệu database.
+   */
+  async all() {
+    return this.store;
+  }
+  /**
+   * Ghi toàn bộ database vào memory.
+   *
+   * ⚠️ Method này **không xử lý key-path**.
+   * Dữ liệu đã được xử lý trước bởi `Database`.
+   *
+   * @param data Toàn bộ database object
+   */
+  async set(data) {
+    this.store = data;
+    return data;
+  }
+  /**
+   * Xóa toàn bộ dữ liệu database trong memory.
+   */
+  async delete() {
+    this.store = {};
+    return true;
+  }
+};
+__name(_MemoryDriver, "MemoryDriver");
+var MemoryDriver = _MemoryDriver;
+
+// src/drivers/SQLiteDriver.ts
+import SQLite from "better-sqlite3";
+var _SQLiteDriver = class _SQLiteDriver {
+  /**
+   * Khởi tạo SQLiteDriver.
+   *
+   * @param filePath Đường dẫn file SQLite
+   * @param table Tên table lưu JSON database
+   * @example
+   * ```ts
+   * const database = new Database({
+   *      driver: new SQLiteDriver({
+   *         filePath: "database.sqlite",
+   *         table: "json_store"
+   *      })
+   * })
+   * ```
+   */
+  constructor(options = {}) {
+    /**
+     * SQLite database instance.
+     */
+    __publicField(this, "db");
+    /**
+     * Tên table lưu trữ dữ liệu JSON.
+     */
+    __publicField(this, "table");
+    this.db = new SQLite(options.filePath ?? "database.sqlite");
+    this.table = options.table ?? "json_store";
+    this.db.prepare(`CREATE TABLE IF NOT EXISTS ${this.table} (id INTEGER PRIMARY KEY, data TEXT)`).run();
+    const row = this.db.prepare(`SELECT * FROM ${this.table} WHERE id = 1`).get();
+    if (!row) {
+      this.db.prepare(`INSERT INTO ${this.table} (id, data) VALUES (1, '{}')`).run();
+    }
+  }
+  /**
+   * Lấy toàn bộ dữ liệu database từ SQLite.
    *
-   * - `V` - The type of data being set.
-   * - `R` - The type of data being returned.
+   * @template T Kiểu dữ liệu database.
+   */
+  async all() {
+    const row = this.db.prepare(`SELECT data FROM ${this.table} WHERE id = 1`).get();
+    return JSON.parse(row.data);
+  }
+  /**
+   * Ghi toàn bộ database vào SQLite.
    *
-   * @param {string} key The key in JSON database.
-   * @returns {Promise<R>} The data from JSON database.
+   * ⚠️ Method này **không xử lý key-path**.
+   * `Database` đã cập nhật object trước khi truyền vào đây.
    *
-   * @template V The type of data being set.
-   * @template R The type of data being returned.
+   * @param data Toàn bộ database object
    */
-  async set(key, value) {
-    const data = await this.all();
-    await fs.writeFile(this.filePath, JSON.stringify(value, null, this.minifyJSON ? void 0 : "	"));
+  async set(data) {
+    this.db.prepare(`UPDATE ${this.table} SET data = ? WHERE id = 1`).run(JSON.stringify(data));
     return data;
   }
   /**
-   * Parses the key and deletes it from JSON database. If no key is provided, clears the database.
-   * @param {V} key The key in JSON database.
-   * @returns {Promise<boolean>} `true` if deleted successfully.
+   * Reset toàn bộ database.
    */
-  async delete(key) {
-    if (key === void 0) {
-      await fs.writeFile(this.filePath, "{}");
-      return true;
-    } else {
-      await fs.writeFile(this.filePath, JSON.stringify(key, null, this.minifyJSON ? void 0 : "	"));
+  async delete() {
+    this.db.prepare(`UPDATE ${this.table} SET data = '{}' WHERE id = 1`).run();
+    return true;
+  }
+};
+__name(_SQLiteDriver, "SQLiteDriver");
+var SQLiteDriver = _SQLiteDriver;
+
+// src/drivers/MongoDriver.ts
+import { MongoClient } from "mongodb";
+var _MongoDriver = class _MongoDriver {
+  /**
+   * Khởi tạo MongoDriver.
+   *
+   * @param options Cấu hình MongoDB driver.
+   * 
+   * @example 
+   * ```ts
+   * const database = new Database({ 
+   *      driver: new MongoDriver({
+   *          mongourl: "mongodb://localhost:27017", 
+   *          databaseName: "mydb",  
+   *          collectionName: "store" 
+   *      })
+   * });
+   */
+  constructor(options = {}) {
+    /**
+     * MongoDB client instance.
+     */
+    __publicField(this, "client");
+    /**
+     * MongoDB database instance.
+     */
+    __publicField(this, "db");
+    /**
+     * Collection lưu dữ liệu JSON.
+     */
+    __publicField(this, "collection");
+    /**
+     * Tên database MongoDB.
+     */
+    __publicField(this, "databaseName");
+    /**
+     * Tên collection MongoDB.
+     */
+    __publicField(this, "collectionName");
+    const {
+      mongourl = "mongodb://localhost:27017",
+      databaseName = "database",
+      collectionName = "json_store"
+    } = options;
+    this.client = new MongoClient(mongourl);
+    this.databaseName = databaseName;
+    this.collectionName = collectionName;
+  }
+  /**
+   * Thiết lập kết nối MongoDB nếu chưa kết nối.
+   */
+  async connect() {
+    if (!this.db) {
+      await this.client.connect();
+      this.db = this.client.db(this.databaseName);
+      this.collection = this.db.collection(this.collectionName);
+      const doc = await this.collection.findOne({ _id: "database" });
+      if (!doc) {
+        await this.collection.insertOne({
+          _id: "database",
+          data: {}
+        });
+      }
     }
-    ;
+  }
+  /**
+   * Lấy toàn bộ dữ liệu database từ MongoDB.
+   */
+  async all() {
+    await this.connect();
+    const doc = await this.collection.findOne({ _id: "database" });
+    return doc?.data ?? {};
+  }
+  /**
+   * Ghi toàn bộ database vào MongoDB.
+   *
+   * ⚠️ Method này **không xử lý key-path**.
+   * Object database đã được xử lý bởi class `Database`.
+   * 
+   * @param data Toàn bộ object database
+   */
+  async set(data) {
+    await this.connect();
+    await this.collection.updateOne(
+      { _id: "database" },
+      { $set: { data } }
+    );
+    return data;
+  }
+  /**
+   * Reset toàn bộ database về object rỗng.
+   */
+  async delete() {
+    await this.connect();
+    await this.collection.updateOne(
+      { _id: "database" },
+      { $set: { data: {} } }
+    );
     return true;
   }
 };
-__name(_JSONDriver, "JSONDriver");
-var JSONDriver = _JSONDriver;
+__name(_MongoDriver, "MongoDriver");
+var MongoDriver = _MongoDriver;
 export {
   Database,
-  JSONDriver
+  JSONDriver,
+  MemoryDriver,
+  MongoDriver,
+  SQLiteDriver
 };
 //# sourceMappingURL=index.mjs.map