inibase 1.1.4 → 1.1.6

package/README.md

@@ -26,6 +26,7 @@
 
 ```js
 import Inibase from "inibase";
+// const db = new Inibase("databaseName", ".", "es");
 const db = new Inibase("databaseName");
 
 // Get all items from "user" table

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import "dotenv/config";
 export interface Data {
-    id?: number | string;
+    id?: string;
     [key: string]: any;
     createdAt?: number;
     updatedAt?: number;
@@ -50,19 +50,20 @@ declare global {
         entries<T extends object>(o: T): Entries<T>;
     }
 }
-export type ErrorCodes = "FIELD_UNIQUE" | "FIELD_REQUIRED" | "NO_SCHEMA" | "TABLE_EMPTY" | "INVALID_ID" | "INVALID_TYPE" | "INVALID_PARAMETERS" | "NO_ENV" | "TABLE_EXISTS" | "TABLE_NOT_EXISTS" | "INVALID_REGEX_MATCH";
-export type ErrorLang = "en";
+export type ErrorCodes = "GROUP_UNIQUE" | "FIELD_UNIQUE" | "FIELD_REQUIRED" | "NO_SCHEMA" | "TABLE_EMPTY" | "INVALID_ID" | "INVALID_TYPE" | "INVALID_PARAMETERS" | "NO_ENV" | "TABLE_EXISTS" | "TABLE_NOT_EXISTS" | "INVALID_REGEX_MATCH";
+export type ErrorLang = "en" | "ar" | "fr" | "es";
 export default class Inibase {
     pageInfo: Record<string, pageInfo>;
+    language: ErrorLang;
     salt: Buffer;
     private databasePath;
     private fileExtension;
     private tablesMap;
     private uniqueMap;
     private totalItems;
-    constructor(database: string, mainFolder?: string);
+    constructor(database: string, mainFolder?: string, language?: ErrorLang);
     private static errorMessages;
-    createError(name: ErrorCodes, variable?: string | number | (string | number)[], language?: ErrorLang): Error;
+    createError(name: ErrorCodes, variable?: string | number | (string | number)[]): Error;
     clear(): void;
     private getFileExtension;
     private _schemaToIdsPath;

package/dist/index.js

@@ -12,15 +12,17 @@ import * as UtilsServer from "./utils.server.js";
 process.removeAllListeners("warning");
 export default class Inibase {
     pageInfo;
+    language;
     salt;
     databasePath;
     fileExtension = ".txt";
     tablesMap;
     uniqueMap;
     totalItems;
-    constructor(database, mainFolder = ".") {
+    constructor(database, mainFolder = ".", language = "en") {
         this.databasePath = join(mainFolder, database);
         this.clear();
+        this.language = language;
         if (!process.env.INIBASE_SECRET) {
             if (existsSync(".env") &&
                 readFileSync(".env").includes("INIBASE_SECRET="))
@@ -37,6 +39,7 @@ export default class Inibase {
             TABLE_EXISTS: "Table {variable} already exists",
             TABLE_NOT_EXISTS: "Table {variable} doesn't exist",
             NO_SCHEMA: "Table {variable} does't have a schema",
+            GROUP_UNIQUE: "Group {variable} should be unique, got duplicated content in {variable}",
             FIELD_UNIQUE: "Field {variable} should be unique, got {variable} instead",
             FIELD_REQUIRED: "Field {variable} is required",
             INVALID_ID: "The given ID(s) is/are not valid(s)",
@@ -47,9 +50,57 @@ export default class Inibase {
                 ? "please run with '--env-file=.env'"
                 : "please use dotenv",
         },
+        ar: {
+            TABLE_EMPTY: "الجدول {variable} فارغ",
+            TABLE_EXISTS: "الجدول {variable} موجود بالفعل",
+            TABLE_NOT_EXISTS: "الجدول {variable} غير موجود",
+            NO_SCHEMA: "الجدول {variable} ليس لديه مخطط",
+            GROUP_UNIQUE: "المجموعة {variable} يجب أن تكون فريدة، تم العثور على محتوى مكرر في {variable}",
+            FIELD_UNIQUE: "الحقل {variable} يجب أن يكون فريدًا، تم العثور على {variable} بدلاً من ذلك",
+            FIELD_REQUIRED: "الحقل {variable} مطلوب",
+            INVALID_ID: "المعرف أو المعرفات المقدمة غير صالحة",
+            INVALID_TYPE: "من المتوقع أن يكون {variable} من النوع {variable}، لكن تم العثور على {variable} بدلاً من ذلك",
+            INVALID_PARAMETERS: "المعلمات المقدمة غير صالحة",
+            INVALID_REGEX_MATCH: "الحقل {variable} لا يتطابق مع النمط المتوقع",
+            NO_ENV: Number(process.versions.node.split(".").reduce((a, b) => a + b)) >= 26
+                ? "يرجى التشغيل باستخدام '--env-file=.env'"
+                : "يرجى استخدام dotenv",
+        },
+        fr: {
+            TABLE_EMPTY: "La table {variable} est vide",
+            TABLE_EXISTS: "La table {variable} existe déjà",
+            TABLE_NOT_EXISTS: "La table {variable} n'existe pas",
+            NO_SCHEMA: "La table {variable} n'a pas de schéma",
+            GROUP_UNIQUE: "Le groupe {variable} doit être unique, contenu dupliqué trouvé dans {variable}",
+            FIELD_UNIQUE: "Le champ {variable} doit être unique, trouvé {variable} à la place",
+            FIELD_REQUIRED: "Le champ {variable} est obligatoire",
+            INVALID_ID: "Le(s) ID donné(s) n'est/ne sont pas valide(s)",
+            INVALID_TYPE: "Attendu que {variable} soit de type {variable}, mais trouvé {variable} à la place",
+            INVALID_PARAMETERS: "Les paramètres donnés ne sont pas valides",
+            INVALID_REGEX_MATCH: "Le champ {variable} ne correspond pas au modèle attendu",
+            NO_ENV: Number(process.versions.node.split(".").reduce((a, b) => a + b)) >= 26
+                ? "veuillez exécuter avec '--env-file=.env'"
+                : "veuillez utiliser dotenv",
+        },
+        es: {
+            TABLE_EMPTY: "La tabla {variable} está vacía",
+            TABLE_EXISTS: "La tabla {variable} ya existe",
+            TABLE_NOT_EXISTS: "La tabla {variable} no existe",
+            NO_SCHEMA: "La tabla {variable} no tiene un esquema",
+            GROUP_UNIQUE: "El grupo {variable} debe ser único, se encontró contenido duplicado en {variable}",
+            FIELD_UNIQUE: "El campo {variable} debe ser único, se encontró {variable} en su lugar",
+            FIELD_REQUIRED: "El campo {variable} es obligatorio",
+            INVALID_ID: "El/los ID proporcionado(s) no es/son válido(s)",
+            INVALID_TYPE: "Se espera que {variable} sea {variable}, pero se encontró {variable} en su lugar",
+            INVALID_PARAMETERS: "Los parámetros proporcionados no son válidos",
+            INVALID_REGEX_MATCH: "El campo {variable} no coincide con el patrón esperado",
+            NO_ENV: Number(process.versions.node.split(".").reduce((a, b) => a + b)) >= 26
+                ? "por favor ejecute con '--env-file=.env'"
+                : "por favor use dotenv",
+        },
     };
-    createError(name, variable, language = "en") {
-        const errorMessage = Inibase.errorMessages[language]?.[name];
+    createError(name, variable) {
+        const errorMessage = Inibase.errorMessages[this.language]?.[name];
         if (!errorMessage)
             return new Error("ERR");
         const error = new Error(variable
@@ -332,6 +383,10 @@ export default class Inibase {
                     Utils.isArrayOfObjects(field.children))
                     this._validateData(data[field.key], field.children, skipRequiredField);
                 else {
+                    if (field.table &&
+                        Utils.isObject(data[field.key]) &&
+                        Object.hasOwn(data[field.key], "id"))
+                        data[field.key] = data[field.key].id;
                     if (field.regex) {
                         const regex = UtilsServer.getCachedRegex(field.regex);
                         if (!regex.test(data[field.key]))
@@ -366,8 +421,9 @@ export default class Inibase {
         }
     }
     async validateData(tableName, data, skipRequiredField = false) {
+        const clonedData = structuredClone(data);
         // Skip ID and (created|updated)At
-        this._validateData(data, this.tablesMap.get(tableName).schema.slice(1, -2), skipRequiredField);
+        this._validateData(clonedData, this.tablesMap.get(tableName).schema.slice(1, -2), skipRequiredField);
         await this.checkUnique(tableName);
     }
     cleanObject(obj) {
@@ -455,16 +511,24 @@ export default class Inibase {
             let index = 0;
             let shouldContinueParent = false; // Flag to manage parent loop continuation
             const mergedLineNumbers = new Set();
+            const fieldsKeys = [];
             for await (const [columnID, values] of valueObject.columnsValues) {
                 index++;
                 const field = flattenSchema.find(({ id }) => id === columnID);
+                fieldsKeys.push(field.key);
                 const [_, totalLines, lineNumbers] = await File.search(join(tablePath, `${field.key}${this.getFileExtension(tableName)}`), "[]", Array.from(values), undefined, valueObject.exclude, field.type, field.children, 1, undefined, false, this.salt);
                 if (totalLines > 0) {
                     if (valueObject.columnsValues.size === 1 ||
-                        hasDuplicates(lineNumbers, mergedLineNumbers)) {
+                        (valueObject.columnsValues.size === index &&
+                            hasDuplicates(lineNumbers, mergedLineNumbers))) {
                         this.uniqueMap = new Map();
+                        if (valueObject.columnsValues.size > 1)
+                            throw this.createError("GROUP_UNIQUE", [
+                                fieldsKeys.join(" & "),
+                                field.key,
+                            ]);
                         throw this.createError("FIELD_UNIQUE", [
-                            field.key,
+                            fieldsKeys.join(" & "),
                             Array.from(values).join(", "),
                         ]);
                     }

package/dist/utils.d.ts

@@ -7,7 +7,7 @@ import type { ComparisonOperator, Field, FieldType, Schema } from "./index.js";
  *
  * Note: Considers empty arrays and arrays where every element is an object.
  */
-export declare const isArrayOfObjects: (input: any) => input is Record<any, any>[];
+export declare const isArrayOfObjects: (input: unknown) => input is Record<any, any>[];
 /**
  * Type guard function to check if the input is an array of arrays.
  *
@@ -16,7 +16,7 @@ export declare const isArrayOfObjects: (input: any) => input is Record<any, any>
  *
  * Note: Considers empty arrays and arrays where every element is also an array.
  */
-export declare const isArrayOfArrays: (input: any) => input is any[][];
+export declare const isArrayOfArrays: (input: unknown) => input is any[][];
 /**
  * Type guard function to check if the input is an array of nulls or an array of arrays of nulls.
  *
@@ -25,7 +25,7 @@ export declare const isArrayOfArrays: (input: any) => input is any[][];
  *
  * Note: Recursively checks each element, allowing for nested arrays of nulls.
  */
-export declare const isArrayOfNulls: (input: any) => input is null[] | null[][];
+export declare const isArrayOfNulls: (input: unknown) => input is null[] | null[][];
 /**
  * Type guard function to check if the input is an object.
  *
@@ -34,17 +34,7 @@ export declare const isArrayOfNulls: (input: any) => input is null[] | null[][];
  *
  * Note: Checks if the input is non-null and either has 'Object' as its constructor name or is of type 'object' without being an array.
  */
-export declare const isObject: (obj: any) => obj is Record<any, any>;
-/**
- * Recursively merges properties from a source object into a target object. If a property exists in both, the source's value overwrites the target's.
- *
- * @param target - The target object to merge properties into.
- * @param source - The source object from which properties are merged.
- * @returns any - The modified target object with merged properties.
- *
- * Note: Performs a deep merge for nested objects. Non-object properties are directly overwritten.
- */
-export declare const deepMerge: (target: any, source: any) => any;
+export declare const isObject: (object: unknown) => object is Record<any, any>;
 /**
  * Type guard function to check if the input is a number.
  *
@@ -53,7 +43,7 @@ export declare const deepMerge: (target: any, source: any) => any;
  *
  * Note: Validates that the input can be parsed as a float and that subtracting zero results in a number, ensuring it's a numeric value.
  */
-export declare const isNumber: (input: any) => input is number;
+export declare const isNumber: (input: unknown) => input is number;
 /**
  * Checks if the input is a valid email format.
  *
@@ -62,7 +52,7 @@ export declare const isNumber: (input: any) => input is number;
  *
  * Note: Uses a regular expression to validate the email format, ensuring it has parts separated by '@' and contains a domain with a period.
  */
-export declare const isEmail: (input: any) => boolean;
+export declare const isEmail: (input: unknown) => boolean;
 /**
  * Checks if the input is a valid URL format.
  *
@@ -72,7 +62,7 @@ export declare const isEmail: (input: any) => boolean;
  * Note: Validates URLs including protocols (http/https), domain names, IP addresses, ports, paths, query strings, and fragments.
  *       Also recognizes 'tel:' and 'mailto:' as valid URL formats, as well as strings starting with '#' without spaces.
  */
-export declare const isURL: (input: any) => boolean;
+export declare const isURL: (input: unknown) => boolean;
 /**
  * Checks if the input contains HTML tags or entities.
  *
@@ -82,7 +72,7 @@ export declare const isURL: (input: any) => boolean;
  * Note: Uses a regular expression to detect HTML tags (like <tag>) and entities (like &entity;).
  *       Recognizes both opening and closing tags, as well as self-closing tags.
  */
-export declare const isHTML: (input: any) => boolean;
+export declare const isHTML: (input: unknown) => boolean;
 /**
  * Type guard function to check if the input is a string, excluding strings that match specific formats (number, boolean, email, URL, IP).
  *
@@ -91,7 +81,7 @@ export declare const isHTML: (input: any) => boolean;
  *
  * Note: Validates the input against being a number, boolean, email, URL, or IP address to ensure it's a general string.
  */
-export declare const isString: (input: any) => input is string;
+export declare const isString: (input: unknown) => input is string;
 /**
  * Checks if the input is a valid IP address format.
  *
@@ -100,7 +90,7 @@ export declare const isString: (input: any) => input is string;
  *
  * Note: Uses a regular expression to validate IP addresses, ensuring they consist of four octets, each ranging from 0 to 255.
  */
-export declare const isIP: (input: any) => boolean;
+export declare const isIP: (input: unknown) => input is string;
 /**
  * Type guard function to check if the input is a boolean or a string representation of a boolean.
  *
@@ -109,7 +99,7 @@ export declare const isIP: (input: any) => boolean;
  *
  * Note: Recognizes both boolean literals (true, false) and their string representations ("true", "false").
  */
-export declare const isBoolean: (input: any) => input is boolean;
+export declare const isBoolean: (input: unknown) => input is boolean;
 /**
  * Type guard function to check if the input is a password based on a specific length criterion.
  *
@@ -118,28 +108,38 @@ export declare const isBoolean: (input: any) => input is boolean;
  *
  * Note: Specifically checks for string length to determine if it matches the defined password length criterion.
  */
-export declare const isPassword: (input: any) => input is string;
+export declare const isPassword: (input: unknown) => input is string;
 /**
  * Checks if the input can be converted to a valid date.
  *
  * @param input - The input to be checked, can be of any type.
  * @returns A boolean indicating whether the input is a valid date.
  */
-export declare function isDate(input?: any): boolean;
+export declare const isDate: (input: unknown) => input is Date | number;
 /**
  * Checks if the input is a valid ID.
  *
  * @param input - The input to be checked, can be of any type.
  * @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;
+export declare const isValidID: (input: unknown) => input is string;
 /**
  * Checks if a given string is a valid JSON.
  *
- * @param {string} str - The string to be checked.
+ * @param {string} input - The string to be checked.
  * @returns {boolean} Returns true if the string is valid JSON, otherwise false.
  */
-export declare const isStringified: (str: string) => boolean;
+export declare const isStringified: (input: unknown) => boolean;
+/**
+ * Recursively merges properties from a source object into a target object. If a property exists in both, the source's value overwrites the target's.
+ *
+ * @param target - The target object to merge properties into.
+ * @param source - The source object from which properties are merged.
+ * @returns any - The modified target object with merged properties.
+ *
+ * Note: Performs a deep merge for nested objects. Non-object properties are directly overwritten.
+ */
+export declare const deepMerge: (target: any, source: any) => any;
 /**
  * Identifies and returns properties that have changed between two objects.
  *
@@ -168,10 +168,7 @@ export declare const filterSchema: (schema: Schema, callback: (arg0: Field) => b
  * @returns A boolean indicating whether the value matches the specified field type(s).
  */
 export declare const validateFieldType: (value: any, fieldType: FieldType | FieldType[], fieldChildrenType?: FieldType | FieldType[]) => boolean;
-export declare function FormatObjectCriteriaValue(value: string): [
-    ComparisonOperator,
-    string | number | boolean | null | (string | number | null)[]
-];
+export declare const FormatObjectCriteriaValue: (value: string) => [ComparisonOperator, string | number | boolean | null | (string | number | null)[]];
 /**
  * Get field from schema
  *
@@ -179,7 +176,7 @@ export declare function FormatObjectCriteriaValue(value: string): [
  * @param {string} keyPath Support dot notation path
  * @param {Schema} schema
  */
-export declare function getField(keyPath: string, schema: Schema): Field;
+export declare const getField: (keyPath: string, schema: Schema) => Field;
 /**
  * Override a schema field, key, type or other properties
  *
@@ -191,10 +188,10 @@ export declare function getField(keyPath: string, schema: Schema): Field;
  * 		type?: FieldType | FieldType[];
  * 	})} field
  */
-export declare function setField(keyPath: string, schema: Schema, field: Omit<Field, "key" | "type"> & {
+export declare const setField: (keyPath: string, schema: Schema, field: Omit<Field, "key" | "type"> & {
     key?: string;
     type?: FieldType | FieldType[];
-}): Field;
+}) => Field;
 /**
  * Remove field from schema
  *
@@ -202,4 +199,4 @@ export declare function setField(keyPath: string, schema: Schema, field: Omit<Fi
  * @param {string} keyPath Support dot notation path
  * @param {Schema} schema
  */
-export declare function unsetField(keyPath: string, schema: Schema): Field;
+export declare const unsetField: (keyPath: string, schema: Schema) => Field;

package/dist/utils.js

@@ -15,7 +15,7 @@ export const isArrayOfObjects = (input) => Array.isArray(input) && (input.length
  *
  * Note: Considers empty arrays and arrays where every element is also an array.
  */
-export const isArrayOfArrays = (input) => Array.isArray(input) && (input.length === 0 || input.every(Array.isArray));
+export const isArrayOfArrays = (input) => Array.isArray(input) && input.length > 0 && input.every(Array.isArray);
 /**
  * Type guard function to check if the input is an array of nulls or an array of arrays of nulls.
  *
@@ -24,7 +24,8 @@ export const isArrayOfArrays = (input) => Array.isArray(input) && (input.length
  *
  * Note: Recursively checks each element, allowing for nested arrays of nulls.
  */
-export const isArrayOfNulls = (input) => input.every((_input) => Array.isArray(_input) ? isArrayOfNulls(_input) : _input === null);
+export const isArrayOfNulls = (input) => Array.isArray(input) &&
+    input.every((_input) => Array.isArray(_input) ? isArrayOfNulls(_input) : _input === null);
 /**
  * Type guard function to check if the input is an object.
  *
@@ -33,29 +34,9 @@ export const isArrayOfNulls = (input) => input.every((_input) => Array.isArray(_
  *
  * Note: Checks if the input is non-null and either has 'Object' as its constructor name or is of type 'object' without being an array.
  */
-export const isObject = (obj) => obj != null &&
-    ((typeof obj === "object" && !Array.isArray(obj)) ||
-        obj.constructor?.name === "Object");
-/**
- * Recursively merges properties from a source object into a target object. If a property exists in both, the source's value overwrites the target's.
- *
- * @param target - The target object to merge properties into.
- * @param source - The source object from which properties are merged.
- * @returns any - The modified target object with merged properties.
- *
- * Note: Performs a deep merge for nested objects. Non-object properties are directly overwritten.
- */
-export const deepMerge = (target, source) => {
-    for (const key in source) {
-        if (Object.hasOwn(source, key)) {
-            if (isObject(source[key]) && isObject(target[key]))
-                target[key] = deepMerge(target[key], source[key]);
-            else if (source[key] !== null)
-                target[key] = source[key];
-        }
-    }
-    return target;
-};
+export const isObject = (object) => object != null &&
+    ((typeof object === "object" && !Array.isArray(object)) ||
+        object.constructor?.name === "Object");
 /**
  * Type guard function to check if the input is a number.
  *
@@ -64,7 +45,24 @@ export const deepMerge = (target, source) => {
  *
  * Note: Validates that the input can be parsed as a float and that subtracting zero results in a number, ensuring it's a numeric value.
  */
-export const isNumber = (input) => !Number.isNaN(Number.parseFloat(input)) && !Number.isNaN(input - 0);
+export const isNumber = (input) => {
+    // Case 1: It's already a number (and not NaN/Infinity).
+    if (typeof input === "number")
+        return !Number.isNaN(input) && Number.isFinite(input);
+    // Case 2: It's a string that can parse to a finite number.
+    if (typeof input === "string") {
+        const trimmed = input.trim();
+        // Empty string or whitespace-only => not numeric
+        if (!trimmed)
+            return false;
+        const parsed = Number(trimmed); // or parseFloat(trimmed)
+        return !Number.isNaN(parsed) && Number.isFinite(parsed);
+    }
+    // Otherwise, not a numeric string or number
+    return false;
+};
+// As a literal (no double-escaping).
+const emailPattern = /^[A-Za-z0-9!#%&'*+\/=?^_`{|}~-]+(?:\.[A-Za-z0-9!#%&'*+\/=?^_`{|}~-]+)*@(?:[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?\.)+[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?$/;
 /**
  * Checks if the input is a valid email format.
  *
@@ -73,7 +71,22 @@ export const isNumber = (input) => !Number.isNaN(Number.parseFloat(input)) && !N
  *
  * Note: Uses a regular expression to validate the email format, ensuring it has parts separated by '@' and contains a domain with a period.
  */
-export const isEmail = (input) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(String(input));
+export const isEmail = (input) => typeof input === "string" && emailPattern.test(String(input));
+const urlPattern = new RegExp("^" +
+    // Optional protocol
+    "(https?:\\/\\/)?" +
+    // domain name (with underscore allowed), localhost, or ipv4
+    "((([a-z\\d_]([a-z\\d_\\-]*[a-z\\d_])*)\\.)+[a-z]{2,}|" +
+    "localhost|" +
+    "((\\d{1,3}\\.){3}\\d{1,3}))" +
+    // optional port
+    "(\\:\\d+)?" +
+    // path
+    "(\\/[-a-z\\d%_.~+]*)*" +
+    // query string
+    "(\\?[;&a-z\\d%_.~+=-]*)?" +
+    // fragment
+    "(\\#[-a-z\\d_]*)?$", "i");
 /**
  * Checks if the input is a valid URL format.
  *
@@ -88,17 +101,12 @@ export const isURL = (input) => {
         return false;
     if ((input[0] === "#" && !input.includes(" ")) ||
         input.startsWith("tel:") ||
-        input.startsWith("mailto:"))
+        input.startsWith("mailto:") ||
+        URL.canParse(input))
         return true;
-    const pattern = new RegExp("^(https?:\\/\\/)?" + // protocol
-        "((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|" + // domain name
-        "localhost|" + // OR localhost
-        "((\\d{1,3}\\.){3}\\d{1,3}))" + // OR ip (v4) address
-        "(\\:\\d+)?(\\/[-a-z\\d%_.~+]*)*" + // port and path
-        "(\\?[;&a-z\\d%_.~+=-]*)?" + // query string
-        "(\\#[-a-z\\d_]*)?$", "i"); // fragment locator
-    return !!pattern.test(input);
+    return urlPattern.test(input);
 };
+const htmlPattern = /<([A-Za-z][A-Za-z0-9-]*)(\s+[A-Za-z-]+(\s*=\s*(?:".*?"|'.*?'|[^'">\s]+))?)*\s*>/;
 /**
  * Checks if the input contains HTML tags or entities.
  *
@@ -108,7 +116,7 @@ export const isURL = (input) => {
  * Note: Uses a regular expression to detect HTML tags (like <tag>) and entities (like &entity;).
  *       Recognizes both opening and closing tags, as well as self-closing tags.
  */
-export const isHTML = (input) => /<\/?\s*[a-z-][^>]*\s*>|(\&(?:[\w\d]+|#\d+|#x[a-f\d]+);)/g.test(input);
+export const isHTML = (input) => typeof input === "string" && htmlPattern.test(input);
 /**
  * Type guard function to check if the input is a string, excluding strings that match specific formats (number, boolean, email, URL, IP).
  *
@@ -119,6 +127,7 @@ export const isHTML = (input) => /<\/?\s*[a-z-][^>]*\s*>|(\&(?:[\w\d]+|#\d+|#x[a
  */
 export const isString = (input) => Object.prototype.toString.call(input) === "[object String]" &&
     (!isNumber(input) || String(input).at(0) === "0");
+const ipPattern = /^(?:(?:2(?:5[0-5]|[0-4]\d)|1?\d?\d)\.){3}(?:2(?:5[0-5]|[0-4]\d)|1?\d?\d)$/;
 /**
  * Checks if the input is a valid IP address format.
  *
@@ -127,7 +136,7 @@ export const isString = (input) => Object.prototype.toString.call(input) === "[o
  *
  * Note: Uses a regular expression to validate IP addresses, ensuring they consist of four octets, each ranging from 0 to 255.
  */
-export const isIP = (input) => /^(?:(?:^|\.)(?:2(?:5[0-5]|[0-4]\d)|1?\d?\d)){4}$/.test(input);
+export const isIP = (input) => typeof input === "string" && ipPattern.test(input);
 /**
  * Type guard function to check if the input is a boolean or a string representation of a boolean.
  *
@@ -152,7 +161,7 @@ export const isPassword = (input) => typeof input === "string" && input.length =
  * @param input - The input to be checked, can be of any type.
  * @returns A boolean indicating whether the input is a valid date.
  */
-export function isDate(input) {
+export const isDate = (input) => {
     // Check if the input is null, undefined, or an empty string
     if (input == null || input === "")
         return false;
@@ -165,7 +174,7 @@ export function isDate(input) {
     const date = new Date(numTimestamp);
     // Check if the date is valid
     return date.getTime() === numTimestamp;
-}
+};
 /**
  * Checks if the input is a valid ID.
  *
@@ -178,10 +187,34 @@ export const isValidID = (input) => {
 /**
  * Checks if a given string is a valid JSON.
  *
- * @param {string} str - The string to be checked.
+ * @param {string} input - The string to be checked.
  * @returns {boolean} Returns true if the string is valid JSON, otherwise false.
  */
-export const isStringified = (str) => str === "null" || str === "undefined" || str[0] === "{" || str[0] === "[";
+export const isStringified = (input) => typeof input === "string" &&
+    (input === "null" ||
+        input === "undefined" ||
+        input[0] === "{" ||
+        input[0] === "[");
+/**
+ * Recursively merges properties from a source object into a target object. If a property exists in both, the source's value overwrites the target's.
+ *
+ * @param target - The target object to merge properties into.
+ * @param source - The source object from which properties are merged.
+ * @returns any - The modified target object with merged properties.
+ *
+ * Note: Performs a deep merge for nested objects. Non-object properties are directly overwritten.
+ */
+export const deepMerge = (target, source) => {
+    for (const key in source) {
+        if (Object.hasOwn(source, key)) {
+            if (isObject(source[key]) && isObject(target[key]))
+                target[key] = deepMerge(target[key], source[key]);
+            else if (source[key] !== null)
+                target[key] = source[key];
+        }
+    }
+    return target;
+};
 /**
  * Identifies and returns properties that have changed between two objects.
  *
@@ -278,7 +311,7 @@ export const isFieldType = (compareAtType, fieldType, fieldChildrenType) => {
 // Function to recursively flatten an array of objects and their nested children
 export const flattenSchema = (schema, keepParents = false) => {
     const result = [];
-    function _flattenHelper(item, parentKey) {
+    const _flattenHelper = (item, parentKey) => {
         if (item.children && isArrayOfObjects(item.children)) {
             if (keepParents)
                 result.push((({ children, ...rest }) => rest)(item));
@@ -290,7 +323,7 @@ export const flattenSchema = (schema, keepParents = false) => {
                 ...item,
                 key: parentKey ? `${parentKey}.${item.key}` : item.key,
             });
-    }
+    };
     for (const item of schema)
         _flattenHelper(item, "");
     return result;
@@ -372,7 +405,7 @@ export const validateFieldType = (value, fieldType, fieldChildrenType) => {
             return false;
     }
 };
-export function FormatObjectCriteriaValue(value) {
+export const FormatObjectCriteriaValue = (value) => {
     switch (value[0]) {
         case ">":
         case "<":
@@ -420,7 +453,7 @@ export function FormatObjectCriteriaValue(value) {
         default:
             return ["=", value];
     }
-}
+};
 /**
  * Get field from schema
  *
@@ -428,7 +461,7 @@ export function FormatObjectCriteriaValue(value) {
  * @param {string} keyPath Support dot notation path
  * @param {Schema} schema
  */
-export function getField(keyPath, schema) {
+export const getField = (keyPath, schema) => {
     let RETURN = schema;
     const keyPathSplited = keyPath.split(".");
     for (const [index, key] of keyPathSplited.entries()) {
@@ -447,7 +480,7 @@ export function getField(keyPath, schema) {
     if (!RETURN)
         return null;
     return isArrayOfObjects(RETURN) ? RETURN[0] : RETURN;
-}
+};
 /**
  * Override a schema field, key, type or other properties
  *
@@ -459,7 +492,7 @@ export function getField(keyPath, schema) {
  * 		type?: FieldType | FieldType[];
  * 	})} field
  */
-export function setField(keyPath, schema, field) {
+export const setField = (keyPath, schema, field) => {
     const keyPathSplited = keyPath.split(".");
     for (const [index, key] of keyPathSplited.entries()) {
         const foundItem = schema.find((item) => item.key === key);
@@ -474,7 +507,7 @@ export function setField(keyPath, schema, field) {
             isArrayOfObjects(foundItem.children))
             schema = foundItem.children;
     }
-}
+};
 /**
  * Remove field from schema
  *
@@ -482,7 +515,7 @@ export function setField(keyPath, schema, field) {
  * @param {string} keyPath Support dot notation path
  * @param {Schema} schema
  */
-export function unsetField(keyPath, schema) {
+export const unsetField = (keyPath, schema) => {
     const keyPathSplited = keyPath.split(".");
     let parent = null;
     let targetIndex;
@@ -518,4 +551,4 @@ export function unsetField(keyPath, schema) {
             targetIndex = undefined;
         }
     }
-}
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inibase",
-  "version": "1.1.4",
+  "version": "1.1.6",
   "type": "module",
   "author": {
     "name": "Karim Amahtil",
@@ -84,6 +84,7 @@
     "prepublish": "npx -q tsc",
     "build": "npx -q tsc",
     "benchmark": "./benchmark/run.js",
-    "test": "npx -q tsx ./tests/inibase.test.ts"
+    "test": "npx -q tsx ./tests/inibase.test.ts",
+    "test:utils": "npx -q tsx ./tests/utils.test.ts"
   }
 }