inibase 1.0.0-rc.98 → 1.1.0

package/README.md

@@ -54,6 +54,15 @@ const users = await db.get("user", { favoriteFoods: "![]Pizza,Burger" });
 <npm|pnpm|yarn|bun> install inibase
 ```
 
+> [!WARNING]
+> If you're using **Windows**, the following Unix commands are required: `zcat`, `sed`, `gzip`, and `echo`.
+>  
+> To use the missing commands, you need to install additional tools:
+> - **[GnuWin32](http://gnuwin32.sourceforge.net/)**: Provides individual GNU utilities for Windows.  
+> - **[Cygwin](https://www.cygwin.com/)**: Offers a full Unix-like environment for Windows.  
+>  
+> Alternatively, consider using the **Windows Subsystem for Linux (WSL)** to run a Linux environment on Windows. Learn more [here](https://learn.microsoft.com/en-us/windows/wsl/).
+
 ## How it works?
 
 `Inibase` organizes data into databases, tables, and columns, each stored in separate files.
@@ -97,40 +106,124 @@ interface {
 <summary>Schema</summary>
 <blockquote>
 
+<details>
+<summary>Types</summary>
+<blockquote>
+
 ```ts
-interface {
+interface Field {
   id: number; // stored as a Number but displayed as a hashed ID
   key: string;
   required?: boolean;
-  unique?: boolean;
-  type: "string" | "number" | "boolean" | "date" | "email" | "url" | "password" | "html" | "ip" | "json" | "id";
+  unique?: boolean | string; // boolean for simple uniqueness, string for grouped uniqueness
+  regex?: RegExp; // Regular expression for custom validation
+  type:
+    | "string"
+    | "number"
+    | "boolean"
+    | "date"
+    | "email"
+    | "url"
+    | "password"
+    | "html"
+    | "ip"
+    | "json"
+    | "id";
 }
-interface Table {
+
+interface TableField {
   id: number;
   key: string;
   required?: boolean;
+  unique?: boolean | string; // Supports uniqueness constraints
   type: "table";
   table: string;
 }
-interface Array {
+
+interface ArrayField {
   id: number;
   key: string;
   required?: boolean;
+  unique?: boolean | string; // Supports uniqueness constraints
   type: "array";
-  children: string|string[];
+  children: string | string[]; // Can be a single type or an array of types
 }
-interface ObjectOrArrayOfObjects {
+
+interface ObjectOrArrayOfObjectsField {
   id: number;
   key: string;
   required?: boolean;
+  unique?: boolean | string; // Supports uniqueness constraints
+  regex?: RegExp; // For validation of object-level keys
   type: "object" | "array";
-  children: Schema;
+  children: Schema; // Nested schema for objects or arrays
 }
 ```
 
 </blockquote>
 </details>
 
+<details>
+<summary>Unique</summary>
+<blockquote>
+
+The `unique` property ensures that the values of a specific column or a group of columns are unique within a table. This property can be either a boolean or a string.
+- **Boolean**: Setting `unique: true` ensures that the values in the column are unique across all rows.
+- **String**: By setting a string value, you can group columns to enforce a combined uniqueness constraint. This is useful when you need to ensure that a combination of values across multiple fields is unique.
+
+<details>
+<summary>Examples</summary>
+<blockquote>
+
+<details>
+<summary>Unique Column</summary>
+<blockquote>
+
+```js
+{
+  key: "email",
+  type: "string",
+  required: true,
+  unique: true, // Ensures all email values are unique
+}
+```
+
+</blockquote>
+</details>
+
+<details>
+<summary>Group of Unique Columns</summary>
+<blockquote>
+
+```js
+[
+  {
+    key: "firstName",
+    type: "string",
+    required: true,
+    unique: "nameGroup", // Part of "nameGroup" uniqueness
+  },
+  {
+    key: "lastName",
+    type: "string",
+    required: true,
+    unique: "nameGroup", // Part of "nameGroup" uniqueness
+  },
+]
+```
+
+</blockquote>
+</details>
+
+</blockquote>
+</details>
+
+</blockquote>
+</details>
+
+</blockquote>
+</details>
+
 <details>
 <summary>Create Table</summary>
 <blockquote>
@@ -348,7 +441,7 @@ const product = await db.post("product", productTableData);
 </blockquote>
 </details>
 
-<details>
+<details open>
 <summary>Methods</summary>
 <blockquote>
 
@@ -667,21 +760,22 @@ await db.get("user", undefined, { sort: {age: -1, username: "asc"} });
 
 ### Bulk
 
-|        | 10              | 100             | 1000            |
-|--------|-----------------|-----------------|-----------------|
-| POST   | 11 ms (0.65 mb) | 19 ms (1.00 mb) | 85 ms (4.58 mb) |
-| GET    | 14 ms (2.77 mb) | 12 ms (3.16 mb) | 34 ms (1.38 mb) |
-| PUT    | 6 ms (1.11 mb)  | 5 ms (1.37 mb)  | 10 ms (1.12 mb) |
-| DELETE | 17 ms (1.68 mb) | 14 ms (5.45 mb) | 25 ms (5.94 mb) |
+|        | 10                | 100               | 1000              |
+|--------|-------------------|-------------------|-------------------|
+| POST   | 11 ms (0.66 mb)   | 5 ms (1.02 mb)    | 24 ms (1.44 mb)   |
+| GET    | 29 ms (2.86 mb)   | 24 ms (2.81 mb)   | 36 ms (0.89 mb)   |
+| PUT    | 21 ms (2.68 mb)   | 16 ms (2.90 mb)   | 12 ms (0.63 mb)   |
+| DELETE | 14 ms (0.82 mb)   | 13 ms (0.84 mb)   | 2 ms (0.17 mb)    |
+
 
 ### Single
 
-|        | 10                | 100                | 1000               |
-|--------|-------------------|--------------------|--------------------|
-| POST   | 43 ms (4.70 mb)   | 387 ms (6.36 mb)   | 5341 ms (24.73 mb) |
-| GET    | 99 ms (12.51 mb)  | 846 ms (30.68 mb)  | 7103 ms (30.86 mb) |
-| PUT    | 33 ms (10.29 mb)  | 312 ms (11.06 mb)  | 3539 ms (14.87 mb) |
-| DELETE | 134 ms (13.50 mb) | 1224 ms (16.57 mb) | 7339 ms (11.46 mb) |
+|        | 10                  | 100                | 1000               |
+|--------|---------------------|--------------------|--------------------|
+| POST   | 45 ms (1.07 mb)     | 12 ms (0.52 mb)    | 11 ms (0.37 mb)    |
+| GET    | 200 ms (2.15 mb)    | 192 ms (2.72 mb)   | 190 ms (2.31 mb)   |
+| PUT    | 49 ms (3.22 mb)     | 17 ms (2.98 mb)    | 17 ms (3.06 mb)    |
+| DELETE | 118 ms (0.59 mb)    | 113 ms (0.51 mb)   | 103 ms (3.14 mb)   |
 
 > Default testing uses a table with username, email, and password fields, ensuring password encryption is included in the process<br>
 > To run benchmarks, install _typescript_ & _[tsx](https://github.com/privatenumber/tsx)_ globally and run `benchmark` by default bulk, for single use `benchmark --single|-s`
@@ -716,12 +810,13 @@ await db.get("user", undefined, { sort: {age: -1, username: "asc"} });
   - [x] Id
   - [x] JSON
 - [ ] TO-DO:
+  - [x] Use new Map() instead of Object
   - [ ] Ability to search in JSON fields
-  - [ ] Re-check used exec functions
+  - [x] Re-check used exec functions
   - [ ] Use smart caching (based on N° of queries)
   - [ ] Commenting the code
   - [ ] Add Backup feature (generate a tar.gz)
-  - [ ] Add Custom field validation property to schema (using RegEx?)
+  - [x] Add Custom field validation property to schema (using RegEx?)
 - [ ] Features:
   - [ ] Encryption
   - [x] Data Compression

package/dist/file.d.ts

@@ -3,6 +3,7 @@ export declare const lock: (folderPath: string, prefix?: string) => Promise<void
 export declare const unlock: (folderPath: string, prefix?: string) => Promise<void>;
 export declare const write: (filePath: string, data: any) => Promise<void>;
 export declare const read: (filePath: string) => Promise<string>;
+export declare function escapeShellPath(filePath: string): string;
 /**
  * Checks if a file or directory exists at the specified path.
  *
@@ -58,7 +59,7 @@ export declare function get(filePath: string, lineNumbers: undefined | number |
  *
  * Note: If the file doesn't exist and replacements is an object, it creates a new file with the specified replacements.
  */
-export declare const replace: (filePath: string, replacements: string | number | boolean | null | (string | number | boolean | null)[] | Record<number, string | boolean | number | null | (string | boolean | number | null)[]>) => Promise<string[]>;
+export declare const replace: (filePath: string, replacements: string | number | boolean | null | (string | number | boolean | null)[] | Record<number, string | boolean | number | null | (string | boolean | number | null)[]>, totalItems?: number) => Promise<string[]>;
 /**
  * Asynchronously appends data to the end of a file.
  *
@@ -106,16 +107,7 @@ export declare const remove: (filePath: string, linesToDelete: number | number[]
  *
  * Note: Decodes each line for comparison and can handle complex queries with multiple conditions.
  */
-export declare const search: (filePath: string, operator: ComparisonOperator | ComparisonOperator[], comparedAtValue: string | number | boolean | null | (string | number | boolean | null)[], logicalOperator?: "and" | "or", fieldType?: FieldType | FieldType[], fieldChildrenType?: FieldType | FieldType[] | Schema, limit?: number, offset?: number, readWholeFile?: boolean, secretKey?: string | Buffer) => Promise<[Record<number, string | number | boolean | null | (string | number | boolean | null)[]> | null, number, Set<number> | null]>;
-/**
- * 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 declare const count: (filePath: string) => Promise<number>;
+export declare const search: (filePath: string, operator: ComparisonOperator | ComparisonOperator[], comparedAtValue: string | number | boolean | null | (string | number | boolean | null)[], logicalOperator?: "and" | "or", searchIn?: Set<number>, fieldType?: FieldType | FieldType[], fieldChildrenType?: FieldType | FieldType[] | Schema, limit?: number, offset?: number, readWholeFile?: boolean, secretKey?: string | Buffer) => Promise<[Record<number, string | number | boolean | null | (string | number | boolean | null)[]> | null, number, Set<number> | null]>;
 /**
  * Asynchronously calculates the sum of numerical values from specified lines in a file.
  *

package/dist/file.js

@@ -1,5 +1,5 @@
 import { access, appendFile, copyFile, constants as fsConstants, open, readFile, unlink, writeFile, } from "node:fs/promises";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 import { createInterface } from "node:readline";
 import { Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
@@ -34,6 +34,12 @@ export const write = async (filePath, data) => {
 export const read = async (filePath) => filePath.endsWith(".gz")
     ? (await gunzip(await readFile(filePath, "utf8"))).toString()
     : await readFile(filePath, "utf8");
+export function escapeShellPath(filePath) {
+    // Resolve the path to avoid relative path issues
+    const resolvedPath = resolve(filePath);
+    // Escape double quotes and special shell characters
+    return `"${resolvedPath.replace(/(["\\$`])/g, "\\$1")}"`;
+}
 const _pipeline = async (filePath, rl, writeStream, transform) => {
     if (filePath.endsWith(".gz"))
         await pipeline(rl, transform, createGzip(), writeStream);
@@ -89,7 +95,7 @@ const secureString = (input) => {
         decodedInput = decodeURIComponent(input.replace(/%(?![0-9][0-9a-fA-F]+)/g, ""));
     }
     // Replace characters using a single regular expression.
-    return decodedInput.replace(/\\n/g, "\n").replace(/\n/g, "\\n");
+    return decodedInput.replace(/\r\n|\r|\n/g, "\\n");
 };
 /**
  * Encodes the input using 'secureString' and 'Inison.stringify' functions.
@@ -168,7 +174,7 @@ export const decode = (input, fieldType, fieldChildrenType, secretKey) => {
     if (!fieldType)
         return null;
     if (input === null || input === "")
-        return null;
+        return undefined;
     // Detect the fieldType based on the input and the provided array of possible types.
     if (Array.isArray(fieldType))
         fieldType = detectFieldType(String(input), fieldType);
@@ -179,6 +185,29 @@ export const decode = (input, fieldType, fieldChildrenType, secretKey) => {
             : unSecureString(input)
         : input, fieldType, fieldChildrenType, secretKey);
 };
+function _groupIntoRanges(arr, action = "p") {
+    if (arr.length === 0)
+        return [];
+    arr.sort((a, b) => a - b); // Ensure the array is sorted
+    const ranges = [];
+    let start = arr[0];
+    let end = arr[0];
+    for (let i = 1; i < arr.length; i++) {
+        if (arr[i] === end + 1) {
+            // Continue the range
+            end = arr[i];
+        }
+        else {
+            // End the current range and start a new one
+            ranges.push(start === end ? `${start}` : `${start},${end}`);
+            start = arr[i];
+            end = arr[i];
+        }
+    }
+    // Push the last range
+    ranges.push(start === end ? `${start}` : `${start},${end}`);
+    return ranges.map((range) => `${range}${action}`).join(";");
+}
 export async function get(filePath, lineNumbers, fieldType, fieldChildrenType, secretKey, readWholeFile = false) {
     let fileHandle = null;
     try {
@@ -192,9 +221,10 @@ export async function get(filePath, lineNumbers, fieldType, fieldChildrenType, s
             }
         }
         else if (lineNumbers == -1) {
+            const escapedFilePath = escapeShellPath(filePath);
             const command = filePath.endsWith(".gz")
-                ? `zcat ${filePath} | sed -n '$p'`
-                : `sed -n '$p' ${filePath}`, foundedLine = (await exec(command)).stdout.trimEnd();
+                ? `zcat ${escapedFilePath} | sed -n '$p'`
+                : `sed -n '$p' ${escapedFilePath}`, foundedLine = (await exec(command)).stdout.trimEnd();
             if (foundedLine)
                 lines[linesCount] = decode(foundedLine, fieldType, fieldChildrenType, secretKey);
         }
@@ -213,9 +243,10 @@ export async function get(filePath, lineNumbers, fieldType, fieldChildrenType, s
                 }
                 return [lines, linesCount];
             }
+            const escapedFilePath = escapeShellPath(filePath);
             const command = filePath.endsWith(".gz")
-                ? `zcat ${filePath} | sed -n '${lineNumbers.join("p;")}p'`
-                : `sed -n '${lineNumbers.join("p;")}p' ${filePath}`, foundedLines = (await exec(command)).stdout.trimEnd().split("\n");
+                ? `zcat ${escapedFilePath} | sed -n '${_groupIntoRanges(lineNumbers)}'`
+                : `sed -n '${_groupIntoRanges(lineNumbers)}' ${escapedFilePath}`, foundedLines = (await exec(command)).stdout.trimEnd().split("\n");
             let index = 0;
             for (const line of foundedLines) {
                 lines[lineNumbers[index]] = decode(line, fieldType, fieldChildrenType, secretKey);
@@ -239,48 +270,103 @@ export async function get(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) => {
+export const replace = async (filePath, replacements, totalItems) => {
     const fileTempPath = filePath.replace(/([^/]+)\/?$/, ".tmp/$1");
+    const isReplacementsObject = isObject(replacements);
+    const isReplacementsLineNumbered = isReplacementsObject && !Number.isNaN(Number(Object.keys(replacements)[0]));
     if (await isExists(filePath)) {
-        let fileHandle = null;
-        let fileTempHandle = null;
+        if (isReplacementsLineNumbered) {
+            let fileHandle = null;
+            let fileTempHandle = null;
+            try {
+                let linesCount = 0;
+                fileHandle = await open(filePath, "r");
+                fileTempHandle = await open(fileTempPath, "w");
+                const writeStream = fileTempHandle.createWriteStream();
+                const rl = createReadLineInternface(filePath, fileHandle);
+                await _pipeline(filePath, rl, writeStream, new Transform({
+                    transform(line, _, callback) {
+                        linesCount++;
+                        const replacement = isReplacementsObject
+                            ? Object.hasOwn(replacements, linesCount)
+                                ? replacements[linesCount]
+                                : line
+                            : replacements;
+                        return callback(null, `${replacement}\n`);
+                    },
+                    flush(callback) {
+                        const remainingReplacementsKeys = Object.keys(replacements)
+                            .map(Number)
+                            .toSorted((a, b) => a - b)
+                            .filter((lineNumber) => lineNumber > linesCount);
+                        if (remainingReplacementsKeys.length)
+                            this.push("\n".repeat(remainingReplacementsKeys[0] - linesCount - 1) +
+                                remainingReplacementsKeys
+                                    .map((lineNumber, index) => index === 0 ||
+                                    lineNumber -
+                                        (remainingReplacementsKeys[index - 1] - 1) ===
+                                        0
+                                    ? replacements[lineNumber]
+                                    : "\n".repeat(lineNumber -
+                                        remainingReplacementsKeys[index - 1] -
+                                        1) + replacements[lineNumber])
+                                    .join("\n"));
+                        callback();
+                    },
+                }));
+                return [fileTempPath, filePath];
+            }
+            catch {
+                return [fileTempPath, null];
+            }
+            finally {
+                // Ensure that file handles are closed, even if an error occurred
+                await fileHandle?.close();
+                await fileTempHandle?.close();
+            }
+        }
+        else {
+            const escapedFilePath = escapeShellPath(filePath);
+            const escapedFileTempPath = escapeShellPath(fileTempPath);
+            const sedCommand = `sed -e s/.*/${replacements}/ -e /^$/s/^/${replacements}/ ${escapedFilePath}`;
+            const command = filePath.endsWith(".gz")
+                ? `zcat ${escapedFilePath} | ${sedCommand} | gzip > ${escapedFileTempPath}`
+                : `${sedCommand} > ${escapedFileTempPath}`;
+            try {
+                await exec(command);
+                return [fileTempPath, filePath];
+            }
+            catch {
+                return [fileTempPath, null];
+            }
+        }
+    }
+    else if (isReplacementsObject) {
         try {
-            let linesCount = 0;
-            fileHandle = await open(filePath, "r");
-            fileTempHandle = await open(fileTempPath, "w");
-            const rl = createReadLineInternface(filePath, fileHandle);
-            await _pipeline(filePath, rl, fileTempHandle.createWriteStream(), new Transform({
-                transform(line, _, callback) {
-                    linesCount++;
-                    const replacement = isObject(replacements)
-                        ? Object.hasOwn(replacements, linesCount)
-                            ? replacements[linesCount]
-                            : line
-                        : replacements;
-                    return callback(null, `${replacement}\n`);
-                },
-            }));
+            if (isReplacementsLineNumbered) {
+                const 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`);
+            }
+            else {
+                if (!totalItems)
+                    throw new Error("INVALID_PARAMETERS");
+                await write(fileTempPath, `${`${replacements}\n`.repeat(totalItems)}\n`);
+            }
             return [fileTempPath, filePath];
         }
