inibase 1.0.0-rc.31 → 1.0.0-rc.33

package/dist/file.d.ts

@@ -1,5 +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 write: (filePath: string, data: any, disableCompression?: boolean) => Promise<void>;
 export declare const read: (filePath: string, disableCompression?: boolean) => Promise<string>;
 /**
@@ -168,4 +170,6 @@ 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>;
 }

package/dist/file.js

@@ -1,16 +1,39 @@
-import { open, access, writeFile, readFile, constants as fsConstants, } from "node:fs/promises";
+import { open, access, writeFile, readFile, constants as fsConstants, unlink, } from "node:fs/promises";
 import { createInterface } from "node:readline";
 import { Transform } from "node:stream";
 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 { 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");
+    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));
+    }
+    finally {
+        await lockFile?.close();
+    }
+};
+export const unlock = async (folderPath) => {
+    try {
+        await unlink(join(folderPath, "locked.inib"));
+    }
+    catch { }
+};
 export const write = async (filePath, data, disableCompression = false) => {
-    await writeFile(filePath, Config.isCompressionEnabled && !disableCompression ? await gzip(data) : data);
+    await writeFile(filePath, Config.isCompressionEnabled && !disableCompression
+        ? await gzip(String(data))
+        : String(data));
 };
 export const read = async (filePath, disableCompression = false) => {
     return Config.isCompressionEnabled && !disableCompression
@@ -765,4 +788,6 @@ export default class File {
     static count = count;
     static write = write;
     static read = read;
+    static lock = lock;
+    static unlock = unlock;
 }

package/dist/index.js

@@ -1,4 +1,4 @@
-import { unlink, rename, mkdir, readdir, open } from "node:fs/promises";
+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";
@@ -66,12 +66,12 @@ export default class Inibase {
         // 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)))
-            await mkdir(TablePath, { recursive: true });
-        if (!(await File.isExists(join(TablePath, ".tmp"))))
-            await mkdir(join(TablePath, ".tmp"));
-        if (await File.isExists(TableSchemaPath)) {
+        const tablePath = join(this.folder, this.database, tableName), tableSchemaPath = join(tablePath, "schema.json");
+        if (!(await File.isExists(tablePath)))
+            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 = {};
@@ -88,17 +88,17 @@ export default class Inibase {
             }, replaceOldPathes = Utils.findChangedProperties(schemaToIdsPath((await this.getTableSchema(tableName)) ?? []), 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));
+                    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(decodeIdFromSchema(schema), null, 2), true);
     }
     async getTableSchema(tableName) {
-        const TableSchemaPath = join(this.folder, this.database, tableName, "schema.json");
-        if (!(await File.isExists(TableSchemaPath)))
+        const tableSchemaPath = join(this.folder, this.database, tableName, "schema.json");
+        if (!(await File.isExists(tableSchemaPath)))
             return undefined;
-        const schemaFile = await File.read(TableSchemaPath, true);
+        const schemaFile = await File.read(tableSchemaPath, true);
         if (!schemaFile)
             return undefined;
         const schema = JSON.parse(schemaFile), lastIdNumber = UtilsServer.findLastIdNumber(schema, this.salt);
@@ -301,7 +301,7 @@ export default class Inibase {
             ]));
     }
     async getItemsFromSchema(tableName, schema, linesNumber, options, prefix) {
-        const path = join(this.folder, this.database, tableName);
+        const tablePath = join(this.folder, this.database, tableName);
         let RETURN = {};
         await Promise.all(schema.map(async (field) => {
             if ((field.type === "array" ||
@@ -392,7 +392,7 @@ export default class Inibase {
                         options.columns = options.columns
                             .filter((column) => column.includes(`${field.key}.`))
                             .map((column) => column.replace(`${field.key}.`, ""));
-                    const items = await File.get(join(path, (prefix ?? "") + field.key + ".inib"), linesNumber, field.type, field.children, this.salt);
+                    const items = await File.get(join(tablePath, (prefix ?? "") + field.key + ".inib"), linesNumber, field.type, field.children, this.salt);
                     if (items)
                         await Promise.all(Object.entries(items).map(async ([index, item]) => {
                             if (!RETURN[index])
@@ -402,8 +402,8 @@ export default class Inibase {
                                 : 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);
+                else if (await File.isExists(join(tablePath, (prefix ?? "") + field.key + ".inib"))) {
+                    const items = await File.get(join(tablePath, (prefix ?? "") + field.key + ".inib"), linesNumber, field.type, field?.children, this.salt);
                     if (items)
                         for (const [index, item] of Object.entries(items)) {
                             if (!RETURN[index])
@@ -428,13 +428,13 @@ export default class Inibase {
             }
             else if (field.type === "table") {
                 if ((await File.isExists(join(this.folder, this.database, field.key))) &&
-                    (await File.isExists(join(path, (prefix ?? "") + field.key + ".inib")))) {
+                    (await File.isExists(join(tablePath, (prefix ?? "") + field.key + ".inib")))) {
                     if (options.columns)
                         options.columns = options.columns
                             .filter((column) => column.includes(`${field.key}.`) &&
                             !column.includes(`${field.key}.`))
                             .map((column) => column.replace(`${field.key}.`, ""));
-                    const items = await File.get(join(path, (prefix ?? "") + field.key + ".inib"), linesNumber, "number", undefined, this.salt);
+                    const items = await File.get(join(tablePath, (prefix ?? "") + field.key + ".inib"), linesNumber, "number", undefined, this.salt);
                     if (items)
                         for await (const [index, item] of Object.entries(items)) {
                             if (!RETURN[index])
@@ -445,8 +445,8 @@ export default class Inibase {
                         }
                 }
             }
-            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);
+            else if (await File.isExists(join(tablePath, (prefix ?? "") + field.key + ".inib"))) {
+                const items = await File.get(join(tablePath, (prefix ?? "") + field.key + ".inib"), linesNumber, field.type, field?.children, this.salt);
                 if (items)
                     for (const [index, item] of Object.entries(items)) {
                         if (!RETURN[index])
@@ -463,6 +463,7 @@ export default class Inibase {
         return RETURN;
     }
     async applyCriteria(tableName, schema, options, criteria, allTrue) {
+        const tablePath = join(this.folder, this.database, tableName);
         let RETURN = {}, RETURN_LineNumbers = null;
         if (!criteria)
             return [null, null];
@@ -545,7 +546,7 @@ export default class Inibase {
                     searchOperator = "=";
                     searchComparedAtValue = value;
                 }
-                const [searchResult, totalLines, linesNumbers] = await File.search(join(this.folder, this.database, tableName, key + ".inib"), searchOperator ?? "=", searchComparedAtValue ?? null, searchLogicalOperator, field?.type, field?.children, options.perPage, options.page - 1 * options.perPage + 1, true, this.salt);
+                const [searchResult, totalLines, linesNumbers] = await File.search(join(tablePath, key + ".inib"), searchOperator ?? "=", searchComparedAtValue ?? null, searchLogicalOperator, field?.type, field?.children, options.perPage, options.page - 1 * options.perPage + 1, true, this.salt);
                 if (searchResult) {
                     RETURN = Utils.deepMerge(RETURN, Object.fromEntries(Object.entries(searchResult).map(([id, value]) => [
                         id,
@@ -592,6 +593,7 @@ export default class Inibase {
         page: 1,
         perPage: 15,
     }, onlyOne, onlyLinesNumbers, tableSchema) {
+        const tablePath = join(this.folder, this.database, tableName);
         // Ensure options.columns is an array
         if (options.columns) {
             options.columns = Array.isArray(options.columns)
@@ -607,8 +609,7 @@ export default class Inibase {
         let schema = tableSchema ?? (await this.getTableSchema(tableName));
         if (!schema)
             throw this.throwError("NO_SCHEMA", tableName);
-        const idFilePath = join(this.folder, this.database, tableName, "id.inib");
-        if (!(await File.isExists(idFilePath)))
+        if (!(await File.isExists(join(tablePath, "id.inib"))))
             return null;
         if (options.columns && options.columns.length)
             schema = this._filterSchemaByColumns(schema, options.columns);
@@ -618,12 +619,15 @@ export default class Inibase {
                 index +
                 1), options));
             if (Config.isCacheEnabled &&
-                (await File.isExists(join(this.folder, this.database, tableName, ".tmp", "totalItems.inib"))))
-                this.totalItems[tableName + "-*"] = Number(await File.read(join(this.folder, this.database, tableName, ".tmp", "totalItems.inib"), true));
+                (await File.isExists(join(tablePath, ".tmp", "pagination.inib"))))
+                this.totalItems[tableName + "-*"] = Number((await File.read(join(tablePath, ".tmp", "pagination.inib"), true)).split(",")[1]);
             else {
-                this.totalItems[tableName + "-*"] = await File.count(idFilePath);
+                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(this.folder, this.database, tableName, ".tmp", "totalItems.inib"), String(this.totalItems[tableName + "-*"]), true);
+                    await File.write(join(tablePath, ".tmp", "pagination.inib"), `${lastId},${totalItems}`, true);
             }
         }
         else if ((Array.isArray(where) && where.every(Utils.isNumber)) ||
@@ -644,7 +648,7 @@ export default class Inibase {
             let Ids = where;
             if (!Array.isArray(Ids))
                 Ids = [Ids];
-            const [lineNumbers, countItems] = await File.search(idFilePath, "[]", Ids.map((id) => Utils.isNumber(id) ? Number(id) : UtilsServer.decodeID(id, this.salt)), undefined, "number", undefined, Ids.length, 0, false, this.salt);
+            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);
             if (onlyLinesNumbers)
@@ -652,16 +656,8 @@ export default class Inibase {
                     ? Object.keys(lineNumbers).map(Number)
                     : null;
             RETURN = Object.values((await this.getItemsFromSchema(tableName, schema, Object.keys(lineNumbers).map(Number), options)) ?? {});
-            if (!this.totalItems[tableName + "-*"]) {
-                if (Config.isCacheEnabled &&
-                    (await File.isExists(join(this.folder, this.database, tableName, ".tmp", "totalItems.inib"))))
-                    this.totalItems[tableName + "-*"] = Number(await File.read(join(this.folder, this.database, tableName, ".tmp", "totalItems.inib"), true));
-                else {
-                    this.totalItems[tableName + "-*"] = await File.count(idFilePath);
-                    if (Config.isCacheEnabled)
-                        await File.write(join(this.folder, this.database, tableName, ".tmp", "totalItems.inib"), String(this.totalItems[tableName + "-*"]), true);
-                }
-            }
+            if (!this.totalItems[tableName + "-*"])
+                this.totalItems[tableName + "-*"] = countItems;
             if (RETURN && RETURN.length && !Array.isArray(where))
                 RETURN = RETURN[0];
         }
@@ -669,7 +665,7 @@ export default class Inibase {
             let cachedFilePath = "";
             // Criteria
             if (Config.isCacheEnabled)
-                cachedFilePath = join(this.folder, this.database, tableName, ".tmp", `${UtilsServer.hashObject(where)}.inib`);
+                cachedFilePath = join(tablePath, ".tmp", `${UtilsServer.hashObject(where)}.inib`);
             if (Config.isCacheEnabled && (await File.isExists(cachedFilePath))) {
                 const cachedItems = (await File.read(cachedFilePath, true)).split(",");
                 this.totalItems[tableName + "-*"] = cachedItems.length;
@@ -714,62 +710,50 @@ export default class Inibase {
                 page: 1,
                 perPage: 15,
             };
-        const idFilePath = join(this.folder, this.database, tableName, "id.inib"), cashFolderPath = join(this.folder, this.database, tableName, ".tmp");
-        let testFileHandle, renameList = [];
-        try {
-            testFileHandle = await open(join(cashFolderPath, "id.inib"), "wx");
-            renameList = [[join(cashFolderPath, "id.inib"), ""]];
-        }
-        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();
-        }
+        const tablePath = join(this.folder, this.database, tableName);
         if (!returnPostedData)
             returnPostedData = false;
         const schema = await this.getTableSchema(tableName);
         let RETURN;
         if (!schema)
             throw this.throwError("NO_SCHEMA", tableName);
-        let lastId = 0, totalItems = 0, lastIdObj;
-        if (await File.isExists(idFilePath)) {
-            if (await File.isExists(join(cashFolderPath, "lastId.inib"))) {
-                lastId = Number(await File.read(join(cashFolderPath, "lastId.inib"), true));
-                if (await File.isExists(join(cashFolderPath, "totalItems.inib")))
-                    totalItems = Number(await File.read(join(cashFolderPath, "totalItems.inib"), true));
-                else
-                    totalItems = await File.count(join(this.folder, this.database, tableName, "id.inib"));
-            }
-            else {
-                [lastIdObj, totalItems] = await File.get(idFilePath, -1, "number", undefined, this.salt, true);
-                if (lastIdObj)
-                    lastId = Number(Object.entries(lastIdObj)[0][1]) ?? 0;
-            }
-        }
-        if (Utils.isArrayOfObjects(data))
-            RETURN = data.map(({ id, updatedAt, createdAt, ...rest }) => ({
-                id: ++lastId,
-                ...rest,
-                createdAt: Date.now(),
-            }));
-        else
-            RETURN = (({ id, updatedAt, createdAt, ...rest }) => ({
-                id: ++lastId,
-                ...rest,
-                createdAt: Date.now(),
-            }))(data);
-        if (!RETURN)
-            throw this.throwError("NO_DATA");
+        let lastId = 0, totalItems = 0, renameList = [];
         try {
+            await File.lock(join(tablePath, ".tmp"));
+            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))
+                        .split(",")
+                        .map(Number);
+                else {
+                    let lastIdObj;
+                    [lastIdObj, totalItems] = await File.get(join(tablePath, "id.inib"), -1, "number", undefined, this.salt, true);
+                    if (lastIdObj)
+                        lastId = Number(Object.keys(lastIdObj)[0] ?? 0);
+                }
+            }
+            if (Utils.isArrayOfObjects(data))
+                RETURN = data.map(({ id, updatedAt, createdAt, ...rest }) => ({
+                    id: ++lastId,
+                    ...rest,
+                    createdAt: Date.now(),
+                }));
+            else
+                RETURN = (({ id, updatedAt, createdAt, ...rest }) => ({
+                    id: ++lastId,
+                    ...rest,
+                    createdAt: Date.now(),
+                }))(data);
+            if (!RETURN)
+                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);
-            renameList = await Promise.all(Object.entries(pathesContents).map(async ([path, content]) => File.append(path, content)));
+            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(renameList.map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
             renameList = [];
-            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 (Config.isCacheEnabled)
+                await File.write(join(tablePath, ".tmp", "pagination.inib"), `${lastId},${totalItems + (Array.isArray(RETURN) ? RETURN.length : 1)}`, true);
             if (returnPostedData)
                 return this.get(tableName, Utils.isArrayOfObjects(RETURN)
                     ? RETURN.map((data) => Number(data.id))
@@ -778,18 +762,20 @@ export default class Inibase {
         }
         finally {
             if (renameList.length)
-                await Promise.all(renameList.map(async ([tempPath, _]) => (await File.isExists(tempPath)) ? unlink(tempPath) : undefined));
+                await Promise.allSettled(renameList.map(async ([tempPath, _]) => unlink(tempPath)));
+            await File.unlock(join(tablePath, ".tmp"));
         }
     }
     async put(tableName, data, where, options = {
         page: 1,
         perPage: 15,
     }, returnPostedData) {
+        let renameList = [];
+        const tablePath = join(this.folder, this.database, tableName);
         const schema = await this.getTableSchema(tableName);
         if (!schema)
             throw this.throwError("NO_SCHEMA", tableName);
-        const idFilePath = join(this.folder, this.database, tableName, "id.inib");
-        if (!(await File.isExists(idFilePath)))
+        if (!(await File.isExists(join(tablePath, "id.inib"))))
             throw this.throwError("NO_ITEMS", tableName);
         data = this.formatData(data, schema, true);
         if (!where) {
@@ -806,7 +792,7 @@ export default class Inibase {
                 return this.put(tableName, data, UtilsServer.decodeID(data.id, this.salt));
             }
             else {
-                const pathesContents = this.joinPathesContents(join(this.folder, this.database, tableName), Utils.isArrayOfObjects(data)
+                const pathesContents = this.joinPathesContents(join(tablePath), Utils.isArrayOfObjects(data)
                     ? data.map((item) => ({
                         ...(({ id, ...restOfData }) => restOfData)(item),
                         updatedAt: Date.now(),
@@ -815,26 +801,22 @@ export default class Inibase {
                         ...(({ id, ...restOfData }) => restOfData)(data),
                         updatedAt: Date.now(),
                     });
-                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));
+                    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(renameList.map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
+                    if (Config.isCacheEnabled)
+                        await Promise.all((await readdir(join(tablePath, ".tmp")))
+                            ?.filter((fileName) => !["pagination.inib", "locked.inib"].includes(fileName))
+                            .map(async (file) => unlink(join(tablePath, ".tmp", file))));
+                    if (returnPostedData)
+                        return this.get(tableName, where, options, undefined, undefined, schema);
                 }
                 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)
-                        await Promise.all(cacheFiles.map(async (file) => unlink(join(this.folder, this.database, tableName, ".tmp", file))));
+                    if (renameList.length)
+                        await Promise.allSettled(renameList.map(async ([tempPath, _]) => unlink(tempPath)));
+                    await File.unlock(join(tablePath, ".tmp"));
                 }
-                if (returnPostedData)
-                    return this.get(tableName, where, options, undefined, undefined, schema);
             }
         }
         else if ((Array.isArray(where) &&
@@ -849,7 +831,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(this.folder, this.database, tableName), Utils.isArrayOfObjects(data)
+                const pathesContents = Object.fromEntries(Object.entries(this.joinPathesContents(join(tablePath), Utils.isArrayOfObjects(data)
                     ? data.map((item) => ({
                         ...item,
                         updatedAt: Date.now(),
@@ -861,26 +843,23 @@ export default class Inibase {
                         [lineNum]: Array.isArray(content) ? content[index] : 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));
+                    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(renameList.map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
+                    renameList = [];
+                    if (Config.isCacheEnabled)
+                        await Promise.all((await readdir(join(tablePath, ".tmp")))
+                            ?.filter((fileName) => !["pagination.inib", "locked.inib"].includes(fileName))
+                            .map(async (file) => unlink(join(tablePath, ".tmp", file))));
+                    if (returnPostedData)
+                        return this.get(tableName, where, options, !Array.isArray(where), undefined, schema);
                 }
                 finally {
-                    await testFileHandle?.close();
+                    if (renameList.length)
+                        await Promise.allSettled(renameList.map(async ([tempPath, _]) => unlink(tempPath)));
+                    await File.unlock(join(tablePath, ".tmp"));
                 }
-                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)
-                        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);
             }
         }
         else if (Utils.isObject(where)) {
@@ -893,20 +872,26 @@ export default class Inibase {
             throw this.throwError("INVALID_PARAMETERS", tableName);
     }
     async delete(tableName, where, _id) {
+        let renameList = [];
+        const tablePath = join(this.folder, this.database, tableName);
         const schema = await this.getTableSchema(tableName);
         if (!schema)
             throw this.throwError("NO_SCHEMA", tableName);
-        const idFilePath = join(this.folder, this.database, tableName, "id.inib");
-        if (!(await File.isExists(idFilePath)))
+        if (!(await File.isExists(join(tablePath, "id.inib"))))
             throw this.throwError("NO_ITEMS", tableName);
         if (!where) {
-            const files = (await readdir(join(this.folder, this.database, tableName)))?.filter((fileName) => fileName.endsWith(".inib"));
-            if (files.length)
-                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)
-                    await Promise.all(cacheFiles.map(async (file) => unlink(join(this.folder, this.database, tableName, ".tmp", file))));
+            try {
+                await File.lock(join(tablePath, ".tmp"));
+                await Promise.all((await readdir(join(tablePath)))
+                    ?.filter((fileName) => fileName.endsWith(".inib"))
+                    .map(async (file) => unlink(join(tablePath, file))));
+                if (Config.isCacheEnabled)
+                    await Promise.all((await readdir(join(tablePath, ".tmp")))
+                        ?.filter((fileName) => !["pagination.inib", "locked.inib"].includes(fileName))
+                        .map(async (file) => unlink(join(tablePath, ".tmp", file))));
+            }
+            finally {
+                await File.unlock(join(tablePath, ".tmp"));
             }
             return "*";
         }
@@ -924,34 +909,34 @@ 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(this.folder, this.database, tableName)))?.filter((fileName) => fileName.endsWith(".inib"));
+                const files = (await readdir(join(tablePath)))?.filter((fileName) => fileName.endsWith(".inib"));
                 if (files.length) {
                     if (!_id)
-                        _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));
+                        _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);
-                    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));
+                        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(renameList.map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
+                        if (Config.isCacheEnabled) {
+                            await Promise.all((await readdir(join(tablePath, ".tmp")))
+                                ?.filter((fileName) => !["pagination.inib", "locked.inib"].includes(fileName))
+                                .map(async (file) => unlink(join(tablePath, ".tmp", file))));
+                            if (await File.isExists(join(tablePath, ".tmp", "pagination.inib"))) {
+                                let [lastId, totalItems] = (await File.read(join(tablePath, ".tmp", "pagination.inib"), true))
+                                    .split(",")
+                                    .map(Number);
+                                await File.write(join(tablePath, ".tmp", "pagination.inib"), `${lastId},${totalItems - (Array.isArray(where) ? where.length : 1)}`, true);
+                            }
+                        }
+                        return Array.isArray(_id) && _id.length === 1 ? _id[0] : _id;
                     }
                     finally {
-                        await testFileHandle?.close();
+                        if (renameList.length)
+                            await Promise.allSettled(renameList.map(async ([tempPath, _]) => unlink(tempPath)));
+                        await File.unlock(join(tablePath, ".tmp"));
                     }
-                    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)
-                            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);
-                    }
-                    return Array.isArray(_id) && _id.length === 1 ? _id[0] : _id;
                 }
             }
         }
@@ -967,10 +952,10 @@ export default class Inibase {
     }
     async sum(tableName, columns, where) {
         let RETURN = {};
-        const schema = await this.getTableSchema(tableName);
+        const tablePath = join(this.folder, this.database, tableName), schema = await this.getTableSchema(tableName);
         if (!schema)
             throw this.throwError("NO_SCHEMA", tableName);
-        if (!(await File.isExists(join(this.folder, this.database, tableName, "id.inib"))))
+        if (!(await File.isExists(join(tablePath, "id.inib"))))
             throw this.throwError("NO_ITEMS", tableName);
         if (!Array.isArray(columns))
             columns = [columns];
@@ -991,10 +976,10 @@ export default class Inibase {
     }
     async max(tableName, columns, where) {
         let RETURN = {};
-        const schema = await this.getTableSchema(tableName);
+        const tablePath = join(this.folder, this.database, tableName), schema = await this.getTableSchema(tableName);
         if (!schema)
             throw this.throwError("NO_SCHEMA", tableName);
-        if (!(await File.isExists(join(this.folder, this.database, tableName, "id.inib"))))
+        if (!(await File.isExists(join(tablePath, "id.inib"))))
             throw this.throwError("NO_ITEMS", tableName);
         if (!Array.isArray(columns))
             columns = [columns];
@@ -1015,10 +1000,10 @@ export default class Inibase {
     }
     async min(tableName, columns, where) {
         let RETURN = {};
-        const schema = await this.getTableSchema(tableName);
+        const tablePath = join(this.folder, this.database, tableName), schema = await this.getTableSchema(tableName);
         if (!schema)
             throw this.throwError("NO_SCHEMA", tableName);
-        if (!(await File.isExists(join(this.folder, this.database, tableName, "id.inib"))))
+        if (!(await File.isExists(join(tablePath, "id.inib"))))
             throw this.throwError("NO_ITEMS", tableName);
         if (!Array.isArray(columns))
             columns = [columns];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inibase",
-  "version": "1.0.0-rc.31",
+  "version": "1.0.0-rc.33",
   "author": {
     "name": "Karim Amahtil",
     "email": "karim.amahtil@gmail.com"