inibase 1.0.0-rc.26 → 1.0.0-rc.28

package/dist/file.js

@@ -1,9 +1,28 @@
-import { open, access, constants, writeFile, } from "node:fs/promises";
+import { open, access, writeFile, readFile, constants as fsConstants, } from "node:fs/promises";
 import { createInterface } from "node:readline";
 import { Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
+import { createGzip, createGunzip, gzip as gzipAsync, gunzip as gunzipAsync, } from "node:zlib";
+import { promisify } from "node:util";
 import { detectFieldType, isArrayOfArrays, isNumber, isObject, } from "./utils.js";
 import { encodeID, comparePassword } from "./utils.server.js";
+import Config from "./config.js";
+const gzip = promisify(gzipAsync);
+const gunzip = promisify(gunzipAsync);
+export const write = async (filePath, data, disableCompression = false) => {
+    await writeFile(filePath, Config.isCompressionEnabled && !disableCompression ? await gzip(data) : data);
+};
+export const read = async (filePath, disableCompression = false) => {
+    return Config.isCompressionEnabled && !disableCompression
+        ? (await gunzip(await readFile(filePath))).toString()
+        : (await readFile(filePath)).toString();
+};
+const _pipeline = async (rl, writeStream, transform) => {
+    if (Config.isCompressionEnabled)
+        await pipeline(rl, transform, createGzip(), writeStream);
+    else
+        await pipeline(rl, transform, writeStream);
+};
 /**
  * Creates a readline interface for a given file handle.
  *
@@ -11,13 +30,12 @@ import { encodeID, comparePassword } from "./utils.server.js";
  * @returns A readline.Interface instance configured with the provided file stream.
  */
 const readLineInternface = (fileHandle) => {
-    const [major, minor, patch] = process.versions.node.split(".").map(Number);
-    return major > 18 || (major === 18 && minor >= 11)
-        ? fileHandle.readLines()
-        : createInterface({
-            input: fileHandle.createReadStream(), // .pipe(createInflate())
-            crlfDelay: Infinity,
-        });
+    return createInterface({
+        input: Config.isCompressionEnabled
+            ? fileHandle.createReadStream().pipe(createGunzip())
+            : fileHandle.createReadStream(),
+        crlfDelay: Infinity,
+    });
 };
 /**
  * Checks if a file or directory exists at the specified path.
@@ -27,7 +45,7 @@ const readLineInternface = (fileHandle) => {
  */
 export const isExists = async (path) => {
     try {
-        await access(path, constants.R_OK | constants.W_OK);
+        await access(path, fsConstants.R_OK | fsConstants.W_OK);
         return true;
     }
     catch {
@@ -44,23 +62,33 @@ const delimiters = [",", "|", "&", "$", "#", "@", "^", ":", "!", ";"];
 const secureString = (input) => {
     if (["true", "false"].includes(String(input)))
         return input ? 1 : 0;
-    return typeof input === "string"
-        ? decodeURIComponent(input.replace(/%(?![0-9][0-9a-fA-F]+)/g, ""))
-            .replaceAll("<", "&lt;")
-            .replaceAll(">", "&gt;")
-            .replaceAll(",", "%2C")
-            .replaceAll("|", "%7C")
-            .replaceAll("&", "%26")
-            .replaceAll("$", "%24")
-            .replaceAll("#", "%23")
-            .replaceAll("@", "%40")
-            .replaceAll("^", "%5E")
-            .replaceAll(":", "%3A")
-            .replaceAll("!", "%21")
-            .replaceAll(";", "%3B")
-            .replaceAll("\n", "\\n")
-            .replaceAll("\r", "\\r")
-        : input;
+    if (typeof input !== "string")
+        return input;
+    let decodedInput = null;
+    try {
+        decodedInput = decodeURIComponent(input);
+    }
+    catch (_error) {
+        decodedInput = decodeURIComponent(input.replace(/%(?![0-9][0-9a-fA-F]+)/g, ""));
+    }
+    const replacements = {
+        "<": "&lt;",
+        ">": "&gt;",
+        ",": "%2C",
+        "|": "%7C",
+        "&": "%26",
+        $: "%24",
+        "#": "%23",
+        "@": "%40",
+        "^": "%5E",
+        ":": "%3A",
+        "!": "%21",
+        ";": "%3B",
+        "\n": "\\n",
+        "\r": "\\r",
+    };
+    // Replace characters using a single regular expression.
+    return decodedInput.replace(/[<>,|&$#@^:!\n\r]/g, (match) => replacements[match]);
 };
 /**
  * Secures each element in an array or a single value using secureString.
@@ -93,31 +121,11 @@ const joinMultidimensionalArray = (arr, delimiter_index = 0) => {
  * @returns The secured and/or joined string.
  */
 export const encode = (input, secretKey) => {
+    // Use the optimized secureArray and joinMultidimensionalArray functions.
     return Array.isArray(input)
         ? joinMultidimensionalArray(secureArray(input))
         : secureString(input);
 };
-/**
- * Reverses the encoding done by 'secureString'. Replaces encoded characters with their original symbols.
- *
- * @param input - Encoded string.
- * @returns Decoded string or null if input is empty.
- */
-const unSecureString = (input) => input
-    .replaceAll("&lt;", "<")
-    .replaceAll("&gt;", ">")
-    .replaceAll("%2C", ",")
-    .replaceAll("%7C", "|")
-    .replaceAll("%26", "&")
-    .replaceAll("%24", "$")
-    .replaceAll("%23", "#")
-    .replaceAll("%40", "@")
-    .replaceAll("%5E", "^")
-    .replaceAll("%3A", ":")
-    .replaceAll("%21", "!")
-    .replaceAll("%3B", ";")
-    .replaceAll("\\n", "\n")
-    .replaceAll("\\r", "\r") || null;
 /**
  * Decodes each element in an array or a single value using unSecureString.
  *
@@ -125,6 +133,32 @@ const unSecureString = (input) => input
  * @returns An array with each element decoded, or a single decoded value.
  */
 const unSecureArray = (arr_str) => Array.isArray(arr_str) ? arr_str.map(unSecureArray) : unSecureString(arr_str);
+/**
+ * Reverses the encoding done by 'secureString'. Replaces encoded characters with their original symbols.
+ *
+ * @param input - Encoded string.
+ * @returns Decoded string or null if input is empty.
+ */
+const unSecureString = (input) => {
+    // Define a mapping of encoded characters to their original symbols.
+    const replacements = {
+        "&lt;": "<",
+        "%2C": ",",
+        "%7C": "|",
+        "%26": "&",
+        "%24": "$",
+        "%23": "#",
+        "%40": "@",
+        "%5E": "^",
+        "%3A": ":",
+        "%21": "!",
+        "%3B": ";",
+        "\\n": "\n",
+        "\\r": "\r",
+    };
+    // Replace encoded characters with their original symbols using the defined mapping.
+    return (input.replace(/%(2C|7C|26|24|23|40|5E|3A|21|3B|\\n|\\r)/g, (match) => replacements[match]) || null);
+};
 /**
  * Reverses the process of 'joinMultidimensionalArray', splitting a string back into a multidimensional array.
  * It identifies delimiters used in the joined string and applies them recursively to reconstruct the original array structure.
@@ -133,16 +167,14 @@ const unSecureArray = (arr_str) => Array.isArray(arr_str) ? arr_str.map(unSecure
  * @returns Original array structure before joining, or the input if no delimiters are found.
  */
 const reverseJoinMultidimensionalArray = (joinedString) => {
+    // Helper function for recursive array splitting based on delimiters.
     const reverseJoinMultidimensionalArrayHelper = (arr, delimiter) => Array.isArray(arr)
         ? arr.map((ar) => reverseJoinMultidimensionalArrayHelper(ar, delimiter))
         : arr.split(delimiter);
+    // Identify available delimiters in the input.
     const availableDelimiters = delimiters.filter((delimiter) => joinedString.includes(delimiter));
-    for (const delimiter of availableDelimiters) {
-        joinedString = Array.isArray(joinedString)
-            ? reverseJoinMultidimensionalArrayHelper(joinedString, delimiter)
-            : joinedString.split(delimiter);
-    }
-    return joinedString;
+    // Apply delimiters recursively to reconstruct the original array structure.
+    return availableDelimiters.reduce((acc, delimiter) => reverseJoinMultidimensionalArrayHelper(acc, delimiter), joinedString);
 };
 /**
  * Decodes a value based on specified field types and optional secret key.
@@ -196,56 +228,53 @@ export const decode = (input, fieldType, fieldChildrenType, secretKey) => {
     if (input === null || input === "")
         return null;
     if (Array.isArray(fieldType))
+        // Detect the fieldType based on the input and the provided array of possible types.
         fieldType = detectFieldType(String(input), fieldType);
+    // Decode the input using the decodeHelper function.
     return decodeHelper(typeof input === "string"
         ? input.includes(",")
             ? unSecureArray(reverseJoinMultidimensionalArray(input))
             : unSecureString(input)
         : input, fieldType, fieldChildrenType, secretKey);
 };
-/**
- * Asynchronously reads and decodes data from a file at specified line numbers.
- * Decodes each line based on specified field types and an optional secret key.
- *
- * @param filePath - Path of the file to be read.
- * @param lineNumbers - Optional line number(s) to read from the file. If -1, reads the last line.
- * @param fieldType - Optional type of the field to guide decoding (e.g., 'number', 'boolean').
- * @param fieldChildrenType - Optional type for child elements in array inputs.
- * @param secretKey - Optional secret key for decoding, can be a string or Buffer.
- * @returns Promise resolving to a tuple:
- *   1. Record of line numbers and their decoded content or null if no lines are read.
- *   2. Total count of lines processed.
- */
-export const get = async (filePath, lineNumbers, fieldType, fieldChildrenType, secretKey) => {
-    const fileHandle = await open(filePath, "r"), rl = readLineInternface(fileHandle);
-    let lines = new Map(), lineCount = 0;
-    if (!lineNumbers) {
-        for await (const line of rl)
-            lineCount++,
-                lines.set(lineCount, decode(line, fieldType, fieldChildrenType, secretKey));
-    }
-    else if (lineNumbers === -1) {
-        let lastLine = null;
-        for await (const line of rl)
-            lineCount++, (lastLine = line);
-        if (lastLine)
-            lines.set(lineCount, decode(lastLine, fieldType, fieldChildrenType, secretKey));
-    }
-    else {
-        let lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
-        for await (const line of rl) {
-            lineCount++;
-            if (!lineNumbersArray.has(lineCount))
-                continue;
-            lines.set(lineCount, decode(line, fieldType, fieldChildrenType, secretKey));
-            lineNumbersArray.delete(lineCount);
-            if (!lineNumbersArray.size)
-                break;
+export async function get(filePath, lineNumbers, fieldType, fieldChildrenType, secretKey, readWholeFile = false) {
+    let fileHandle, rl;
+    try {
+        fileHandle = await open(filePath, "r");
+        rl = readLineInternface(fileHandle);
+        let lines = {}, linesCount = 0;
+        if (!lineNumbers) {
+            for await (const line of rl)
+                linesCount++,
+                    (lines[linesCount] = decode(line, fieldType, fieldChildrenType, secretKey));
         }
+        else if (lineNumbers === -1) {
+            let lastLine = null;
+            for await (const line of rl)
+                linesCount++, (lastLine = line);
+            if (lastLine)
+                lines[linesCount] = decode(lastLine, fieldType, fieldChildrenType, secretKey);
+        }
+        else {
+            let lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
+            for await (const line of rl) {
+                linesCount++;
+                if (!lineNumbersArray.has(linesCount))
+                    continue;
+                lines[linesCount] = decode(line, fieldType, fieldChildrenType, secretKey);
+                lineNumbersArray.delete(linesCount);
+                if (!lineNumbersArray.size && !readWholeFile)
+                    break;
+            }
+        }
+        return readWholeFile ? [lines, linesCount] : lines;
     }
-    await fileHandle.close();
-    return [lines.size ? Object.fromEntries(lines) : null, lineCount];
-};
+    finally {
+        // Ensure that file handles are closed, even if an error occurred
+        rl?.close();
+        await fileHandle?.close();
+    }
+}
 /**
  * Asynchronously replaces specific lines in a file based on the provided replacements map or string.
  *
@@ -257,47 +286,52 @@ export const get = async (filePath, lineNumbers, fieldType, fieldChildrenType, s
  * Note: If the file doesn't exist and replacements is an object, it creates a new file with the specified replacements.
  */
 export const replace = async (filePath, replacements) => {
-    let lineCount = 0;
-    const fileHandle = await open(filePath, "r"), fileTempPath = filePath.replace(/([^/]+)\/?$/, `.tmp/${Date.now()}-$1`), fileTempHandle = await open(fileTempPath, "w"), rl = readLineInternface(fileHandle);
-    if (isObject(replacements))
-        await pipeline(rl, new Transform({
-            transform(line, encoding, callback) {
-                lineCount++;
-                callback(null, (replacements.hasOwnProperty(lineCount)
-                    ? replacements[lineCount]
-                    : line) + "\n");
-            },
-            final(callback) {
-                const newLinesNumbers = Object.entries(replacements)
-                    .map(([key, value]) => Number(key))
-                    .filter((num) => num > lineCount);
-                if (newLinesNumbers.length) {
-                    if (Math.min(...newLinesNumbers) - lineCount - 1 > 1)
-                        this.push("\n".repeat(Math.min(...newLinesNumbers) - lineCount - 1));
-                    this.push(newLinesNumbers
-                        .map((newLineNumber) => replacements[newLineNumber])
-                        .join("\n") + "\n");
-                }
-                callback();
-            },
-        }), 
-        // createDeflate(),
-        fileTempHandle.createWriteStream());
-    else
-        await pipeline(rl, new Transform({
-            transform(line, encoding, callback) {
-                lineCount++;
-                callback(null, replacements + "\n");
-            },
-        }), 
-        // createDeflate(),
-        fileTempHandle.createWriteStream());
-    await fileHandle.close();
-    await fileTempHandle.close();
-    return [fileTempPath, filePath];
+    const fileTempPath = filePath.replace(/([^/]+)\/?$/, `.tmp/${Date.now()}-$1`);
+    if (await isExists(filePath)) {
+        let fileHandle, fileTempHandle, rl;
+        try {
+            let linesCount = 0;
+            fileHandle = await open(filePath, "r");
+            fileTempHandle = await open(fileTempPath, "w");
+            rl = readLineInternface(fileHandle);
+            await _pipeline(rl, fileTempHandle.createWriteStream(), new Transform({
+                transform(line, encoding, callback) {
+                    linesCount++;
+                    const replacement = isObject(replacements)
+                        ? replacements.hasOwnProperty(linesCount)
+                            ? replacements[linesCount]
+                            : line
+                        : replacements;
+                    return callback(null, replacement + "\n");
+                },
+            }));
+            return [fileTempPath, filePath];
+        }
+        finally {
+            // Ensure that file handles are closed, even if an error occurred
+            rl?.close();
+            await fileHandle?.close();
+            await fileTempHandle?.close();
+        }
+    }
+    else if (isObject(replacements)) {
+        let replacementsKeys = Object.keys(replacements)
+            .map(Number)
+            .toSorted((a, b) => a - b);
+        await write(fileTempPath, "\n".repeat(replacementsKeys[0] - 1) +
+            replacementsKeys
+                .map((lineNumber, index) => index === 0 || lineNumber - replacementsKeys[index - 1] - 1 === 0
+                ? replacements[lineNumber]
+                : "\n".repeat(lineNumber - replacementsKeys[index - 1] - 1) +
+                    replacements[lineNumber])
+                .join("\n") +
+            "\n");
+        return [fileTempPath, filePath];
+    }
+    return [];
 };
 /**
- * Asynchronously appends data to a file.
+ * Asynchronously appends data to the beginning of a file.
  *
  * @param filePath - Path of the file to append to.
  * @param data - Data to append. Can be a string, number, or an array of strings/numbers.
@@ -307,23 +341,32 @@ export const replace = async (filePath, replacements) => {
 export const append = async (filePath, data) => {
     const fileTempPath = filePath.replace(/([^/]+)\/?$/, `.tmp/${Date.now()}-$1`);
     if (await isExists(filePath)) {
-        const fileHandle = await open(filePath, "r"), fileTempHandle = await open(fileTempPath, "w"), rl = readLineInternface(fileHandle);
-        await pipeline(rl, new Transform({
-            transform(line, encoding, callback) {
-                callback(null, `${line}\n`);
-            },
-            final(callback) {
-                this.push((Array.isArray(data) ? data.join("\n") : data) + "\n");
-                callback();
-            },
-        }), 
-        // createDeflate(),
-        fileTempHandle.createWriteStream());
-        await fileHandle.close();
-        await fileTempHandle.close();
+        let fileHandle, fileTempHandle, rl;
+        try {
+            fileHandle = await open(filePath, "r");
+            fileTempHandle = await open(fileTempPath, "w");
+            rl = readLineInternface(fileHandle);
+            let isAppended = false;
+            await _pipeline(rl, fileTempHandle.createWriteStream(), new Transform({
+                transform(line, encoding, callback) {
+                    if (!isAppended) {
+                        isAppended = true;
+                        return callback(null, `${Array.isArray(data) ? data.join("\n") : data}\n${line}\n`);
+                    }
+                    else
+                        return callback(null, `${line}\n`);
+                },
+            }));
+        }
+        finally {
+            // Ensure that file handles are closed, even if an error occurred
+            rl?.close();
+            await fileHandle?.close();
+            await fileTempHandle?.close();
+        }
     }
     else
-        await writeFile(fileTempPath, `${Array.isArray(data) ? data.join("\n") : data}\n`);
+        await write(fileTempPath, `${Array.isArray(data) ? data.join("\n") : data}\n`);
     return [fileTempPath, filePath];
 };
 /**
@@ -336,41 +379,22 @@ export const append = async (filePath, data) => {
  * Note: Creates a temporary file during the process and replaces the original file with it after removing lines.
  */
 export const remove = async (filePath, linesToDelete) => {
-    let lineCount = 0;
+    let linesCount = 0;
     const fileHandle = await open(filePath, "r"), fileTempPath = filePath.replace(/([^/]+)\/?$/, `.tmp/${Date.now()}-$1`), fileTempHandle = await open(fileTempPath, "w"), linesToDeleteArray = new Set(Array.isArray(linesToDelete)
         ? linesToDelete.map(Number)
         : [Number(linesToDelete)]), rl = readLineInternface(fileHandle);
-    await pipeline(rl, new Transform({
+    await _pipeline(rl, fileTempHandle.createWriteStream(), new Transform({
         transform(line, encoding, callback) {
-            lineCount++;
-            if (!linesToDeleteArray.has(lineCount))
-                callback(null, `${line}\n`);
-            callback();
+            linesCount++;
+            return !linesToDeleteArray.has(linesCount)
+                ? callback(null, `${line}\n`)
+                : callback();
         },
-    }), 
-    // createDeflate(),
-    fileTempHandle.createWriteStream());
+    }));
     await fileTempHandle.close();
     await fileHandle.close();
     return [fileTempPath, filePath];
 };
-/**
- * Asynchronously counts the number of lines in a file.
- *
- * @param filePath - Path of the file to count lines in.
- * @returns Promise<number>. The number of lines in the file.
- *
- * Note: Reads through the file line by line to count the total number of lines.
- */
-export const count = async (filePath) => {
-    // return Number((await exec(`wc -l < ${filePath}`)).stdout.trim());
-    let lineCount = 0;
-    const fileHandle = await open(filePath, "r"), rl = readLineInternface(fileHandle);
-    for await (const line of rl)
-        lineCount++;
-    await fileHandle.close();
-    return lineCount;
-};
 /**
  * Evaluates a comparison between two values based on a specified operator and field types.
  *
@@ -384,64 +408,118 @@ export const count = async (filePath) => {
  * Note: Handles various data types and comparison logic, including special handling for passwords and regex patterns.
  */
 const handleComparisonOperator = (operator, originalValue, comparedAtValue, fieldType, fieldChildrenType) => {
-    if (Array.isArray(fieldType))
+    // Determine the field type if it's an array of potential types.
+    if (Array.isArray(fieldType)) {
         fieldType = detectFieldType(String(originalValue), fieldType);
-    if (Array.isArray(comparedAtValue) && !["[]", "![]"].includes(operator))
+    }
+    // Handle comparisons involving arrays.
+    if (Array.isArray(comparedAtValue) && !["[]", "![]"].includes(operator)) {
         return comparedAtValue.some((comparedAtValueSingle) => handleComparisonOperator(operator, originalValue, comparedAtValueSingle, fieldType));
-    // check if not array or object // it can't be array or object!
+    }
+    // Switch statement for different comparison operators.
     switch (operator) {
+        // Equal (Case Insensitive for strings, specific handling for passwords and booleans).
         case "=":
-            switch (fieldType) {
-                case "password":
-                    return typeof originalValue === "string" &&
-                        typeof comparedAtValue === "string"
-                        ? comparePassword(originalValue, comparedAtValue)
-                        : false;
-                case "boolean":
-                    return Number(originalValue) - Number(comparedAtValue) === 0;
-                default:
-                    return originalValue === comparedAtValue;
-            }
+            return isEqual(originalValue, comparedAtValue, fieldType);
+        // Not Equal.
         case "!=":
-            return !handleComparisonOperator("=", originalValue, comparedAtValue, fieldType);
+            return !isEqual(originalValue, comparedAtValue, fieldType);
+        // Greater Than.
         case ">":
             return (originalValue !== null &&
                 comparedAtValue !== null &&
                 originalValue > comparedAtValue);
+        // Less Than.
         case "<":
             return (originalValue !== null &&
                 comparedAtValue !== null &&
                 originalValue < comparedAtValue);
+        // Greater Than or Equal.
         case ">=":
             return (originalValue !== null &&
                 comparedAtValue !== null &&
                 originalValue >= comparedAtValue);
+        // Less Than or Equal.
         case "<=":
             return (originalValue !== null &&
                 comparedAtValue !== null &&
                 originalValue <= comparedAtValue);
+        // Array Contains (equality check for arrays).
         case "[]":
-            return ((Array.isArray(originalValue) &&
-                Array.isArray(comparedAtValue) &&
-                originalValue.some(comparedAtValue.includes)) ||
-                (Array.isArray(originalValue) &&
-                    !Array.isArray(comparedAtValue) &&
-                    originalValue.includes(comparedAtValue)) ||
-                (!Array.isArray(originalValue) &&
-                    Array.isArray(comparedAtValue) &&
-                    comparedAtValue.includes(originalValue)));
+            return isArrayEqual(originalValue, comparedAtValue);
+        // Array Does Not Contain.
         case "![]":
-            return !handleComparisonOperator("[]", originalValue, comparedAtValue, fieldType);
+            return !isArrayEqual(originalValue, comparedAtValue);
+        // Wildcard Match (using regex pattern).
         case "*":
-            return new RegExp(`^${(String(comparedAtValue).includes("%")
-                ? String(comparedAtValue)
-                : "%" + String(comparedAtValue) + "%").replace(/%/g, ".*")}$`, "i").test(String(originalValue));
+            return isWildcardMatch(originalValue, comparedAtValue);
+        // Not Wildcard Match.
         case "!*":
-            return !handleComparisonOperator("*", originalValue, comparedAtValue, fieldType);
+            return !isWildcardMatch(originalValue, comparedAtValue);
+        // Unsupported operator.
         default:
-            throw new Error(operator);
+            throw new Error(`Unsupported operator: ${operator}`);
     }
 };
+/**
+ * Helper function to check equality based on the field type.
+ *
+ * @param originalValue - The original value.
+ * @param comparedAtValue - The value to compare against.
+ * @param fieldType - Type of the field.
+ * @returns boolean - Result of the equality check.
+ */
+const isEqual = (originalValue, comparedAtValue, fieldType) => {
+    // Switch based on the field type for specific handling.
+    switch (fieldType) {
+        // Password comparison.
+        case "password":
+            return typeof originalValue === "string" &&
+                typeof comparedAtValue === "string"
+                ? comparePassword(originalValue, comparedAtValue)
+                : false;
+        // Boolean comparison.
+        case "boolean":
+            return Number(originalValue) === Number(comparedAtValue);
+        // Default comparison.
+        default:
+            return originalValue === comparedAtValue;
+    }
+};
+/**
+ * Helper function to check array equality.
+ *
+ * @param originalValue - The original value.
+ * @param comparedAtValue - The value to compare against.
+ * @returns boolean - Result of the array equality check.
+ */
+const isArrayEqual = (originalValue, comparedAtValue) => {
+    return ((Array.isArray(originalValue) &&
+        Array.isArray(comparedAtValue) &&
+        originalValue.some((v) => comparedAtValue.includes(v))) ||
+        (Array.isArray(originalValue) &&
+            !Array.isArray(comparedAtValue) &&
+            originalValue.includes(comparedAtValue)) ||
+        (!Array.isArray(originalValue) &&
+            Array.isArray(comparedAtValue) &&
+            comparedAtValue.includes(originalValue)) ||
+        (!Array.isArray(originalValue) &&
+            !Array.isArray(comparedAtValue) &&
+            comparedAtValue === originalValue));
+};
+/**
+ * Helper function to check wildcard pattern matching using regex.
+ *
+ * @param originalValue - The original value.
+ * @param comparedAtValue - The value with wildcard pattern.
+ * @returns boolean - Result of the wildcard pattern matching.
+ */
+const isWildcardMatch = (originalValue, comparedAtValue) => {
+    const wildcardPattern = `^${(String(comparedAtValue).includes("%")
+        ? String(comparedAtValue)
+        : "%" + String(comparedAtValue) + "%").replace(/%/g, ".*")}$`;
+    return new RegExp(wildcardPattern, "i").test(String(originalValue));
+};
 /**
  * Asynchronously searches a file for lines matching specified criteria, using comparison and logical operators.
  *
@@ -462,34 +540,88 @@ const handleComparisonOperator = (operator, originalValue, comparedAtValue, fiel
  * Note: Decodes each line for comparison and can handle complex queries with multiple conditions.
  */
 export const search = async (filePath, operator, comparedAtValue, logicalOperator, fieldType, fieldChildrenType, limit, offset, readWholeFile, secretKey) => {
-    let RETURN = new Map(), lineCount = 0, foundItems = 0;
-    const fileHandle = await open(filePath, "r"), rl = readLineInternface(fileHandle);
-    for await (const line of rl) {
-        lineCount++;
-        const decodedLine = decode(line, fieldType, fieldChildrenType, secretKey);
-        if ((Array.isArray(operator) &&
-            Array.isArray(comparedAtValue) &&
-            ((logicalOperator &&
-                logicalOperator === "or" &&
-                operator.some((single_operator, index) => handleComparisonOperator(single_operator, decodedLine, comparedAtValue[index], fieldType))) ||
-                operator.every((single_operator, index) => handleComparisonOperator(single_operator, decodedLine, comparedAtValue[index], fieldType)))) ||
-            (!Array.isArray(operator) &&
-                handleComparisonOperator(operator, decodedLine, comparedAtValue, fieldType))) {
-            foundItems++;
-            if (offset && foundItems < offset)
-                continue;
-            if (limit && foundItems > limit)
-                if (readWholeFile)
+    // Initialize a Map to store the matching lines with their line numbers.
+    const matchingLines = {};
+    // Initialize counters for line number, found items, and processed items.
+    let linesCount = 0, foundItems = 0, linesNumbers = new Set();
+    let fileHandle, rl;
+    try {
+        // Open the file for reading.
+        fileHandle = await open(filePath, "r");
+        // Create a Readline interface to read the file line by line.
+        rl = readLineInternface(fileHandle);
+        // Iterate through each line in the file.
+        for await (const line of rl) {
+            // Increment the line count for each line.
+            linesCount++;
+            // Decode the line for comparison.
+            const decodedLine = decode(line, fieldType, fieldChildrenType, secretKey);
+            // Check if the line meets the specified conditions based on comparison and logical operators.
+            const meetsConditions = (Array.isArray(operator) &&
+                Array.isArray(comparedAtValue) &&
+                ((logicalOperator === "or" &&
+                    operator.some((single_operator, index) => handleComparisonOperator(single_operator, decodedLine, comparedAtValue[index], fieldType))) ||
+                    operator.every((single_operator, index) => handleComparisonOperator(single_operator, decodedLine, comparedAtValue[index], fieldType)))) ||
+                (!Array.isArray(operator) &&
+                    handleComparisonOperator(operator, decodedLine, comparedAtValue, fieldType));
+            // If the line meets the conditions, process it.
+            if (meetsConditions) {
+                // Increment the found items counter.
+                foundItems++;
+                linesNumbers.add(linesCount);
+                // Check if the line should be skipped based on the offset.
+                if (offset && foundItems < offset)
                     continue;
-                else
-                    break;
-            RETURN.set(lineCount, decodedLine);
+                // Check if the limit has been reached.
+                if (limit && foundItems > limit)
+                    if (readWholeFile)
+                        continue;
+                    else
+                        break;
+                // Store the decoded line in the result object.
+                matchingLines[linesCount] = decodedLine;
+            }
         }
+        // Convert the Map to an object using Object.fromEntries and return the result.
+        return foundItems
+            ? [
+                matchingLines,
+                readWholeFile ? foundItems : foundItems - 1,
+                linesNumbers.size ? linesNumbers : null,
+            ]
+            : [null, 0, null];
     }
-    await fileHandle.close();
-    return foundItems
-        ? [Object.fromEntries(RETURN), readWholeFile ? foundItems : foundItems - 1]
-        : [null, 0];
+    finally {
+        // Close the file handle in the finally block to ensure it is closed even if an error occurs.
+        rl?.close();
+        await fileHandle?.close();
+    }
+};
+/**
+ * Asynchronously counts the number of lines in a file.
+ *
+ * @param filePath - Path of the file to count lines in.
+ * @returns Promise<number>. The number of lines in the file.
+ *
+ * Note: Reads through the file line by line to count the total number of lines.
+ */
+export const count = async (filePath) => {
+    // return Number((await exec(`wc -l < ${filePath}`)).stdout.trim());
+    let linesCount = 0;
+    if (await isExists(filePath)) {
+        let fileHandle, rl;
+        try {
+            (fileHandle = await open(filePath, "r")),
+                (rl = readLineInternface(fileHandle));
+            for await (const line of rl)
+                linesCount++;
+        }
+        finally {
+            rl?.close();
+            await fileHandle?.close();
+        }
+    }
+    return linesCount;
 };
 /**
  * Asynchronously calculates the sum of numerical values from specified lines in a file.
@@ -504,14 +636,14 @@ export const sum = async (filePath, lineNumbers) => {
     let sum = 0;
     const fileHandle = await open(filePath, "r"), rl = readLineInternface(fileHandle);
     if (lineNumbers) {
-        let lineCount = 0;
+        let linesCount = 0;
         let lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
         for await (const line of rl) {
-            lineCount++;
-            if (!lineNumbersArray.has(lineCount))
+            linesCount++;
+            if (!lineNumbersArray.has(linesCount))
                 continue;
             sum += +(decode(line, "number") ?? 0);
-            lineNumbersArray.delete(lineCount);
+            lineNumbersArray.delete(linesCount);
             if (!lineNumbersArray.size)
                 break;
         }
@@ -535,16 +667,16 @@ export const max = async (filePath, lineNumbers) => {
     let max = 0;
     const fileHandle = await open(filePath, "r"), rl = readLineInternface(fileHandle);
     if (lineNumbers) {
-        let lineCount = 0;
+        let linesCount = 0;
         let lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
         for await (const line of rl) {
-            lineCount++;
-            if (!lineNumbersArray.has(lineCount))
+            linesCount++;
+            if (!lineNumbersArray.has(linesCount))
                 continue;
             const lineContentNum = +(decode(line, "number") ?? 0);
             if (lineContentNum > max)
                 max = lineContentNum;
-            lineNumbersArray.delete(lineCount);
+            lineNumbersArray.delete(linesCount);
             if (!lineNumbersArray.size)
                 break;
         }
@@ -571,16 +703,16 @@ export const min = async (filePath, lineNumbers) => {
     let min = 0;
     const fileHandle = await open(filePath, "r"), rl = readLineInternface(fileHandle);
     if (lineNumbers) {
-        let lineCount = 0;
+        let linesCount = 0;
         let lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
         for await (const line of rl) {
-            lineCount++;
-            if (!lineNumbersArray.has(lineCount))
+            linesCount++;
+            if (!lineNumbersArray.has(linesCount))
                 continue;
             const lineContentNum = +(decode(line, "number") ?? 0);
             if (lineContentNum < min)
                 min = lineContentNum;
-            lineNumbersArray.delete(lineCount);
+            lineNumbersArray.delete(linesCount);
             if (!lineNumbersArray.size)
                 break;
         }
@@ -611,7 +743,6 @@ export default class File {
     static remove = remove;
     static search = search;
     static replace = replace;
-    static count = count;
     static encode = encode;
     static decode = decode;
     static isExists = isExists;
@@ -619,4 +750,7 @@ export default class File {
     static min = min;
     static max = max;
     static append = append;
+    static count = count;
+    static write = write;
+    static read = read;
 }