inibase 1.0.0-rc.101 → 1.0.0-rc.102

package/dist/file.d.ts

@@ -58,7 +58,7 @@ export declare function get(filePath: string, lineNumbers: undefined | number |
  *
  * Note: If the file doesn't exist and replacements is an object, it creates a new file with the specified replacements.
  */
-export declare const replace: (filePath: string, replacements: string | number | boolean | null | (string | number | boolean | null)[] | Record<number, string | boolean | number | null | (string | boolean | number | null)[]>) => Promise<string[]>;
+export declare const replace: (filePath: string, replacements: string | number | boolean | null | (string | number | boolean | null)[] | Record<number, string | boolean | number | null | (string | boolean | number | null)[]>, totalItems?: number) => Promise<string[]>;
 /**
  * Asynchronously appends data to the end of a file.
  *

package/dist/file.js

@@ -1,3 +1,4 @@
+import { createWriteStream } from "node:fs";
 import { access, appendFile, copyFile, constants as fsConstants, open, readFile, unlink, writeFile, } from "node:fs/promises";
 import { join } from "node:path";
 import { createInterface } from "node:readline";
@@ -7,6 +8,7 @@ import { createGunzip, createGzip } from "node:zlib";
 import Inison from "inison";
 import { detectFieldType, isArrayOfObjects, isStringified, isNumber, isObject, } from "./utils.js";
 import { compare, encodeID, exec, gunzip, gzip } from "./utils.server.js";
+import { spawn } from "node:child_process";
 export const lock = async (folderPath, prefix) => {
     let lockFile = null;
     const lockFilePath = join(folderPath, `${prefix ?? ""}.locked`);
@@ -239,48 +241,93 @@ 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) => {
+export const replace = async (filePath, replacements, totalItems) => {
     const fileTempPath = filePath.replace(/([^/]+)\/?$/, ".tmp/$1");
+    const isReplacementsObject = isObject(replacements);
+    const isReplacementsObjectHasLineNumbers = isReplacementsObject && !Number.isNaN(Number(Object.keys(replacements)[0]));
     if (await isExists(filePath)) {
-        let fileHandle = null;
-        let fileTempHandle = null;
+        if (isReplacementsObjectHasLineNumbers) {
+            let fileHandle = null;
+            let fileTempHandle = null;
+            try {
+                let linesCount = 0;
+                fileHandle = await open(filePath, "r");
+                fileTempHandle = await open(fileTempPath, "w");
+                const rl = createReadLineInternface(filePath, fileHandle);
+                await _pipeline(filePath, rl, fileTempHandle.createWriteStream(), new Transform({
+                    transform(line, _, callback) {
+                        linesCount++;
+                        const replacement = isReplacementsObject
+                            ? Object.hasOwn(replacements, linesCount)
+                                ? replacements[linesCount]
+                                : line
+                            : replacements;
+                        return callback(null, `${replacement}\n`);
+                    },
+                }));
+                return [fileTempPath, filePath];
+            }
+            catch {
+                return [fileTempPath, null];
+            }
+            finally {
+                // Ensure that file handles are closed, even if an error occurred
+                await fileHandle?.close();
+                await fileTempHandle?.close();
+            }
+        }
+        else {
+            return new Promise((resolve) => {
+                const sedProcess = spawn("sed", [
+                    "-e",
+                    `s/.*/${replacements}/`,
+                    "-e",
+                    `/^$/s/^/${replacements}/`,
+                    filePath,
+                ]);
+                const outputStream = createWriteStream(fileTempPath); // Temp file for output
+                // Pipe sed output to the temporary file
+                sedProcess.stdout.pipe(outputStream);
+                // Handle the process close
+                sedProcess.on("close", (code) => {
+                    if (code === 0)
+                        resolve([fileTempPath, filePath]);
+                    else
+                        resolve([fileTempPath, null]);
+                });
+                // Handle errors in spawning the sed process
+                sedProcess.on("error", () => {
+                    resolve([fileTempPath, null]);
+                });
+            });
+        }
+    }
+    else if (isReplacementsObject) {
         try {
-            let linesCount = 0;
-            fileHandle = await open(filePath, "r");
-            fileTempHandle = await open(fileTempPath, "w");
-            const rl = createReadLineInternface(filePath, fileHandle);
-            await _pipeline(filePath, rl, fileTempHandle.createWriteStream(), new Transform({
-                transform(line, _, callback) {
-                    linesCount++;
-                    const replacement = isObject(replacements)
-                        ? Object.hasOwn(replacements, linesCount)
-                            ? replacements[linesCount]
-                            : line
-                        : replacements;
-                    return callback(null, `${replacement}\n`);
-                },
-            }));
+            if (isReplacementsObjectHasLineNumbers) {
+                const 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`);
+            }
+            else {
+                if (!totalItems)
+                    throw new Error("INVALID_PARAMETERS");
+                await write(fileTempPath, `${`${replacements}\n`.repeat(totalItems)}\n`);
+            }
             return [fileTempPath, filePath];
         }
