blackcat.js-database 1.0.0-test

package/dist/index.js

@@ -0,0 +1,995 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Database: () => Database,
+  JSONDriver: () => JSONDriver
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/utils/isObject.function.ts
+var isObject = /* @__PURE__ */ __name((item) => !Array.isArray(item) && item !== null && typeof item == "object", "isObject");
+
+// src/utils/typeOf.function.ts
+var typeOf = /* @__PURE__ */ __name((input) => {
+  if (input == null || typeof input === "number" && Number.isNaN(input)) return String(input);
+  if (typeof input === "function" && input.prototype) return `${input.name} class instance`;
+  return input?.constructor?.name ?? typeof input;
+}, "typeOf");
+
+// src/utils/isNumber.function.ts
+var isNumber = /* @__PURE__ */ __name((input) => !isNaN(input) && input !== "" && input !== null && typeOf(input) !== "Array", "isNumber");
+
+// src/utils/BlackCatError.ts
+var errors = {
+  DEVICE_IS_OFFLINE: "Your device appears to be offline so it's impossible to proceed with connection to your online MongoDB cluster. Please connect your device to the internet or switch to the local MongoDB database and try again.",
+  CONNECTION_NOT_ESTABLISHED: "Failed to connect to MongoDB. Please double-check the specified connection URI and make sure that you're performing the database connection using the `QuickMongoClient.connect()` method.",
+  CONNECTION_URI_NOT_SPECIFIED: "The MongoDB connection URI must be specified.",
+  INVALID_CONNECTION_URI: "The specified MongoDB connection URI is invalid.",
+  UNKNOWN_ERROR: "Unknown error.",
+  REQUIRED_PARAMETER_MISSING: "'{1}' parameter is required but is missing.",
+  REQUIRED_CONSTRUCTOR_PARAMETER_MISSING: "'{1}' parameter in constructor '{2}' is required but is missing.",
+  INVALID_CONSTRUCTOR_PARAMETER_TYPE: "'{1}' parameter in constructor '{2}' must be a type of {3}. Received type: {4}.",
+  INVALID_TYPE: "'{1}' must be a type of {2}. Received type: {3}.",
+  ONE_OR_MORE_ARRAY_TYPES_INVALID: "All specified elements from array in '{1}' parameter must be a type of {2}. Received array of types: {3}.",
+  INVALID_TARGET: "The target in database must be a type of {1}. Received target type: {2}.",
+  INVALID_KEY: "{1}",
+  INVALID_PARAMETER: "{1} {2}",
+  DATABASE_CONNECTION_FAILED: "{1}"
+};
+var createTypesArray = /* @__PURE__ */ __name((...elements) => `[${elements.map((element) => typeOf(element))}]`, "createTypesArray");
+var _BlackCatError = class _BlackCatError extends Error {
+  /**  
+   * Creates a BlackCatError instance.
+   * @param {string} errorCode Quick Mongo error code.
+   * @param {any[]} params Additional parameters to replace the placeholders in the error message.
+   */
+  constructor(errorCode, ...params) {
+    const code = errors[errorCode] ? errorCode : "UNKNOWN_ERROR";
+    let message = errors[code];
+    for (let i = 0; i < params.length; i++) {
+      message = message.replaceAll(`{${i + 1}}`, params[i]);
+    }
+    ;
+    super(message);
+    this.name = `BlackCatError [${code}]`;
+  }
+};
+__name(_BlackCatError, "BlackCatError");
+var BlackCatError = _BlackCatError;
+
+// src/utils/TypedObject.ts
+var _TypedObject = class _TypedObject {
+  /**
+   * Returns the names of the enumerable string properties and methods of an object.
+   *
+   * Type parameters:
+   *
+   * - `TObject` (`Record<string, any>`) - The object to get the object keys types from.
+   *
+   * @param {TObject} obj Object to get the keys from.
+   *
+   * @returns {Array<ExtractObjectKeys<TObject>>}
+   * Array of names of the enumerable string properties and methods of the specified object.
+   */
+  static keys(obj) {
+    return Object.keys(obj || {});
+  }
+  /**
+   * Returns an array of values of the enumerable properties of an object.
+   *
+   * Type parameters:
+   *
+   * - `TObject` (`Record<string, any>`) - The object to get the object values types from.
+   *
+   * @param {TObject} obj Object to get the values from.
+   *
+   * @returns {Array<ExtractObjectValues<TObject>>}
+   * Array of values of the enumerable properties of the specified object.
+   */
+  static values(obj) {
+    return Object.values(obj || {});
+  }
+  /**
+   * Returns an array of entries (key-value pairs) of the enumerable properties of an object.
+   *
+   * Type parameters:
+   *
+   * - `TObject` (`Record<string, any>`) - The object to get the object entries types (key-value pairs types) from.
+   *
+   * @param {TObject} obj Object to get the entries from.
+   *
+   * @returns {ExtractObjectEntries<TObject>[]}
+   * Array of entries (key-value pairs) of the enumerable properties of the specified object.
+   */
+  static entries(obj) {
+    return Object.entries(obj || {});
+  }
+};
+__name(_TypedObject, "TypedObject");
+var TypedObject = _TypedObject;
+
+// src/utils/Emitter.ts
+var import_node_events = require("events");
+
+// src/Database.ts
+var _Database = class _Database {
+  constructor(options) {
+    /**
+     * The low-level database driver handling basic operations.
+     */
+    __publicField(this, "driver");
+    this.driver = options.driver;
+  }
+  /**
+   * Gets all the database contents from the cache.
+   *
+   * Type parameters:
+   *
+   * - `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.
+   *
+   * @example
+   * const databaseContents = await database.all();
+   * console.log(databaseContents); // -> { ... (the object of all the data stored in database) }
+   */
+  async all() {
+    const allDatabase = await this.driver.all();
+    return allDatabase;
+  }
+  /**
+   * Retrieves a value from database by a key.
+   *
+   * @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.
+   *
+   * @example
+   * const simpleValue = await database.get("simpleValue");
+   * console.log(simpleValue); // -> 123
+   *
+   * const databaseObjectPropertyAccessed = await database.get("youCanAlso.accessDatabaseObjectProperties.likeThat");
+   * console.log(databaseObjectPropertyAccessed); // -> "hello world!"
+   *
+   * // Assuming that the initial database object for this example is:
+   * // {
+   * //    simpleValue: 123,
+   * //    youCanAlso: {
+   * //        accessDatabaseObjectProperties: {
+   * //            likeThat: "hello world!"
+   * //        }
+   * //    }
+   * // }
+   */
+  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();
+    }
+    ;
+  }
+  /**
+   * Retrieves a value from database by a key.
+   *
+   * - This method is an alias for {@link Database.get()} method.
+   *
+   * @param {AutocompletableString<P>} key The key to access the target in database by.
+   * @returns {Maybe<ObjectValue<V, P>>} The value from database.
+   *
+   * @example
+   * const simpleValue = await database.fetch("simpleValue");
+   * console.log(simpleValue); // -> 123
+   *
+   * // You can use the dot notation to access the database object properties:
+   * const playerInventory = await database.fetch("player.inventory");
+   * console.log(playerInventory); // -> []
+   *
+   * // 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.
+   *
+   * @example
+   * const isSimpleValueInDatabase = await database.has("simpleValue");
+   * console.log(isSimpleValueInDatabase); // -> true
+   *
+   * const somethingElse = await database.has("somethingElse");
+   * console.log(somethingElse); // -> false
+   *
+   * // You can use the dot notation to check the database object properties:
+   * const isObjectInDatabase = await database.has("youCanAlso.accessObjectProperties.likeThat");
+   * console.log(isObjectInDatabase); // -> true
+   *
+   * // Assuming that the initial database object for this example is:
+   * // {
+   * //    simpleValue: 123,
+   * //    player: {
+   * //        inventory: []
+   * //    },
+   * //    youCanAlso: {
+   * //        accessObjectProperties: {
+   * //            likeThat: "hello world!"
+   * //        }
+   * //    }
+   * // }
+   */
+  async has(key) {
+    return this.get(key) !== null && this.get(key) !== void 0;
+  }
+  /**
+   * Writes the specified value into database under the specified key.
+   *
+   * @param {AutocompletableString<P>} key The key to write in the target.
+   * @param {ObjectValue<V, P>} value The value to write.
+   *
+   * @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.
+   *
+   * - 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`))
+   *
+   * @example
+   * // Assuming that the initial database object for this example is empty.
+   *
+   * await database.set("something", "hello");
+   * const hello = await database.get("something");
+   *
+   * console.log(hello); // -> "hello"
+   *
+   * // You can use the dot notation to write data in objects:
+   * const dotNotationSetResult = await database.set("member.user.id", 2000);
+   * console.log(dotNotationSetResult); // -> 2000
+   *
+   * await database.set("member.inventory", []);
+   * const inventory = await database.get("member.inventory");
+   *
+   * console.log(inventory); // -> []
+   *
+   * // Using objects as value will return the object of key `thats`:
+   * await database.set("member.user", { name: "Jerry" }); // -> { member: { user: { name: "Jerry" } } }
+   *
+   * // After these manipulations, the database object will look like this:
+   * // {
+   * //     "something": "hello",
+   * //     "member": {
+   * //       "inventory": [],
+   * //       "user": { 
+   * //          "name": "Jerry",
+   * //          "id": 2000 
+   * //       }
+   * //     }
+   * // }
+   */
+  async set(key, value) {
+    const allDatabase = await this.all();
+    if (!key) {
+      throw new BlackCatError("REQUIRED_PARAMETER_MISSING", "key");
+    }
+    if (typeof key !== "string") {
+      throw new BlackCatError("INVALID_TYPE", "key", "string", typeOf(key));
+    }
+    const keys = key.split(".");
+    let currentObj = allDatabase;
+    for (let i = 0; i < keys.length; i++) {
+      if (keys.length - 1 === i) {
+        currentObj[keys[i]] = value;
+      } else {
+        if (!isObject(currentObj[keys[i]])) {
+          currentObj[keys[i]] = {};
+        }
+        currentObj = currentObj[keys[i]];
+      }
+      ;
+    }
+    ;
+    await this.driver.set(keys[0], allDatabase);
+    return typeof value == "object" && value !== null ? await this.get(keys[0]) : value;
+  }
+  /**
+   * Update the specified value into database under the specified key.
+   *
+   * @param {AutocompletableString<P>} key The key to update the target.
+   * @param {ObjectValue<V, P>} value The value to update.
+   *
+   * @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.
+   *
+   * - 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`))
+   */
+  async update(key, value) {
+    const allDatabase = await this.all();
+    const keys = key.split(".");
+    let current = allDatabase;
+    for (let i = 0; i < keys.length - 1; i++) {
+      const part = keys[i];
+      if (!(part in current)) {
+        current[part] = {};
+      }
+      current = current[part];
+    }
+    const lastKey = keys[keys.length - 1];
+    current[lastKey] = value;
+    await this.driver.set(keys[0], allDatabase);
+    return current;
+  }
+  /**
+   * Performs an arithmetical addition on a target number in database.
+   *
+   * [!!!] The type of target value must be a number.
+   *
+   * @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.
+   *
+   * @example
+   * const additionResult = await database.add("points", 5);
+   * console.log(additionResult); // -> 10 (5 + 5 = 10)
+   *
+   * // 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);
+   *
+   * 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
+   * // }
+   */
+  async add(key, numberToAdd) {
+    const targetNumber = await this.get(key) ?? 0;
+    if (!isNumber(targetNumber)) {
+      throw new BlackCatError("INVALID_TARGET", "number", typeOf(targetNumber));
+    }
+    if (numberToAdd === void 0) {
+      throw new BlackCatError("REQUIRED_PARAMETER_MISSING", "numberToAdd");
+    }
+    if (!isNumber(numberToAdd)) {
+      throw new BlackCatError("INVALID_TYPE", "numberToAdd", "number", typeOf(numberToAdd));
+    }
+    return await this.set(key, targetNumber + numberToAdd);
+  }
+  /**
+   * Performs an arithmetical subtraction on a target number in database.
+   *
+   * [!!!] The type of target value must be a number.
+   *
+   * @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.
+   *
+   * @example
+   * const subtractionResult = await database.subtract("points", 5)
+   * console.log(subtractionResult) // -> 5 (10 - 5 = 5)
+   *
+   * // 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)
+   *
+   * 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
+   * // }
+   */
+  async subtract(key, numberToSubtract) {
+    const targetNumber = await this.get(key) ?? 0;
+    if (!isNumber(targetNumber)) {
+      throw new BlackCatError("INVALID_TARGET", "number", typeOf(targetNumber));
+    }
+    if (numberToSubtract === void 0) {
+      throw new BlackCatError("REQUIRED_PARAMETER_MISSING", "numberToSubtract");
+    }
+    if (!isNumber(numberToSubtract)) {
+      throw new BlackCatError("INVALID_TYPE", "numberToSubtract", "number", typeOf(numberToSubtract));
+    }
+    return await this.set(key, targetNumber - numberToSubtract);
+  }
+  /**
+   * Pushes the specified value(s) into the target array in database.
+   *
+   * [!!!] The type of target value must be an array.
+   * [!!!] get only values ​​not stored in the database.
+   *
+   * @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.
+   *
+   * @returns {Promise<Array<ExtractFromArray<ObjectValue<V, P>>>>} Updated target array from database.
+   *
+   * @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"]
+   *
+   * // Assuming that the initial database object for this example is:
+   * // {
+   * //    members: ["Tom"],
+   * //    currencies: ["USD"]
+   * // }
+   */
+  async push(key, ...values) {
+    if (!values.length) {
+      throw new BlackCatError("REQUIRED_PARAMETER_MISSING", "values");
+    }
+    const root = await this.all();
+    const pathParts = key.split(".");
+    let target = root;
+    for (let i = 0; i < pathParts.length; i++) {
+      const part = pathParts[i];
+      if (!(part in target)) {
+        throw new BlackCatError("INVALID_KEY", key);
+      }
+      if (i === pathParts.length - 1) {
+        if (!Array.isArray(target[part])) {
+          throw new BlackCatError("INVALID_TARGET", "array", typeOf(target[part]));
+        }
+        const uniqueValues = values.filter((v) => !target[part].includes(v));
+        target[part].push(...uniqueValues);
+      } else {
+        target = target[part];
+      }
+    }
+    ;
+    const topKey = pathParts[0];
+    await this.set(topKey, root[topKey]);
+    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"]
+  * // }
+  */
+  async pull(key, targetArrayElementIndex, value) {
+    if (!isNumber(targetArrayElementIndex)) {
+      throw new BlackCatError("INVALID_TYPE", "targetArrayElementIndex", "number", typeOf(targetArrayElementIndex));
+    }
+    ;
+    if (value === void 0) {
+      throw new BlackCatError("REQUIRED_PARAMETER_MISSING", "value");
+    }
+    ;
+    const root = await this.all();
+    const pathParts = key.split(".");
+    let target = root;
+    for (let i = 0; i < pathParts.length; i++) {
+      const part = pathParts[i];
+      if (!(part in target)) {
+        throw new BlackCatError("INVALID_KEY", `Path "${key}" does not exist`);
+      }
+      if (i === pathParts.length - 1) {
+        if (!Array.isArray(target[part])) {
+          throw new BlackCatError("INVALID_TARGET", "array", typeOf(target[part]));
+        }
+        ;
+        const arr = target[part];
+        const index = targetArrayElementIndex >= 0 ? targetArrayElementIndex : arr.length + targetArrayElementIndex;
+        if (index < 0 || index >= arr.length) {
+          console.error(`Index ${targetArrayElementIndex} is out of bounds`);
+        }
+        ;
+        arr[index] = value;
+      } else {
+        target = target[part];
+      }
+      ;
+    }
+    ;
+    await this.set(pathParts[0], root[pathParts[0]]);
+    return target[pathParts[pathParts.length - 1]];
+  }
+  /**
+   * Removes the specified element(s) from 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 {RestOrArray<ExtractFromArray<number>>} targetArrayElementIndexes
+   * The index(es) to find the element(s) in target array by.
+   *
+   * @returns {Promise<Array<ExtractFromArray<ObjectValue<V, P>>>>} Updated target array from database.
+   *
+   * @example
+   * console.log(await database.pop("members", 1)); // -> ["Jerry", "Tom"]
+   *
+   * console.log(await database.pop("currencies", 1)); // -> ["VND", "Euro"]
+   *
+   * // Assuming that the initial database object for this example is:
+   * // {
+   * //    members: ["Jerry", "William", "Tom"],
+   * //    currencies: ["VND", "USD", "Euro"]
+   * // }
+   */
+  async pop(key, ...targetArrayElementIndexes) {
+    const targetArray = await this.get(key) ?? [];
+    if (!Array.isArray(targetArray)) {
+      throw new BlackCatError("INVALID_TARGET", "array", typeOf(targetArray));
+    }
+    ;
+    if (!targetArrayElementIndexes.length) {
+      throw new BlackCatError("REQUIRED_PARAMETER_MISSING", "targetArrayElementIndex");
+    }
+    ;
+    const indexes = Array.isArray(targetArrayElementIndexes[0]) ? targetArrayElementIndexes[0] : targetArrayElementIndexes;
+    if (indexes.some((index) => !isNumber(index))) {
+      throw new BlackCatError("ONE_OR_MORE_ARRAY_TYPES_INVALID", "targetArrayElementIndexes", "number", createTypesArray(indexes));
+    }
+    ;
+    const sortedIndexes = [...indexes].sort((a, b) => b - a);
+    const removedElements = [];
+    for (const index of sortedIndexes) {
+      const removed = targetArray.splice(index, 1);
+      removedElements.push(...removed);
+    }
+    ;
+    const parentPath = key.split(".").slice(0, -1).join(".");
+    const fieldName = key.split(".").slice(-1)[0];
+    if (parentPath) {
+      const parentObject = await this.get(parentPath) ?? {};
+      parentObject[fieldName] = targetArray;
+      await this.set(parentPath, parentObject);
+    } else {
+      await this.set(key, targetArray);
+    }
+    ;
+    return removedElements;
+  }
+  /**
+   * Determines whether the specified target is an array.
+   *
+   * @param {AutocompletableString<P>} key The key to access the target in database by.
+   * @returns {Promise<boolean>} Whether the target is an array.
+   *
+   * @example
+   * console.log(await databse.isTargetArray("array")); // => true
+   * console.log(await databse.isTargetArray("notArray")); // => false
+   *
+   * // Assuming that the initial database object for this example is:
+   * // {
+   * //    array: [],
+   * //    notArray: 123
+   * // }
+   */
+  async isTargetArray(key) {
+    const target = await this.get(key);
+    return Array.isArray(target);
+  }
+  /**
+   * Determines whether the specified target is a number.
+   *
+   * @param {AutocompletableString<P>} key The key to access the target in database by.
+   * @returns {Promise<boolean>} Whether the target is a number.
+   *
+   * @example
+   * console.log(await database.isTargetNumber("number")); // -> true
+   * console.log(await database.isTargetNumber("notNumber")); // -> false
+   *
+   * // Assuming that the initial database object for this example is:
+   * // {
+   * //    number: 123,
+   * //    notNumber: []
+   * // }
+   */
+  async isTargetNumber(key) {
+    const target = await this.get(key);
+    return isNumber(target);
+  }
+  /**
+   * Returns an array of object keys by specified database key.
+   *
+   * If `key` parameter is omitted, then an array of object keys of database root object will be returned.
+   *
+   * Type parameters:
+   *
+   * - `TKeys` (`TupleOrArray<string>`, defaults to `K[]`) - The tuple or array of a type of keys to be returned.
+   *
+   * @param {P} [key] The key to access the target in database by.
+   * @returns {Array<ObjectPath<P>>} Database object keys array.
+   *
+   * @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 
+   * //       } 
+   * //    }
+   * // }
+   */
+  async keys(key) {
+    if (!key) return TypedObject.keys(await this.all());
+    const data = await this.get(key);
+    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.
+   */
+  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 }]
+   *
+   * const prop5Values = await database.values("prop3.prop5");
+   * console.log(prop5Values); // -> []
+   *
+   * 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)
+   *
+   * const databaseValues = await database.values();
+   * // in this example, `key` parameter is omitted - object values of database object are being returned
+   *
+   * console.log(databaseValues); // -> [123, 456, { prop4: 789, prop5: { prop6: 111 } }]
+   *
+   * const unexistentValues = await database.values("somethingElse");
+   * console.log(unexistentValues); // -> [] (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 
+   * //       } 
+   * //    }
+   * // }
+   */
+  async values(key) {
+    if (!key) return TypedObject.values(await this.all());
+    const data = await this.get(key);
+    return TypedObject.values(data);
+  }
+  /**
+   * This method works the same way as `Array.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<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 {Promise<Maybe<V>>} The search
+   */
+  async find(queryFunction) {
+    const values = await this.values();
+    return values.find(queryFunction) ?? null;
+  }
+  /**
+   * This method works the same way as `Array.map()`.
+   *
+   * Calls a defined callback function on each element of an array,
+   * and returns an array that contains the results.
+   *
+   * @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.
+   *
+   * @returns {Promise<TReturnType[]>}
+   */
+  async map(queryFunction) {
+    const values = await this.values();
+    return values.map(queryFunction);
+  }
+  /**
+   * This method works the same way as `Array.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<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 {Promise<number>}
+   */
+  async findIndex(queryFunction) {
+    const values = await this.values();
+    return values.findIndex(queryFunction);
+  }
+  /**
+   * This method works the same way as `Array.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<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 {Promise<V[]>}
+   */
+  async filter(queryFunction) {
+    const values = await this.values();
+    return values.filter(queryFunction);
+  }
+  /**
+   * This method works the same way as `Array.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<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 {Promise<boolean>}
+   */
+  async some(queryFunction) {
+    const values = await this.values();
+    return values.some(queryFunction);
+  }
+  /**
+   * This method works the same way as `Array.every()`.
+   *
+   * 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.
+   *
+   * @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.
+   *
+   * @returns {Promise<boolean>}
+   */
+  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;
+
+// src/drivers/JSONDriver.ts
+var import_fs = require("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.
+   */
+  constructor(options) {
+    /**
+     * JSON database file path.
+     * @type {string}
+     */
+    __publicField(this, "filePath");
+    /**
+     * Minifies the JSON content in database file to save some space.
+     * @type {boolean}
+     */
+    __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.
+   */
+  async all() {
+    return import_fs.promises.readFile(this.filePath, "utf-8").then((content) => JSON.parse(content)).catch((error) => {
+      console.error(`Failed to load database file: ${this.filePath}`, error);
+      return {};
+    });
+  }
+  /**
+   * Parses the key and fetches the value from JSON database.
+   *
+   * Type parameters:
+   *
+   * - `V` - The type of data being returned.
+   *
+   * @param {string} key The key in JSON database.
+   * @returns {Promise<V>} The data from JSON database.
+   *
+   * @template V The type of data being returned.
+   */
+  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;
+  }
+  /**
+   * Parses the key and sets the value in JSON database.
+   *
+   * Type parameters:
+   *
+   * - `V` - The type of data being set.
+   * - `R` - The type of data being returned.
+   *
+   * @param {string} key The key in JSON database.
+   * @returns {Promise<R>} The data from JSON database.
+   *
+   * @template V The type of data being set.
+   * @template R The type of data being returned.
+   */
+  async set(key, value) {
+    const data = await this.all();
+    await import_fs.promises.writeFile(this.filePath, JSON.stringify(value, null, this.minifyJSON ? void 0 : "	"));
+    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.
+   */
+  async delete(key) {
+    if (key === void 0) {
+      await import_fs.promises.writeFile(this.filePath, "{}");
+      return true;
+    } else {
+      await import_fs.promises.writeFile(this.filePath, JSON.stringify(key, null, this.minifyJSON ? void 0 : "	"));
+    }
+    ;
+    return true;
+  }
+};
+__name(_JSONDriver, "JSONDriver");
+var JSONDriver = _JSONDriver;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Database,
+  JSONDriver
+});
+//# sourceMappingURL=index.js.map