inibase 1.0.0-rc.37 → 1.0.0-rc.39

package/README.md

@@ -105,6 +105,7 @@ Ps: Testing by default with `user` table, with username, email, password fields
   - [x] IP
   - [x] HTML
   - [x] Id
+  - [x] JSON
 - [ ] TO-DO:
   - [x] Improve caching
   - [x] Commenting the code
@@ -491,6 +492,33 @@ await db.min("user", ["age", ...], { isActive: false });
 
 </details>
 
+<details>
+<summary>createWorker</summary>
+
+```js
+import Inibase from "inibase";
+const db = new Inibase("/database_name");
+
+// POST 10,000 USER
+await Promise.all(
+  [...Array(10)]
+    .map((x, i) => i)
+    .map(
+      (_index) =>
+        db.createWorker("post", [
+          "user",
+          [...Array(1000)].map((_, i) => ({
+            username: `username_${i + 1}`,
+            email: `email_${i + 1}@test.com`,
+            password: `password_${i + 1}`,
+          })),
+        ])
+    )
+)
+```
+
+</details>
+
 ## Config
 
 The `.env` file supports the following parameters (make sure to run command with flag --env-file=.env)

package/dist/file.d.ts

@@ -17,10 +17,9 @@ export declare const isExists: (path: string) => Promise<boolean>;
  * If the input is a single value, it is directly secured.
  *
  * @param input - A value or array of values (string, number, boolean, null).
- * @param secretKey - Optional secret key for encoding, can be a string or Buffer.
  * @returns The secured and/or joined string.
  */
-export declare const encode: (input: string | number | boolean | null | (string | number | boolean | null)[], secretKey?: string | Buffer) => string | number | boolean | null;
+export declare const encode: (input: string | number | boolean | null | (string | number | boolean | null)[]) => string | number | boolean | null;
 /**
  * Decodes the input based on the specified field type(s) and an optional secret key.
  * Handles different formats of input, including strings, numbers, and their array representations.
@@ -143,6 +142,7 @@ export declare const max: (filePath: string, lineNumbers?: number | number[]) =>
  * Note: Decodes each line as a number using the 'decode' function. Considers only numerical values for determining the minimum.
  */
 export declare const min: (filePath: string, lineNumbers?: number | number[]) => Promise<number>;
+export declare function createWorker(functionName: "get" | "remove" | "search" | "replace" | "sum" | "min" | "max" | "append" | "count", arg: any[]): Promise<any>;
 /**
  * Asynchronously sorts the lines in a file in the specified direction.
  *
@@ -160,7 +160,7 @@ export default class File {
     static remove: (filePath: string, linesToDelete: number | number[]) => Promise<string[]>;
     static search: (filePath: string, operator: ComparisonOperator | ComparisonOperator[], comparedAtValue: string | number | boolean | (string | number | boolean | null)[] | null, logicalOperator?: "and" | "or" | undefined, fieldType?: FieldType | FieldType[] | undefined, fieldChildrenType?: FieldType | FieldType[] | undefined, limit?: number | undefined, offset?: number | undefined, readWholeFile?: boolean | undefined, secretKey?: string | Buffer | undefined) => Promise<[Record<number, string | number | boolean | (string | number | boolean | null)[] | null> | null, number, Set<number> | null]>;
     static replace: (filePath: string, replacements: string | number | boolean | (string | number | boolean | null)[] | Record<number, string | number | boolean | (string | number | boolean | null)[] | null> | null) => Promise<string[]>;
-    static encode: (input: string | number | boolean | (string | number | boolean | null)[] | null, secretKey?: string | Buffer | undefined) => string | number | boolean | null;
+    static encode: (input: string | number | boolean | (string | number | boolean | null)[] | null) => string | number | boolean | null;
     static decode: (input: string | number | null, fieldType?: FieldType | FieldType[] | undefined, fieldChildrenType?: FieldType | FieldType[] | undefined, secretKey?: string | Buffer | undefined) => string | number | boolean | (string | number | boolean | null)[] | null;
     static isExists: (path: string) => Promise<boolean>;
     static sum: (filePath: string, lineNumbers?: number | number[] | undefined) => Promise<number>;
@@ -172,4 +172,5 @@ export default class File {
     static read: (filePath: string, disableCompression?: boolean) => Promise<string>;
     static lock: (folderPath: string) => Promise<void>;
     static unlock: (folderPath: string) => Promise<void>;
+    static createWorker: typeof createWorker;
 }

package/dist/file.js

@@ -5,7 +5,8 @@ import { pipeline } from "node:stream/promises";
 import { createGzip, createGunzip, gzip as gzipAsync, gunzip as gunzipAsync, } from "node:zlib";
 import { promisify } from "node:util";
 import { join } from "node:path";
-import { detectFieldType, isArrayOfArrays, isNumber, isObject, } from "./utils.js";
+import { Worker } from "node:worker_threads";
+import { detectFieldType, isArrayOfArrays, isNumber, isObject, isPassword, } from "./utils.js";
 import { encodeID, comparePassword } from "./utils.server.js";
 import Config from "./config.js";
 const gzip = promisify(gzipAsync);
@@ -144,10 +145,9 @@ const joinMultidimensionalArray = (arr, delimiter_index = 0) => {
  * If the input is a single value, it is directly secured.
  *
  * @param input - A value or array of values (string, number, boolean, null).
- * @param secretKey - Optional secret key for encoding, can be a string or Buffer.
  * @returns The secured and/or joined string.
  */