-        finally {
-            // Ensure that file handles are closed, even if an error occurred
-            await fileHandle?.close();
-            await fileTempHandle?.close();
+        catch {
+            return [fileTempPath, null];
         }
     }
-    else if (isObject(replacements)) {
-        const 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 [];
 };
 /**
@@ -293,20 +340,25 @@ export const replace = async (filePath, replacements) => {
  */
 export const append = async (filePath, data) => {
     const fileTempPath = filePath.replace(/([^/]+)\/?$/, ".tmp/$1");
-    if (await isExists(filePath)) {
-        await copyFile(filePath, fileTempPath);
-        if (!filePath.endsWith(".gz")) {
-            await appendFile(fileTempPath, `${Array.isArray(data) ? data.join("\n") : data}\n`);
-        }
-        else {
-            await exec(`echo $'${(Array.isArray(data) ? data.join("\n") : data)
-                .toString()
-                .replace(/'/g, "\\'")}' | gzip - >> ${fileTempPath}`);
+    try {
+        if (await isExists(filePath)) {
+            await copyFile(filePath, fileTempPath);
+            if (!filePath.endsWith(".gz")) {
+                await appendFile(fileTempPath, `${Array.isArray(data) ? data.join("\n") : data}\n`);
+            }
+            else {
+                await exec(`echo $'${(Array.isArray(data) ? data.join("\n") : data)
+                    .toString()
+                    .replace(/'/g, "\\'")}' | gzip - >> ${fileTempPath}`);
+            }
         }
+        else
+            await write(fileTempPath, `${Array.isArray(data) ? data.join("\n") : data}\n`);
+        return [fileTempPath, filePath];
+    }
+    catch {
+        return [fileTempPath, null];
     }
-    else
-        await write(fileTempPath, `${Array.isArray(data) ? data.join("\n") : data}\n`);
-    return [fileTempPath, filePath];
 };
 /**
  * Asynchronously prepends data to the beginning of a file.
@@ -337,6 +389,9 @@ export const prepend = async (filePath, data) => {
                     },
                 }));
             }
+            catch {
+                return [fileTempPath, null];
+            }
             finally {
                 // Ensure that file handles are closed, even if an error occurred
                 await fileHandle?.close();
@@ -349,13 +404,22 @@ export const prepend = async (filePath, data) => {
                 await write(fileChildTempPath, `${Array.isArray(data) ? data.join("\n") : data}\n`);
                 await exec(`cat ${fileChildTempPath} ${filePath} > ${fileTempPath}`);
             }
+            catch {
+                return [fileTempPath, null];
+            }
             finally {
                 await unlink(fileChildTempPath);
             }
         }
     }
-    else
-        await write(fileTempPath, `${Array.isArray(data) ? data.join("\n") : data}\n`);
+    else {
+        try {
+            await write(fileTempPath, `${Array.isArray(data) ? data.join("\n") : data}\n`);
+        }
+        catch {
+            return [fileTempPath, null];
+        }
+    }
     return [fileTempPath, filePath];
 };
 /**
@@ -374,11 +438,16 @@ export const remove = async (filePath, linesToDelete) => {
     if (linesToDelete.some(Number.isNaN))
         throw new Error("UNVALID_LINE_NUMBERS");
     const fileTempPath = filePath.replace(/([^/]+)\/?$/, ".tmp/$1");
-    const command = filePath.endsWith(".gz")
-        ? `zcat ${filePath} | sed "${linesToDelete.join("d;")}d" | gzip > ${fileTempPath}`
-        : `sed "${linesToDelete.join("d;")}d" ${filePath} > ${fileTempPath}`;
-    await exec(command);
-    return [fileTempPath, filePath];
+    try {
+        const command = filePath.endsWith(".gz")
+            ? `zcat ${filePath} | sed "${linesToDelete.join("d;")}d" | gzip > ${fileTempPath}`
+            : `sed "${linesToDelete.join("d;")}d" ${filePath} > ${fileTempPath}`;
+        await exec(command);
+        return [fileTempPath, filePath];
+    }
+    catch {
+        return [fileTempPath, null];
+    }
 };
 /**
  * Asynchronously searches a file for lines matching specified criteria, using comparison and logical operators.

package/dist/index.d.ts

@@ -49,7 +49,7 @@ declare global {
         entries<T extends object>(o: T): Entries<T>;
     }
 }
-export type ErrorCodes = "FIELD_UNIQUE" | "FIELD_REQUIRED" | "NO_SCHEMA" | "NO_ITEMS" | "INVALID_ID" | "INVALID_TYPE" | "INVALID_PARAMETERS" | "NO_ENV" | "TABLE_EXISTS" | "TABLE_NOT_EXISTS";
+export type ErrorCodes = "FIELD_UNIQUE" | "FIELD_REQUIRED" | "NO_SCHEMA" | "TABLE_EMPTY" | "INVALID_ID" | "INVALID_TYPE" | "INVALID_PARAMETERS" | "NO_ENV" | "TABLE_EXISTS" | "TABLE_NOT_EXISTS";
 export type ErrorLang = "en";
 export default class Inibase {
     pageInfo: Record<string, pageInfo>;
@@ -72,7 +72,6 @@ export default class Inibase {
      */
     createTable(tableName: string, schema?: Schema, config?: Config): Promise<void>;
     private replaceStringInFile;
-    private replaceStringInSchemas;
     /**
      * Update table schema or config
      *

package/dist/index.js

@@ -1,13 +1,15 @@
 import "dotenv/config";
 import { randomBytes, scryptSync } from "node:crypto";
 import { appendFileSync, existsSync, readFileSync } from "node:fs";
-import { mkdir, readFile, readdir, rename, stat, unlink, writeFile, } from "node:fs/promises";
+import { glob, mkdir, readFile, readdir, rename, rm, unlink, writeFile, } from "node:fs/promises";
 import { join, parse } from "node:path";
 import { inspect } from "node:util";
 import Inison from "inison";
 import * as File from "./file.js";
 import * as Utils from "./utils.js";
 import * as UtilsServer from "./utils.server.js";
+// hide ExperimentalWarning glob()
+process.removeAllListeners("warning");
 export default class Inibase {
     pageInfo;
     salt;
@@ -35,12 +37,12 @@ export default class Inibase {
     Error(code, variable, language = "en") {
         const errorMessages = {
             en: {
-                FIELD_UNIQUE: "Field {variable} should be unique, got {variable} instead",
-                FIELD_REQUIRED: "Field {variable} is required",
+                TABLE_EMPTY: "Table {variable} is empty",
                 TABLE_EXISTS: "Table {variable} already exists",
                 TABLE_NOT_EXISTS: "Table {variable} doesn't exist",
                 NO_SCHEMA: "Table {variable} does't have a schema",
-                NO_ITEMS: "Table {variable} is empty",
+                FIELD_UNIQUE: "Field {variable} should be unique, got {variable} instead",
+                FIELD_REQUIRED: "Field {variable} is required",
                 INVALID_ID: "The given ID(s) is/are not valid(s)",
                 INVALID_TYPE: "Expect {variable} to be {variable}, got {variable} instead",
                 INVALID_PARAMETERS: "The given parameters are not valid",
@@ -108,8 +110,14 @@ export default class Inibase {
             if (config.prepend)
                 await writeFile(join(tablePath, ".prepend.config"), "");
         }
-        if (schema)
-            await writeFile(join(tablePath, "schema.json"), JSON.stringify(UtilsServer.addIdToSchema(schema, 0, this.salt), null, 2));
+        if (schema) {
+            const lastSchemaId = 0;
+            await writeFile(join(tablePath, "schema.json"), JSON.stringify(UtilsServer.addIdToSchema(schema, lastSchemaId, this.salt), null, 2));
+            await writeFile(join(tablePath, `${lastSchemaId}.schema`), "");
+        }
+        else
+            await writeFile(join(tablePath, "0.schema"), "");
+        await writeFile(join(tablePath, "0-0.pagination"), "");
     }
     // Function to replace the string in one schema.json file
     async replaceStringInFile(filePath, targetString, replaceString) {
@@ -119,20 +127,6 @@ export default class Inibase {
             await writeFile(filePath, updatedContent, "utf8");
         }
     }
-    // Function to process schema files one by one (sequentially)
-    async replaceStringInSchemas(directoryPath, targetString, replaceString) {
-        const files = await readdir(directoryPath);
-        for (const file of files) {
-            const fullPath = join(directoryPath, file);
-            const fileStat = await stat(fullPath);
-            if (fileStat.isDirectory()) {
-                await this.replaceStringInSchemas(fullPath, targetString, replaceString);
-            }
-            else if (file === "schema.json") {
-                await this.replaceStringInFile(fullPath, targetString, replaceString);
-            }
-        }
-    }
     /**
      * Update table schema or config
      *
@@ -145,11 +139,13 @@ export default class Inibase {
         if (schema) {
             // remove id from schema
             schema = schema.filter(({ key }) => !["id", "createdAt", "updatedAt"].includes(key));
+            let schemaIdFilePath;
+            for await (const filePath of glob("*.schema", { cwd: this.databasePath }))
+                schemaIdFilePath = filePath;
+            const lastSchemaId = Number(parse(schemaIdFilePath).name);
             if (await File.isExists(join(tablePath, "schema.json"))) {
                 // update columns files names based on field id
-                schema = UtilsServer.addIdToSchema(schema, table.schema?.length
-                    ? UtilsServer.findLastIdNumber(table.schema, this.salt)
-                    : 0, this.salt);
+                schema = UtilsServer.addIdToSchema(schema, lastSchemaId, this.salt);
                 if (table.schema?.length) {
                     const replaceOldPathes = Utils.findChangedProperties(this._schemaToIdsPath(tableName, table.schema), this._schemaToIdsPath(tableName, schema));
                     if (replaceOldPathes)
@@ -160,8 +156,9 @@ export default class Inibase {
                 }
             }
             else
-                schema = UtilsServer.addIdToSchema(schema, 0, this.salt);
+                schema = UtilsServer.addIdToSchema(schema, lastSchemaId, this.salt);
             await writeFile(join(tablePath, "schema.json"), JSON.stringify(schema, null, 2));
+            await rename(schemaIdFilePath, join(tablePath, `${lastSchemaId}.schema`));
         }
         if (config) {
             if (config.compression !== undefined &&
@@ -186,8 +183,10 @@ export default class Inibase {
             if (config.cache !== undefined && config.cache !== table.config.cache) {
                 if (config.cache)
                     await writeFile(join(tablePath, ".cache.config"), "");
-                else
+                else {
+                    await this.clearCache(tableName);
                     await unlink(join(tablePath, ".cache.config"));
+                }
             }
             if (config.prepend !== undefined &&
                 config.prepend !== table.config.prepend) {
@@ -213,8 +212,12 @@ export default class Inibase {
                     await unlink(join(tablePath, ".prepend.config"));
             }
             if (config.name) {
-                await this.replaceStringInSchemas(this.databasePath, `"table": "${tableName}"`, `"table": "${config.name}"`);
                 await rename(tablePath, join(this.databasePath, config.name));
+                // replace table name in other linked tables (relationship)
+                for await (const schemaPath of glob("**/schema.json", {
+                    cwd: this.databasePath,
+                }))
+                    await this.replaceStringInFile(schemaPath, `"table": "${tableName}"`, `"table": "${config.name}"`);
             }
         }
         delete this.tables[tableName];
