inibase 1.0.0-rc.40 → 1.0.0-rc.43

package/README.md

@@ -84,7 +84,7 @@ Ps: Testing by default with `user` table, with username, email, password fields
     - [x] Pagination
     - [x] Criteria
     - [x] Columns
-    - [ ] Order By
+    - [x] Order By (using UNIX commands)
   - [x] POST
   - [x] PUT
   - [x] DELETE
@@ -109,6 +109,8 @@ Ps: Testing by default with `user` table, with username, email, password fields
 - [ ] TO-DO:
   - [x] Improve caching
   - [x] Commenting the code
+  - [ ] Add Backup feature (generate a tar.gz)
+  - [ ] Add Custom field validation property to schema (using RegEx?)
 - [ ] Features:
   - [ ] Encryption
   - [x] Data Compression

package/dist/file.d.ts

@@ -12,7 +12,7 @@ export declare const read: (filePath: string, disableCompression?: boolean) => P
  */
 export declare const isExists: (path: string) => Promise<boolean>;
 /**
- * Encodes the input using 'secureString' and 'joinMultidimensionalArray' functions.
+ * Encodes the input using 'secureString' and 'Inison.stringify' functions.
  * If the input is an array, it is first secured and then joined into a string.
  * If the input is a single value, it is directly secured.
  *

package/dist/file.js

@@ -2,15 +2,13 @@ import { open, access, writeFile, readFile, constants as fsConstants, unlink, co
 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 { createGzip, createGunzip, gunzipSync, gzipSync } from "node:zlib";
 import { join } from "node:path";
 import { Worker } from "node:worker_threads";
-import { detectFieldType, isArrayOfArrays, isNumber, isObject, isPassword, } from "./utils.js";
-import { encodeID, comparePassword } from "./utils.server.js";
+import { detectFieldType, isJSON, isNumber, isObject } from "./utils.js";
+import { encodeID, compare } from "./utils.server.js";
 import Config from "./config.js";
-const gzip = promisify(gzipAsync);
-const gunzip = promisify(gunzipAsync);
+import Inison from "inison";
 export const lock = async (folderPath, prefix) => {
     let lockFile, lockFilePath = join(folderPath, `${prefix ?? ""}.locked`);
     try {
@@ -33,12 +31,12 @@ export const unlock = async (folderPath, prefix) => {
 };
 export const write = async (filePath, data, disableCompression = false) => {
     await writeFile(filePath, Config.isCompressionEnabled && !disableCompression
-        ? await gzip(String(data))
+        ? gzipSync(String(data))
         : String(data));
 };
 export const read = async (filePath, disableCompression = false) => {
     return Config.isCompressionEnabled && !disableCompression
-        ? (await gunzip(await readFile(filePath))).toString()
+        ? gunzipSync(await readFile(filePath)).toString()
         : (await readFile(filePath)).toString();
 };
 const _pipeline = async (rl, writeStream, transform) => {
@@ -80,7 +78,6 @@ export const isExists = async (path) => {
         return false;
     }
 };
-const delimiters = [",", "|", "&", "$", "#", "@", "^", ":", "!", ";"];
 /**
  * Secures input by encoding/escaping characters.
  *
@@ -99,24 +96,8 @@ const secureString = (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]);
+    return decodedInput.replace(/\\n/g, "\n").replace(/\n/g, "\\n");
 };
 /**
  * Secures each element in an array or a single value using secureString.
@@ -126,33 +107,16 @@ const secureString = (input) => {
  */
 const secureArray = (arr_str) => Array.isArray(arr_str) ? arr_str.map(secureArray) : secureString(arr_str);
 /**
- * Joins elements of a multidimensional array into a string.
- *
- * @param arr - A multidimensional array or a single level array.
- * @param delimiter_index - Index for selecting delimiter, defaults to 0.
- * @returns Joined string of array elements with appropriate delimiters.
- */
-const joinMultidimensionalArray = (arr, delimiter_index = 0) => {
-    delimiter_index++;
-    if (isArrayOfArrays(arr))
-        arr = arr.map((ar) => joinMultidimensionalArray(ar, delimiter_index));
-    delimiter_index--;
-    return arr.join(delimiters[delimiter_index]);
-};
-/**
- * Encodes the input using 'secureString' and 'joinMultidimensionalArray' functions.
+ * Encodes the input using 'secureString' and 'Inison.stringify' functions.
  * If the input is an array, it is first secured and then joined into a string.
  * If the input is a single value, it is directly secured.
  *
  * @param input - A value or array of values (string, number, boolean, null).
  * @returns The secured and/or joined string.
  */
