inibase 1.0.0-rc.25 → 1.0.0-rc.27

package/dist/utils.d.ts

@@ -1,23 +1,178 @@
 import { type FieldType } from "./index.js";
+/**
+ * Type guard function to check if the input is an array of objects.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input is an array of objects, false otherwise.
+ *
+ * Note: Considers empty arrays and arrays where every element is an object.
+ */
 export declare const isArrayOfObjects: (input: any) => input is Record<any, any>[];
+/**
+ * Type guard function to check if the input is an array of arrays.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input is an array of arrays, false otherwise.
+ *
+ * Note: Considers empty arrays and arrays where every element is also an array.
+ */
 export declare const isArrayOfArrays: (input: any) => input is any[][];
+/**
+ * Type guard function to check if the input is an array of nulls or an array of arrays of nulls.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input is an array consisting entirely of nulls or arrays of nulls, false otherwise.
+ *
+ * Note: Recursively checks each element, allowing for nested arrays of nulls.
+ */
 export declare const isArrayOfNulls: (input: any) => input is null[] | null[][];
+/**
+ * Type guard function to check if the input is an object.
+ *
+ * @param obj - The value to be checked.
+ * @returns boolean - True if the input is an object (excluding arrays), false otherwise.
+ *
+ * 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;
+/**
+ * Combines an array of objects into a single object. If the same key exists in multiple objects, the values are merged.
+ *
+ * @param arr - Array of objects to be combined.
+ * @returns Record<string, any> - A single object with combined keys and values.
+ *
+ * Note: Handles nested objects by recursively combining them. Non-object values with the same key are merged into arrays.
+ */
 export declare const combineObjects: (arr: Record<string, any>[]) => Record<string, any>;
+/**
+ * Type guard function to check if the input is a number.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input is a number, false otherwise.
+ *
+ * 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;
+/**
+ * Checks if the input is a valid email format.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input matches the email format, false otherwise.
+ *
+ * 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;
+/**
+ * Checks if the input is a valid URL format.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input matches the URL format, false otherwise.
+ *
+ * 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;
+/**
+ * Checks if the input contains HTML tags or entities.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input contains HTML tags or entities, false otherwise.
+ *
+ * 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;
+/**
+ * Type guard function to check if the input is a string, excluding strings that match specific formats (number, boolean, email, URL, IP).
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input is a string that doesn't match the specific formats, false otherwise.
+ *
+ * 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;
+/**
+ * Checks if the input is a valid IP address format.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input matches the IP address format, false otherwise.
+ *
+ * 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;
+/**
+ * Type guard function to check if the input is a boolean or a string representation of a boolean.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input is a boolean value or 'true'/'false' strings, false otherwise.
+ *
+ * Note: Recognizes both boolean literals (true, false) and their string representations ("true", "false").
+ */
 export declare const isBoolean: (input: any) => input is boolean;
+/**
+ * Type guard function to check if the input is a password based on a specific length criterion.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input is a string with a length of 161 characters, false otherwise.
+ *
+ * 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;
+/**
+ * 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 const isDate: (input: any) => boolean;
+/**
+ * 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;
+/**
+ * Identifies and returns properties that have changed between two objects.
+ *
+ * @param obj1 - The first object for comparison, with string keys and values.
+ * @param obj2 - The second object for comparison, with string keys and values.
+ * @returns A record of changed properties with original values from obj1 and new values from obj2, or null if no changes are found.
+ */
 export declare const findChangedProperties: (obj1: Record<string, string>, obj2: Record<string, string>) => Record<string, string> | null;
+/**
+ * Detects the field type of an input based on available types.
+ *
+ * @param input - The input whose field type is to be detected.
+ * @param availableTypes - An array of potential field types to consider.
+ * @returns The detected field type as a string, or undefined if no matching type is found.
+ */
 export declare const detectFieldType: (input: any, availableTypes: FieldType[]) => FieldType | undefined;