-export const encode = (input, secretKey) => {
+export const encode = (input) => {
     // Use the optimized secureArray and joinMultidimensionalArray functions.
     return Array.isArray(input)
         ? joinMultidimensionalArray(secureArray(input))
@@ -217,6 +217,8 @@ 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":
@@ -510,8 +512,7 @@ const isEqual = (originalValue, comparedAtValue, fieldType) => {
     switch (fieldType) {
         // Password comparison.
         case "password":
-            return typeof originalValue === "string" &&
-                typeof comparedAtValue === "string"
+            return isPassword(originalValue) && typeof comparedAtValue === "string"
                 ? comparePassword(originalValue, comparedAtValue)
                 : false;
         // Boolean comparison.
@@ -762,6 +763,19 @@ export const min = async (filePath, lineNumbers) => {
     await fileHandle.close();
     return min;
 };
+export function createWorker(functionName, arg) {
+    return new Promise(function (resolve, reject) {
+        const worker = new Worker("./dist/file.thread.js", {
+            workerData: { functionName, arg },
+        });
+        worker.on("message", (data) => {
+            resolve(data);
+        });
+        worker.on("error", (msg) => {
+            reject(`An error ocurred: ${msg}`);
+        });
+    });
+}
 /**
  * Asynchronously sorts the lines in a file in the specified direction.
  *
@@ -791,4 +805,5 @@ export default class File {
     static read = read;
     static lock = lock;
     static unlock = unlock;
+    static createWorker = createWorker;
 }

package/dist/file.thread.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/file.thread.js

@@ -0,0 +1,5 @@
+import { parentPort, workerData } from "node:worker_threads";
+import File from "./file.js";
+const { functionName, arg } = workerData;
+// @ts-ignore
+File[functionName](...arg).then((res) => parentPort.postMessage(res));

package/dist/index.d.ts

@@ -5,7 +5,7 @@ export interface Data {
     createdAt?: number;
     updatedAt?: number;
 }
-export type FieldType = "string" | "number" | "boolean" | "date" | "email" | "url" | "table" | "object" | "array" | "password" | "html" | "ip" | "id";
+export type FieldType = "string" | "number" | "boolean" | "date" | "email" | "url" | "table" | "object" | "array" | "password" | "html" | "ip" | "json" | "id";
 type FieldDefault = {
     id?: string | number;
     key: string;
@@ -62,10 +62,14 @@ export default class Inibase {
     database: string;
     table: string | null;
     pageInfo: Record<string, pageInfo>;
+    private isThreadEnabled;
     private totalItems;
     salt: Buffer;
-    constructor(database: string, mainFolder?: string);
+    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>;
+    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;
@@ -73,7 +77,12 @@ export default class Inibase {
     private formatField;
     private formatData;
     private getDefaultValue;
-    private joinPathesContents;
+    private _combineObjectsToArray;
+    private _CombineData;
+    private _addPathToKeys;
+    joinPathesContents(mainPath: string, data: Data | Data[]): {
+        [key: string]: string[];
+    };
     private getItemsFromSchema;
     private applyCriteria;
     private _filterSchemaByColumns;

package/dist/index.js

@@ -1,26 +1,27 @@
 import { unlink, rename, mkdir, readdir } from "node:fs/promises";
 import { existsSync, appendFileSync } from "node:fs";
 import { join } from "node:path";
-import { cpus } from "node:os";
 import { scryptSync, randomBytes } from "node:crypto";
+import { Worker } from "node:worker_threads";
 import File from "./file.js";
 import Utils from "./utils.js";
 import UtilsServer from "./utils.server.js";
 import Config from "./config.js";
-process.env.UV_THREADPOOL_SIZE = cpus().length.toString();
 export default class Inibase {
     folder;
     database;
     table;
     pageInfo;
+    isThreadEnabled = false;
     totalItems;
     salt;
-    constructor(database, mainFolder = ".") {
+    constructor(database, mainFolder = ".", _table = null, _totalItems = {}, _pageInfo = {}, _isThreadEnabled = false) {
         this.database = database;
         this.folder = mainFolder;
-        this.table = null;
-        this.totalItems = {};
-        this.pageInfo = {};
+        this.table = _table;
+        this.totalItems = _totalItems;
+        this.pageInfo = _pageInfo;
+        this.isThreadEnabled = _isThreadEnabled;
         if (!existsSync(".env") || !process.env.INIBASE_SECRET) {
             this.salt = scryptSync(randomBytes(16), randomBytes(16), 32);
             appendFileSync(".env", `\nINIBASE_SECRET=${this.salt.toString("hex")}\n`);
@@ -53,46 +54,67 @@ export default class Inibase {
         }
         return new Error(errorMessage);
     }
-    async setTableSchema(tableName, schema) {
-        const decodeIdFromSchema = (schema) => schema.map((field) => {
+    async createWorker(functionName, arg) {
+        return new Promise((resolve, reject) => {
+            const worker = new Worker("./dist/index.thread.js", {
+                workerData: {
+                    _constructor: [
+                        this.database,
+                        this.folder,
+                        this.table,
+                        this.totalItems,
+                        this.pageInfo,
+                        true, // enable Thread
+                    ],
+                    functionName,
+                    arg,
+                },
+            });
+            worker.on("message", resolve);
+            worker.on("error", reject);
+        });
+    }
+    _decodeIdFromSchema = (schema) => schema.map((field) => {
+        if ((field.type === "array" || field.type === "object") &&
+            field.children &&
+            Utils.isArrayOfObjects(field.children))
+            field.children = this._decodeIdFromSchema(field.children);
+        if (field.id && !Utils.isNumber(field.id))
+            field.id = UtilsServer.decodeID(field.id, this.salt);
+        return field;
+    });
+    _schemaToIdsPath = (schema, prefix = "") => {
+        let RETURN = {};
+        for (const field of schema)
             if ((field.type === "array" || field.type === "object") &&
                 field.children &&
-                Utils.isArrayOfObjects(field.children))
-                field.children = decodeIdFromSchema(field.children);
-            if (field.id && !Utils.isNumber(field.id))
-                field.id = UtilsServer.decodeID(field.id, this.salt);
-            return field;
-        });
+                Utils.isArrayOfObjects(field.children)) {
+                Utils.deepMerge(RETURN, this._schemaToIdsPath(field.children, (prefix ?? "") + field.key + "."));
+            }
+            else if (Utils.isValidID(field.id))
+                RETURN[UtilsServer.decodeID(field.id, this.salt)] =
+                    (prefix ?? "") + field.key + ".inib";
+        return RETURN;
+    };
+    async setTableSchema(tableName, schema) {
+        const tablePath = join(this.folder, this.database, tableName), tableSchemaPath = join(tablePath, "schema.json"), isTablePathExists = await File.isExists(tablePath);
         // remove id from schema
         schema = schema.filter(({ key }) => !["id", "createdAt", "updatedAt"].includes(key));
-        schema = UtilsServer.addIdToSchema(schema, UtilsServer.findLastIdNumber(schema, this.salt), this.salt);
-        const tablePath = join(this.folder, this.database, tableName), tableSchemaPath = join(tablePath, "schema.json");
-        if (!(await File.isExists(tablePath)))
+        schema = UtilsServer.addIdToSchema(schema, UtilsServer.findLastIdNumber(schema, this.salt), this.salt, isTablePathExists);
+        if (!isTablePathExists)
             await mkdir(tablePath, { recursive: true });
         if (!(await File.isExists(join(tablePath, ".tmp"))))
             await mkdir(join(tablePath, ".tmp"));
         if (await File.isExists(tableSchemaPath)) {
             // update columns files names based on field id
-            const schemaToIdsPath = (schema, prefix = "") => {
-                let RETURN = {};
-                for (const field of schema)
-                    if ((field.type === "array" || field.type === "object") &&
-                        field.children &&
-                        Utils.isArrayOfObjects(field.children)) {
-                        Utils.deepMerge(RETURN, schemaToIdsPath(field.children, (prefix ?? "") + field.key + "."));
-                    }
-                    else if (Utils.isValidID(field.id))
-                        RETURN[UtilsServer.decodeID(field.id, this.salt)] =
-                            (prefix ?? "") + field.key + ".inib";
-                return RETURN;
-            }, replaceOldPathes = Utils.findChangedProperties(schemaToIdsPath((await this.getTableSchema(tableName)) ?? []), schemaToIdsPath(schema));
+            const replaceOldPathes = Utils.findChangedProperties(this._schemaToIdsPath((await this.getTableSchema(tableName)) ?? []), this._schemaToIdsPath(schema));
             if (replaceOldPathes)
                 await Promise.all(Object.entries(replaceOldPathes).map(async ([oldPath, newPath]) => {
                     if (await File.isExists(join(tablePath, oldPath)))
                         await rename(join(tablePath, oldPath), join(tablePath, newPath));
                 }));
         }
-        await File.write(join(tablePath, "schema.json"), JSON.stringify(decodeIdFromSchema(schema), null, 2), true);
+        await File.write(join(tablePath, "schema.json"), JSON.stringify(isTablePathExists ? this._decodeIdFromSchema(schema) : schema, null, 2), true);
     }
     async getTableSchema(tableName) {
         const tableSchemaPath = join(this.folder, this.database, tableName, "schema.json");
@@ -158,7 +180,7 @@ export default class Inibase {
                         !Utils.isArrayOfObjects(field.children)
                         ? field.children
                         : undefined))
-                    throw this.throwError("INVALID_TYPE", field.key + " " + field.type + " " + data[field.key]);
+                    throw this.throwError("INVALID_TYPE", [field.key, field.type]);
                 if ((field.type === "array" || field.type === "object") &&
                     field.children &&
                     Utils.isArrayOfObjects(field.children))
@@ -225,7 +247,7 @@ export default class Inibase {
             case "password":
                 if (Array.isArray(value))
                     value = value[0];
-                return typeof value === "string" && value.length === 161
+                return Utils.isPassword(value)
                     ? value
                     : UtilsServer.hashPassword(String(value));
             case "number":
@@ -238,6 +260,8 @@ export default class Inibase {
                 return Utils.isNumber(value)
                     ? value
                     : UtilsServer.decodeID(value, this.salt);
+            case "json":
+                return JSON.stringify(value);
             default:
                 return value;
         }
@@ -292,13 +316,41 @@ export default class Inibase {
                 return null;
         }
     }
+    _combineObjectsToArray = (input) => input.reduce((result, current) => {
+        for (const [key, value] of Object.entries(current))
+            if (!result[key])
+                result[key] = [value];
+            else
+                result[key].push(value);
+        return result;
+    }, {});
+    _CombineData = (_data, prefix) => {
+        let RETURN = {};
+        if (Utils.isArrayOfObjects(_data))
+            RETURN = this._combineObjectsToArray(_data.map((single_data) => this._CombineData(single_data)));
+        else
+            for (const [key, value] of Object.entries(_data)) {
+                if (Utils.isObject(value))
+                    Object.assign(RETURN, this._CombineData(value, `${key}.`));
+                else if (Utils.isArrayOfObjects(value)) {
+                    Object.assign(RETURN, this._CombineData(this._combineObjectsToArray(value), (prefix ?? "") + key + "."));
+                }
+                else if (Utils.isArrayOfArrays(value) &&
+                    value.every(Utils.isArrayOfObjects))
+                    Object.assign(RETURN, this._CombineData(this._combineObjectsToArray(value.map(this._combineObjectsToArray)), (prefix ?? "") + key + "."));
+                else
+                    RETURN[(prefix ?? "") + key] = File.encode(value);
+            }
+        return RETURN;
+    };
+    _addPathToKeys = (obj, path) => {
+        const newObject = {};
+        for (const key in obj)
+            newObject[join(path, key + ".inib")] = obj[key];
+        return newObject;
+    };
     joinPathesContents(mainPath, data) {
-        return Utils.isArrayOfObjects(data)
-            ? Utils.combineObjects(data.map((single_data) => this.joinPathesContents(mainPath, single_data)))
-            : Object.fromEntries(Object.entries(Utils.objectToDotNotation(data)).map(([key, value]) => [
-                join(mainPath, key + ".inib"),
-                File.encode(value, this.salt),
-            ]));
+        return this._addPathToKeys(this._CombineData(data), mainPath);
     }
     async getItemsFromSchema(tableName, schema, linesNumber, options, prefix) {
         const tablePath = join(this.folder, this.database, tableName);
@@ -755,7 +807,9 @@ export default class Inibase {
                 throw this.throwError("NO_DATA");
             RETURN = this.formatData(RETURN, schema);
             const pathesContents = this.joinPathesContents(join(tablePath), Array.isArray(RETURN) ? RETURN.toReversed() : RETURN);
-            await Promise.all(Object.entries(pathesContents).map(async ([path, content]) => renameList.push(await File.append(path, content))));
+            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))));
             await Promise.all(renameList.map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
             renameList = [];
             if (Config.isCacheEnabled) {
@@ -809,7 +863,9 @@ export default class Inibase {
                     });
                 try {
                     await File.lock(join(tablePath, ".tmp"));
-                    await Promise.all(Object.entries(pathesContents).map(async ([path, content]) => renameList.push(await File.replace(path, content))));
+                    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)));
                     if (Config.isCacheEnabled)
                         await this.clearCache(join(tablePath, ".tmp"));
@@ -849,7 +905,9 @@ export default class Inibase {
                 ]));
                 try {
                     await File.lock(join(tablePath, ".tmp"));
-                    await Promise.all(Object.entries(pathesContents).map(async ([path, content]) => renameList.push(await File.replace(path, content))));
+                    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)
@@ -917,7 +975,12 @@ export default class Inibase {
                         throw this.throwError("NO_ITEMS", tableName);
                     try {
                         await File.lock(join(tablePath, ".tmp"));
-                        await Promise.all(files.map(async (file) => renameList.push(await File.remove(join(tablePath, file), where))));
+                        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);

package/dist/index.thread.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.thread.js

@@ -0,0 +1,6 @@
+import Inibase from "./index.js";
+import { parentPort, workerData } from "node:worker_threads";
+const { _constructor, functionName, arg } = workerData;
+// @ts-ignore
+new Inibase(..._constructor)[functionName](...arg)
+    .then((res) => parentPort?.postMessage(res));

package/dist/utils.d.ts

@@ -167,13 +167,6 @@ export declare const detectFieldType: (input: any, availableTypes: FieldType[])
  * @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 declare function FormatObjectCriteriaValue(value: string, isParentArray?: boolean): [
     ComparisonOperator,
     string | number | boolean | null | (string | number | null)[]
@@ -197,7 +190,6 @@ export default class Utils {
     static isHTML: (input: any) => boolean;
     static isIP: (input: any) => boolean;
     static validateFieldType: (value: any, fieldType: FieldType | FieldType[], fieldChildrenType?: FieldType | FieldType[] | undefined) => boolean;
-    static objectToDotNotation: (input: Record<string, any>) => Record<string, string | number | (string | number)[]>;
     static isArrayOfNulls: (input: any) => input is null[] | null[][];
     static FormatObjectCriteriaValue: typeof FormatObjectCriteriaValue;
 }

package/dist/utils.js

@@ -135,6 +135,7 @@ export const isURL = (input) => {
     else {
         var 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
@@ -192,7 +193,7 @@ export const isBoolean = (input) => typeof input === "boolean" ||
  *
  * Note: Specifically checks for string length to determine if it matches the defined password length criterion.
  */
-export const isPassword = (input) => input.length === 161;
+export const isPassword = (input) => typeof input === "string" && input.length === 97;
 /**
  * Checks if the input can be converted to a valid date.
  *
@@ -209,6 +210,24 @@ export const isDate = (input) => !isNaN(new Date(input).getTime()) || !isNaN(Dat
 export const isValidID = (input) => {
     return typeof input === "string" && input.length === 32;
 };
+/**
+ * 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.
+ */
+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;
+    }
+}
 /**
  * Identifies and returns properties that have changed between two objects.
  *
@@ -256,8 +275,10 @@ export const detectFieldType = (input, availableTypes) => {
             return "url";
         else if (availableTypes.includes("password") && isPassword(input))
             return "password";
-        else if (availableTypes.includes("date") && isDate(input))
-            return "date";
+        else if (availableTypes.includes("json") && isJSON(input))
+            return "json";
+        else if (availableTypes.includes("json") && isDate(input))
+            return "json";
         else if (availableTypes.includes("string") && isString(input))
             return "string";
         else if (availableTypes.includes("ip") && isIP(input))
@@ -288,7 +309,7 @@ export const validateFieldType = (value, fieldType, fieldChildrenType) => {
         case "string":
             return isString(value);
         case "password":
-            return isNumber(value) || isString(value) || isPassword(value);
+            return isNumber(value) || isPassword(value) || isString(value);
         case "number":
             return isNumber(value);
         case "html":
@@ -322,47 +343,12 @@ export const validateFieldType = (value, fieldType, fieldChildrenType) => {
                 return isNumber(value) || isValidID(value);
         case "id":
             return isNumber(value) || isValidID(value);
+        case "json":
+            return isJSON(value) || Array.isArray(value) || isObject(value);
         default:
             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 = [
-        { obj: input },
-    ];
-    while (stack.length > 0) {
-        const { obj, parentKey } = stack.pop();
-        for (const key in obj) {
-            if (obj.hasOwnProperty(key)) {
-                const newKey = parentKey ? `${parentKey}.${key}` : key;
-                const value = obj[key];
-                const isArray = Array.isArray(value);
-                const isStringOrNumberArray = isArray &&
-                    value.every((item) => typeof item === "string" || typeof item === "number");
-                if (isStringOrNumberArray) {
-                    // If the property is an array of strings or numbers, keep the array as is
-                    result[newKey] = value;
-                }
-                else if (isObject(value)) {
-                    // If the property is an object, push it onto the stack for further processing
-                    stack.push({ obj: value, parentKey: newKey });
-                }
-                else {
-                    // Otherwise, assign the value to the dot notation key
-                    result[newKey] = value;
-                }
-            }
-        }
-    }
-    return result;
-};
 export function FormatObjectCriteriaValue(value, isParentArray = false) {
     switch (value[0]) {
         case ">":
@@ -436,7 +422,6 @@ export default class Utils {
     static isHTML = isHTML;
     static isIP = isIP;
     static validateFieldType = validateFieldType;
-    static objectToDotNotation = objectToDotNotation;
     static isArrayOfNulls = isArrayOfNulls;
     static FormatObjectCriteriaValue = FormatObjectCriteriaValue;
 }

package/dist/utils.server.d.ts

@@ -45,14 +45,15 @@ export declare const findLastIdNumber: (schema: Schema, secretKeyOrSalt: string
  * @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.
+ * @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) => (({
+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" | "date" | "password" | "ip";
+    type: "string" | "number" | "boolean" | "id" | "url" | "html" | "table" | "email" | "json" | "date" | "password" | "ip";
     children?: undefined;
 }) | ({
     id?: string | number | undefined;
@@ -67,7 +68,7 @@ export declare const addIdToSchema: (schema: Schema, oldIndex: number | undefine
     required?: boolean | undefined;
 } & {
     type: "array";
-    children: "string" | "number" | "boolean" | "object" | "id" | "url" | "html" | "table" | "email" | "date" | "password" | "ip" | Schema | ("string" | "number" | "boolean" | "object" | "id" | "url" | "html" | "table" | "email" | "date" | "password" | "ip")[];
+    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 default class UtilsServer {
@@ -76,12 +77,12 @@ export default class UtilsServer {
     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) => (({
+    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" | "date" | "password" | "ip";
+        type: "string" | "number" | "boolean" | "id" | "url" | "html" | "table" | "email" | "json" | "date" | "password" | "ip";
         children?: undefined;
     }) | ({
         id?: string | number | undefined;
@@ -96,7 +97,7 @@ export default class UtilsServer {
         required?: boolean | undefined;
     } & {
         type: "array";
-        children: "string" | "number" | "boolean" | "object" | "id" | "url" | "html" | "table" | "email" | "date" | "password" | "ip" | Schema | ("string" | "number" | "boolean" | "object" | "id" | "url" | "html" | "table" | "email" | "date" | "password" | "ip")[];
+        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;
 }

package/dist/utils.server.js

@@ -87,24 +87,25 @@ export const findLastIdNumber = (schema, secretKeyOrSalt) => {
  * @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.
+ * @param encodeIDs - If true, IDs will be encoded, else they will remain as numbers.
  * @returns The updated schema with encoded IDs.
  */
-export const addIdToSchema = (schema, oldIndex = 0, secretKeyOrSalt) => schema.map((field) => {
+export const addIdToSchema = (schema, oldIndex = 0, secretKeyOrSalt, encodeIDs) => schema.map((field) => {
     if (!field.id) {
         oldIndex++;
-        field.id = encodeID(oldIndex, secretKeyOrSalt);
+        field.id = encodeIDs ? encodeID(oldIndex, secretKeyOrSalt) : oldIndex;
     }
     else {
         if (!isNumber(field.id))
             oldIndex = decodeID(field.id, secretKeyOrSalt);
         else {
             oldIndex = field.id;
-            field.id = encodeID(field.id, secretKeyOrSalt);
+            field.id = encodeIDs ? encodeID(field.id, secretKeyOrSalt) : field.id;
         }
     }
     if ((field.type === "array" || field.type === "object") &&
         isArrayOfObjects(field.children)) {
-        field.children = addIdToSchema(field.children, oldIndex, secretKeyOrSalt);
+        field.children = addIdToSchema(field.children, oldIndex, secretKeyOrSalt, encodeIDs);
         oldIndex += field.children.length;
     }
     return field;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inibase",
-  "version": "1.0.0-rc.37",
+  "version": "1.0.0-rc.39",
   "author": {
     "name": "Karim Amahtil",
     "email": "karim.amahtil@gmail.com"
@@ -9,7 +9,9 @@
   "main": "./dist/index.js",
   "exports": {
     ".": "./dist/index.js",
+    "./thread": "./dist/index.thread.js",
     "./file": "./dist/file.js",
+    "./file.thread": "./dist/file.thread.js",
     "./config": "./dist/config.js",
     "./utils": "./dist/utils.js",
     "./utils.server": "./dist/utils.server.js"
@@ -51,9 +53,15 @@
   "types": "./dist",
   "typesVersions": {
     "*": {
+      "thread": [
+        "./dist/index.thread.d.ts"
+      ],
       "file": [
         "./dist/file.d.ts"
       ],
+      "file.thread": [
+        "./dist/file.thread.d.ts"
+      ],
       "utils": [
         "./dist/utils.d.ts"
       ],