-export const encode = (input) => {
-    // Use the optimized secureArray and joinMultidimensionalArray functions.
-    return Array.isArray(input)
-        ? joinMultidimensionalArray(secureArray(input))
-        : secureString(input);
-};
+export const encode = (input) => Array.isArray(input)
+    ? Inison.stringify(secureArray(input))
+    : secureString(input);
 /**
  * Decodes each element in an array or a single value using unSecureString.
  *
@@ -167,44 +131,11 @@ const unSecureArray = (arr_str) => Array.isArray(arr_str) ? arr_str.map(unSecure
  * @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.
-    const decodedString = input.replace(/%(2C|7C|26|24|23|40|5E|3A|21|3B|\\n|\\r)/g, (match) => replacements[match]) || null;
-    if (decodedString === null)
-        return null;
-    return isNumber(decodedString) ? Number(decodedString) : decodedString;
-};
-/**
- * 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.
- *
- * @param joinedString - A string, array, or multidimensional array.
- * @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));
-    // Apply delimiters recursively to reconstruct the original array structure.
-    return availableDelimiters.reduce((acc, delimiter) => reverseJoinMultidimensionalArrayHelper(acc, delimiter), joinedString);
+    if (isNumber(input))
+        return Number(input);
+    if (typeof input === "string")
+        return input.replace(/\n/g, "\\n") || null;
+    return null;
 };
 /**
  * Decodes a value based on specified field types and optional secret key.
@@ -220,8 +151,6 @@ const decodeHelper = (value, fieldType, fieldChildrenType, secretKey) => {
     if (Array.isArray(value) && fieldType !== "array")
         return value.map((v) => decodeHelper(v, fieldType, fieldChildrenType, secretKey));
     switch (fieldType) {
-        case "json":
-            return JSON.parse(value);
         case "number":
             return isNumber(value) ? Number(value) : null;
         case "boolean":
@@ -264,8 +193,8 @@ export const decode = (input, fieldType, fieldChildrenType, secretKey) => {
         fieldType = detectFieldType(String(input), fieldType);
     // Decode the input using the decodeHelper function.
     return decodeHelper(typeof input === "string"
-        ? input.includes(",")
-            ? unSecureArray(reverseJoinMultidimensionalArray(input))
+        ? isJSON(input)
+            ? Inison.unstringify(input)
             : unSecureString(input)
         : input, fieldType, fieldChildrenType, secretKey);
 };
@@ -442,130 +371,6 @@ export const remove = async (filePath, linesToDelete) => {
     await fileHandle.close();
     return [fileTempPath, filePath];
 };
-/**
- * Evaluates a comparison between two values based on a specified operator and field types.
- *
- * @param operator - The comparison operator (e.g., '=', '!=', '>', '<', '>=', '<=', '[]', '![]', '*', '!*').
- * @param originalValue - The value to compare, can be a single value or an array of values.
- * @param comparedAtValue - The value or values to compare against.
- * @param fieldType - Optional type of the field to guide comparison (e.g., 'password', 'boolean').
- * @param fieldChildrenType - Optional type for child elements in array inputs.
- * @returns boolean - Result of the comparison operation.
- *
- * Note: Handles various data types and comparison logic, including special handling for passwords and regex patterns.
- */
-const handleComparisonOperator = (operator, originalValue, comparedAtValue, fieldType, fieldChildrenType) => {
-    // Determine the field type if it's an array of potential types.
-    if (Array.isArray(fieldType)) {
-        fieldType = detectFieldType(String(originalValue), fieldType);
-    }
-    // Handle comparisons involving arrays.
-    if (Array.isArray(comparedAtValue) && !["[]", "![]"].includes(operator)) {
-        return comparedAtValue.some((comparedAtValueSingle) => handleComparisonOperator(operator, originalValue, comparedAtValueSingle, fieldType));
-    }
-    // Switch statement for different comparison operators.
-    switch (operator) {
-        // Equal (Case Insensitive for strings, specific handling for passwords and booleans).
-        case "=":
-            return isEqual(originalValue, comparedAtValue, fieldType);
-        // Not Equal.
-        case "!=":
-            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 isArrayEqual(originalValue, comparedAtValue);
-        // Array Does Not Contain.
-        case "![]":
-            return !isArrayEqual(originalValue, comparedAtValue);
-        // Wildcard Match (using regex pattern).
-        case "*":
-            return isWildcardMatch(originalValue, comparedAtValue);
-        // Not Wildcard Match.
-        case "!*":
-            return !isWildcardMatch(originalValue, comparedAtValue);
-        // Unsupported operator.
-        default:
-            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 isPassword(originalValue) && 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.
  *
@@ -606,10 +411,10 @@ export const search = async (filePath, operator, comparedAtValue, logicalOperato
             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)))) ||
