inibase 1.0.0-rc.30 → 1.0.0-rc.32

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
@@ -30,12 +53,16 @@ const _pipeline = async (rl, writeStream, transform) => {
  * @returns A readline.Interface instance configured with the provided file stream.
  */
 const readLineInternface = (fileHandle) => {
-    return createInterface({
-        input: Config.isCompressionEnabled
-            ? fileHandle.createReadStream().pipe(createGunzip())
-            : fileHandle.createReadStream(),
-        crlfDelay: Infinity,
-    });
+    const [major, minor, patch] = process.versions.node.split(".").map(Number);
+    return major > 18 ||
+        (major === 18 && minor >= 11 && !Config.isCompressionEnabled)
+        ? fileHandle.readLines()
+        : createInterface({
+            input: Config.isCompressionEnabled
+                ? fileHandle.createReadStream().pipe(createGunzip())
+                : fileHandle.createReadStream(),
+            crlfDelay: Infinity,
+        });
 };
 /**
  * Checks if a file or directory exists at the specified path.
@@ -190,7 +217,6 @@ const decodeHelper = (value, fieldType, fieldChildrenType, secretKey) => {
     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":
@@ -204,6 +230,7 @@ const decodeHelper = (value, fieldType, fieldChildrenType, secretKey) => {
                         ? detectFieldType(v, fieldChildrenType)
                         : fieldChildrenType, undefined, secretKey))
                     : value;
+        case "table":
         case "id":
             return isNumber(value) && secretKey
                 ? encodeID(value, secretKey)
@@ -227,8 +254,8 @@ export const decode = (input, fieldType, fieldChildrenType, secretKey) => {
         return null;
     if (input === null || input === "")
         return null;
+    // Detect the fieldType based on the input and the provided array of possible types.
     if (Array.isArray(fieldType))
-        // Detect the fieldType based on the input and the provided array of possible types.
         fieldType = detectFieldType(String(input), fieldType);
     // Decode the input using the decodeHelper function.
     return decodeHelper(typeof input === "string"
@@ -761,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.d.ts

@@ -86,7 +86,7 @@ export default class Inibase {
     put(tableName: string, data: Data, where: number | string | (number | string)[] | Criteria | undefined, options: Options | undefined, returnPostedData: true): Promise<Data | null>;
     put(tableName: string, data: Data[], where: number | string | (number | string)[] | Criteria | undefined, options: Options | undefined, returnPostedData: true): Promise<Data[] | null>;
     delete(tableName: string, where?: number | string, _id?: string | string[]): Promise<string | null>;
-    delete(tableName: string, where?: (number | string)[], _id?: string | string[]): Promise<string[] | null>;
+    delete(tableName: string, where?: (number | string)[] | Criteria, _id?: string | string[]): Promise<string[] | null>;
     sum(tableName: string, columns: string, where?: number | string | (number | string)[] | Criteria): Promise<number>;
     sum(tableName: string, columns: string[], where?: number | string | (number | string)[] | Criteria): Promise<Record<string, number>>;
     max(tableName: string, columns: string, where?: number | string | (number | string)[] | Criteria): Promise<number>;

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,10 +665,12 @@ 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;
+                if (onlyLinesNumbers)
+                    return cachedItems.map(Number);
                 return this.get(tableName, cachedItems
                     .slice((options.page - 1) * options.perPage, options.page * options.perPage)
                     .map(Number), options, undefined, undefined, schema);
@@ -712,37 +710,26 @@ export default class Inibase {
                 page: 1,
                 perPage: 15,
             };
+        const tablePath = join(this.folder, this.database, tableName);
+        await File.lock(join(tablePath, ".tmp"));
         if (!returnPostedData)
             returnPostedData = false;
         const schema = await this.getTableSchema(tableName);
         let RETURN;
         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"))) {
-                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"));
-            }
+        let lastId = 0, totalItems = 0, renameList = [];
+        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 {
-                [lastIdObj, totalItems] = await File.get(idFilePath, -1, "number", undefined, this.salt, true);
+                let lastIdObj;
+                [lastIdObj, totalItems] = await File.get(join(tablePath, "id.inib"), -1, "number", undefined, this.salt, true);
                 if (lastIdObj)
-                    lastId = Number(Object.entries(lastIdObj)[0][1]) ?? 0;
+                    lastId = Number(Object.keys(lastIdObj)[0] ?? 0);
             }
         }
         if (Utils.isArrayOfObjects(data))
@@ -759,29 +746,39 @@ export default class Inibase {
             }))(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);
-        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)
-            return this.get(tableName, Utils.isArrayOfObjects(RETURN)
-                ? RETURN.map((data) => Number(data.id))
-                : RETURN.id, options, !Utils.isArrayOfObjects(data), // return only one item if data is not array of objects
-            undefined, schema);
+        try {
+            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(renameList.map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
+            renameList = [];
+            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))
+                    : RETURN.id, options, !Utils.isArrayOfObjects(data), // return only one item if data is not array of objects
+                undefined, schema);
+        }
+        finally {
+            await File.unlock(join(tablePath, ".tmp"));
+            if (renameList.length)
+                await Promise.all(renameList.map(async ([tempPath, _]) => (await File.isExists(tempPath)) ? unlink(tempPath) : undefined));
+        }
     }
     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);
+        await File.lock(join(tablePath, ".tmp"));
         if (!where) {
             if (Utils.isArrayOfObjects(data)) {
                 if (!data.every((item) => item.hasOwnProperty("id") && Utils.isValidID(item.id)))
@@ -796,7 +793,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(),
@@ -805,26 +802,21 @@ 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 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();
+                    if (renameList.length)
+                        await Promise.all(renameList.map(async ([tempPath, _]) => (await File.isExists(tempPath)) ? unlink(tempPath) : undefined));
+                    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, undefined, undefined, schema);
             }
         }
         else if ((Array.isArray(where) &&
@@ -839,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(),
@@ -851,26 +843,22 @@ 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 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.all(renameList.map(async ([tempPath, _]) => (await File.isExists(tempPath)) ? unlink(tempPath) : undefined));
+                    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)) {
@@ -883,21 +871,22 @@ 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);
+        await File.lock(join(tablePath, ".tmp"));
         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))));
-            }
+            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))));
             return "*";
         }
         else if ((Array.isArray(where) &&
@@ -914,34 +903,33 @@ 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 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.all(renameList.map(async ([tempPath, _]) => (await File.isExists(tempPath)) ? unlink(tempPath) : undefined));
+                        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;
                 }
             }
         }
@@ -957,10 +945,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];
@@ -981,10 +969,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];
@@ -1005,10 +993,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.30",
+  "version": "1.0.0-rc.32",
   "author": {
     "name": "Karim Amahtil",
     "email": "karim.amahtil@gmail.com"