@@ -241,14 +244,13 @@ export default class Inibase {
         return this.tables[tableName];
     }
     async getTableSchema(tableName, encodeIDs = true) {
-        const tableSchemaPath = join(this.databasePath, tableName, "schema.json");
-        if (!(await File.isExists(tableSchemaPath)))
+        const tablePath = join(this.databasePath, tableName);
+        if (!(await File.isExists(join(tablePath, "schema.json"))))
             return undefined;
-        const schemaFile = await readFile(tableSchemaPath, "utf8");
+        const schemaFile = await readFile(join(tablePath, "schema.json"), "utf8");
         if (!schemaFile)
             return undefined;
         let schema = JSON.parse(schemaFile);
-        const lastIdNumber = UtilsServer.findLastIdNumber(schema, this.salt);
         schema = [
             {
                 id: 0,
@@ -256,19 +258,19 @@ export default class Inibase {
                 type: "id",
                 required: true,
             },
-            ...schema,
             {
-                id: lastIdNumber + 1,
+                id: -1,
                 key: "createdAt",
                 type: "date",
                 required: true,
             },
             {
-                id: lastIdNumber + 2,
+                id: -2,
                 key: "updatedAt",
                 type: "date",
                 required: false,
             },
+            ...schema,
         ];
         if (!encodeIDs)
             return schema;
@@ -279,7 +281,7 @@ export default class Inibase {
         if (!table.schema)
             throw this.Error("NO_SCHEMA", tableName);
         if (!(await File.isExists(join(this.databasePath, tableName, `id${this.getFileExtension(tableName)}`))))
-            throw this.Error("NO_ITEMS", tableName);
+            throw this.Error("TABLE_EMPTY", tableName);
         return table;
     }
     validateData(data, schema, skipRequiredField = false) {
@@ -455,15 +457,17 @@ export default class Inibase {
                 return null;
         }
     }
-    _combineObjectsToArray = (input) => input.reduce((result, current) => {
-        for (const [key, value] of Object.entries(current))
-            if (Object.hasOwn(result, key) && Array.isArray(result[key]))
-                result[key].push(value);
-            else
-                result[key] = [value];
-        return result;
-    }, {});
-    _CombineData = (data, prefix) => {
+    _combineObjectsToArray(input) {
+        return input.reduce((result, current) => {
+            for (const [key, value] of Object.entries(current))
+                if (Object.hasOwn(result, key) && Array.isArray(result[key]))
+                    result[key].push(value);
+                else
+                    result[key] = [value];
+            return result;
+        }, {});
+    }
+    _CombineData(data, prefix) {
         if (Utils.isArrayOfObjects(data))
             return this._combineObjectsToArray(data.map((single_data) => this._CombineData(single_data)));
         const RETURN = {};
@@ -480,7 +484,7 @@ export default class Inibase {
                 RETURN[(prefix ?? "") + key] = File.encode(value);
         }
         return RETURN;
-    };
+    }
     joinPathesContents(tableName, data) {
         const tablePath = join(this.databasePath, tableName), combinedData = this._CombineData(data);
         const newCombinedData = {};
@@ -834,9 +838,8 @@ export default class Inibase {
      */
     async clearCache(tableName) {
         const cacheFolderPath = join(this.databasePath, tableName, ".cache");
-        await Promise.all((await readdir(cacheFolderPath))
-            .filter((file) => file !== ".pagination")
-            .map((file) => unlink(join(cacheFolderPath, file))));
+        await rm(cacheFolderPath, { recursive: true, force: true });
+        await mkdir(cacheFolderPath);
     }
     async get(tableName, where, options = {
         page: 1,
@@ -858,7 +861,12 @@ export default class Inibase {
         let schema = (await this.getTable(tableName)).schema;
         if (!schema)
             throw this.Error("NO_SCHEMA", tableName);
-        if (!(await File.isExists(join(tablePath, `id${this.getFileExtension(tableName)}`))))
+        let pagination;
+        for await (const paginationFilePath of glob("*.pagination", {
+            cwd: tablePath,
+        }))
+            pagination = parse(paginationFilePath).name.split("-").map(Number);
+        if (!pagination[1])
             return null;
         if (options.columns?.length)
             schema = this._filterSchemaByColumns(schema, options.columns);
@@ -931,7 +939,7 @@ export default class Inibase {
                 if (where)
                     lines = lines.slice((options.page - 1) * options.perPage, options.page * options.perPage);
                 else if (!this.totalItems[`${tableName}-*`])
-                    this.totalItems[`${tableName}-*`] = await File.count(join(tablePath, `id${this.getFileExtension(tableName)}`));
+                    this.totalItems[`${tableName}-*`] = pagination[1];
                 if (!lines.length)
                     return null;
                 // Parse the result and extract the specified lines
@@ -964,16 +972,8 @@ export default class Inibase {
             RETURN = Object.values(await this.getItemsFromSchema(tableName, schema, Array.from({ length: options.perPage }, (_, index) => (options.page - 1) * options.perPage +
                 index +
                 1), options));
-            if (await File.isExists(join(tablePath, ".cache", ".pagination"))) {
-                if (!this.totalItems[`${tableName}-*`])
-                    this.totalItems[`${tableName}-*`] = Number((await readFile(join(tablePath, ".cache", ".pagination"), "utf8")).split(",")[1]);
-            }
-            else {
-                const lastId = Number(Object.keys((await File.get(join(tablePath, `id${this.getFileExtension(tableName)}`), -1, "number", undefined, this.salt, true))?.[0] ?? 0));
-                if (!this.totalItems[`${tableName}-*`])
-                    this.totalItems[`${tableName}-*`] = await File.count(join(tablePath, `id${this.getFileExtension(tableName)}`));
-                await writeFile(join(tablePath, ".cache", ".pagination"), `${lastId},${this.totalItems[`${tableName}-*`]}`);
-            }
+            if (!this.totalItems[`${tableName}-*`])
+                this.totalItems[`${tableName}-*`] = pagination[1];
         }
         else if ((Array.isArray(where) && where.every(Utils.isNumber)) ||
             Utils.isNumber(where)) {
@@ -1076,23 +1076,17 @@ export default class Inibase {
             returnPostedData = false;
         const keys = UtilsServer.hashString(Object.keys(Array.isArray(data) ? data[0] : data).join("."));
         // Skip Id and (created|updated)At
-        this.validateData(data, schema.slice(1, -2));
-        let lastId = 0, renameList = [];
+        this.validateData(data, schema.slice(3));
+        let lastId = 0;
+        const renameList = [];
         try {
             await File.lock(join(tablePath, ".tmp"), keys);
-            if (await File.isExists(join(tablePath, `id${this.getFileExtension(tableName)}`))) {
-                if (await File.isExists(join(tablePath, ".cache", ".pagination")))
-                    [lastId, this.totalItems[`${tableName}-*`]] = (await readFile(join(tablePath, ".cache", ".pagination"), "utf8"))
-                        .split(",")
-                        .map(Number);
-                else {
-                    lastId = Number(Object.keys((await File.get(join(tablePath, `id${this.getFileExtension(tableName)}`), -1, "number", undefined, this.salt, true))?.[0] ?? 0));
-                    if (!this.totalItems[`${tableName}-*`])
-                        this.totalItems[`${tableName}-*`] = await File.count(join(tablePath, `id${this.getFileExtension(tableName)}`));
-                }
-            }
-            else
-                this.totalItems[`${tableName}-*`] = 0;
+            let paginationFilePath;
+            for await (const filePath of glob("*.pagination", { cwd: tablePath }))
+                paginationFilePath = filePath;
+            [lastId, this.totalItems[`${tableName}-*`]] = parse(paginationFilePath)
+                .name.split("-")
+                .map(Number);
             if (Utils.isArrayOfObjects(data))
                 for (let index = 0; index < data.length; index++) {
                     const element = data[index];
@@ -1112,17 +1106,18 @@ export default class Inibase {
                     ? data.toReversed()
                     : data
                 : data);
-            await Promise.all(Object.entries(pathesContents).map(async ([path, content]) => renameList.push(this.tables[tableName].config.prepend
+            await Promise.allSettled(Object.entries(pathesContents).map(async ([path, content]) => renameList.push(this.tables[tableName].config.prepend
                 ? await File.prepend(path, content)
                 : await File.append(path, content))));
-            await Promise.all(renameList.map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
-            renameList = [];
+            await Promise.allSettled(renameList
+                .filter(([_, filePath]) => filePath)
+                .map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
             if (this.tables[tableName].config.cache)
                 await this.clearCache(tableName);
             this.totalItems[`${tableName}-*`] += Array.isArray(data)
                 ? data.length
                 : 1;
-            await writeFile(join(tablePath, ".cache", ".pagination"), `${lastId},${this.totalItems[`${tableName}-*`]}`);
+            await rename(join(tablePath, paginationFilePath), join(tablePath, `${lastId}-${this.totalItems[`${tableName}-*`]}.pagination`));
             if (returnPostedData)
                 return this.get(tableName, this.tables[tableName].config.prepend
                     ? Array.isArray(data)
@@ -1144,7 +1139,7 @@ export default class Inibase {
         page: 1,
         perPage: 15,
     }, returnUpdatedData) {
-        let renameList = [];
+        const renameList = [];
         const tablePath = join(this.databasePath, tableName);
         const schema = (await this.throwErrorIfTableEmpty(tableName))
             .schema;
@@ -1159,13 +1154,6 @@ export default class Inibase {
                     throw this.Error("INVALID_ID", data.id);
                 return this.put(tableName, data, data.id, options, returnUpdatedData || undefined);
             }
-            let totalItems;
-            if (await File.isExists(join(tablePath, ".cache", ".pagination")))
-                totalItems = (await readFile(join(tablePath, ".cache", ".pagination"), "utf8"))
-                    .split(",")
-                    .map(Number)[1];
-            else
-                totalItems = await File.count(join(tablePath, `id${this.getFileExtension(tableName)}`));
             this.validateData(data, schema, true);
             await this.checkUnique(tableName, schema);
             data = this.formatData(data, schema, true);
@@ -1175,13 +1163,16 @@ export default class Inibase {
             });
             try {
                 await File.lock(join(tablePath, ".tmp"));
-                await Promise.all(Object.entries(pathesContents).map(async ([path, content]) => {
-                    const replacementObject = {};
-                    for (const index of [...Array(totalItems)].keys())
-                        replacementObject[`${index + 1}`] = content;
-                    renameList.push(await File.replace(path, replacementObject));
-                }));
-                await Promise.all(renameList.map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
+                for await (const paginationFilePath of glob("*.pagination", {
+                    cwd: tablePath,
+                }))
+                    this.totalItems[`${tableName}-*`] = parse(paginationFilePath)
+                        .name.split("-")
+                        .map(Number)[1];
+                await Promise.allSettled(Object.entries(pathesContents).map(async ([path, content]) => renameList.push(await File.replace(path, content, this.totalItems[`${tableName}-*`]))));
+                await Promise.allSettled(renameList
+                    .filter(([_, filePath]) => filePath)
+                    .map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
                 if (this.tables[tableName].config.cache)
                     await this.clearCache(join(tablePath, ".cache"));
                 if (returnUpdatedData)
@@ -1220,9 +1211,10 @@ export default class Inibase {
                 .join("."));
             try {
                 await File.lock(join(tablePath, ".tmp"), keys);
-                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 = [];
+                await Promise.allSettled(Object.entries(pathesContents).map(async ([path, content]) => renameList.push(await File.replace(path, content))));
+                await Promise.allSettled(renameList
+                    .filter(([_, filePath]) => filePath)
+                    .map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
                 if (this.tables[tableName].config.cache)
                     await this.clearCache(tableName);
                 if (returnUpdatedData)
@@ -1236,7 +1228,8 @@ export default class Inibase {
         }
         else if (Utils.isObject(where)) {
             const lineNumbers = await this.get(tableName, where, undefined, undefined, true);
-            return this.put(tableName, data, lineNumbers, options, returnUpdatedData || undefined);
+            if (lineNumbers)
+                return this.put(tableName, data, lineNumbers, options, returnUpdatedData || undefined);
         }
         else
             throw this.Error("INVALID_PARAMETERS");
@@ -1254,19 +1247,20 @@ export default class Inibase {
         if (!where) {
             try {
                 await File.lock(join(tablePath, ".tmp"));
-                let lastId;
-                if (await File.isExists(join(tablePath, ".cache", ".pagination")))
-                    lastId = (await readFile(join(tablePath, ".cache", ".pagination"), "utf8"))
-                        .split(",")
-                        .map(Number)[0];
-                else
-                    lastId = Number(Object.keys((await File.get(join(tablePath, `id${this.getFileExtension(tableName)}`), -1, "number", undefined, this.salt, true))?.[0] ?? 0));
+                let paginationFilePath;
+                let pagination;
+                for await (const filePath of glob("*.pagination", {
+                    cwd: tablePath,
+                })) {
+                    paginationFilePath = filePath;
+                    pagination = parse(filePath).name.split("-").map(Number);
+                }
                 await Promise.all((await readdir(tablePath))
                     ?.filter((fileName) => fileName.endsWith(this.getFileExtension(tableName)))
                     .map(async (file) => unlink(join(tablePath, file))));
                 if (this.tables[tableName].config.cache)
                     await this.clearCache(tableName);
-                await writeFile(join(tablePath, ".cache", ".pagination"), `${lastId},0`);
+                await rename(join(tablePath, paginationFilePath), join(tablePath, `${pagination[0]}-0.pagination`));
                 return true;
             }
             finally {
@@ -1286,22 +1280,20 @@ export default class Inibase {
                 const renameList = [];
                 try {
                     await File.lock(join(tablePath, ".tmp"));
-                    let lastId;
-                    if (await File.isExists(join(tablePath, ".cache", ".pagination")))
-                        [lastId, this.totalItems[`${tableName}-*`]] = (await readFile(join(tablePath, ".cache", ".pagination"), "utf8"))
-                            .split(",")
-                            .map(Number);
-                    else {
-                        lastId = Number(Object.keys((await File.get(join(tablePath, `id${this.getFileExtension(tableName)}`), -1, "number", undefined, this.salt, true))?.[0] ?? 0));
-                        if (!this.totalItems[`${tableName}-*`])
-                            this.totalItems[`${tableName}-*`] = await File.count(join(tablePath, `id${this.getFileExtension(tableName)}`));
+                    let paginationFilePath;
+                    let pagination;
+                    for await (const filePath of glob("*.pagination", {
+                        cwd: tablePath,
+                    })) {
+                        paginationFilePath = filePath;
+                        pagination = parse(filePath).name.split("-").map(Number);
                     }
-                    if (this.totalItems[`${tableName}-*`] &&
-                        this.totalItems[`${tableName}-*`] -
-                            (Array.isArray(where) ? where.length : 1) >
-                            0) {
+                    if (pagination[1] &&
+                        pagination[1] - (Array.isArray(where) ? where.length : 1) > 0) {
                         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)));
+                        await Promise.all(renameList
+                            .filter(([_, filePath]) => filePath)
+                            .map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
                     }
                     else
                         await Promise.all((await readdir(tablePath))
@@ -1309,8 +1301,7 @@ export default class Inibase {
                             .map(async (file) => unlink(join(tablePath, file))));
                     if (this.tables[tableName].config.cache)
                         await this.clearCache(tableName);
-                    await writeFile(join(tablePath, ".cache", ".pagination"), `${lastId},${this.totalItems[`${tableName}-*`] -
-                        (Array.isArray(where) ? where.length : 1)}`);
+                    await rename(join(tablePath, paginationFilePath), join(tablePath, `${pagination[0]}-${pagination[1] - (Array.isArray(where) ? where.length : 1)}.pagination`));
                     return true;
                 }
                 finally {
@@ -1322,7 +1313,8 @@ export default class Inibase {
         }
         else if (Utils.isObject(where)) {
             const lineNumbers = await this.get(tableName, where, undefined, undefined, true);
-            return this.delete(tableName, lineNumbers);
+            if (lineNumbers)
+                return this.delete(tableName, lineNumbers);
         }
         else
             throw this.Error("INVALID_PARAMETERS");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inibase",
-  "version": "1.0.0-rc.101",
+  "version": "1.0.0-rc.102",
   "type": "module",
   "author": {
     "name": "Karim Amahtil",