+                    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) &&
-                    handleComparisonOperator(operator, decodedLine, comparedAtValue, fieldType));
+                    compare(operator, decodedLine, comparedAtValue, fieldType));
             // If the line meets the conditions, process it.
             if (meetsConditions) {
                 // Increment the found items counter.
@@ -796,7 +601,9 @@ export function createWorker(functionName, arg) {
  *
  * Note: The sorting is applied either to the entire file or to the specified lines. Large files are handled in chunks.
  */
-export const sort = async (filePath, sortDirection, lineNumbers, _lineNumbersPerChunk = 100000) => { };
+export const sort = async (filePath, sortDirection, lineNumbers, _lineNumbersPerChunk = 100000) => {
+    // return Number((await exec(`wc -l < ${filePath}`)).stdout.trim());
+};
 export default class File {
     static get = get;
     static remove = remove;

package/dist/index.d.ts

@@ -16,22 +16,22 @@ type FieldStringType = {
     children?: never;
 };
 type FieldStringArrayType = {
-    type: Array<Exclude<FieldType, "array" | "object">>;
+    type: Array<Exclude<FieldType, "object">>;
     children?: never;
 };
 type FieldArrayType = {
     type: "array";
-    children: Exclude<FieldType, "array"> | Exclude<FieldType, "array">[] | Schema;
+    children: Exclude<FieldType, "array"> | Array<Exclude<FieldType, "array">> | Schema;
 };
 type FieldArrayArrayType = {
     type: Array<"array" | Exclude<FieldType, "array" | "object">>;
-    children: Exclude<FieldType, "array" | "object"> | Exclude<FieldType, "array" | "object">[];
+    children: Exclude<FieldType, "array" | "object"> | Array<Exclude<FieldType, "array" | "object">>;
 };
 type FieldObjectType = {
     type: "object";
     children: Schema;
 };
-export type Field = FieldDefault & (FieldStringType | (FieldStringArrayType & FieldArrayArrayType) | FieldObjectType | FieldArrayType);
+export type Field = FieldDefault & (FieldStringType | FieldStringArrayType | FieldArrayArrayType | FieldObjectType | FieldArrayType);
 export type Schema = Field[];
 export interface Options {
     page?: number;
@@ -69,12 +69,13 @@ export default class Inibase {
     salt: Buffer;
     constructor(database: string, mainFolder?: string, _table?: string | null, _totalItems?: Record<string, number>, _pageInfo?: Record<string, pageInfo>, _isThreadEnabled?: boolean);
     private throwError;
-    createWorker(functionName: "get" | "post" | "put" | "delete" | "sum" | "min" | "max", arg: any[]): Promise<any>;
+    createWorker(functionName: "get" | "post" | "put" | "delete" | "sum" | "min" | "max" | "sort", arg: any[]): Promise<any>;
     private _decodeIdFromSchema;
     private _schemaToIdsPath;
     setTableSchema(tableName: string, schema: Schema): Promise<void>;
     getTableSchema(tableName: string): Promise<Schema | undefined>;
-    getField(keyPath: string, schema: Schema): (FieldDefault & FieldStringType) | (FieldDefault & FieldObjectType) | (FieldDefault & FieldArrayType) | null;
+    isTableEmpty(tableName: string): Promise<never | Schema>;
+    getField(keyPath: string, schema: Schema): Field | null;
     private validateData;
     private formatField;
     private formatData;
@@ -89,8 +90,8 @@ export default class Inibase {
     private applyCriteria;
     private _filterSchemaByColumns;
     clearCache(tablePath: string): Promise<void>;
-    get(tableName: string, where?: string | number | (string | number)[] | Criteria | undefined, options?: Options | undefined, onlyOne?: true, onlyLinesNumbers?: undefined, tableSchema?: Schema): Promise<Data | null>;
-    get(tableName: string, where?: string | number | (string | number)[] | Criteria | undefined, options?: Options | undefined, onlyOne?: boolean | undefined, onlyLinesNumbers?: true, tableSchema?: Schema): Promise<number[] | null>;
+    get(tableName: string, where?: string | number | (string | number)[] | Criteria | undefined, options?: Options | undefined, onlyOne?: true, onlyLinesNumbers?: undefined, tableSchema?: Schema, skipIdColumn?: boolean): Promise<Data | null>;
+    get(tableName: string, where?: string | number | (string | number)[] | Criteria | undefined, options?: Options | undefined, onlyOne?: boolean | undefined, onlyLinesNumbers?: true, tableSchema?: Schema, skipIdColumn?: boolean): Promise<number[]>;
     post(tableName: string, data: Data | Data[], options?: Options, returnPostedData?: boolean): Promise<void | null>;
     post(tableName: string, data: Data, options: Options | undefined, returnPostedData: true): Promise<Data | null>;
     post(tableName: string, data: Data[], options: Options | undefined, returnPostedData: true): Promise<Data[] | null>;
@@ -105,5 +106,6 @@ export default class Inibase {
     max(tableName: string, columns: string[], where?: number | string | (number | string)[] | Criteria): Promise<Record<string, number>>;
     min(tableName: string, columns: string, where?: number | string | (number | string)[] | Criteria): Promise<number>;
     min(tableName: string, columns: string[], where?: number | string | (number | string)[] | Criteria): Promise<Record<string, number>>;
+    sort(tableName: string, columns: string | string[] | Record<string, 1 | -1 | "asc" | "ASC" | "desc" | "DESC">, where?: string | number | (string | number)[] | Criteria, options?: Options): Promise<any[]>;
 }
 export {};

package/dist/index.js

@@ -1,6 +1,6 @@
 import { unlink, rename, mkdir, readdir } from "node:fs/promises";
 import { existsSync, appendFileSync } from "node:fs";
-import { join } from "node:path";
+import { join, parse } from "node:path";
 import { scryptSync, randomBytes } from "node:crypto";
 import { Worker } from "node:worker_threads";
 import File from "./file.js";
@@ -8,6 +8,7 @@ import Utils from "./utils.js";
 import UtilsServer from "./utils.server.js";
 import Config from "./config.js";
 import { inspect } from "node:util";
+import Inison from "inison";
 export default class Inibase {
     folder;
     database;
@@ -146,6 +147,14 @@ export default class Inibase {
             },
         ];
     }
+    async isTableEmpty(tableName) {
+        const schema = await this.getTableSchema(tableName), tablePath = join(this.folder, this.database, tableName);
+        if (!schema)
+            throw this.throwError("NO_SCHEMA", tableName);
+        if (!(await File.isExists(join(tablePath, "id.inib"))))
+            throw this.throwError("NO_ITEMS", tableName);
+        return schema;
+    }
     getField(keyPath, schema) {
         let RETURN = null;
         const keyPathSplited = keyPath.split(".");
@@ -182,7 +191,7 @@ export default class Inibase {
                         : undefined))
                     throw this.throwError("INVALID_TYPE", [
                         field.key,
-                        field.type,
+                        Array.isArray(field.type) ? field.type.join(", ") : field.type,
                         typeof data[field.key],
                     ]);
                 if ((field.type === "array" || field.type === "object") &&
@@ -265,7 +274,7 @@ export default class Inibase {
                     ? value
                     : UtilsServer.decodeID(value, this.salt);
             case "json":
-                return JSON.stringify(value);
+                return Inison.stringify(value);
             default:
                 return value;
         }
@@ -653,25 +662,23 @@ export default class Inibase {
     async get(tableName, where, options = {
         page: 1,
         perPage: 15,
-    }, onlyOne, onlyLinesNumbers, tableSchema) {
+    }, onlyOne, onlyLinesNumbers, tableSchema, skipIdColumn) {
         const tablePath = join(this.folder, this.database, tableName);
         // Ensure options.columns is an array
         if (options.columns) {
             options.columns = Array.isArray(options.columns)
                 ? options.columns
                 : [options.columns];
-            if (options.columns.length && !options.columns.includes("id"))
+            if (!skipIdColumn &&
+                options.columns.length &&
+                !options.columns.includes("id"))
                 options.columns.push("id");
         }
         // Default values for page and perPage
         options.page = options.page || 1;
         options.perPage = options.perPage || 15;
         let RETURN;
-        let schema = tableSchema ?? (await this.getTableSchema(tableName));
-        if (!schema)
-            throw this.throwError("NO_SCHEMA", tableName);
-        if (!(await File.isExists(join(tablePath, "id.inib"))))
-            return null;
+        let schema = tableSchema ?? (await this.isTableEmpty(tableName));
         if (options.columns && options.columns.length)
             schema = this._filterSchemaByColumns(schema, options.columns);
         if (!where) {
@@ -692,21 +699,22 @@ export default class Inibase {
             }
         }
         else if ((Array.isArray(where) && where.every(Utils.isNumber)) ||
-            (Utils.isNumber(where) && !onlyLinesNumbers)) {
-            // "where" in this case, is the lineNumbers instead of IDs
+            Utils.isNumber(where)) {
+            // "where" in this case, is the line(s) number(s) and not id(s)
             let lineNumbers = where;
             if (!Array.isArray(lineNumbers))
                 lineNumbers = [lineNumbers];
+            // useless
+            if (onlyLinesNumbers)
+                return lineNumbers;
             RETURN = Object.values((await this.getItemsFromSchema(tableName, schema, lineNumbers, options)) ?? {});
             if (!this.totalItems[tableName + "-*"])
                 this.totalItems[tableName + "-*"] = lineNumbers.length;
             if (RETURN && RETURN.length && !Array.isArray(where))
                 RETURN = RETURN[0];
         }
-        else if ((Array.isArray(where) &&
-            (where.every(Utils.isValidID) || where.every(Utils.isNumber))) ||
-            Utils.isValidID(where) ||
-            Utils.isNumber(where)) {
+        else if ((Array.isArray(where) && where.every(Utils.isValidID)) ||
+            Utils.isValidID(where)) {
             let Ids = where;
             if (!Array.isArray(Ids))
                 Ids = [Ids];
@@ -772,13 +780,12 @@ export default class Inibase {
                 page: 1,
                 perPage: 15,
             };
-        const tablePath = join(this.folder, this.database, tableName);
+        const tablePath = join(this.folder, this.database, tableName), schema = await this.getTableSchema(tableName);
+        if (!schema)
+            throw this.throwError("NO_SCHEMA", tableName);
         if (!returnPostedData)
             returnPostedData = false;
-        const schema = await this.getTableSchema(tableName);
         let RETURN;
-        if (!schema)
-            throw this.throwError("NO_SCHEMA", tableName);
         const keys = UtilsServer.hashString(Object.keys(Array.isArray(data) ? data[0] : data).join("."));
         let lastId = 0, totalItems = 0, renameList = [];
         try {
@@ -824,7 +831,13 @@ export default class Inibase {
                 await File.write(join(tablePath, ".cache", "pagination.inib"), `${lastId},${totalItems + (Array.isArray(RETURN) ? RETURN.length : 1)}`, true);
             }
             if (returnPostedData)
-                return this.get(tableName, Array.isArray(RETURN) ? RETURN.map((_, index) => index + 1) : 1, options, !Utils.isArrayOfObjects(data), // return only one item if data is not array of objects
+                return this.get(tableName, Config.isReverseEnabled
+                    ? Array.isArray(RETURN)
+                        ? RETURN.map((_, index) => index + 1)
+                        : 1
+                    : Array.isArray(RETURN)
+                        ? RETURN.map((_, index) => totalItems - index)
+                        : totalItems, options, !Utils.isArrayOfObjects(data), // return only one item if data is not array of objects
                 undefined, schema);
         }
         finally {
@@ -838,25 +851,20 @@ export default class Inibase {
         perPage: 15,
     }, returnPostedData) {
         let renameList = [];
-        const tablePath = join(this.folder, this.database, tableName);
-        const schema = await this.getTableSchema(tableName);
-        if (!schema)
-            throw this.throwError("NO_SCHEMA", tableName);
-        if (!(await File.isExists(join(tablePath, "id.inib"))))
-            throw this.throwError("NO_ITEMS", tableName);
+        const tablePath = join(this.folder, this.database, tableName), schema = await this.isTableEmpty(tableName);
         data = this.formatData(data, schema, true);
         if (!where) {
             if (Utils.isArrayOfObjects(data)) {
                 if (!data.every((item) => item.hasOwnProperty("id") && Utils.isValidID(item.id)))
                     throw this.throwError("INVALID_ID");
                 return this.put(tableName, data, data
-                    .filter((item) => item.id !== undefined)
-                    .map((item) => item.id));
+                    .filter(({ id }) => id !== undefined)
+                    .map(({ id }) => id));
             }
             else if (data.hasOwnProperty("id")) {
                 if (!Utils.isValidID(data.id))
                     throw this.throwError("INVALID_ID", data.id);
-                return this.put(tableName, data, UtilsServer.decodeID(data.id, this.salt));
+                return this.put(tableName, data, data.id);
             }
             else {
                 let totalItems;
@@ -896,56 +904,49 @@ export default class Inibase {
                 }
             }
         }
-        else if ((Array.isArray(where) &&
-            (where.every(Utils.isValidID) || where.every(Utils.isNumber))) ||
-            Utils.isValidID(where) ||
+        else if ((Array.isArray(where) && where.every(Utils.isValidID)) ||
+            Utils.isValidID(where)) {
+            const lineNumbers = await this.get(tableName, where, undefined, undefined, true, schema);
+            return this.put(tableName, data, lineNumbers);
+        }
+        else if ((Array.isArray(where) && where.every(Utils.isNumber)) ||
             Utils.isNumber(where)) {
-            if ((Array.isArray(where) && where.every(Utils.isValidID)) ||
-                Utils.isValidID(where)) {
-                const lineNumbers = await this.get(tableName, where, undefined, undefined, true, schema);
-                return this.put(tableName, data, lineNumbers);
+            // "where" in this case, is the line(s) number(s) and not id(s)
+            const pathesContents = Object.fromEntries(Object.entries(this.joinPathesContents(tablePath, Utils.isArrayOfObjects(data)
+                ? data.map((item) => ({
+                    ...item,
+                    updatedAt: Date.now(),
+                }))
+                : { ...data, updatedAt: Date.now() })).map(([path, content]) => [
+                path,
+                [...(Array.isArray(where) ? where : [where])].reduce((obj, lineNum, index) => ({
+                    ...obj,
+                    [lineNum]: Array.isArray(content) ? content[index] : content,
+                }), {}),
+            ]));
+            const keys = UtilsServer.hashString(Object.keys(pathesContents)
+                .map((path) => path.replaceAll(".inib", ""))
+                .join("."));
+            try {
+                await File.lock(join(tablePath, ".tmp"), keys);
+                await Promise.all(Object.entries(pathesContents).map(async ([path, content]) => renameList.push(this.isThreadEnabled
+                    ? await File.createWorker("replace", [path, content])
+                    : await File.replace(path, content))));
+                await Promise.all(renameList.map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
+                renameList = [];
+                if (Config.isCacheEnabled)
+                    await this.clearCache(tablePath);
+                if (returnPostedData)
+                    return this.get(tableName, where, options, !Array.isArray(where), undefined, schema);
             }
-            else if ((Array.isArray(where) && where.every(Utils.isNumber)) ||
-                Utils.isNumber(where)) {
-                // "where" in this case, is the line(s) number(s) and not id(s)
-                const pathesContents = Object.fromEntries(Object.entries(this.joinPathesContents(tablePath, Utils.isArrayOfObjects(data)
-                    ? data.map((item) => ({
-                        ...item,
-                        updatedAt: Date.now(),
-                    }))
-                    : { ...data, updatedAt: Date.now() })).map(([path, content]) => [
-                    path,
-                    [...(Array.isArray(where) ? where : [where])].reduce((obj, lineNum, index) => ({
-                        ...obj,
-                        [lineNum]: Array.isArray(content) ? content[index] : content,
-                    }), {}),
-                ]));
-                const keys = UtilsServer.hashString(Object.keys(pathesContents)
-                    .map((path) => path.replaceAll(".inib", ""))
-                    .join("."));
-                try {
-                    await File.lock(join(tablePath, ".tmp"), keys);
-                    await Promise.all(Object.entries(pathesContents).map(async ([path, content]) => renameList.push(this.isThreadEnabled
-                        ? await File.createWorker("replace", [path, content])
-                        : await File.replace(path, content))));
-                    await Promise.all(renameList.map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
-                    renameList = [];
-                    if (Config.isCacheEnabled)
-                        await this.clearCache(tablePath);
-                    if (returnPostedData)
-                        return this.get(tableName, where, options, !Array.isArray(where), undefined, schema);
-                }
-                finally {
-                    if (renameList.length)
-                        await Promise.allSettled(renameList.map(async ([tempPath, _]) => unlink(tempPath)));
-                    await File.unlock(join(tablePath, ".tmp"), keys);
-                }
+            finally {
+                if (renameList.length)
+                    await Promise.allSettled(renameList.map(async ([tempPath, _]) => unlink(tempPath)));
+                await File.unlock(join(tablePath, ".tmp"), keys);
             }
         }
         else if (Utils.isObject(where)) {
             const lineNumbers = await this.get(tableName, where, undefined, undefined, true, schema);
-            if (!lineNumbers || !lineNumbers.length)
-                throw this.throwError("NO_RESULTS", tableName);
             return this.put(tableName, data, lineNumbers);
         }
         else
@@ -953,12 +954,7 @@ export default class Inibase {
     }
     async delete(tableName, where, _id) {
         let renameList = [];
-        const tablePath = join(this.folder, this.database, tableName);
-        const schema = await this.getTableSchema(tableName);
-        if (!schema)
-            throw this.throwError("NO_SCHEMA", tableName);
-        if (!(await File.isExists(join(tablePath, "id.inib"))))
-            throw this.throwError("NO_ITEMS", tableName);
+        const tablePath = join(this.folder, this.database, tableName), schema = await this.isTableEmpty(tableName);
         if (!where) {
             try {
                 await File.lock(join(tablePath, ".tmp"));
@@ -973,58 +969,49 @@ export default class Inibase {
             }
             return "*";
         }
-        else if ((Array.isArray(where) &&
-            (where.every(Utils.isValidID) || where.every(Utils.isNumber))) ||
-            Utils.isValidID(where) ||
+        else if ((Array.isArray(where) && where.every(Utils.isValidID)) ||
+            Utils.isValidID(where)) {
+            const lineNumbers = await this.get(tableName, where, undefined, undefined, true, schema);
+            return this.delete(tableName, lineNumbers, where);
+        }
+        else if ((Array.isArray(where) && where.every(Utils.isNumber)) ||
             Utils.isNumber(where)) {
-            if ((Array.isArray(where) && where.every(Utils.isValidID)) ||
-                Utils.isValidID(where)) {
-                const lineNumbers = await this.get(tableName, where, undefined, undefined, true, schema);
-                if (!lineNumbers)
-                    return null;
-                return this.delete(tableName, lineNumbers, where);
-            }
-            else if ((Array.isArray(where) && where.every(Utils.isNumber)) ||
-                Utils.isNumber(where)) {
-                // "where" in this case, is the line(s) number(s) and not id(s)
-                const files = (await readdir(tablePath))?.filter((fileName) => fileName.endsWith(".inib"));
-                if (files.length) {
-                    if (!_id)
-                        _id = Object.entries((await File.get(join(tablePath, "id.inib"), where, "number", undefined, this.salt)) ?? {}).map(([_key, id]) => UtilsServer.encodeID(Number(id), this.salt));
-                    if (!_id.length)
-                        throw this.throwError("NO_RESULTS", tableName);
-                    try {
-                        await File.lock(join(tablePath, ".tmp"));
-                        await Promise.all(files.map(async (file) => renameList.push(this.isThreadEnabled
-                            ? await File.createWorker("remove", [
-                                join(tablePath, file),
-                                where,
-                            ])
-                            : await File.remove(join(tablePath, file), where))));
-                        await Promise.all(renameList.map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
-                        if (Config.isCacheEnabled) {
-                            await this.clearCache(tablePath);
-                            if (await File.isExists(join(tablePath, ".cache", "pagination.inib"))) {
-                                let [lastId, totalItems] = (await File.read(join(tablePath, ".cache", "pagination.inib"), true))
-                                    .split(",")
-                                    .map(Number);
-                                await File.write(join(tablePath, ".cache", "pagination.inib"), `${lastId},${totalItems - (Array.isArray(where) ? where.length : 1)}`, true);
-                            }
+            // "where" in this case, is the line(s) number(s) and not id(s)
+            const files = (await readdir(tablePath))?.filter((fileName) => fileName.endsWith(".inib"));
+            if (files.length) {
+                if (!_id)
+                    _id = Object.entries((await File.get(join(tablePath, "id.inib"), where, "number", undefined, this.salt)) ?? {}).map(([_key, id]) => UtilsServer.encodeID(Number(id), this.salt));
+                if (!_id.length)
+                    throw this.throwError("NO_RESULTS", tableName);
+                try {
+                    await File.lock(join(tablePath, ".tmp"));
+                    await Promise.all(files.map(async (file) => renameList.push(this.isThreadEnabled
+                        ? await File.createWorker("remove", [
+                            join(tablePath, file),
+                            where,
+                        ])
+                        : await File.remove(join(tablePath, file), where))));
+                    await Promise.all(renameList.map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
+                    if (Config.isCacheEnabled) {
+                        await this.clearCache(tablePath);
+                        if (await File.isExists(join(tablePath, ".cache", "pagination.inib"))) {
+                            let [lastId, totalItems] = (await File.read(join(tablePath, ".cache", "pagination.inib"), true))
+                                .split(",")
+                                .map(Number);
+                            await File.write(join(tablePath, ".cache", "pagination.inib"), `${lastId},${totalItems - (Array.isArray(where) ? where.length : 1)}`, true);
                         }
-                        return Array.isArray(_id) && _id.length === 1 ? _id[0] : _id;
-                    }
-                    finally {
-                        if (renameList.length)
-                            await Promise.allSettled(renameList.map(async ([tempPath, _]) => unlink(tempPath)));
-                        await File.unlock(join(tablePath, ".tmp"));
                     }
+                    return Array.isArray(_id) && _id.length === 1 ? _id[0] : _id;
+                }
+                finally {
+                    if (renameList.length)
+                        await Promise.allSettled(renameList.map(async ([tempPath, _]) => unlink(tempPath)));
+                    await File.unlock(join(tablePath, ".tmp"));
                 }
             }
         }
         else if (Utils.isObject(where)) {
             const lineNumbers = await this.get(tableName, where, undefined, undefined, true, schema);
-            if (!lineNumbers || !lineNumbers.length)
-                throw this.throwError("NO_RESULTS", tableName);
             return this.delete(tableName, lineNumbers);
         }
         else
@@ -1033,11 +1020,7 @@ export default class Inibase {
     }
     async sum(tableName, columns, where) {
         let RETURN = {};
-        const tablePath = join(this.folder, this.database, tableName), schema = await this.getTableSchema(tableName);
-        if (!schema)
-            throw this.throwError("NO_SCHEMA", tableName);
-        if (!(await File.isExists(join(tablePath, "id.inib"))))
-            throw this.throwError("NO_ITEMS", tableName);
+        const tablePath = join(this.folder, this.database, tableName), schema = await this.isTableEmpty(tableName);
         if (!Array.isArray(columns))
             columns = [columns];
         for await (const column of columns) {
@@ -1057,11 +1040,7 @@ export default class Inibase {
     }
     async max(tableName, columns, where) {
         let RETURN = {};
-        const tablePath = join(this.folder, this.database, tableName), schema = await this.getTableSchema(tableName);
-        if (!schema)
-            throw this.throwError("NO_SCHEMA", tableName);
-        if (!(await File.isExists(join(tablePath, "id.inib"))))
-            throw this.throwError("NO_ITEMS", tableName);
+        const tablePath = join(this.folder, this.database, tableName), schema = await this.isTableEmpty(tableName);
         if (!Array.isArray(columns))
             columns = [columns];
         for await (const column of columns) {
@@ -1081,11 +1060,7 @@ export default class Inibase {
     }
     async min(tableName, columns, where) {
         let RETURN = {};
-        const tablePath = join(this.folder, this.database, tableName), schema = await this.getTableSchema(tableName);
-        if (!schema)
-            throw this.throwError("NO_SCHEMA", tableName);
-        if (!(await File.isExists(join(tablePath, "id.inib"))))
-            throw this.throwError("NO_ITEMS", tableName);
+        const tablePath = join(this.folder, this.database, tableName), schema = await this.isTableEmpty(tableName);
         if (!Array.isArray(columns))
             columns = [columns];
         for await (const column of columns) {
@@ -1103,4 +1078,101 @@ export default class Inibase {
         }
         return RETURN;
     }
+    async sort(tableName, columns, where, options = {
+        page: 1,
+        perPage: 15,
+    }) {
+        // TO-DO: Cache Results based on "Columns and Sort Direction"
+        const tablePath = join(this.folder, this.database, tableName), schema = await this.isTableEmpty(tableName);
+        // Default values for page and perPage
+        options.page = options.page || 1;
+        options.perPage = options.perPage || 15;
+        let sortArray, isLineNumbers = true, keepItems = [];
+        if (Utils.isObject(columns) && !Array.isArray(columns)) {
+            // {name: "ASC", age: "DESC"}
+            sortArray = Object.entries(columns).map(([key, value]) => [
+                key,
+                typeof value === "string" ? value.toLowerCase() === "asc" : value > 0,
+            ]);
+        }
+        else {
+            if (!Array.isArray(columns))
+                columns = [columns];
+            sortArray = columns.map((column) => [column, true]);
+        }
+        let cacheKey = "";
+        // Criteria
+        if (Config.isCacheEnabled)
+            cacheKey = UtilsServer.hashString(inspect(sortArray, { sorted: true }));
+        if (where) {
+            let lineNumbers = await this.get(tableName, where, undefined, undefined, true, schema);
+            keepItems = Object.values((await File.get(join(tablePath, "id.inib"), lineNumbers, "number", undefined, this.salt)) ?? {}).map(Number);
+            isLineNumbers = false;
+            if (!keepItems.length)
+                throw this.throwError("NO_RESULTS", tableName);
+            keepItems = keepItems.slice((options.page - 1) * options.perPage, options.page * options.perPage);
+        }
+        if (!keepItems.length)
+            keepItems = Array.from({ length: options.perPage }, (_, index) => (options.page - 1) * options.perPage +
+                index +
+                1);
+        const filesPathes = [["id", true], ...sortArray].map((column) => join(tablePath, `${column[0]}.inib`));
+        // Construct the paste command to merge files and filter lines by IDs
+        const pasteCommand = `paste ${filesPathes.join(" ")}`;
+        // Construct the sort command dynamically based on the number of files for sorting
+        let index = 2;
+        const sortColumns = sortArray
+            .map(([key, ascending], i) => {
+            const field = this.getField(key, schema);
+            if (field)
+                return `-k${i + index},${i + index}${field.type === "number" ? "n" : ""}${!ascending ? "r" : ""}`;
+            else
+                return "";
+        })
+            .join(" ");
+        const sortCommand = `sort ${sortColumns}`;
+        // Construct the awk command to keep only the specified lines after sorting
+        const awkCommand = isLineNumbers
+            ? `awk '${keepItems.map((line) => `NR==${line}`).join(" || ")}'`
+            : `awk 'NR==${keepItems[0]}${keepItems
+                .map((num) => `||NR==${num}`)
+                .join("")}'`;
+        try {
+            if (cacheKey)
+                await File.lock(join(tablePath, ".tmp"), cacheKey);
+            // Combine the commands
+            // Execute the command synchronously
+            const { stdout, stderr } = await UtilsServer.exec(Config.isCacheEnabled
+                ? (await File.isExists(join(tablePath, ".cache", `${cacheKey}.inib`)))
+                    ? `${awkCommand} ${join(tablePath, ".cache", `${cacheKey}.inib`)}`
+                    : `${pasteCommand} | ${sortCommand} -o ${join(tablePath, ".cache", `${cacheKey}.inib`)} && ${awkCommand} ${join(tablePath, ".cache", `${cacheKey}.inib`)}`
+                : `${pasteCommand} | ${sortCommand} | ${awkCommand}`, {
+                encoding: "utf-8",
+            });
+            // Parse the result and extract the specified lines
+            const lines = stdout.trim().split("\n");
+            const outputArray = lines.map((line) => {
+                const splitedFileColumns = line.split("\t"); // Assuming tab-separated columns
+                const outputObject = {};
+                // Extract values for each file, including "id.inib"
+                filesPathes.forEach((fileName, index) => {
+                    const Field = this.getField(parse(fileName).name, schema);
+                    if (Field)
+                        outputObject[Field.key] = File.decode(splitedFileColumns[index], Field?.type, Field?.children, this.salt);
+                });
+                return outputObject;
+            });
+            const restOfColumns = await this.get(tableName, outputArray.map(({ id }) => id), options, undefined, undefined, schema, true);
+            return restOfColumns
+                ? outputArray.map((item, index) => ({
+                    ...item,
+                    ...restOfColumns[index],
+                }))
+                : outputArray;
+        }
+        finally {
+            if (cacheKey)
+                await File.unlock(join(tablePath, ".tmp"), cacheKey);
+        }
+    }
 }

package/dist/utils.d.ts

@@ -142,6 +142,13 @@ export declare const isDate: (input: any) => boolean;
  * @returns A boolean indicating whether the input is a string representing a valid ID of length 32.
  */
 export declare const isValidID: (input: any) => input is string;
+/**
+ * Checks if a given string is a valid JSON.
+ *
+ * @param {string} str - The string to be checked.
+ * @returns {boolean} Returns true if the string is valid JSON, otherwise false.
+ */
+export declare const isJSON: (str: string) => boolean;
 /**
  * Identifies and returns properties that have changed between two objects.
  *
@@ -171,6 +178,8 @@ export declare function FormatObjectCriteriaValue(value: string, isParentArray?:
     ComparisonOperator,
     string | number | boolean | null | (string | number | null)[]
 ];
+type ValidKey = number | string;
+export declare const swapKeyValue: <K extends ValidKey, V extends ValidKey>(object: Record<K, V>) => Record<V, K>;
 export default class Utils {
     static isNumber: (input: any) => input is number;
     static isObject: (obj: any) => obj is Record<any, any>;
@@ -192,4 +201,6 @@ export default class Utils {
     static validateFieldType: (value: any, fieldType: FieldType | FieldType[], fieldChildrenType?: FieldType | FieldType[] | undefined) => boolean;
     static isArrayOfNulls: (input: any) => input is null[] | null[][];
     static FormatObjectCriteriaValue: typeof FormatObjectCriteriaValue;
+    static swapKeyValue: <K extends ValidKey, V extends ValidKey>(object: Record<K, V>) => Record<V, K>;
 }
+export {};

package/dist/utils.js

@@ -216,18 +216,7 @@ export const isValidID = (input) => {
  * @param {string} str - The string to be checked.
  * @returns {boolean} Returns true if the string is valid JSON, otherwise false.
  */
-function isJSON(str) {
-    try {
-        // Attempt to parse the string as JSON
-        JSON.parse(str);
-        // If parsing succeeds, return true
-        return true;
-    }
-    catch (error) {
-        // If an error occurs during parsing, return false
-        return false;
-    }
-}
+export const isJSON = (str) => str[0] === "{" || str[0] === "[";
 /**
  * Identifies and returns properties that have changed between two objects.
  *
@@ -302,7 +291,7 @@ export const validateFieldType = (value, fieldType, fieldChildrenType) => {
     if (Array.isArray(fieldType))
         return detectFieldType(value, fieldType) !== undefined;
     if (fieldType === "array" && fieldChildrenType && Array.isArray(value))
-        return value.some((v) => detectFieldType(v, Array.isArray(fieldChildrenType)
+        return value.every((v) => detectFieldType(v, Array.isArray(fieldChildrenType)
             ? fieldChildrenType
             : [fieldChildrenType]) !== undefined);
     switch (fieldType) {
@@ -403,6 +392,7 @@ export function FormatObjectCriteriaValue(value, isParentArray = false) {
             return ["=", value];
     }
 }
+export const swapKeyValue = (object) => Object.entries(object).reduce((swapped, [key, value]) => ({ ...swapped, [value]: key }), {});
 export default class Utils {
     static isNumber = isNumber;
     static isObject = isObject;
@@ -424,4 +414,5 @@ export default class Utils {
     static validateFieldType = validateFieldType;
     static isArrayOfNulls = isArrayOfNulls;
     static FormatObjectCriteriaValue = FormatObjectCriteriaValue;
+    static swapKeyValue = swapKeyValue;
 }

package/dist/utils.server.d.ts

@@ -1,5 +1,8 @@
 /// <reference types="node" resolution-mode="require"/>
-import { type Schema } from "./index.js";
+/// <reference types="node" resolution-mode="require"/>
+import type { ComparisonOperator, FieldType, Schema } from "./index.js";
+import { exec as execAsync } from "node:child_process";
+export declare const exec: typeof execAsync.__promisify__;
 /**
  * Generates a hashed password using SHA-256.
  *
@@ -48,56 +51,57 @@ export declare const findLastIdNumber: (schema: Schema, secretKeyOrSalt: string
  * @param encodeIDs - If true, IDs will be encoded, else they will remain as numbers.
  * @returns The updated schema with encoded IDs.
  */
-export declare const addIdToSchema: (schema: Schema, oldIndex: number | undefined, secretKeyOrSalt: string | number | Buffer, encodeIDs?: boolean) => (({
-    id?: string | number | undefined;
-    key: string;
-    required?: boolean | undefined;
-} & {
-    type: "string" | "number" | "boolean" | "id" | "url" | "html" | "table" | "email" | "json" | "date" | "password" | "ip";
-    children?: undefined;
-}) | ({
-    id?: string | number | undefined;
-    key: string;
-    required?: boolean | undefined;
-} & {
-    type: "object";
-    children: Schema;
-}) | ({
-    id?: string | number | undefined;
-    key: string;
-    required?: boolean | undefined;
-} & {
-    type: "array";
-    children: "string" | "number" | "boolean" | "object" | "id" | "url" | "html" | "table" | "email" | "json" | "date" | "password" | "ip" | Schema | ("string" | "number" | "boolean" | "object" | "id" | "url" | "html" | "table" | "email" | "json" | "date" | "password" | "ip")[];
-}))[];
+export declare const addIdToSchema: (schema: Schema, oldIndex: number | undefined, secretKeyOrSalt: string | number | Buffer, encodeIDs?: boolean) => import("./index.js").Field[];
 export declare const hashString: (str: string) => string;
+/**
+ * Evaluates a comparison between two values based on a specified operator and field types.
+ *
+ * @param operator - The comparison operator (e.g., '=', '!=', '>', '<', '>=', '<=', '[]', '![]', '*', '!*').
+ * @param originalValue - The value to compare, can be a single value or an array of values.
+ * @param comparedAtValue - The value or values to compare against.
+ * @param fieldType - Optional type of the field to guide comparison (e.g., 'password', 'boolean').
+ * @param fieldChildrenType - Optional type for child elements in array inputs.
+ * @returns boolean - Result of the comparison operation.
+ *
+ * Note: Handles various data types and comparison logic, including special handling for passwords and regex patterns.
+ */
+export declare const compare: (operator: ComparisonOperator, originalValue: string | number | boolean | null | (string | number | boolean | null)[], comparedAtValue: string | number | boolean | null | (string | number | boolean | null)[], fieldType?: FieldType | FieldType[], fieldChildrenType?: FieldType | FieldType[]) => boolean;
+/**
+ * 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.
+ */
+export declare const isEqual: (originalValue: string | number | boolean | null | (string | number | boolean | null)[], comparedAtValue: string | number | boolean | null | (string | number | boolean | null)[], fieldType?: FieldType | FieldType[]) => boolean;
+/**
+ * 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.
+ */
+export declare const isArrayEqual: (originalValue: string | number | boolean | null | (string | number | boolean | null)[], comparedAtValue: string | number | boolean | null | (string | number | boolean | null)[]) => boolean;
+/**
+ * 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.
+ */
+export declare const isWildcardMatch: (originalValue: string | number | boolean | null | (string | number | boolean | null)[], comparedAtValue: string | number | boolean | null | (string | number | boolean | null)[]) => boolean;
 export default class UtilsServer {
     static encodeID: (id: string | number, secretKeyOrSalt: string | number | Buffer) => string;
     static decodeID: (input: string, secretKeyOrSalt: string | number | Buffer) => number;
     static hashPassword: (password: string) => string;
     static comparePassword: (hashedPassword: string, inputPassword: string) => boolean;
     static findLastIdNumber: (schema: Schema, secretKeyOrSalt: string | number | Buffer) => number;
-    static addIdToSchema: (schema: Schema, oldIndex: number | undefined, secretKeyOrSalt: string | number | Buffer, encodeIDs?: boolean | undefined) => (({
-        id?: string | number | undefined;
-        key: string;
-        required?: boolean | undefined;
-    } & {
-        type: "string" | "number" | "boolean" | "id" | "url" | "html" | "table" | "email" | "json" | "date" | "password" | "ip";
-        children?: undefined;
-    }) | ({
-        id?: string | number | undefined;
-        key: string;
-        required?: boolean | undefined;
-    } & {
-        type: "object";
-        children: Schema;
-    }) | ({
-        id?: string | number | undefined;
-        key: string;
-        required?: boolean | undefined;
-    } & {
-        type: "array";
-        children: "string" | "number" | "boolean" | "object" | "id" | "url" | "html" | "table" | "email" | "json" | "date" | "password" | "ip" | Schema | ("string" | "number" | "boolean" | "object" | "id" | "url" | "html" | "table" | "email" | "json" | "date" | "password" | "ip")[];
-    }))[];
+    static addIdToSchema: (schema: Schema, oldIndex: number | undefined, secretKeyOrSalt: string | number | Buffer, encodeIDs?: boolean | undefined) => import("./index.js").Field[];
     static hashString: (str: string) => string;
+    static exec: typeof execAsync.__promisify__;
+    static compare: (operator: ComparisonOperator, originalValue: string | number | boolean | (string | number | boolean | null)[] | null, comparedAtValue: string | number | boolean | (string | number | boolean | null)[] | null, fieldType?: FieldType | FieldType[] | undefined, fieldChildrenType?: FieldType | FieldType[] | undefined) => boolean;
+    static isEqual: (originalValue: string | number | boolean | (string | number | boolean | null)[] | null, comparedAtValue: string | number | boolean | (string | number | boolean | null)[] | null, fieldType?: FieldType | FieldType[] | undefined) => boolean;
+    static isArrayEqual: (originalValue: string | number | boolean | (string | number | boolean | null)[] | null, comparedAtValue: string | number | boolean | (string | number | boolean | null)[] | null) => boolean;
+    static isWildcardMatch: (originalValue: string | number | boolean | (string | number | boolean | null)[] | null, comparedAtValue: string | number | boolean | (string | number | boolean | null)[] | null) => boolean;
 }

package/dist/utils.server.js

@@ -1,5 +1,8 @@
 import { createCipheriv, createDecipheriv, randomBytes, scryptSync, createHash, } from "node:crypto";
-import { isArrayOfObjects, isNumber, isValidID } from "./utils.js";
+import { detectFieldType, isArrayOfObjects, isNumber, isPassword, isValidID, } from "./utils.js";
+import { promisify } from "node:util";
+import { exec as execAsync } from "node:child_process";
+export const exec = promisify(execAsync);
 /**
  * Generates a hashed password using SHA-256.
  *
@@ -111,6 +114,130 @@ export const addIdToSchema = (schema, oldIndex = 0, secretKeyOrSalt, encodeIDs)
     return field;
 });
 export const hashString = (str) => createHash("sha256").update(str).digest("hex");
+/**
+ * Evaluates a comparison between two values based on a specified operator and field types.
+ *
+ * @param operator - The comparison operator (e.g., '=', '!=', '>', '<', '>=', '<=', '[]', '![]', '*', '!*').
+ * @param originalValue - The value to compare, can be a single value or an array of values.
+ * @param comparedAtValue - The value or values to compare against.
+ * @param fieldType - Optional type of the field to guide comparison (e.g., 'password', 'boolean').
+ * @param fieldChildrenType - Optional type for child elements in array inputs.
+ * @returns boolean - Result of the comparison operation.
+ *
+ * Note: Handles various data types and comparison logic, including special handling for passwords and regex patterns.
+ */
+export const compare = (operator, originalValue, comparedAtValue, fieldType, fieldChildrenType) => {
+    // Determine the field type if it's an array of potential types.
+    if (Array.isArray(fieldType)) {
+        fieldType = detectFieldType(String(originalValue), fieldType);
+    }
+    // Handle comparisons involving arrays.
+    if (Array.isArray(comparedAtValue) && !["[]", "![]"].includes(operator)) {
+        return comparedAtValue.some((comparedAtValueSingle) => compare(operator, originalValue, comparedAtValueSingle, fieldType));
+    }
+    // Switch statement for different comparison operators.
+    switch (operator) {
+        // Equal (Case Insensitive for strings, specific handling for passwords and booleans).
+        case "=":
+            return isEqual(originalValue, comparedAtValue, fieldType);
+        // Not Equal.
+        case "!=":
+            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 isArrayEqual(originalValue, comparedAtValue);
+        // Array Does Not Contain.
+        case "![]":
+            return !isArrayEqual(originalValue, comparedAtValue);
+        // Wildcard Match (using regex pattern).
+        case "*":
+            return isWildcardMatch(originalValue, comparedAtValue);
+        // Not Wildcard Match.
+        case "!*":
+            return !isWildcardMatch(originalValue, comparedAtValue);
+        // Unsupported operator.
+        default:
+            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.
+ */
+export const isEqual = (originalValue, comparedAtValue, fieldType) => {
+    // Switch based on the field type for specific handling.
+    switch (fieldType) {
+        // Password comparison.
+        case "password":
+            return isPassword(originalValue) && 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.
+ */
+export 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.
+ */
+export const isWildcardMatch = (originalValue, comparedAtValue) => {
+    const wildcardPattern = `^${(String(comparedAtValue).includes("%")
+        ? String(comparedAtValue)
+        : "%" + String(comparedAtValue) + "%").replace(/%/g, ".*")}$`;
+    return new RegExp(wildcardPattern, "i").test(String(originalValue));
+};
 export default class UtilsServer {
     static encodeID = encodeID;
     static decodeID = decodeID;
@@ -119,4 +246,9 @@ export default class UtilsServer {
     static findLastIdNumber = findLastIdNumber;
     static addIdToSchema = addIdToSchema;
     static hashString = hashString;
+    static exec = exec;
+    static compare = compare;
+    static isEqual = isEqual;
+    static isArrayEqual = isArrayEqual;
+    static isWildcardMatch = isWildcardMatch;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inibase",
-  "version": "1.0.0-rc.40",
+  "version": "1.0.0-rc.43",
   "author": {
     "name": "Karim Amahtil",
     "email": "karim.amahtil@gmail.com"
@@ -53,6 +53,9 @@
   "types": "./dist",
   "typesVersions": {
     "*": {
+      "class": [
+        "./dist/index.d.ts"
+      ],
       "thread": [
         "./dist/index.thread.d.ts"
       ],
@@ -78,6 +81,9 @@
     "tinybench": "^2.6.0",
     "typescript": "^5.3.3"
   },
+  "dependencies": {
+    "inison": "^1.0.0-rc.2"
+  },
   "scripts": {
     "build": "npx tsc",
     "test": "npx tsx watch --expose-gc --env-file=.env ./index.test",