-        finally {
-            // Ensure that file handles are closed, even if an error occurred
-            await fileHandle?.close();
-            await fileTempHandle?.close();
+        catch {
+            return [fileTempPath, null];
         }
     }
-    else if (isObject(replacements)) {
-        const 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 [];
 };
 /**
@@ -293,20 +379,26 @@ export const replace = async (filePath, replacements) => {
  */
 export const append = async (filePath, data) => {
     const fileTempPath = filePath.replace(/([^/]+)\/?$/, ".tmp/$1");
-    if (await isExists(filePath)) {
-        await copyFile(filePath, fileTempPath);
-        if (!filePath.endsWith(".gz")) {
-            await appendFile(fileTempPath, `${Array.isArray(data) ? data.join("\n") : data}\n`);
-        }
-        else {
-            await exec(`echo $'${(Array.isArray(data) ? data.join("\n") : data)
-                .toString()
-                .replace(/'/g, "\\'")}' | gzip - >> ${fileTempPath}`);
+    try {
+        if (await isExists(filePath)) {
+            await copyFile(filePath, fileTempPath);
+            if (!filePath.endsWith(".gz")) {
+                await appendFile(fileTempPath, `${Array.isArray(data) ? data.join("\n") : data}\n`);
+            }
+            else {
+                const escapedFileTempPath = escapeShellPath(fileTempPath);
+                await exec(`echo '${(Array.isArray(data) ? data.join("\n") : data)
+                    .toString()
+                    .replace(/'/g, "\\'")}' | gzip - >> ${escapedFileTempPath}`);
+            }
         }
+        else
+            await write(fileTempPath, `${Array.isArray(data) ? data.join("\n") : data}\n`);
+        return [fileTempPath, filePath];
+    }
+    catch {
+        return [fileTempPath, null];
     }
-    else
-        await write(fileTempPath, `${Array.isArray(data) ? data.join("\n") : data}\n`);
-    return [fileTempPath, filePath];
 };
 /**
  * Asynchronously prepends data to the beginning of a file.
@@ -337,6 +429,9 @@ export const prepend = async (filePath, data) => {
                     },
                 }));
             }
+            catch {
+                return [fileTempPath, null];
+            }
             finally {
                 // Ensure that file handles are closed, even if an error occurred
                 await fileHandle?.close();
@@ -347,15 +442,27 @@ export const prepend = async (filePath, data) => {
             const fileChildTempPath = filePath.replace(/([^/]+)\/?$/, ".tmp/tmp_$1");
             try {
                 await write(fileChildTempPath, `${Array.isArray(data) ? data.join("\n") : data}\n`);
-                await exec(`cat ${fileChildTempPath} ${filePath} > ${fileTempPath}`);
+                const escapedFilePath = escapeShellPath(filePath);
+                const escapedFileTempPath = escapeShellPath(fileTempPath);
+                const escapedFileChildTempPath = escapeShellPath(fileChildTempPath);
+                await exec(`cat ${escapedFileChildTempPath} ${escapedFilePath} > ${escapedFileTempPath}`);
+            }
+            catch {
+                return [fileTempPath, null];
             }
             finally {
                 await unlink(fileChildTempPath);
             }
         }
     }
-    else
-        await write(fileTempPath, `${Array.isArray(data) ? data.join("\n") : data}\n`);
+    else {
+        try {
+            await write(fileTempPath, `${Array.isArray(data) ? data.join("\n") : data}\n`);
+        }
+        catch {
+            return [fileTempPath, null];
+        }
+    }
     return [fileTempPath, filePath];
 };
 /**
@@ -374,11 +481,18 @@ export const remove = async (filePath, linesToDelete) => {
     if (linesToDelete.some(Number.isNaN))
         throw new Error("UNVALID_LINE_NUMBERS");
     const fileTempPath = filePath.replace(/([^/]+)\/?$/, ".tmp/$1");
-    const command = filePath.endsWith(".gz")
-        ? `zcat ${filePath} | sed "${linesToDelete.join("d;")}d" | gzip > ${fileTempPath}`
-        : `sed "${linesToDelete.join("d;")}d" ${filePath} > ${fileTempPath}`;
-    await exec(command);
-    return [fileTempPath, filePath];
+    try {
+        const escapedFilePath = escapeShellPath(filePath);
+        const escapedFileTempPath = escapeShellPath(fileTempPath);
+        const command = filePath.endsWith(".gz")
+            ? `zcat ${escapedFilePath} | sed '${_groupIntoRanges(linesToDelete, "d")}' | gzip > ${escapedFileTempPath}`
+            : `sed '${_groupIntoRanges(linesToDelete, "d")}' ${escapedFilePath} > ${escapedFileTempPath}`;
+        await exec(command);
+        return [fileTempPath, filePath];
+    }
+    catch {
+        return [fileTempPath, null];
+    }
 };
 /**
  * Asynchronously searches a file for lines matching specified criteria, using comparison and logical operators.
@@ -399,13 +513,20 @@ export const remove = async (filePath, linesToDelete) => {
  *
  * 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) => {
+export const search = async (filePath, operator, comparedAtValue, logicalOperator, searchIn, fieldType, fieldChildrenType, limit, offset, readWholeFile, secretKey) => {
     // 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;
     const linesNumbers = new Set();
     let fileHandle = null;
+    const meetsConditions = (value) => (Array.isArray(operator) &&
+        Array.isArray(comparedAtValue) &&
+        ((logicalOperator === "or" &&
+            operator.some((single_operator, index) => compare(single_operator, value, comparedAtValue[index], fieldType))) ||
+            operator.every((single_operator, index) => compare(single_operator, value, comparedAtValue[index], fieldType)))) ||
+        (!Array.isArray(operator) &&
+            compare(operator, value, comparedAtValue, fieldType));
     try {
         // Open the file for reading.
         fileHandle = await open(filePath, "r");
@@ -415,18 +536,19 @@ export const search = async (filePath, operator, comparedAtValue, logicalOperato
         for await (const line of rl) {
             // Increment the line count for each line.
             linesCount++;
+            // Search only in provided linesNumbers
+            if (searchIn?.size &&
+                (!searchIn.has(linesCount) || searchIn.has(-linesCount)))
+                continue;
             // 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) => compare(single_operator, decodedLine, comparedAtValue[index], fieldType))) ||
-                    operator.every((single_operator, index) => compare(single_operator, decodedLine, comparedAtValue[index], fieldType)))) ||
-                (!Array.isArray(operator) &&
-                    compare(operator, decodedLine, comparedAtValue, fieldType));
+            const doesMeetCondition = (Array.isArray(decodedLine) &&
+                !Array.isArray(decodedLine[1]) &&
+                decodedLine.some(meetsConditions)) ||
+                meetsConditions(decodedLine);
             // If the line meets the conditions, process it.
-            if (meetsConditions) {
+            if (doesMeetCondition) {
                 // Increment the found items counter.
                 linesNumbers.add(linesCount);
                 // Check if the line should be skipped based on the offset.
@@ -447,36 +569,14 @@ export const search = async (filePath, operator, comparedAtValue, logicalOperato
             ? [matchingLines, linesNumbers.size, linesNumbers]
             : [null, 0, null];
     }
+    catch {
+        return [null, 0, null];
+    }
     finally {
         // Close the file handle in the finally block to ensure it is closed even if an error occurs.
         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) => {
-    // Number((await exec(`wc -l < ${filePath}`)).stdout.trimEnd());
-    let linesCount = 0;
-    if (await isExists(filePath)) {
-        let fileHandle = null;
-        try {
-            fileHandle = await open(filePath, "r");
-            const rl = createReadLineInternface(filePath, fileHandle);
-            for await (const _ of rl)
-                linesCount++;
-        }
-        finally {
-            await fileHandle?.close();
-        }
-    }
-    return linesCount;
-};
 /**
  * Asynchronously calculates the sum of numerical values from specified lines in a file.
  *