inibase 1.0.0-rc.27 → 1.0.0-rc.29

package/README.md

@@ -4,7 +4,7 @@
 
 [![npmjs](https://img.shields.io/npm/dm/inibase.svg?style=flat)](https://www.npmjs.org/package/inibase) [![License](https://img.shields.io/github/license/inicontent/inibase.svg?style=flat&colorA=18181B&colorB=28CF8D)](./LICENSE) [![Activity](https://img.shields.io/github/commit-activity/m/inicontent/inibase)](https://github.com/inicontent/inibase/pulse) [![GitHub stars](https://img.shields.io/github/stars/inicontent/inibase?style=social)](https://github.com/inicontent/inibase)
 
-> A file-based & memory-efficient, serverless relational database management system :fire:
+> A file-based & memory-efficient, serverless, ACID compliant, relational database management system :fire:
 
 ## Features
 
@@ -74,6 +74,8 @@ To simplify the idea, each database has tables, each table has columns, each col
 | PUT    | 33 ms (10.29 mb)  | 312 ms (11.06 mb)  | 3539 ms (14.87 mb) |
 | DELETE | 134 ms (13.50 mb) | 1224 ms (16.57 mb) | 7339 ms (11.46 mb) |
 
+Ps: Testing by default with `user` table, with username, email, password fields _so results include password encryption process_
+
 
 ## Roadmap
 

package/dist/file.d.ts

@@ -43,7 +43,7 @@ export declare const decode: (input: string | null | number, fieldType?: FieldTy
  *   1. Record of line numbers and their decoded content or null if no lines are read.
  *   2. Total count of lines processed.
  */
-export declare function get(filePath: string, lineNumbers?: number | number[], fieldType?: FieldType | FieldType[], fieldChildrenType?: FieldType | FieldType[], secretKey?: string | Buffer): Promise<Record<number, string | number | boolean | null | (string | number | boolean | (string | number | boolean)[] | null)[]> | null>;
+export declare function get(filePath: string, lineNumbers?: number | number[], fieldType?: FieldType | FieldType[], fieldChildrenType?: FieldType | FieldType[], secretKey?: string | Buffer, readWholeFile?: false): Promise<Record<number, string | number | boolean | null | (string | number | boolean | (string | number | boolean)[] | null)[]> | null>;
 export declare function get(filePath: string, lineNumbers: undefined | number | number[], fieldType: undefined | FieldType | FieldType[], fieldChildrenType: undefined | FieldType | FieldType[], secretKey: undefined | string | Buffer, readWholeFile: true): Promise<[
     Record<number, string | number | boolean | null | (string | number | boolean | (string | number | boolean)[] | null)[]> | null,
     number

package/dist/file.js

@@ -187,46 +187,29 @@ const reverseJoinMultidimensionalArray = (joinedString) => {
  * @returns Decoded value, transformed according to the specified field type(s).
  */
 const decodeHelper = (value, fieldType, fieldChildrenType, secretKey) => {
-    // Use a stack-based approach for efficient processing without recursion.
-    const stack = [{ value }];
-    while (stack.length > 0) {
-        // Explicitly check if stack.pop() is not undefined.
-        const stackItem = stack.pop();
-        if (!stackItem) {
-            // Skip the rest of the loop if the stack item is undefined.
-            continue;
-        }
-        const { value } = stackItem;
-        if (Array.isArray(value) && fieldType !== "array") {
-            // If the value is an array and the fieldType is not 'array', process each element.
-            stack.push(...value.map((v) => ({ value: v })));
-        }
-        else {
-            switch (fieldType) {
-                // Handle different field types with appropriate decoding logic.
-                case "table":
-                case "number":
-                    return isNumber(value) ? Number(value) : null;
-                case "boolean":
-                    return typeof value === "string" ? value === "true" : Boolean(value);
-                case "array":
-                    if (!Array.isArray(value))
-                        return [value];
-                    if (fieldChildrenType)
-                        // Decode each element in the array based on the specified fieldChildrenType.
-                        return fieldChildrenType
-                            ? value.map((v) => decode(v, Array.isArray(fieldChildrenType)
-                                ? detectFieldType(v, fieldChildrenType)
-                                : fieldChildrenType, undefined, secretKey))
-                            : value;
-                case "id":
-                    return isNumber(value) && secretKey
-                        ? encodeID(value, secretKey)
-                        : value;
-                default:
-                    return value;
-            }
-        }
+    if (Array.isArray(value) && fieldType !== "array")
+        return value.map((v) => decodeHelper(v, fieldType, fieldChildrenType, secretKey));
+    switch (fieldType) {
+        case "table":
+        case "number":
+            return isNumber(value) ? Number(value) : null;
+        case "boolean":
+            return typeof value === "string" ? value === "true" : Boolean(value);
+        case "array":
+            if (!Array.isArray(value))
+                return [value];
+            if (fieldChildrenType)
+                return fieldChildrenType
+                    ? value.map((v) => decode(v, Array.isArray(fieldChildrenType)
+                        ? detectFieldType(v, fieldChildrenType)
+                        : fieldChildrenType, undefined, secretKey))
+                    : value;
+        case "id":
+            return isNumber(value) && secretKey
+                ? encodeID(value, secretKey)
+                : value;
+        default:
+            return value;
     }
 };
 /**
@@ -254,7 +237,7 @@ export const decode = (input, fieldType, fieldChildrenType, secretKey) => {
             : unSecureString(input)
         : input, fieldType, fieldChildrenType, secretKey);
 };
-export async function get(filePath, lineNumbers, fieldType, fieldChildrenType, secretKey, readWholeFile) {
+export async function get(filePath, lineNumbers, fieldType, fieldChildrenType, secretKey, readWholeFile = false) {
     let fileHandle, rl;
     try {
         fileHandle = await open(filePath, "r");
@@ -303,32 +286,49 @@ export async function get(filePath, lineNumbers, fieldType, fieldChildrenType, s
  * Note: If the file doesn't exist and replacements is an object, it creates a new file with the specified replacements.
  */
 export const replace = async (filePath, replacements) => {
-    let fileHandle, fileTempHandle, rl;
-    const fileTempPath = filePath.replace(/([^/]+)\/?$/, `.tmp/${Date.now()}-$1`);
-    try {
-        let linesCount = 0;
-        fileHandle = await open(filePath, "r");
-        fileTempHandle = await open(fileTempPath, "w");
-        rl = readLineInternface(fileHandle);
-        await _pipeline(rl, fileTempHandle.createWriteStream(), new Transform({
-            transform(line, encoding, callback) {
-                linesCount++;
-                const replacement = isObject(replacements)
-                    ? replacements.hasOwnProperty(linesCount)
-                        ? replacements[linesCount]
-                        : line
-                    : replacements;
-                callback(null, replacement + "\n");
-            },
-        }));
-        return [fileTempPath, filePath];
+    const fileTempPath = filePath.replace(/([^/]+)\/?$/, `.tmp/$1`);
+    if (await isExists(filePath)) {
+        let fileHandle, fileTempHandle, rl;
+        try {
+            let linesCount = 0;
+            fileHandle = await open(filePath, "r");
+            fileTempHandle = await open(fileTempPath, "w");
+            rl = readLineInternface(fileHandle);
+            await _pipeline(rl, fileTempHandle.createWriteStream(), new Transform({
+                transform(line, encoding, callback) {
+                    linesCount++;
+                    const replacement = isObject(replacements)
+                        ? replacements.hasOwnProperty(linesCount)
+                            ? replacements[linesCount]
+                            : line
+                        : replacements;
+                    return callback(null, replacement + "\n");
+                },
+            }));
+            return [fileTempPath, filePath];
+        }
+        finally {
+            // Ensure that file handles are closed, even if an error occurred
+            rl?.close();
+            await fileHandle?.close();
+            await fileTempHandle?.close();
+        }
     }
-    finally {
-        // Ensure that file handles are closed, even if an error occurred
-        rl?.close();
-        await fileHandle?.close();
-        await fileTempHandle?.close();
+    else if (isObject(replacements)) {
+        let replacementsKeys = Object.keys(replacements)
+            .map(Number)
+            .toSorted((a, b) => a - b);
+        await write(fileTempPath, "\n".repeat(replacementsKeys[0] - 1) +
+            replacementsKeys
+                .map((lineNumber, index) => index === 0 || lineNumber - replacementsKeys[index - 1] - 1 === 0
+                ? replacements[lineNumber]
+                : "\n".repeat(lineNumber - replacementsKeys[index - 1] - 1) +
+                    replacements[lineNumber])
+                .join("\n") +
+            "\n");
+        return [fileTempPath, filePath];
     }
+    return [];
 };
 /**
  * Asynchronously appends data to the beginning of a file.
@@ -339,7 +339,7 @@ export const replace = async (filePath, replacements) => {
  *
  */
 export const append = async (filePath, data) => {
-    const fileTempPath = filePath.replace(/([^/]+)\/?$/, `.tmp/${Date.now()}-$1`);
+    const fileTempPath = filePath.replace(/([^/]+)\/?$/, `.tmp/$1`);
     if (await isExists(filePath)) {
         let fileHandle, fileTempHandle, rl;
         try {
@@ -351,10 +351,10 @@ export const append = async (filePath, data) => {
                 transform(line, encoding, callback) {
                     if (!isAppended) {
                         isAppended = true;
-                        callback(null, `${Array.isArray(data) ? data.join("\n") : data}\n${line}\n`);
+                        return callback(null, `${Array.isArray(data) ? data.join("\n") : data}\n${line}\n`);
                     }
                     else
-                        callback(null, `${line}\n`);
+                        return callback(null, `${line}\n`);
                 },
             }));
         }
@@ -366,7 +366,7 @@ export const append = async (filePath, data) => {
         }
     }
     else
-        await write(fileTempPath, `${Array.isArray(data) ? data.join("\n") : data}\n`);
+        await write(fileTempPath, `${Array.isArray(data) ? data.join("\n") : data}\n`, undefined);
     return [fileTempPath, filePath];
 };
 /**
@@ -379,16 +379,24 @@ export const append = async (filePath, data) => {
  * Note: Creates a temporary file during the process and replaces the original file with it after removing lines.
  */
 export const remove = async (filePath, linesToDelete) => {
-    let linesCount = 0;
-    const fileHandle = await open(filePath, "r"), fileTempPath = filePath.replace(/([^/]+)\/?$/, `.tmp/${Date.now()}-$1`), fileTempHandle = await open(fileTempPath, "w"), linesToDeleteArray = new Set(Array.isArray(linesToDelete)
+    let linesCount = 0, deletedCount = 0;
+    const fileHandle = await open(filePath, "r"), fileTempPath = filePath.replace(/([^/]+)\/?$/, `.tmp/$1`), fileTempHandle = await open(fileTempPath, "w"), linesToDeleteArray = new Set(Array.isArray(linesToDelete)
         ? linesToDelete.map(Number)
         : [Number(linesToDelete)]), rl = readLineInternface(fileHandle);
     await _pipeline(rl, fileTempHandle.createWriteStream(), new Transform({
         transform(line, encoding, callback) {
             linesCount++;
-            if (!linesToDeleteArray.has(linesCount))
-                callback(null, `${line}\n`);
-            callback();
+            if (linesToDeleteArray.has(linesCount)) {
+                deletedCount++;
+                return callback();
+            }
+            else
+                return callback(null, `${line}\n`);
+        },
+        final(callback) {
+            if (deletedCount === linesCount)
+                this.push("\n");
+            return callback();
         },
     }));
     await fileTempHandle.close();

package/dist/index.d.ts

@@ -13,23 +13,25 @@ type FieldDefault = {
 };
 type FieldStringType = {
     type: Exclude<FieldType, "array" | "object">;
+    children?: never;
 };
 type FieldStringArrayType = {
-    type: Exclude<FieldType, "array" | "object">[];
+    type: Array<Exclude<FieldType, "array" | "object">>;
+    children?: never;
 };
 type FieldArrayType = {
     type: "array";
     children: Exclude<FieldType, "array"> | Exclude<FieldType, "array">[] | Schema;
 };
 type FieldArrayArrayType = {
-    type: ["array", ...Exclude<FieldType, "array" | "object">[]];
+    type: Array<"array" | Exclude<FieldType, "array" | "object">>;
     children: Exclude<FieldType, "array" | "object"> | Exclude<FieldType, "array" | "object">[];
 };
 type FieldObjectType = {
     type: "object";
     children: Schema;
 };
-export type Field = FieldDefault & (FieldStringType | FieldStringArrayType | FieldObjectType | FieldArrayType | FieldArrayArrayType);
+export type Field = FieldDefault & (FieldStringType | (FieldStringArrayType & FieldArrayArrayType) | FieldObjectType | FieldArrayType);
 export type Schema = Field[];
 export interface Options {
     page?: number;
@@ -66,19 +68,18 @@ export default class Inibase {
     private throwError;
     setTableSchema(tableName: string, schema: Schema): Promise<void>;
     getTableSchema(tableName: string): Promise<Schema | undefined>;
-    getField(keyPath: string, schema: Schema): Field | null;
+    getField(keyPath: string, schema: Schema): (FieldDefault & FieldStringType) | (FieldDefault & FieldObjectType) | (FieldDefault & FieldArrayType) | null;
     private validateData;
     private formatField;
     private formatData;
     private getDefaultValue;
     private joinPathesContents;
     private getItemsFromSchema;
-    private FormatObjectCriteriaValue;
     private applyCriteria;
     private _filterSchemaByColumns;
     get(tableName: string, where?: string | number | (string | number)[] | Criteria | undefined, options?: Options | undefined, onlyOne?: true, onlyLinesNumbers?: undefined, tableSchema?: Schema): Promise<Data | null>;
     get(tableName: string, where?: string | number | (string | number)[] | Criteria | undefined, options?: Options | undefined, onlyOne?: boolean | undefined, onlyLinesNumbers?: true, tableSchema?: Schema): Promise<number[] | null>;
-    post(tableName: string, data: Data | Data[], options?: Options, returnPostedData?: false): Promise<void | null>;
+    post(tableName: string, data: Data | Data[], options?: Options, returnPostedData?: boolean): Promise<void | null>;
     post(tableName: string, data: Data, options: Options | undefined, returnPostedData: true): Promise<Data | null>;
     post(tableName: string, data: Data[], options: Options | undefined, returnPostedData: true): Promise<Data[] | null>;
     put(tableName: string, data: Data | Data[], where?: number | string | (number | string)[] | Criteria, options?: Options, returnPostedData?: false): Promise<void | null>;

package/dist/index.js

@@ -1,4 +1,4 @@
-import { unlink, rename, mkdir, readdir } from "node:fs/promises";
+import { unlink, rename, mkdir, readdir, open } from "node:fs/promises";
 import { existsSync, appendFileSync } from "node:fs";
 import { join } from "node:path";
 import { cpus } from "node:os";
@@ -87,9 +87,10 @@ export default class Inibase {
                 return RETURN;
             }, replaceOldPathes = Utils.findChangedProperties(schemaToIdsPath((await this.getTableSchema(tableName)) ?? []), schemaToIdsPath(schema));
             if (replaceOldPathes)
-                for await (const [oldPath, newPath] of Object.entries(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);
     }
@@ -302,8 +303,10 @@ export default class Inibase {
     async getItemsFromSchema(tableName, schema, linesNumber, options, prefix) {
         const path = join(this.folder, this.database, tableName);
         let RETURN = {};
-        for await (const field of schema) {
-            if (field.type === "array" && field.children) {
+        await Promise.all(schema.map(async (field) => {
+            if ((field.type === "array" ||
+                (Array.isArray(field.type) && field.type.includes("array"))) &&
+                field.children) {
                 if (Utils.isArrayOfObjects(field.children)) {
                     if (field.children.filter((children) => children.type === "array" &&
                         Utils.isArrayOfObjects(children.children)).length) {
@@ -320,14 +323,17 @@ export default class Inibase {
                                     if (Utils.isObject(item[child_field.key])) {
                                         Object.entries(item[child_field.key]).forEach(([key, value]) => {
                                             if (!Utils.isArrayOfArrays(value))
-                                                value = value.map((_value) => child_field.type === "array" ? [[_value]] : [_value]);
+                                                value = value.map((_value) => child_field.type === "array"
+                                                    ? [[_value]]
+                                                    : [_value]);
                                             for (let _i = 0; _i < value.length; _i++) {
                                                 if (Utils.isArrayOfNulls(value[_i]))
                                                     continue;
                                                 if (!RETURN[index][field.key][_i])
                                                     RETURN[index][field.key][_i] = {};
                                                 if (!RETURN[index][field.key][_i][child_field.key])
-                                                    RETURN[index][field.key][_i][child_field.key] = [];
+                                                    RETURN[index][field.key][_i][child_field.key] =
+                                                        [];
                                                 value[_i].forEach((_element, _index) => {
                                                     if (!RETURN[index][field.key][_i][child_field.key][_index])
                                                         RETURN[index][field.key][_i][child_field.key][_index] = {};
@@ -380,6 +386,7 @@ export default class Inibase {
                     });
                 }
                 else if (field.children === "table" ||
+                    (Array.isArray(field.type) && field.type.includes("table")) ||
                     (Array.isArray(field.children) && field.children.includes("table"))) {
                     if (options.columns)
                         options.columns = options.columns
@@ -387,13 +394,13 @@ export default class Inibase {
                             .map((column) => column.replace(`${field.key}.`, ""));
                     const items = await File.get(join(path, (prefix ?? "") + field.key + ".inib"), linesNumber, field.type, field.children, this.salt);
                     if (items)
-                        for await (const [index, item] of Object.entries(items)) {
+                        await Promise.all(Object.entries(items).map(async ([index, item]) => {
                             if (!RETURN[index])
                                 RETURN[index] = {};
                             RETURN[index][field.key] = item
                                 ? await this.get(field.key, item, options)
                                 : this.getDefaultValue(field);
-                        }
+                        }));
                 }
                 else if (await File.isExists(join(path, (prefix ?? "") + field.key + ".inib"))) {
                     const items = await File.get(join(path, (prefix ?? "") + field.key + ".inib"), linesNumber, field.type, field?.children, this.salt);
@@ -452,63 +459,9 @@ export default class Inibase {
                         { ...data, [field.key]: this.getDefaultValue(field) },
                     ]));
             }
-        }
+        }));
         return RETURN;
     }
-    FormatObjectCriteriaValue(value, isParentArray = false) {
-        switch (value[0]) {
-            case ">":
-            case "<":
-                return value[1] === "="
-                    ? [
-                        value.slice(0, 2),
-                        value.slice(2),
-                    ]
-                    : [
-                        value.slice(0, 1),
-                        value.slice(1),
-                    ];
-            case "[":
-                return value[1] === "]"
-                    ? [
-                        value.slice(0, 2),
-                        value.slice(2).toString().split(","),
-                    ]
-                    : ["[]", value.slice(1)];
-            case "!":
-                return ["=", "*"].includes(value[1])
-                    ? [
-                        value.slice(0, 2),
-                        value.slice(2),
-                    ]
-                    : value[1] === "["
-                        ? [
-                            value.slice(0, 3),
-                            value.slice(3),
-                        ]
-                        : [
-                            (value.slice(0, 1) + "="),
-                            value.slice(1),
-                        ];
-            case "=":
-                return isParentArray
-                    ? [
-                        value.slice(0, 1),
-                        value.slice(1),
-                    ]
-                    : [
-                        value.slice(0, 1),
-                        (value.slice(1) + ","),
-                    ];
-            case "*":
-                return [
-                    value.slice(0, 1),
-                    value.slice(1),
-                ];
-            default:
-                return ["=", value];
-        }
-    }
     async applyCriteria(tableName, schema, options, criteria, allTrue) {
         let RETURN = {}, RETURN_LineNumbers = null;
         if (!criteria)
@@ -544,7 +497,7 @@ export default class Inibase {
                         Array.isArray(value?.or)) {
                         const searchCriteria = (value?.or)
                             .map((single_or) => typeof single_or === "string"
-                            ? this.FormatObjectCriteriaValue(single_or)
+                            ? Utils.FormatObjectCriteriaValue(single_or)
                             : ["=", single_or])
                             .filter((a) => a);
                         if (searchCriteria.length > 0) {
@@ -558,7 +511,7 @@ export default class Inibase {
                         Array.isArray(value?.and)) {
                         const searchCriteria = (value?.and)
                             .map((single_and) => typeof single_and === "string"
-                            ? this.FormatObjectCriteriaValue(single_and)
+                            ? Utils.FormatObjectCriteriaValue(single_and)
                             : ["=", single_and])
                             .filter((a) => a);
                         if (searchCriteria.length > 0) {
@@ -572,7 +525,7 @@ export default class Inibase {
                 else if (Array.isArray(value)) {
                     const searchCriteria = value
                         .map((single) => typeof single === "string"
-                        ? this.FormatObjectCriteriaValue(single)
+                        ? Utils.FormatObjectCriteriaValue(single)
                         : ["=", single])
                         .filter((a) => a);
                     if (searchCriteria.length > 0) {
@@ -582,7 +535,7 @@ export default class Inibase {
                     }
                 }
                 else if (typeof value === "string") {
-                    const ComparisonOperatorValue = this.FormatObjectCriteriaValue(value);
+                    const ComparisonOperatorValue = Utils.FormatObjectCriteriaValue(value);
                     if (ComparisonOperatorValue) {
                         searchOperator = ComparisonOperatorValue[0];
                         searchComparedAtValue = ComparisonOperatorValue[1];
@@ -731,7 +684,7 @@ export default class Inibase {
                     if (onlyLinesNumbers)
                         return Object.keys(RETURN).map(Number);
                     const alreadyExistsColumns = Object.keys(Object.values(RETURN)[0]);
-                    RETURN = Object.values(Utils.deepMerge(RETURN, await this.getItemsFromSchema(tableName, schema.filter((field) => !alreadyExistsColumns.includes(field.key)), Object.keys(RETURN).map(Number), options)));
+                    RETURN = Object.values(Utils.deepMerge(RETURN, await this.getItemsFromSchema(tableName, schema.filter(({ key }) => !alreadyExistsColumns.includes(key)), Object.keys(RETURN).map(Number), options)));
                     if (Config.isCacheEnabled)
                         await File.write(cachedFilePath, Array.from(linesNumbers).join(","), true);
                 }
@@ -766,6 +719,17 @@ export default class Inibase {
         if (!schema)
             throw this.throwError("NO_SCHEMA", tableName);
         const idFilePath = join(this.folder, this.database, tableName, "id.inib"), cashFolderPath = join(this.folder, this.database, tableName, ".tmp");
+        let testFileHandle;
+        try {
+            testFileHandle = await open(join(cashFolderPath, "id.inib"), "wx");
+        }
+        catch ({ message }) {
+            if (message.split(":")[0] === "EEXIST")
+                return await new Promise((resolve, reject) => setTimeout(() => resolve(this.post(tableName, data, options, returnPostedData)), 13));
+        }
+        finally {
+            await testFileHandle?.close();
+        }
         let lastId = 0, totalItems = 0, lastIdObj;
         if (await File.isExists(idFilePath)) {
             if (await File.isExists(join(cashFolderPath, "lastId.inib"))) {
@@ -797,11 +761,8 @@ export default class Inibase {
             throw this.throwError("NO_DATA");
         RETURN = this.formatData(RETURN, schema);
         const pathesContents = this.joinPathesContents(join(this.folder, this.database, tableName), Array.isArray(RETURN) ? RETURN.toReversed() : RETURN);
-        const renameList = [];
-        for await (const [path, content] of Object.entries(pathesContents))
-            renameList.push(await File.append(path, content));
-        for await (const [tempPath, filePath] of renameList)
-            await rename(tempPath, filePath);
+        const renameList = await Promise.all(Object.entries(pathesContents).map(async ([path, content]) => File.append(path, content)));
+        await Promise.all(renameList.map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
         await File.write(join(cashFolderPath, "lastId.inib"), lastId.toString(), true);
         await File.write(join(cashFolderPath, "totalItems.inib"), String(totalItems + (Array.isArray(RETURN) ? RETURN.length : 1)), true);
         if (returnPostedData)
@@ -844,13 +805,23 @@ export default class Inibase {
                         ...(({ id, ...restOfData }) => restOfData)(data),
                         updatedAt: Date.now(),
                     });
-                for await (const [path, content] of Object.entries(pathesContents))
-                    await File.replace(path, content);
+                let testFileHandle;
+                try {
+                    testFileHandle = await open(Object.keys(pathesContents)[0].replace(/([^/]+)\/?$/, `.tmp/$1`), "wx");
+                }
+                catch ({ message }) {
+                    if (message.split(":")[0] === "EEXIST")
+                        return await new Promise((resolve, reject) => setTimeout(() => resolve(this.put(tableName, data, where, options)), 13));
+                }
+                finally {
+                    await testFileHandle?.close();
+                }
+                const renameList = await Promise.all(Object.entries(pathesContents).map(async ([path, content]) => File.replace(path, content)));
+                await Promise.all(renameList.map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
                 if (Config.isCacheEnabled) {
                     const cacheFiles = (await readdir(join(this.folder, this.database, tableName, ".tmp")))?.filter((fileName) => !["lastId.inib", "totalItems.inib"].includes(fileName));
                     if (cacheFiles.length)
-                        for await (const file of cacheFiles)
-                            await unlink(join(this.folder, this.database, tableName, ".tmp", file));
+                        await Promise.all(cacheFiles.map(async (file) => unlink(join(this.folder, this.database, tableName, ".tmp", file))));
                 }
                 if (returnPostedData)
                     return this.get(tableName, where, options, undefined, undefined, schema);
@@ -880,16 +851,23 @@ export default class Inibase {
                         [lineNum]: Array.isArray(content) ? content[index] : content,
                     }), {}),
                 ]));
-                const renameList = [];
-                for await (const [path, content] of Object.entries(pathesContents))
-                    renameList.push(await File.replace(path, content));
-                for await (const [tempPath, filePath] of renameList)
-                    await rename(tempPath, filePath);
+                let testFileHandle;
+                try {
+                    testFileHandle = await open(Object.keys(pathesContents)[0].replace(/([^/]+)\/?$/, `.tmp/$1`), "wx");
+                }
+                catch ({ message }) {
+                    if (message.split(":")[0] === "EEXIST")
+                        return await new Promise((resolve, reject) => setTimeout(() => resolve(this.put(tableName, data, where, options)), 13));
+                }
+                finally {
+                    await testFileHandle?.close();
+                }
+                const renameList = await Promise.all(Object.entries(pathesContents).map(async ([path, content]) => File.replace(path, content)));
+                await Promise.all(renameList.map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
                 if (Config.isCacheEnabled) {
                     const cacheFiles = (await readdir(join(this.folder, this.database, tableName, ".tmp")))?.filter((fileName) => !["lastId.inib", "totalItems.inib"].includes(fileName));
                     if (cacheFiles.length)
-                        for await (const file of cacheFiles)
-                            await unlink(join(this.folder, this.database, tableName, ".tmp", file));
+                        await Promise.all(cacheFiles.map(async (file) => unlink(join(this.folder, this.database, tableName, ".tmp", file))));
                 }
                 if (returnPostedData)
                     return this.get(tableName, where, options, !Array.isArray(where), undefined, schema);
@@ -914,13 +892,11 @@ export default class Inibase {
         if (!where) {
             const files = (await readdir(join(this.folder, this.database, tableName)))?.filter((fileName) => fileName.endsWith(".inib"));
             if (files.length)
-                for await (const file of files)
-                    await unlink(join(this.folder, this.database, tableName, file));
+                await Promise.all(files.map(async (file) => unlink(join(this.folder, this.database, tableName, file))));
             if (Config.isCacheEnabled) {
                 const cacheFiles = (await readdir(join(this.folder, this.database, tableName, ".tmp")))?.filter((fileName) => !["lastId.inib", "totalItems.inib"].includes(fileName));
                 if (cacheFiles.length)
-                    for await (const file of cacheFiles)
-                        await unlink(join(this.folder, this.database, tableName, ".tmp", file));
+                    await Promise.all(cacheFiles.map(async (file) => unlink(join(this.folder, this.database, tableName, ".tmp", file))));
             }
             return "*";
         }
@@ -944,16 +920,23 @@ export default class Inibase {
                         _id = Object.entries((await File.get(join(this.folder, this.database, tableName, "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);
-                    const renameList = [];
-                    for await (const file of files)
-                        renameList.push(await File.remove(join(this.folder, this.database, tableName, file), where));
-                    for await (const [tempPath, filePath] of renameList)
-                        await rename(tempPath, filePath);
+                    let testFileHandle;
+                    try {
+                        testFileHandle = await open(join(this.folder, this.database, tableName, ".tmp", "id.inib"), "wx");
+                    }
+                    catch ({ message }) {
+                        if (message.split(":")[0] === "EEXIST")
+                            return await new Promise((resolve, reject) => setTimeout(() => resolve(this.delete(tableName, where, _id)), 13));
+                    }
+                    finally {
+                        await testFileHandle?.close();
+                    }
+                    const renameList = await Promise.all(files.map(async (file) => File.remove(join(this.folder, this.database, tableName, file), where)));
+                    await Promise.all(renameList.map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
                     if (Config.isCacheEnabled) {
                         const cacheFiles = (await readdir(join(this.folder, this.database, tableName, ".tmp")))?.filter((fileName) => !["lastId.inib", "totalItems.inib"].includes(fileName));
                         if (cacheFiles.length)
-                            for await (const file of cacheFiles)
-                                await unlink(join(this.folder, this.database, tableName, ".tmp", file));
+                            await Promise.all(cacheFiles.map(async (file) => unlink(join(this.folder, this.database, tableName, ".tmp", file))));
                         await File.write(join(this.folder, this.database, tableName, ".tmp", "totalItems.inib"), String(((await File.isExists(join(this.folder, this.database, tableName, ".tmp", "totalItems.inib")))
                             ? Number(await File.read(join(this.folder, this.database, tableName, ".tmp", "totalItems.inib"), true))
                             : await File.count(join(this.folder, this.database, tableName, "id.inib"))) - (Array.isArray(where) ? where.length : 1)), true);

package/dist/utils.d.ts

@@ -1,4 +1,4 @@
-import { type FieldType } from "./index.js";
+import { type FieldType, ComparisonOperator } from "./index.js";
 /**
  * Type guard function to check if the input is an array of objects.
  *
@@ -174,6 +174,10 @@ export declare const validateFieldType: (value: any, fieldType: FieldType | Fiel
  * @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)[]
+];
 export default class Utils {
     static isNumber: (input: any) => input is number;
     static isObject: (obj: any) => obj is Record<any, any>;
@@ -195,4 +199,5 @@ export default class Utils {
     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

@@ -363,6 +363,60 @@ export const objectToDotNotation = (input) => {
     }
     return result;
 };
+export function FormatObjectCriteriaValue(value, isParentArray = false) {
+    switch (value[0]) {
+        case ">":
+        case "<":
+            return value[1] === "="
+                ? [
+                    value.slice(0, 2),
+                    value.slice(2),
+                ]
+                : [
+                    value.slice(0, 1),
+                    value.slice(1),
+                ];
+        case "[":
+            return value[1] === "]"
+                ? [
+                    value.slice(0, 2),
+                    value.slice(2).toString().split(","),
+                ]
+                : ["[]", value.slice(1)];
+        case "!":
+            return ["=", "*"].includes(value[1])
+                ? [
+                    value.slice(0, 2),
+                    value.slice(2),
+                ]
+                : value[1] === "["
+                    ? [
+                        value.slice(0, 3),
+                        value.slice(3),
+                    ]
+                    : [
+                        (value.slice(0, 1) + "="),
+                        value.slice(1),
+                    ];
+        case "=":
+            return isParentArray
+                ? [
+                    value.slice(0, 1),
+                    value.slice(1),
+                ]
+                : [
+                    value.slice(0, 1),
+                    (value.slice(1) + ","),
+                ];
+        case "*":
+            return [
+                value.slice(0, 1),
+                value.slice(1),
+            ];
+        default:
+            return ["=", value];
+    }
+}
 export default class Utils {
     static isNumber = isNumber;
     static isObject = isObject;
@@ -384,4 +438,5 @@ export default class Utils {
     static validateFieldType = validateFieldType;
     static objectToDotNotation = objectToDotNotation;
     static isArrayOfNulls = isArrayOfNulls;
+    static FormatObjectCriteriaValue = FormatObjectCriteriaValue;
 }

package/dist/utils.server.d.ts

@@ -47,7 +47,28 @@ export declare const findLastIdNumber: (schema: Schema, secretKeyOrSalt: string
  * @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 addIdToSchema: (schema: Schema, oldIndex: number | undefined, secretKeyOrSalt: string | number | Buffer) => (({
+    id?: string | number | undefined;
+    key: string;
+    required?: boolean | undefined;
+} & {
+    type: "string" | "number" | "boolean" | "id" | "url" | "html" | "table" | "email" | "date" | "password" | "ip";
+    children?: undefined;
+}) | ({
+    id?: string | number | undefined;
+    key: string;
+    required?: boolean | undefined;
+} & {
+    type: "object";
+    children: Schema;
+}) | ({
+    id?: string | number | undefined;
+    key: string;
+    required?: boolean | undefined;
+} & {
+    type: "array";
+    children: "string" | "number" | "boolean" | "object" | "id" | "url" | "html" | "table" | "email" | "date" | "password" | "ip" | Schema | ("string" | "number" | "boolean" | "object" | "id" | "url" | "html" | "table" | "email" | "date" | "password" | "ip")[];
+}))[];
 export declare const hashObject: (obj: any) => string;
 export default class UtilsServer {
     static encodeID: (id: string | number, secretKeyOrSalt: string | number | Buffer) => string;
@@ -55,6 +76,27 @@ 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) => import("./index.js").Field[];
+    static addIdToSchema: (schema: Schema, oldIndex: number | undefined, secretKeyOrSalt: string | number | Buffer) => (({
+        id?: string | number | undefined;
+        key: string;
+        required?: boolean | undefined;
+    } & {
+        type: "string" | "number" | "boolean" | "id" | "url" | "html" | "table" | "email" | "date" | "password" | "ip";
+        children?: undefined;
+    }) | ({
+        id?: string | number | undefined;
+        key: string;
+        required?: boolean | undefined;
+    } & {
+        type: "object";
+        children: Schema;
+    }) | ({
+        id?: string | number | undefined;
+        key: string;
+        required?: boolean | undefined;
+    } & {
+        type: "array";
+        children: "string" | "number" | "boolean" | "object" | "id" | "url" | "html" | "table" | "email" | "date" | "password" | "ip" | Schema | ("string" | "number" | "boolean" | "object" | "id" | "url" | "html" | "table" | "email" | "date" | "password" | "ip")[];
+    }))[];
     static hashObject: (obj: any) => string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inibase",
-  "version": "1.0.0-rc.27",
+  "version": "1.0.0-rc.29",
   "author": {
     "name": "Karim Amahtil",
     "email": "karim.amahtil@gmail.com"
@@ -10,6 +10,7 @@
   "exports": {
     ".": "./dist/index.js",
     "./file": "./dist/file.js",
+    "./config": "./dist/config.js",
     "./utils": "./dist/utils.js",
     "./utils.server": "./dist/utils.server.js"
   },
@@ -53,13 +54,16 @@
       "utils": [
         "./dist/utils.d.ts"
       ],
+      "config": [
+        "./dist/config.d.ts"
+      ],
       "utils.server": [
         "./dist/utils.server.d.ts"
       ]
     }
   },
   "devDependencies": {
-    "@types/node": "^20.10.4",
+    "@types/node": "^20.10.6",
     "typescript": "^5.3.3"
   },
   "scripts": {