+/**
+ * Validates if the given value matches the specified field type(s).
+ *
+ * @param value - The value to be validated.
+ * @param fieldType - The expected field type or an array of possible field types.
+ * @param fieldChildrenType - Optional; the expected type(s) of children elements, used if the field type is an array.
+ * @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;
+/**
+ * Converts a nested object to dot notation, flattening the object's structure.
+ *
+ * @param input - The input object to be converted.
+ * @returns A flattened object using dot notation for keys.
+ */
 export declare const objectToDotNotation: (input: Record<string, any>) => Record<string, string | number | (string | number)[]>;
 export default class Utils {
     static isNumber: (input: any) => input is number;

package/dist/utils.js

@@ -1,9 +1,50 @@
+/**
+ * Type guard function to check if the input is an array of objects.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input is an array of objects, false otherwise.
+ *
+ * Note: Considers empty arrays and arrays where every element is an object.
+ */
 export const isArrayOfObjects = (input) => Array.isArray(input) && (input.length === 0 || input.every(isObject));
+/**
+ * Type guard function to check if the input is an array of arrays.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input is an array of arrays, false otherwise.
+ *
+ * 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));
+/**
+ * Type guard function to check if the input is an array of nulls or an array of arrays of nulls.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input is an array consisting entirely of nulls or arrays of nulls, false otherwise.
+ *
+ * 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);
+/**
+ * Type guard function to check if the input is an object.
+ *
+ * @param obj - The value to be checked.
+ * @returns boolean - True if the input is an object (excluding arrays), false otherwise.
+ *
+ * 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 &&
     (obj.constructor.name === "Object" ||
         (typeof obj === "object" && !Array.isArray(obj)));
+/**
+ * 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 (source.hasOwnProperty(key)) {
@@ -15,6 +56,14 @@ export const deepMerge = (target, source) => {
     }
     return target;
 };
+/**
+ * Combines an array of objects into a single object. If the same key exists in multiple objects, the values are merged.
+ *
+ * @param arr - Array of objects to be combined.
+ * @returns Record<string, any> - A single object with combined keys and values.
+ *
+ * Note: Handles nested objects by recursively combining them. Non-object values with the same key are merged into arrays.
+ */
 export const combineObjects = (arr) => {
     const result = {};
     for (const obj of arr) {
@@ -49,8 +98,33 @@ export const combineObjects = (arr) => {
     }
     return result;
 };
+/**
+ * Type guard function to check if the input is a number.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input is a number, false otherwise.
+ *
+ * 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) => !isNaN(parseFloat(input)) && !isNaN(input - 0);
+/**
+ * Checks if the input is a valid email format.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input matches the email format, false otherwise.
+ *
+ * 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));
+/**
+ * Checks if the input is a valid URL format.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input matches the URL format, false otherwise.
+ *
+ * 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 const isURL = (input) => {
     if (typeof input !== "string")
         return false;
@@ -68,20 +142,80 @@ export const isURL = (input) => {
         return !!pattern.test(input);
     }
 };
+/**
+ * Checks if the input contains HTML tags or entities.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input contains HTML tags or entities, false otherwise.
+ *
+ * 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);
+/**
+ * Type guard function to check if the input is a string, excluding strings that match specific formats (number, boolean, email, URL, IP).
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input is a string that doesn't match the specific formats, false otherwise.
+ *
+ * Note: Validates the input against being a number, boolean, email, URL, or IP address to ensure it's a general string.
+ */
 export const isString = (input) => Object.prototype.toString.call(input) === "[object String]" &&
     [isNumber, isBoolean, isEmail, isURL, isIP].every((fn) => !fn(input));
+/**
+ * Checks if the input is a valid IP address format.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input matches the IP address format, false otherwise.
+ *
+ * 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);
+/**
+ * Type guard function to check if the input is a boolean or a string representation of a boolean.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input is a boolean value or 'true'/'false' strings, false otherwise.
+ *
+ * Note: Recognizes both boolean literals (true, false) and their string representations ("true", "false").
+ */
 export const isBoolean = (input) => typeof input === "boolean" ||
     input === "true" ||
     input === "false" ||
     input === true ||
     input === false;
+/**
+ * Type guard function to check if the input is a password based on a specific length criterion.
+ *
+ * @param input - The value to be checked.
+ * @returns boolean - True if the input is a string with a length of 161 characters, false otherwise.
+ *
+ * Note: Specifically checks for string length to determine if it matches the defined password length criterion.
+ */
 export const isPassword = (input) => input.length === 161;
+/**
+ * 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 const isDate = (input) => !isNaN(new Date(input).getTime()) || !isNaN(Date.parse(input));
+/**
+ * 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 const isValidID = (input) => {
     return typeof input === "string" && input.length === 32;
 };
+/**
+ * Identifies and returns properties that have changed between two objects.
+ *
+ * @param obj1 - The first object for comparison, with string keys and values.
+ * @param obj2 - The second object for comparison, with string keys and values.
+ * @returns A record of changed properties with original values from obj1 and new values from obj2, or null if no changes are found.
+ */
 export const findChangedProperties = (obj1, obj2) => {
     const result = {};
     for (const key1 in obj1)
@@ -89,6 +223,13 @@ export const findChangedProperties = (obj1, obj2) => {
             result[obj1[key1]] = obj2[key1];
     return Object.keys(result).length ? result : null;
 };
+/**
+ * Detects the field type of an input based on available types.
+ *
+ * @param input - The input whose field type is to be detected.
+ * @param availableTypes - An array of potential field types to consider.
+ * @returns The detected field type as a string, or undefined if no matching type is found.
+ */
 export const detectFieldType = (input, availableTypes) => {
     if (!Array.isArray(input)) {
         if ((input === "0" ||
@@ -126,6 +267,14 @@ export const detectFieldType = (input, availableTypes) => {
         return "array";
     return undefined;
 };
+/**
+ * Validates if the given value matches the specified field type(s).
+ *
+ * @param value - The value to be validated.
+ * @param fieldType - The expected field type or an array of possible field types.
+ * @param fieldChildrenType - Optional; the expected type(s) of children elements, used if the field type is an array.
+ * @returns A boolean indicating whether the value matches the specified field type(s).
+ */
 export const validateFieldType = (value, fieldType, fieldChildrenType) => {
     if (value === null)
         return true;
@@ -177,6 +326,12 @@ export const validateFieldType = (value, fieldType, fieldChildrenType) => {
             return false;
     }
 };
+/**
+ * Converts a nested object to dot notation, flattening the object's structure.
+ *
+ * @param input - The input object to be converted.
+ * @returns A flattened object using dot notation for keys.
+ */
 export const objectToDotNotation = (input) => {
     const result = {};
     const stack = [

package/dist/utils.server.d.ts

@@ -1,11 +1,54 @@
 /// <reference types="node" resolution-mode="require"/>
 import { type Schema } from "./index.js";
+/**
+ * Generates a hashed password using SHA-256.
+ *
+ * @param password - The plain text password to hash.
+ * @returns A string containing the salt and the hashed password, separated by a colon.
+ */
 export declare const hashPassword: (password: string) => string;
+/**
+ * Compares a hashed password with an input password to verify a match.
+ *
+ * @param hashedPassword - The hashed password, containing both the salt and the hash, separated by a colon.
+ * @param inputPassword - The plain text input password to compare against the hashed password.
+ * @returns A boolean indicating whether the input password matches the hashed password.
+ */
 export declare const comparePassword: (hashedPassword: string, inputPassword: string) => boolean;
+/**
+ * Encodes an ID using AES-256-CBC encryption.
+ *
+ * @param id - The ID to encode, either a number or a string.
+ * @param secretKeyOrSalt - The secret key or salt for encryption, can be a string, number, or Buffer.
+ * @returns The encoded ID as a hexadecimal string.
+ */
 export declare const encodeID: (id: number | string, secretKeyOrSalt: string | number | Buffer) => string;
+/**
+ * Decodes an encrypted ID using AES-256-CBC decryption.
+ *
+ * @param input - The encrypted ID as a hexadecimal string.
+ * @param secretKeyOrSalt - The secret key or salt used for decryption, can be a string, number, or Buffer.
+ * @returns The decoded ID as a number.
+ */
 export declare const decodeID: (input: string, secretKeyOrSalt: string | number | Buffer) => number;
+/**
+ * Finds the last ID number in a schema, potentially decoding it if encrypted.
+ *
+ * @param schema - The schema to search, defined as an array of schema objects.
+ * @param secretKeyOrSalt - The secret key or salt for decoding an encrypted ID, can be a string, number, or Buffer.
+ * @returns The last ID number in the schema, decoded if necessary.
+ */
 export declare const findLastIdNumber: (schema: Schema, secretKeyOrSalt: string | number | Buffer) => number;
+/**
+ * Adds or updates IDs in a schema, encoding them using a provided secret key or salt.
+ *
+ * @param schema - The schema to update, defined as an array of schema objects.
+ * @param oldIndex - The starting index for generating new IDs, defaults to 0.
+ * @param secretKeyOrSalt - The secret key or salt for encoding IDs, can be a string, number, or Buffer.
+ * @returns The updated schema with encoded IDs.
+ */
 export declare const addIdToSchema: (schema: Schema, oldIndex: number | undefined, secretKeyOrSalt: string | number | Buffer) => import("./index.js").Field[];
+export declare const hashObject: (obj: any) => string;
 export default class UtilsServer {
     static encodeID: (id: string | number, secretKeyOrSalt: string | number | Buffer) => string;
     static decodeID: (input: string, secretKeyOrSalt: string | number | Buffer) => number;
@@ -13,4 +56,5 @@ export default class UtilsServer {
     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) => import("./index.js").Field[];
+    static hashObject: (obj: any) => string;
 }

package/dist/utils.server.js

@@ -1,5 +1,11 @@
 import { createCipheriv, createDecipheriv, randomBytes, scryptSync, createHash, } from "node:crypto";
 import { isArrayOfObjects, isNumber, isValidID } from "./utils.js";
+/**
+ * Generates a hashed password using SHA-256.
+ *
+ * @param password - The plain text password to hash.
+ * @returns A string containing the salt and the hashed password, separated by a colon.
+ */
 export const hashPassword = (password) => {
     const salt = randomBytes(16).toString("hex");
     const hash = createHash("sha256")
@@ -7,6 +13,13 @@ export const hashPassword = (password) => {
         .digest("hex");
     return `${salt}:${hash}`;
 };
+/**
+ * Compares a hashed password with an input password to verify a match.
+ *
+ * @param hashedPassword - The hashed password, containing both the salt and the hash, separated by a colon.
+ * @param inputPassword - The plain text input password to compare against the hashed password.
+ * @returns A boolean indicating whether the input password matches the hashed password.
+ */
 export const comparePassword = (hashedPassword, inputPassword) => {
     const [salt, originalHash] = hashedPassword.split(":");
     const inputHash = createHash("sha256")
@@ -14,6 +27,13 @@ export const comparePassword = (hashedPassword, inputPassword) => {
         .digest("hex");
     return inputHash === originalHash;
 };
+/**
+ * Encodes an ID using AES-256-CBC encryption.
+ *
+ * @param id - The ID to encode, either a number or a string.
+ * @param secretKeyOrSalt - The secret key or salt for encryption, can be a string, number, or Buffer.
+ * @returns The encoded ID as a hexadecimal string.
+ */
 export const encodeID = (id, secretKeyOrSalt) => {
     let cipher;
     if (Buffer.isBuffer(secretKeyOrSalt))
@@ -24,6 +44,13 @@ export const encodeID = (id, secretKeyOrSalt) => {
     }
     return cipher.update(id.toString(), "utf8", "hex") + cipher.final("hex");
 };
+/**
+ * Decodes an encrypted ID using AES-256-CBC decryption.
+ *
+ * @param input - The encrypted ID as a hexadecimal string.
+ * @param secretKeyOrSalt - The secret key or salt used for decryption, can be a string, number, or Buffer.
+ * @returns The decoded ID as a number.
+ */
 export const decodeID = (input, secretKeyOrSalt) => {
     let decipher;
     if (Buffer.isBuffer(secretKeyOrSalt))
@@ -34,6 +61,13 @@ export const decodeID = (input, secretKeyOrSalt) => {
     }
     return Number(decipher.update(input, "hex", "utf8") + decipher.final("utf8"));
 };
+/**
+ * Finds the last ID number in a schema, potentially decoding it if encrypted.
+ *
+ * @param schema - The schema to search, defined as an array of schema objects.
+ * @param secretKeyOrSalt - The secret key or salt for decoding an encrypted ID, can be a string, number, or Buffer.
+ * @returns The last ID number in the schema, decoded if necessary.
+ */
 export const findLastIdNumber = (schema, secretKeyOrSalt) => {
     const lastField = schema[schema.length - 1];
     if (lastField) {
@@ -47,6 +81,14 @@ export const findLastIdNumber = (schema, secretKeyOrSalt) => {
     }
     return 0;
 };
+/**
+ * Adds or updates IDs in a schema, encoding them using a provided secret key or salt.
+ *
+ * @param schema - The schema to update, defined as an array of schema objects.
+ * @param oldIndex - The starting index for generating new IDs, defaults to 0.
+ * @param secretKeyOrSalt - The secret key or salt for encoding IDs, can be a string, number, or Buffer.
+ * @returns The updated schema with encoded IDs.
+ */
 export const addIdToSchema = (schema, oldIndex = 0, secretKeyOrSalt) => schema.map((field) => {
     if (!field.id) {
         oldIndex++;
@@ -67,6 +109,35 @@ export const addIdToSchema = (schema, oldIndex = 0, secretKeyOrSalt) => schema.m
     }
     return field;
 });
+function sortObject(obj) {
+    if (typeof obj !== "object" || obj === null)
+        return obj;
+    if (Array.isArray(obj))
+        return obj.toSorted().map(sortObject);
+    const sorted = {};
+    const keys = Object.keys(obj).sort();
+    const length = keys.length;
+    for (let i = 0; i < length; i++) {
+        const key = keys[i];
+        sorted[key] = sortObject(obj[key]);
+    }
+    return sorted;
+}
+function stringifyObject(obj) {
+    if (typeof obj !== "object" || obj === null)
+        return String(obj);
+    if (Array.isArray(obj))
+        return "[" + obj.map((value) => stringifyObject(value)).join(",") + "]";
+    return ("{" +
+        Object.keys(obj)
+            .toSorted()
+            .map((key) => `${key}:${stringifyObject(obj[key])}`)
+            .join(",") +
+        "}");
+}
+export const hashObject = (obj) => createHash("sha256")
+    .update(stringifyObject(sortObject(obj)))
+    .digest("hex");
 export default class UtilsServer {
     static encodeID = encodeID;
     static decodeID = decodeID;
@@ -74,4 +145,5 @@ export default class UtilsServer {
     static comparePassword = comparePassword;
     static findLastIdNumber = findLastIdNumber;
     static addIdToSchema = addIdToSchema;
+    static hashObject = hashObject;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inibase",
-  "version": "1.0.0-rc.25",
+  "version": "1.0.0-rc.27",
   "author": {
     "name": "Karim Amahtil",
     "email": "karim.amahtil@gmail.com"
@@ -62,12 +62,10 @@
     "@types/node": "^20.10.4",
     "typescript": "^5.3.3"
   },
-  "dependencies": {
-    "csv-parser": "^3.0.0"
-  },
   "scripts": {
     "build": "npx tsc",
     "test": "npx tsx watch --expose-gc --env-file=.env ./index.test",
-    "benchmark": "npx tsx watch --expose-gc --env-file=.env ./benchmark"
+    "benchmark:single": "npx tsx watch --expose-gc --env-file=.env ./benchmark/single",
+    "benchmark:bulk": "npx tsx watch --expose-gc --env-file=.env ./benchmark/bulk"
   }
 }