inibase 1.0.0-rc.39 → 1.0.0-rc.40

package/README.md

@@ -519,9 +519,9 @@ await Promise.all(
 
 </details>
 
-## Config
+## Config (.env)
 
-The `.env` file supports the following parameters (make sure to run command with flag --env-file=.env)
+The `.env` file supports the following parameters (make sure to run commands with flag --env-file=.env)
 
 ```ini
 # Auto generated secret key, will be using for encrypting the IDs
@@ -529,6 +529,9 @@ INIBASE_SECRET=
 
 INIBASE_COMPRESSION=true
 INIBASE_CACHE=true
+
+# Prepend new items to the beginning of file 
+INIBASE_REVERSE=true
 ```
 
 ## License

package/dist/config.d.ts

@@ -1,4 +1,5 @@
 export default class Config {
     static isCompressionEnabled: boolean;
     static isCacheEnabled: boolean;
+    static isReverseEnabled: boolean;
 }

package/dist/config.js

@@ -1,4 +1,5 @@
 export default class Config {
     static isCompressionEnabled = process.env.INIBASE_COMPRESSION === "true";
     static isCacheEnabled = process.env.INIBASE_CACHE === "true";
+    static isReverseEnabled = process.env.INIBASE_REVERSE === "true";
 }

package/dist/file.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" resolution-mode="require"/>
 import { ComparisonOperator, FieldType } from "./index.js";
-export declare const lock: (folderPath: string) => Promise<void>;
-export declare const unlock: (folderPath: string) => Promise<void>;
+export declare const lock: (folderPath: string, prefix?: string) => Promise<void>;
+export declare const unlock: (folderPath: string, prefix?: string) => Promise<void>;
 export declare const write: (filePath: string, data: any, disableCompression?: boolean) => Promise<void>;
 export declare const read: (filePath: string, disableCompression?: boolean) => Promise<string>;
 /**
@@ -170,7 +170,7 @@ export default class File {
     static count: (filePath: string) => Promise<number>;
     static write: (filePath: string, data: any, disableCompression?: boolean) => Promise<void>;
     static read: (filePath: string, disableCompression?: boolean) => Promise<string>;
-    static lock: (folderPath: string) => Promise<void>;
-    static unlock: (folderPath: string) => Promise<void>;
+    static lock: (folderPath: string, prefix?: string | undefined) => Promise<void>;
+    static unlock: (folderPath: string, prefix?: string | undefined) => Promise<void>;
     static createWorker: typeof createWorker;
 }

package/dist/file.js

@@ -1,4 +1,4 @@
-import { open, access, writeFile, readFile, constants as fsConstants, unlink, } from "node:fs/promises";
+import { open, access, writeFile, readFile, constants as fsConstants, unlink, copyFile, appendFile, } from "node:fs/promises";
 import { createInterface } from "node:readline";
 import { Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
@@ -11,23 +11,23 @@ import { encodeID, comparePassword } from "./utils.server.js";
 import Config from "./config.js";
 const gzip = promisify(gzipAsync);
 const gunzip = promisify(gunzipAsync);
-export const lock = async (folderPath) => {
-    let lockFile, lockFilePath = join(folderPath, "locked.inib");
+export const lock = async (folderPath, prefix) => {
+    let lockFile, lockFilePath = join(folderPath, `${prefix ?? ""}.locked`);
     try {
         lockFile = await open(lockFilePath, "wx");
         return;
     }
     catch ({ message }) {
         if (message.split(":")[0] === "EEXIST")
-            return await new Promise((resolve, reject) => setTimeout(() => resolve(lock(folderPath)), 13));
+            return await new Promise((resolve, reject) => setTimeout(() => resolve(lock(folderPath, prefix)), 13));
     }
     finally {
         await lockFile?.close();
     }
 };
-export const unlock = async (folderPath) => {
+export const unlock = async (folderPath, prefix) => {
     try {
-        await unlink(join(folderPath, "locked.inib"));
+        await unlink(join(folderPath, `${prefix ?? ""}.locked`));
     }
     catch { }
 };
@@ -184,7 +184,10 @@ const unSecureString = (input) => {
         "\\r": "\r",
     };
     // Replace encoded characters with their original symbols using the defined mapping.
-    return (input.replace(/%(2C|7C|26|24|23|40|5E|3A|21|3B|\\n|\\r)/g, (match) => replacements[match]) || null);
+    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.
@@ -370,29 +373,35 @@ export const replace = async (filePath, replacements) => {
 export const append = async (filePath, data) => {
     const fileTempPath = filePath.replace(/([^/]+)\/?$/, `.tmp/$1`);
     if (await isExists(filePath)) {
-        let fileHandle, fileTempHandle, rl;
-        try {
-            fileHandle = await open(filePath, "r");
-            fileTempHandle = await open(fileTempPath, "w");
-            rl = readLineInternface(fileHandle);
-            let isAppended = false;
-            await _pipeline(rl, fileTempHandle.createWriteStream(), new Transform({
-                transform(line, encoding, callback) {
-                    if (!isAppended) {
-                        isAppended = true;
-                        return callback(null, `${Array.isArray(data) ? data.join("\n") : data}\n` +
-                            (line.length ? `${line}\n` : ""));
-                    }
-                    else
-                        return callback(null, `${line}\n`);
-                },
-            }));
+        if (!Config.isReverseEnabled && !Config.isCompressionEnabled) {
+            await copyFile(filePath, fileTempPath);
+            await appendFile(fileTempPath, `${Array.isArray(data) ? data.join("\n") : data}\n`);
         }
-        finally {
-            // Ensure that file handles are closed, even if an error occurred
-            rl?.close();
-            await fileHandle?.close();
-            await fileTempHandle?.close();
+        else {
+            let fileHandle, fileTempHandle, rl;
+            try {
+                fileHandle = await open(filePath, "r");
+                fileTempHandle = await open(fileTempPath, "w");
+                rl = readLineInternface(fileHandle);
+                let isAppended = false;
+                await _pipeline(rl, fileTempHandle.createWriteStream(), new Transform({
+                    transform(line, encoding, callback) {
+                        if (!isAppended) {
+                            isAppended = true;
+                            return callback(null, `${Array.isArray(data) ? data.join("\n") : data}\n` +
+                                (line.length ? `${line}\n` : ""));
+                        }
+                        else
+                            return callback(null, `${line}\n`);
+                    },
+                }));
+            }
+            finally {
+                // Ensure that file handles are closed, even if an error occurred
+                rl?.close();
+                await fileHandle?.close();
+                await fileTempHandle?.close();
+            }
         }
     }
     else

package/dist/index.d.ts

@@ -57,6 +57,8 @@ declare global {
         entries<T extends object>(o: T): Entries<T>;
     }
 }
+export type ErrorCodes = "FIELD_REQUIRED" | "NO_SCHEMA" | "NO_ITEMS" | "NO_RESULTS" | "INVALID_ID" | "INVALID_TYPE" | "INVALID_PARAMETERS";
+export type ErrorLang = "en";
 export default class Inibase {
     folder: string;
     database: string;

package/dist/index.js

@@ -7,6 +7,7 @@ import File from "./file.js";
 import Utils from "./utils.js";
 import UtilsServer from "./utils.server.js";
 import Config from "./config.js";
+import { inspect } from "node:util";
 export default class Inibase {
     folder;
     database;
@@ -32,27 +33,24 @@ export default class Inibase {
     throwError(code, variable, language = "en") {
         const errorMessages = {
             en: {
-                FIELD_REQUIRED: "REQUIRED: {variable}",
-                NO_SCHEMA: "NO_SCHEMA: {variable}",
-                NO_ITEMS: "NO_ITEMS: {variable}",
-                NO_DATA: "NO_DATA: {variable}",
-                INVALID_ID: "INVALID_ID: {variable}",
-                INVALID_TYPE: "INVALID_TYPE: {variable}",
-                INVALID_OPERATOR: "INVALID_OPERATOR: {variable}",
-                INVALID_PARAMETERS: "PARAMETERS: {variable}",
+                FIELD_REQUIRED: "Field {variable} is required",
+                NO_SCHEMA: "Table {variable} does't have a schema",
+                NO_ITEMS: "Table {variable} is empty",
+                NO_RESULTS: "No results found for table {variable}",
+                INVALID_ID: "The given ID(s) is/are not valid(s)",
+                INVALID_TYPE: "Expect {variable} to be {variable}, got {variable} instead",
+                INVALID_PARAMETERS: "The given parameters are not valid",
             },
             // Add more languages and error messages as needed
         };
-        let errorMessage = errorMessages[language][code] || code;
-        if (variable) {
-            if (typeof variable === "string" ||
-                typeof variable === "number" ||
-                Array.isArray(variable))
-                errorMessage = errorMessage.replaceAll(`{variable}`, Array.isArray(variable) ? variable.join(", ") : variable);
-            else
-                Object.keys(variable).forEach((variableKey) => (errorMessage = errorMessage.replaceAll(`{${variableKey}}`, variable[variableKey].toString())));
-        }
-        return new Error(errorMessage);
+        let errorMessage = errorMessages[language][code];
+        if (!errorMessage)
+            return new Error("ERR");
+        return new Error(variable
+            ? Array.isArray(variable)
+                ? errorMessage.replace(/\{variable\}/g, () => variable.shift()?.toString() ?? "")
+                : errorMessage.replaceAll(`{variable}`, `'${variable.toString()}'`)
+            : errorMessage.replaceAll(`{variable}`, ""));
     }
     async createWorker(functionName, arg) {
         return new Promise((resolve, reject) => {
@@ -105,6 +103,8 @@ export default class Inibase {
             await mkdir(tablePath, { recursive: true });
         if (!(await File.isExists(join(tablePath, ".tmp"))))
             await mkdir(join(tablePath, ".tmp"));
+        if (!(await File.isExists(join(tablePath, ".cache"))))
+            await mkdir(join(tablePath, ".cache"));
         if (await File.isExists(tableSchemaPath)) {
             // update columns files names based on field id
             const replaceOldPathes = Utils.findChangedProperties(this._schemaToIdsPath((await this.getTableSchema(tableName)) ?? []), this._schemaToIdsPath(schema));
@@ -180,7 +180,11 @@ export default class Inibase {
                         !Utils.isArrayOfObjects(field.children)
                         ? field.children
                         : undefined))
-                    throw this.throwError("INVALID_TYPE", [field.key, field.type]);
+                    throw this.throwError("INVALID_TYPE", [
+                        field.key,
+                        field.type,
+                        typeof data[field.key],
+                    ]);
                 if ((field.type === "array" || field.type === "object") &&
                     field.children &&
                     Utils.isArrayOfObjects(field.children))
@@ -642,9 +646,9 @@ export default class Inibase {
             .filter((i) => i);
     }
     async clearCache(tablePath) {
-        await Promise.all((await readdir(join(tablePath, ".tmp")))
-            ?.filter((fileName) => !["pagination.inib", "locked.inib"].includes(fileName))
-            .map(async (file) => unlink(join(tablePath, ".tmp", file))));
+        await Promise.all((await readdir(join(tablePath, ".cache")))
+            ?.filter((fileName) => fileName !== "pagination.inib")
+            .map(async (file) => unlink(join(tablePath, ".cache", file))));
     }
     async get(tableName, where, options = {
         page: 1,
@@ -676,15 +680,15 @@ export default class Inibase {
                 index +
                 1), options));
             if (Config.isCacheEnabled &&
-                (await File.isExists(join(tablePath, ".tmp", "pagination.inib"))))
-                this.totalItems[tableName + "-*"] = Number((await File.read(join(tablePath, ".tmp", "pagination.inib"), true)).split(",")[1]);
+                (await File.isExists(join(tablePath, ".cache", "pagination.inib"))))
+                this.totalItems[tableName + "-*"] = Number((await File.read(join(tablePath, ".cache", "pagination.inib"), true)).split(",")[1]);
             else {
                 let [lastId, totalItems] = await File.get(join(tablePath, "id.inib"), -1, "number", undefined, this.salt, true);
                 if (lastId)
                     lastId = Number(Object.keys(lastId)[0] ?? 0);
                 this.totalItems[tableName + "-*"] = totalItems;
                 if (Config.isCacheEnabled)
-                    await File.write(join(tablePath, ".tmp", "pagination.inib"), `${lastId},${totalItems}`, true);
+                    await File.write(join(tablePath, ".cache", "pagination.inib"), `${lastId},${totalItems}`, true);
             }
         }
         else if ((Array.isArray(where) && where.every(Utils.isNumber)) ||
@@ -708,7 +712,7 @@ export default class Inibase {
                 Ids = [Ids];
             const [lineNumbers, countItems] = await File.search(join(tablePath, "id.inib"), "[]", Ids.map((id) => Utils.isNumber(id) ? Number(id) : UtilsServer.decodeID(id, this.salt)), undefined, "number", undefined, Ids.length, 0, !this.totalItems[tableName + "-*"], this.salt);
             if (!lineNumbers)
-                throw this.throwError("INVALID_ID", where);
+                throw this.throwError("NO_RESULTS", tableName);
             if (onlyLinesNumbers)
                 return Object.keys(lineNumbers).length
                     ? Object.keys(lineNumbers).map(Number)
@@ -723,7 +727,7 @@ export default class Inibase {
             let cachedFilePath = "";
             // Criteria
             if (Config.isCacheEnabled)
-                cachedFilePath = join(tablePath, ".tmp", `${UtilsServer.hashObject(where)}.inib`);
+                cachedFilePath = join(tablePath, ".cache", `${UtilsServer.hashString(inspect(where, { sorted: true }))}.inib`);
             if (Config.isCacheEnabled && (await File.isExists(cachedFilePath))) {
                 const cachedItems = (await File.read(cachedFilePath, true)).split(",");
                 this.totalItems[tableName + "-*"] = cachedItems.length;
@@ -775,13 +779,14 @@ export default class Inibase {
         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 {
-            await File.lock(join(tablePath, ".tmp"));
+            await File.lock(join(tablePath, ".tmp"), keys);
             if (await File.isExists(join(tablePath, "id.inib"))) {
                 if (Config.isCacheEnabled &&
-                    (await File.isExists(join(tablePath, ".tmp", "pagination.inib"))))
-                    [lastId, totalItems] = (await File.read(join(tablePath, ".tmp", "pagination.inib"), true))
+                    (await File.isExists(join(tablePath, ".cache", "pagination.inib"))))
+                    [lastId, totalItems] = (await File.read(join(tablePath, ".cache", "pagination.inib"), true))
                         .split(",")
                         .map(Number);
                 else {
@@ -803,10 +808,12 @@ export default class Inibase {
                     ...rest,
                     createdAt: Date.now(),
                 }))(data);
-            if (!RETURN)
-                throw this.throwError("NO_DATA");
             RETURN = this.formatData(RETURN, schema);
-            const pathesContents = this.joinPathesContents(join(tablePath), Array.isArray(RETURN) ? RETURN.toReversed() : RETURN);
+            const pathesContents = this.joinPathesContents(tablePath, Config.isReverseEnabled
+                ? Array.isArray(RETURN)
+                    ? RETURN.toReversed()
+                    : RETURN
+                : RETURN);
             await Promise.all(Object.entries(pathesContents).map(async ([path, content]) => renameList.push(this.isThreadEnabled
                 ? await File.createWorker("append", [path, content])
                 : await File.append(path, content))));
@@ -814,7 +821,7 @@ export default class Inibase {
             renameList = [];
             if (Config.isCacheEnabled) {
                 await this.clearCache(tablePath);
-                await File.write(join(tablePath, ".tmp", "pagination.inib"), `${lastId},${totalItems + (Array.isArray(RETURN) ? RETURN.length : 1)}`, true);
+                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
@@ -823,7 +830,7 @@ export default class Inibase {
         finally {
             if (renameList.length)
                 await Promise.allSettled(renameList.map(async ([tempPath, _]) => unlink(tempPath)));
-            await File.unlock(join(tablePath, ".tmp"));
+            await File.unlock(join(tablePath, ".tmp"), keys);
         }
     }
     async put(tableName, data, where, options = {
@@ -852,23 +859,33 @@ export default class Inibase {
                 return this.put(tableName, data, UtilsServer.decodeID(data.id, this.salt));
             }
             else {
-                const pathesContents = this.joinPathesContents(join(tablePath), Utils.isArrayOfObjects(data)
-                    ? data.map((item) => ({
-                        ...(({ id, ...restOfData }) => restOfData)(item),
-                        updatedAt: Date.now(),
-                    }))
-                    : {
-                        ...(({ id, ...restOfData }) => restOfData)(data),
-                        updatedAt: Date.now(),
-                    });
+                let totalItems;
+                if (Config.isCacheEnabled &&
+                    (await File.isExists(join(tablePath, ".cache", "pagination.inib"))))
+                    totalItems = (await File.read(join(tablePath, ".cache", "pagination.inib"), true))
+                        .split(",")
+                        .map(Number)[1];
+                else
+                    totalItems = await File.count(join(tablePath, "id.inib"));
+                const pathesContents = this.joinPathesContents(tablePath, {
+                    ...(({ id, ...restOfData }) => restOfData)(data),
+                    updatedAt: Date.now(),
+                });
                 try {
                     await File.lock(join(tablePath, ".tmp"));
                     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 File.createWorker("replace", [
+                            path,
+                            Utils.combineObjects([...Array(totalItems)].map((_, i) => ({
+                                [`${i + 1}`]: content,
+                            }))),
+                        ])
+                        : await File.replace(path, Utils.combineObjects([...Array(totalItems)].map((_, i) => ({
+                            [`${i + 1}`]: content,
+                        })))))));
                     await Promise.all(renameList.map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
                     if (Config.isCacheEnabled)
-                        await this.clearCache(join(tablePath, ".tmp"));
+                        await this.clearCache(join(tablePath, ".cache"));
                     if (returnPostedData)
                         return this.get(tableName, where, options, undefined, undefined, schema);
                 }
@@ -891,7 +908,7 @@ export default class Inibase {
             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(join(tablePath), Utils.isArrayOfObjects(data)
+                const pathesContents = Object.fromEntries(Object.entries(this.joinPathesContents(tablePath, Utils.isArrayOfObjects(data)
                     ? data.map((item) => ({
                         ...item,
                         updatedAt: Date.now(),
@@ -903,8 +920,11 @@ export default class Inibase {
                         [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"));
+                    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))));
@@ -918,18 +938,18 @@ export default class Inibase {
                 finally {
                     if (renameList.length)
                         await Promise.allSettled(renameList.map(async ([tempPath, _]) => unlink(tempPath)));
-                    await File.unlock(join(tablePath, ".tmp"));
+                    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_ITEMS", tableName);
+                throw this.throwError("NO_RESULTS", tableName);
             return this.put(tableName, data, lineNumbers);
         }
         else
-            throw this.throwError("INVALID_PARAMETERS", tableName);
+            throw this.throwError("INVALID_PARAMETERS");
     }
     async delete(tableName, where, _id) {
         let renameList = [];
@@ -942,7 +962,7 @@ export default class Inibase {
         if (!where) {
             try {
                 await File.lock(join(tablePath, ".tmp"));
-                await Promise.all((await readdir(join(tablePath)))
+                await Promise.all((await readdir(tablePath))
                     ?.filter((fileName) => fileName.endsWith(".inib"))
                     .map(async (file) => unlink(join(tablePath, file))));
                 if (Config.isCacheEnabled)
@@ -967,12 +987,12 @@ export default class Inibase {
             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(join(tablePath)))?.filter((fileName) => fileName.endsWith(".inib"));
+                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_ITEMS", tableName);
+                        throw this.throwError("NO_RESULTS", tableName);
                     try {
                         await File.lock(join(tablePath, ".tmp"));
                         await Promise.all(files.map(async (file) => renameList.push(this.isThreadEnabled
@@ -984,11 +1004,11 @@ export default class Inibase {
                         await Promise.all(renameList.map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
                         if (Config.isCacheEnabled) {
                             await this.clearCache(tablePath);
-                            if (await File.isExists(join(tablePath, ".tmp", "pagination.inib"))) {
-                                let [lastId, totalItems] = (await File.read(join(tablePath, ".tmp", "pagination.inib"), true))
+                            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, ".tmp", "pagination.inib"), `${lastId},${totalItems - (Array.isArray(where) ? where.length : 1)}`, true);
+                                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;
@@ -1004,11 +1024,11 @@ export default class Inibase {
         else if (Utils.isObject(where)) {
             const lineNumbers = await this.get(tableName, where, undefined, undefined, true, schema);
             if (!lineNumbers || !lineNumbers.length)
-                throw this.throwError("NO_ITEMS", tableName);
+                throw this.throwError("NO_RESULTS", tableName);
             return this.delete(tableName, lineNumbers);
         }
         else
-            throw this.throwError("INVALID_PARAMETERS", tableName);
+            throw this.throwError("INVALID_PARAMETERS");
         return null;
     }
     async sum(tableName, columns, where) {

package/dist/utils.d.ts

@@ -1,4 +1,4 @@
-import { type FieldType, ComparisonOperator } from "./index.js";
+import type { FieldType, ComparisonOperator } from "./index.js";
 /**
  * Type guard function to check if the input is an array of objects.
  *

package/dist/utils.server.d.ts

@@ -70,7 +70,7 @@ export declare const addIdToSchema: (schema: Schema, oldIndex: number | undefine
     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 hashObject: (obj: any) => string;
+export declare const hashString: (str: string) => string;
 export default class UtilsServer {
     static encodeID: (id: string | number, secretKeyOrSalt: string | number | Buffer) => string;
     static decodeID: (input: string, secretKeyOrSalt: string | number | Buffer) => number;
@@ -99,5 +99,5 @@ export default class UtilsServer {
         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 hashObject: (obj: any) => string;
+    static hashString: (str: string) => string;
 }

package/dist/utils.server.js

@@ -110,35 +110,7 @@ export const addIdToSchema = (schema, oldIndex = 0, secretKeyOrSalt, encodeIDs)
     }
     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 const hashString = (str) => createHash("sha256").update(str).digest("hex");
 export default class UtilsServer {
     static encodeID = encodeID;
     static decodeID = decodeID;
@@ -146,5 +118,5 @@ export default class UtilsServer {
     static comparePassword = comparePassword;
     static findLastIdNumber = findLastIdNumber;
     static addIdToSchema = addIdToSchema;
-    static hashObject = hashObject;
+    static hashString = hashString;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inibase",
-  "version": "1.0.0-rc.39",
+  "version": "1.0.0-rc.40",
   "author": {
     "name": "Karim Amahtil",
     "email": "karim.amahtil@gmail.com"
@@ -75,12 +75,14 @@
   },
   "devDependencies": {
     "@types/node": "^20.10.6",
+    "tinybench": "^2.6.0",
     "typescript": "^5.3.3"
   },
   "scripts": {
     "build": "npx tsc",
     "test": "npx tsx watch --expose-gc --env-file=.env ./index.test",
-    "benchmark:single": "npx tsx watch --expose-gc --env-file=.env ./benchmark/single",
-    "benchmark:bulk": "npx tsx watch --expose-gc --env-file=.env ./benchmark/bulk"
+    "benchmark": "npx tsx watch --env-file=.env ./benchmark/index",
+    "benchmark:single": "npx tsx --expose-gc --env-file=.env ./benchmark/single",
+    "benchmark:bulk": "npx tsx --expose-gc --env-file=.env ./benchmark/bulk"
   }
 }