inibase 1.0.0-rc.99 → 1.1.0

package/dist/index.js

@@ -1,85 +1,93 @@
 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;
     databasePath;
-    tables;
     fileExtension = ".txt";
-    checkIFunique;
+    tablesMap;
+    uniqueMap;
     totalItems;
     constructor(database, mainFolder = ".") {
         this.databasePath = join(mainFolder, database);
-        this.tables = {};
-        this.totalItems = {};
-        this.pageInfo = {};
-        this.checkIFunique = {};
+        this.clear();
         if (!process.env.INIBASE_SECRET) {
             if (existsSync(".env") &&
                 readFileSync(".env").includes("INIBASE_SECRET="))
-                throw this.Error("NO_ENV");
+                throw this.createError("NO_ENV");
             this.salt = scryptSync(randomBytes(16), randomBytes(16), 32);
             appendFileSync(".env", `\nINIBASE_SECRET=${this.salt.toString("hex")}\n`);
         }
         else
             this.salt = Buffer.from(process.env.INIBASE_SECRET, "hex");
     }
-    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_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",
-                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",
-                NO_ENV: Number(process.versions.node.split(".").reduce((a, b) => a + b)) >= 26
-                    ? "please run with '--env-file=.env'"
-                    : "please use dotenv",
-            },
-            // Add more languages and error messages as needed
-        };
-        const errorMessage = errorMessages[language][code];
+    static errorMessages = {
+        en: {
+            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",
+            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",
+            INVALID_REGEX_MATCH: "Field {variable} does not match the expected pattern",
+            NO_ENV: Number(process.versions.node.split(".").reduce((a, b) => a + b)) >= 26
+                ? "please run with '--env-file=.env'"
+                : "please use dotenv",
+        },
+    };
+    createError(name, variable, language = "en") {
+        const errorMessage = Inibase.errorMessages[language]?.[name];
         if (!errorMessage)
             return new Error("ERR");
-        return new Error(variable
+        const error = new Error(variable
             ? Array.isArray(variable)
                 ? errorMessage.replace(/\{variable\}/g, () => variable.shift()?.toString() ?? "")
                 : errorMessage.replaceAll("{variable}", `'${variable.toString()}'`)
             : errorMessage.replaceAll("{variable}", ""));
+        error.name = name;
+        return error;
+    }
+    clear() {
+        this.tablesMap = new Map();
+        this.totalItems = new Map();
+        this.pageInfo = {};
+        this.uniqueMap = new Map();
     }
-    getFileExtension = (tableName) => {
+    getFileExtension(tableName) {
         let mainExtension = this.fileExtension;
         // TODO: ADD ENCRYPTION
-        // if(this.tables[tableName].config.encryption)
+        // if(this.tablesMap.get(tableName).config.encryption)
         // 	mainExtension += ".enc"
-        if (this.tables[tableName].config.compression)
+        if (this.tablesMap.get(tableName).config.compression)
             mainExtension += ".gz";
         return mainExtension;
-    };
-    _schemaToIdsPath = (tableName, schema, prefix = "") => {
+    }
+    _schemaToIdsPath(tableName, schema, prefix = "") {
         const RETURN = {};
         for (const field of schema)
             if ((field.type === "array" || field.type === "object") &&
                 field.children &&
-                Utils.isArrayOfObjects(field.children)) {
+                Utils.isArrayOfObjects(field.children))
                 Utils.deepMerge(RETURN, this._schemaToIdsPath(tableName, field.children, `${(prefix ?? "") + field.key}.`));
-            }
             else if (field.id)
-                RETURN[field.id] = `${(prefix ?? "") + field.key}${this.getFileExtension(tableName)}`;
+                RETURN[Utils.isValidID(field.id)
+                    ? UtilsServer.decodeID(field.id, this.salt)
+                    : field.id] = `${(prefix ?? "") + field.key}${this.getFileExtension(tableName)}`;
         return RETURN;
-    };
+    }
     /**
      * Create a new table inside database, with predefined schema and config
      *
@@ -90,7 +98,7 @@ export default class Inibase {
     async createTable(tableName, schema, config) {
         const tablePath = join(this.databasePath, tableName);
         if (await File.isExists(tablePath))
-            throw this.Error("TABLE_EXISTS", tableName);
+            throw this.createError("TABLE_EXISTS", tableName);
         await mkdir(join(tablePath, ".tmp"), { recursive: true });
         await mkdir(join(tablePath, ".cache"));
         // if config not set => load default global env config
@@ -108,8 +116,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 = { value: 0 };
+            await writeFile(join(tablePath, "schema.json"), JSON.stringify(UtilsServer.addIdToSchema(schema, lastSchemaID, this.salt), null, 2));
+            await writeFile(join(tablePath, `${lastSchemaID.value}.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 +133,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
      *
@@ -141,15 +141,20 @@ export default class Inibase {
      * @param {(Config&{name?: string})} [config]
      */
     async updateTable(tableName, schema, config) {
-        const table = await this.getTable(tableName), tablePath = join(this.databasePath, tableName);
+        const table = await this.getTable(tableName);
+        const tablePath = join(this.databasePath, tableName);
         if (schema) {
             // remove id from schema
             schema = schema.filter(({ key }) => !["id", "createdAt", "updatedAt"].includes(key));
+            let schemaIdFilePath;
+            for await (const fileName of glob("*.schema", { cwd: tablePath }))
+                schemaIdFilePath = join(tablePath, fileName);
+            const lastSchemaID = {
+                value: schemaIdFilePath ? Number(parse(schemaIdFilePath).name) : 0,
+            };
             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 +165,12 @@ 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));
+            if (schemaIdFilePath)
+                await rename(schemaIdFilePath, join(tablePath, `${lastSchemaID.value}.schema`));
+            else
+                await writeFile(join(tablePath, `${lastSchemaID.value}.schema`), "");
         }
         if (config) {
             if (config.compression !== undefined &&
@@ -186,8 +195,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,11 +224,15 @@ 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];
+        this.tablesMap.delete(tableName);
     }
     /**
      * Get table schema and config
@@ -225,30 +240,29 @@ export default class Inibase {
      * @param {string} tableName
      * @return {*}  {Promise<TableObject>}
      */
-    async getTable(tableName) {
+    async getTable(tableName, encodeIDs = true) {
         const tablePath = join(this.databasePath, tableName);
         if (!(await File.isExists(tablePath)))
-            throw this.Error("TABLE_NOT_EXISTS", tableName);
-        if (!this.tables[tableName])
-            this.tables[tableName] = {
-                schema: await this.getTableSchema(tableName),
+            throw this.createError("TABLE_NOT_EXISTS", tableName);
+        if (!this.tablesMap.has(tableName))
+            this.tablesMap.set(tableName, {
+                schema: await this.getTableSchema(tableName, encodeIDs),
                 config: {
                     compression: await File.isExists(join(tablePath, ".compression.config")),
                     cache: await File.isExists(join(tablePath, ".cache.config")),
                     prepend: await File.isExists(join(tablePath, ".prepend.config")),
                 },
-            };
-        return this.tables[tableName];
+            });
+        return this.tablesMap.get(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,
@@ -258,16 +272,15 @@ export default class Inibase {
             },
             ...schema,
             {
-                id: lastIdNumber + 1,
+                id: -1,
                 key: "createdAt",
                 type: "date",
                 required: true,
             },
             {
-                id: lastIdNumber + 2,
+                id: -2,
                 key: "updatedAt",
                 type: "date",
-                required: false,
             },
         ];
         if (!encodeIDs)
@@ -275,49 +288,88 @@ export default class Inibase {
         return UtilsServer.encodeSchemaID(schema, this.salt);
     }
     async throwErrorIfTableEmpty(tableName) {
-        const table = await this.getTable(tableName);
+        const table = await this.getTable(tableName, false);
         if (!table.schema)
-            throw this.Error("NO_SCHEMA", tableName);
+            throw this.createError("NO_SCHEMA", tableName);
         if (!(await File.isExists(join(this.databasePath, tableName, `id${this.getFileExtension(tableName)}`))))
-            throw this.Error("NO_ITEMS", tableName);
-        return table;
+            throw this.createError("TABLE_EMPTY", tableName);
     }
-    validateData(data, schema, skipRequiredField = false) {
-        if (Utils.isArrayOfObjects(data))
+    _validateData(data, schema, skipRequiredField = false) {
+        if (Utils.isArrayOfObjects(data)) {
             for (const single_data of data)
-                this.validateData(single_data, schema, skipRequiredField);
-        else if (Utils.isObject(data)) {
+                this._validateData(single_data, schema, skipRequiredField);
+            return;
+        }
+        if (Utils.isObject(data)) {
             for (const field of schema) {
                 if (!Object.hasOwn(data, field.key) ||
                     data[field.key] === null ||
                     data[field.key] === undefined ||
                     data[field.key] === "") {
                     if (field.required && !skipRequiredField)
-                        throw this.Error("FIELD_REQUIRED", field.key);
-                    return;
+                        throw this.createError("FIELD_REQUIRED", field.key);
+                    continue;
                 }
                 if (!Utils.validateFieldType(data[field.key], field.type, (field.type === "array" || field.type === "object") &&
                     field.children &&
                     !Utils.isArrayOfObjects(field.children)
                     ? field.children
                     : undefined))
-                    throw this.Error("INVALID_TYPE", [
+                    throw this.createError("INVALID_TYPE", [
                         field.key,
-                        Array.isArray(field.type) ? field.type.join(", ") : field.type,
+                        (Array.isArray(field.type) ? field.type.join(", ") : field.type) +
+                            (field.children
+                                ? Array.isArray(field.children)
+                                    ? Utils.isArrayOfObjects(field.children)
+                                        ? "[object]"
+                                        : `[${field.children.join("|")}]`
+                                    : `[${field.children}]`
+                                : ""),
                         data[field.key],
                     ]);
                 if ((field.type === "array" || field.type === "object") &&
                     field.children &&
                     Utils.isArrayOfObjects(field.children))
-                    this.validateData(data[field.key], field.children, skipRequiredField);
-                else if (field.unique) {
-                    if (!this.checkIFunique[field.key])
-                        this.checkIFunique[field.key] = [];
-                    this.checkIFunique[`${field.key}`].push(data[field.key]);
+                    this._validateData(data[field.key], field.children, skipRequiredField);
+                else {
+                    if (field.regex) {
+                        const regex = UtilsServer.getCachedRegex(field.regex);
+                        if (!regex.test(data[field.key]))
+                            throw this.createError("INVALID_REGEX_MATCH", [field.key]);
+                    }
+                    if (field.unique) {
+                        let uniqueKey;
+                        if (typeof field.unique === "boolean")
+                            uniqueKey = field.id;
+                        else
+                            uniqueKey = field.unique;
+                        if (!this.uniqueMap.has(uniqueKey))
+                            this.uniqueMap.set(uniqueKey, {
+                                exclude: new Set(),
+                                columnsValues: new Map(),
+                            });
+                        if (!this.uniqueMap
+                            .get(uniqueKey)
+                            .columnsValues.has(field.id))
+                            this.uniqueMap
+                                .get(uniqueKey)
+                                .columnsValues.set(field.id, new Set());
+                        if (data.id)
+                            this.uniqueMap.get(uniqueKey).exclude.add(-data.id);
+                        this.uniqueMap
+                            .get(uniqueKey)
+                            .columnsValues.get(field.id)
+                            .add(data[field.key]);
+                    }
                 }
             }
         }
     }
+    async validateData(tableName, data, skipRequiredField = false) {
+        // Skip ID and (created|updated)At
+        this._validateData(data, this.tablesMap.get(tableName).schema.slice(1, -2), skipRequiredField);
+        await this.checkUnique(tableName);
+    }
     cleanObject(obj) {
         const cleanedObject = Object.entries(obj).reduce((acc, [key, value]) => {
             if (value !== undefined && value !== null && value !== "")
@@ -339,8 +391,9 @@ export default class Inibase {
                     return null;
                 if (!Array.isArray(value))
                     value = [value];
-                if (Utils.isArrayOfObjects(fieldChildrenType))
+                if (Utils.isArrayOfObjects(fieldChildrenType)) {
                     return this.formatData(value, fieldChildrenType, _formatOnlyAvailiableKeys);
+                }
                 if (!value.length)
                     return null;
                 return value.map((_value) => this.formatField(_value, fieldChildrenType));
@@ -389,34 +442,63 @@ export default class Inibase {
         }
         return null;
     }
-    async checkUnique(tableName, schema) {
+    async checkUnique(tableName) {
         const tablePath = join(this.databasePath, tableName);
-        for await (const [key, values] of Object.entries(this.checkIFunique)) {
-            const field = Utils.getField(key, schema);
-            if (!field)
+        const flattenSchema = Utils.flattenSchema(this.tablesMap.get(tableName).schema);
+        function hasDuplicates(setA, setB) {
+            for (const value of setA)
+                if (setB.has(value))
+                    return true; // Stop and return true if a duplicate is found
+            return false; // No duplicates found
+        }
+        for await (const [_uniqueID, valueObject] of this.uniqueMap) {
+            let index = 0;
+            let shouldContinueParent = false; // Flag to manage parent loop continuation
+            const mergedLineNumbers = new Set();
+            for await (const [columnID, values] of valueObject.columnsValues) {
+                index++;
+                const field = flattenSchema.find(({ id }) => id === columnID);
+                const [_, totalLines, lineNumbers] = await File.search(join(tablePath, `${field.key}${this.getFileExtension(tableName)}`), "[]", Array.from(values), undefined, valueObject.exclude, field.type, field.children, 1, undefined, false, this.salt);
+                if (totalLines > 0) {
+                    if (valueObject.columnsValues.size === 1 ||
+                        hasDuplicates(lineNumbers, mergedLineNumbers)) {
+                        this.uniqueMap = new Map();
+                        throw this.createError("FIELD_UNIQUE", [
+                            field.key,
+                            Array.from(values).join(", "),
+                        ]);
+                    }
+                    lineNumbers.forEach(mergedLineNumbers.add, mergedLineNumbers);
+                }
+                else {
+                    shouldContinueParent = true; // Flag to skip the rest of this inner loop
+                    break; // Exit the inner loop
+                }
+            }
+            if (shouldContinueParent)
                 continue;
-            const [searchResult, totalLines] = await File.search(join(tablePath, `${key}${this.getFileExtension(tableName)}`), Array.isArray(values) ? "=" : "[]", values, undefined, field.type, field.children, 1, undefined, false, this.salt);
-            if (searchResult && totalLines > 0)
-                throw this.Error("FIELD_UNIQUE", [
-                    field.key,
-                    Array.isArray(values) ? values.join(", ") : values,
-                ]);
         }
-        this.checkIFunique = {};
+        this.uniqueMap = new Map();
     }
     formatData(data, schema, formatOnlyAvailiableKeys) {
-        if (Utils.isArrayOfObjects(data))
-            return data.map((single_data) => this.formatData(single_data, schema, formatOnlyAvailiableKeys));
-        if (Utils.isObject(data)) {
+        const clonedData = structuredClone(data);
+        if (Utils.isArrayOfObjects(clonedData))
+            return clonedData.map((singleData) => this.formatData(singleData, schema, formatOnlyAvailiableKeys));
+        if (Utils.isObject(clonedData)) {
             const RETURN = {};
             for (const field of schema) {
-                if (!Object.hasOwn(data, field.key)) {
+                if (!Object.hasOwn(clonedData, field.key)) {
                     if (formatOnlyAvailiableKeys)
                         continue;
                     RETURN[field.key] = this.getDefaultValue(field);
                     continue;
                 }
-                RETURN[field.key] = this.formatField(data[field.key], field.type, field.children, formatOnlyAvailiableKeys);
+                if (Array.isArray(clonedData[field.key]) &&
+                    !clonedData[field.key].length) {
+                    RETURN[field.key] = this.getDefaultValue(field);
+                    continue;
+                }
+                RETURN[field.key] = this.formatField(clonedData[field.key], field.type, field.children, formatOnlyAvailiableKeys);
             }
             return RETURN;
         }
@@ -432,15 +514,6 @@ export default class Inibase {
             });
         switch (field.type) {
             case "array":
-                return Utils.isArrayOfObjects(field.children)
-                    ? [
-                        this.getDefaultValue({
-                            ...field,
-                            type: "object",
-                            children: field.children,
-                        }),
-                    ]
-                    : null;
             case "object": {
                 if (!field.children || !Utils.isArrayOfObjects(field.children))
                     return null;
@@ -455,15 +528,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 +555,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 = {};
@@ -488,19 +563,21 @@ export default class Inibase {
             newCombinedData[join(tablePath, `${key}${this.getFileExtension(tableName)}`)] = value;
         return newCombinedData;
     }
-    _getItemsFromSchemaHelper(RETURN, item, index, field) {
+    _processSchemaDataHelper(RETURN, item, index, field) {
+        // If the item is an object, we need to process its children
         if (Utils.isObject(item)) {
             if (!RETURN[index])
-                RETURN[index] = {};
+                RETURN[index] = {}; // Ensure the index exists
             if (!RETURN[index][field.key])
                 RETURN[index][field.key] = [];
+            // Process children fields (recursive if needed)
             for (const child_field of field.children.filter((children) => children.type === "array" &&
                 Utils.isArrayOfObjects(children.children))) {
                 if (Utils.isObject(item[child_field.key])) {
                     for (const [key, value] of Object.entries(item[child_field.key])) {
                         for (let _i = 0; _i < value.length; _i++) {
-                            if ((Array.isArray(value[_i]) && Utils.isArrayOfNulls(value[_i])) ||
-                                value[_i] === null)
+                            if (value[_i] === null ||
+                                (Array.isArray(value[_i]) && Utils.isArrayOfNulls(value[_i])))
                                 continue;
                             if (!RETURN[index][field.key][_i])
                                 RETURN[index][field.key][_i] = {};
@@ -513,15 +590,18 @@ export default class Inibase {
                                     value[_i];
                             }
                             else {
-                                value[_i].forEach((_element, _index) => {
-                                    // Recursive call
-                                    this._getItemsFromSchemaHelper(RETURN[index][field.key][_i][child_field.key][_index], _element, _index, child_field);
+                                for (let _index = 0; _index < value[_i].length; _index++) {
+                                    const element = value[_i][_index];
+                                    if (element === null)
+                                        continue;
+                                    // Recursive call to handle nested structure
+                                    this._processSchemaDataHelper(RETURN, element, _index, child_field);
                                     // Perform property assignments
                                     if (!RETURN[index][field.key][_i][child_field.key][_index])
                                         RETURN[index][field.key][_i][child_field.key][_index] = {};
                                     RETURN[index][field.key][_i][child_field.key][_index][key] =
-                                        _element;
-                                });
+                                        element;
+                                }
                             }
                         }
                     }
@@ -529,206 +609,258 @@ export default class Inibase {
             }
         }
     }
-    async getItemsFromSchema(tableName, schema, linesNumber, options, prefix) {
-        const tablePath = join(this.databasePath, tableName);
+    async processSchemaData(tableName, schema, linesNumber, options, prefix) {
         const RETURN = {};
-        for await (const field of schema) {
-            if ((field.type === "array" ||
-                (Array.isArray(field.type) && field.type.includes("array"))) &&
-                field.children) {
-                if (Utils.isArrayOfObjects(field.children)) {
-                    if (field.children.filter((children) => children.type === "array" &&
-                        Utils.isArrayOfObjects(children.children)).length) {
-                        // one of children has array field type and has children array of object = Schema
-                        const childItems = await this.getItemsFromSchema(tableName, field.children.filter((children) => children.type === "array" &&
-                            Utils.isArrayOfObjects(children.children)), linesNumber, options, `${(prefix ?? "") + field.key}.`);
-                        if (childItems)
-                            for (const [index, item] of Object.entries(childItems))
-                                this._getItemsFromSchemaHelper(RETURN, item, index, field);
-                        field.children = field.children.filter((children) => children.type !== "array" ||
-                            !Utils.isArrayOfObjects(children.children));
-                    }
-                    const fieldItems = await this.getItemsFromSchema(tableName, field.children, linesNumber, options, `${(prefix ?? "") + field.key}.`);
-                    if (fieldItems)
-                        for (const [index, item] of Object.entries(fieldItems)) {
-                            if (!RETURN[index])
-                                RETURN[index] = {};
-                            if (Utils.isObject(item)) {
-                                if (!Utils.isArrayOfNulls(Object.values(item))) {
-                                    if (RETURN[index][field.key])
-                                        Object.entries(item).forEach(([key, value], _index) => {
-                                            for (let _index = 0; _index < value.length; _index++)
-                                                if (RETURN[index][field.key][_index])
-                                                    Object.assign(RETURN[index][field.key][_index], {
-                                                        [key]: value[_index],
-                                                    });
-                                                else
-                                                    RETURN[index][field.key][_index] = {
-                                                        [key]: value[_index],
-                                                    };
-                                        });
-                                    else if (Object.values(item).every((_i) => Utils.isArrayOfArrays(_i) || Array.isArray(_i)) &&
-                                        prefix)
-                                        RETURN[index][field.key] = item;
-                                    else {
-                                        RETURN[index][field.key] = [];
-                                        Object.entries(item).forEach(([key, value], _ind) => {
-                                            if (!Array.isArray(value)) {
-                                                RETURN[index][field.key][_ind] = {};
-                                                RETURN[index][field.key][_ind][key] = value;
-                                            }
+        for (const field of schema) {
+            // If the field is of simple type (non-recursive), process it directly
+            if (this.isSimpleField(field.type)) {
+                await this.processSimpleField(tableName, field, linesNumber, RETURN, options, prefix);
+            }
+            else if (this.isArrayField(field.type)) {
+                // Process array fields (recursive if needed)
+                await this.processArrayField(tableName, field, linesNumber, RETURN, options, prefix);
+            }
+            else if (this.isObjectField(field.type)) {
+                // Process object fields (recursive if needed)
+                await this.processObjectField(tableName, field, linesNumber, RETURN, options, prefix);
+            }
+            else if (this.isTableField(field.type)) {
+                // Process table reference fields
+                await this.processTableField(tableName, field, linesNumber, RETURN, options, prefix);
+            }
+        }
+        return RETURN;
+    }
+    // Helper function to determine if a field is simple
+    isSimpleField(fieldType) {
+        const complexTypes = ["array", "object", "table"];
+        if (Array.isArray(fieldType))
+            return fieldType.every((type) => typeof type === "string" && !complexTypes.includes(type));
+        return !complexTypes.includes(fieldType);
+    }
+    // Process a simple field (non-recursive)
+    async processSimpleField(tableName, field, linesNumber, RETURN, _options, prefix) {
+        const fieldPath = join(this.databasePath, tableName, `${prefix ?? ""}${field.key}${this.getFileExtension(tableName)}`);
+        if (await File.isExists(fieldPath)) {
+            const items = await File.get(fieldPath, linesNumber, field.type, field.children, this.salt);
+            if (items) {
+                for (const [index, item] of Object.entries(items)) {
+                    if (typeof item === "undefined")
+                        continue; // Skip undefined items
+                    if (!RETURN[index])
+                        RETURN[index] = {}; // Ensure the index exists
+                    RETURN[index][field.key] = item; // Assign item to the RETURN object
+                }
+            }
+        }
+    }
+    // Helper function to check if the field type is array
+    isArrayField(fieldType) {
+        return ((Array.isArray(fieldType) &&
+            fieldType.every((type) => typeof type === "string") &&
+            fieldType.includes("array")) ||
+            fieldType === "array");
+    }
+    // Process array fields (recursive if needed)
+    async processArrayField(tableName, field, linesNumber, RETURN, options, prefix) {
+        if (Array.isArray(field.children)) {
+            if (this.isSimpleField(field.children)) {
+                await this.processSimpleField(tableName, field, linesNumber, RETURN, options, prefix);
+            }
+            else if (this.isTableField(field.children)) {
+                await this.processTableField(tableName, field, linesNumber, RETURN, options, prefix);
+            }
+            else {
+                // Handling array of objects and filtering nested arrays
+                const nestedArrayFields = field.children.filter((children) => children.type === "array" &&
+                    Utils.isArrayOfObjects(children.children));
+                if (nestedArrayFields.length > 0) {
+                    // one of children has array field type and has children array of object = Schema
+                    const childItems = await this.processSchemaData(tableName, nestedArrayFields, linesNumber, options, `${(prefix ?? "") + field.key}.`);
+                    if (childItems)
+                        for (const [index, item] of Object.entries(childItems))
+                            this._processSchemaDataHelper(RETURN, item, index, field);
+                    // Remove nested arrays after processing
+                    field.children = field.children.filter((children) => !nestedArrayFields.map(({ key }) => key).includes(children.key));
+                }
+                // Process remaining items for the field's children
+                const items = await this.processSchemaData(tableName, field.children, linesNumber, options, `${(prefix ?? "") + field.key}.`);
+                // Process the items after retrieval
+                if (items) {
+                    for (const [index, item] of Object.entries(items)) {
+                        if (typeof item === "undefined")
+                            continue; // Skip undefined items
+                        if (!RETURN[index])
+                            RETURN[index] = {};
+                        if (Utils.isObject(item)) {
+                            const itemEntries = Object.entries(item);
+                            const itemValues = itemEntries.map(([_key, value]) => value);
+                            if (!Utils.isArrayOfNulls(itemValues)) {
+                                if (RETURN[index][field.key])
+                                    for (let _index = 0; _index < itemEntries.length; _index++) {
+                                        const [key, value] = itemEntries[_index];
+                                        for (let _index = 0; _index < value.length; _index++) {
+                                            if (value[_index] === null)
+                                                continue;
+                                            if (RETURN[index][field.key][_index])
+                                                Object.assign(RETURN[index][field.key][_index], {
+                                                    [key]: value[_index],
+                                                });
                                             else
-                                                for (let _i = 0; _i < value.length; _i++) {
-                                                    if (value[_i] === null ||
-                                                        (Array.isArray(value[_i]) &&
-                                                            Utils.isArrayOfNulls(value[_i])))
-                                                        continue;
-                                                    if (!RETURN[index][field.key][_i])
-                                                        RETURN[index][field.key][_i] = {};
-                                                    RETURN[index][field.key][_i][key] = value[_i];
-                                                }
-                                        });
+                                                RETURN[index][field.key][_index] = {
+                                                    [key]: value[_index],
+                                                };
+                                        }
                                     }
-                                }
-                                else
-                                    RETURN[index][field.key] = null;
-                            }
-                            else
-                                RETURN[index][field.key] = item;
-                        }
-                }
-                else if (field.children === "table" ||
-                    (Array.isArray(field.type) && field.type.includes("table")) ||
-                    (Array.isArray(field.children) && field.children.includes("table"))) {
-                    if (field.table &&
-                        (await File.isExists(join(this.databasePath, field.table))) &&
-                        (await File.isExists(join(tablePath, `${(prefix ?? "") + field.key}${this.getFileExtension(tableName)}`)))) {
-                        const itemsIDs = await File.get(join(tablePath, `${(prefix ?? "") + field.key}${this.getFileExtension(tableName)}`), linesNumber, field.type, field.children, this.salt);
-                        if (itemsIDs) {
-                            const searchableIDs = new Map();
-                            for (const [lineNumber, lineContent] of Object.entries(itemsIDs)) {
-                                if (!RETURN[lineNumber])
-                                    RETURN[lineNumber] = {};
-                                if (lineContent !== null && lineContent !== undefined)
-                                    searchableIDs.set(lineNumber, lineContent);
-                            }
-                            if (searchableIDs.size) {
-                                const items = await this.get(field.table, Array.from(new Set(Array.from(searchableIDs.values()).flat())), {
-                                    ...options,
-                                    perPage: Number.POSITIVE_INFINITY,
-                                    columns: options.columns
-                                        ?.filter((column) => column.includes(`${field.key}.`))
-                                        .map((column) => column.replace(`${field.key}.`, "")),
-                                });
-                                if (items) {
-                                    for (const [lineNumber, lineContent,] of searchableIDs.entries()) {
-                                        const foundedItems = items.filter(({ id }) => lineContent.includes(id));
-                                        if (foundedItems)
-                                            RETURN[lineNumber][field.key] = foundedItems;
+                                else if (itemValues.every((_i) => Utils.isArrayOfArrays(_i)) &&
+                                    prefix)
+                                    RETURN[index][field.key] = item;
+                                else {
+                                    RETURN[index][field.key] = [];
+                                    for (let _index = 0; _index < itemEntries.length; _index++) {
+                                        const [key, value] = itemEntries[_index];
+                                        if (!Array.isArray(value)) {
+                                            RETURN[index][field.key][_index] = {};
+                                            RETURN[index][field.key][_index][key] = value;
+                                        }
+                                        else
+                                            for (let _i = 0; _i < value.length; _i++) {
+                                                if (value[_i] === null ||
+                                                    (Array.isArray(value[_i]) &&
+                                                        Utils.isArrayOfNulls(value[_i])))
+                                                    continue;
+                                                if (!RETURN[index][field.key][_i])
+                                                    RETURN[index][field.key][_i] = {};
+                                                RETURN[index][field.key][_i][key] = value[_i];
+                                            }
                                     }
                                 }
                             }
                         }
+                        else
+                            RETURN[index][field.key] = item;
                     }
                 }
-                else if (await File.isExists(join(tablePath, `${(prefix ?? "") + field.key}${this.getFileExtension(tableName)}`))) {
-                    const items = await File.get(join(tablePath, `${(prefix ?? "") + field.key}${this.getFileExtension(tableName)}`), linesNumber, field.type, field.children, this.salt);
-                    if (items)
-                        for (const [index, item] of Object.entries(items)) {
-                            if (!RETURN[index])
-                                RETURN[index] = {};
-                            if (item !== null && item !== undefined)
-                                RETURN[index][field.key] = item;
-                        }
+            }
+        }
+        else if (this.isSimpleField(field.children)) {
+            // If `children` is FieldType, handle it as an array of simple types (no recursion needed here)
+            await this.processSimpleField(tableName, field, linesNumber, RETURN, options, prefix);
+        }
+        else if (this.isTableField(field.children)) {
+            await this.processTableField(tableName, field, linesNumber, RETURN, options, prefix);
+        }
+    }
+    // Helper function to check if the field type is object
+    isObjectField(fieldType) {
+        return (fieldType === "object" ||
+            (Array.isArray(fieldType) &&
+                fieldType.every((type) => typeof type === "string") &&
+                fieldType.includes("object")));
+    }
+    // Process object fields (recursive if needed)
+    async processObjectField(tableName, field, linesNumber, RETURN, options, prefix) {
+        if (Array.isArray(field.children)) {
+            // If `children` is a Schema (array of Field objects), recurse
+            const items = await this.processSchemaData(tableName, field.children, linesNumber, options, `${prefix ?? ""}${field.key}.`);
+            for (const [index, item] of Object.entries(items)) {
+                if (typeof item === "undefined")
+                    continue; // Skip undefined items
+                if (!RETURN[index])
+                    RETURN[index] = {};
+                if (Utils.isObject(item)) {
+                    if (!Object.values(item).every((i) => i === null))
+                        RETURN[index][field.key] = item;
                 }
             }
-            else if (field.type === "object") {
-                const fieldItems = await this.getItemsFromSchema(tableName, field.children, linesNumber, options, `${(prefix ?? "") + field.key}.`);
-                if (fieldItems)
-                    for (const [index, item] of Object.entries(fieldItems)) {
-                        if (!RETURN[index])
-                            RETURN[index] = {};
-                        if (Utils.isObject(item)) {
-                            if (!Object.values(item).every((i) => i === null))
-                                RETURN[index][field.key] = item;
-                        }
+        }
+    }
+    // Helper function to check if the field type is table
+    isTableField(fieldType) {
+        return (fieldType === "table" ||
+            (Array.isArray(fieldType) &&
+                fieldType.every((type) => typeof type === "string") &&
+                fieldType.includes("table")));
+    }
+    // Process table reference fields
+    async processTableField(tableName, field, linesNumber, RETURN, options, prefix) {
+        if (field.table &&
+            (await File.isExists(join(this.databasePath, field.table)))) {
+            const fieldPath = join(this.databasePath, tableName, `${prefix ?? ""}${field.key}${this.getFileExtension(tableName)}`);
+            if (await File.isExists(fieldPath)) {
+                const itemsIDs = await File.get(fieldPath, linesNumber, field.type, field.children, this.salt);
+                const isArrayField = this.isArrayField(field.type);
+                if (itemsIDs) {
+                    const searchableIDs = new Map();
+                    for (const [lineNumber, lineContent] of Object.entries(itemsIDs)) {
+                        if (typeof lineContent === "undefined")
+                            continue; // Skip undefined items
+                        if (!RETURN[lineNumber])
+                            RETURN[lineNumber] = {};
+                        if (lineContent !== null && lineContent !== undefined)
+                            searchableIDs.set(lineNumber, lineContent);
                     }
-            }
-            else if (field.type === "table") {
-                if (field.table &&
-                    (await File.isExists(join(this.databasePath, field.table))) &&
-                    (await File.isExists(join(tablePath, `${(prefix ?? "") + field.key}${this.getFileExtension(tableName)}`)))) {
-                    const itemsIDs = await File.get(join(tablePath, `${(prefix ?? "") + field.key}${this.getFileExtension(tableName)}`), linesNumber, field.type, field.children, this.salt);
-                    if (itemsIDs) {
-                        const searchableIDs = new Map();
-                        for (const [lineNumber, lineContent] of Object.entries(itemsIDs)) {
-                            if (!RETURN[lineNumber])
-                                RETURN[lineNumber] = {};
-                            if (lineContent !== null && lineContent !== undefined)
-                                searchableIDs.set(lineNumber, lineContent);
-                        }
-                        if (searchableIDs.size) {
-                            const items = await this.get(field.table, Array.from(new Set(searchableIDs.values())), {
-                                ...options,
-                                perPage: Number.POSITIVE_INFINITY,
-                                columns: options.columns
-                                    ?.filter((column) => column.includes(`${field.key}.`))
-                                    .map((column) => column.replace(`${field.key}.`, "")),
-                            });
-                            if (items) {
-                                for (const [lineNumber, lineContent,] of searchableIDs.entries()) {
-                                    const foundedItem = items.find(({ id }) => id === lineContent);
-                                    if (foundedItem)
-                                        RETURN[lineNumber][field.key] = foundedItem;
-                                }
+                    if (searchableIDs.size) {
+                        const items = await this.get(field.table, isArrayField
+                            ? Array.from(new Set(Array.from(searchableIDs.values()).flat()))
+                            : Array.from(new Set(searchableIDs.values())), {
+                            ...options,
+                            perPage: Number.POSITIVE_INFINITY,
+                            columns: options.columns
+                                ?.filter((column) => column.includes(`${field.key}.`))
+                                .map((column) => column.replace(`${field.key}.`, "")),
+                        });
+                        if (items) {
+                            for (const [lineNumber, lineContent] of searchableIDs.entries()) {
+                                const foundedItem = isArrayField
+                                    ? items.filter(({ id }) => lineContent.includes(id))
+                                    : items.find(({ id }) => id === lineContent);
+                                if (foundedItem)
+                                    RETURN[lineNumber][field.key] = foundedItem;
                             }
                         }
                     }
                 }
             }
-            else if (await File.isExists(join(tablePath, `${(prefix ?? "") + field.key}${this.getFileExtension(tableName)}`))) {
-                const items = await File.get(join(tablePath, `${(prefix ?? "") + field.key}${this.getFileExtension(tableName)}`), linesNumber, field.type, field.children, this.salt);
-                if (items)
-                    for (const [index, item] of Object.entries(items)) {
-                        if (!RETURN[index])
-                            RETURN[index] = {};
-                        if (item !== null && item !== undefined)
-                            RETURN[index][field.key] = item;
-                    }
-            }
         }
-        return RETURN;
     }
-    async applyCriteria(tableName, schema, options, criteria, allTrue) {
+    _setNestedKey(obj, path, value) {
+        const keys = path.split(".");
+        let current = obj;
+        keys.forEach((key, index) => {
+            if (index === keys.length - 1) {
+                current[key] = value; // Set the value at the last key
+            }
+            else {
+                current[key] = current[key] || {}; // Ensure the object structure exists
+                current = current[key];
+            }
+        });
+    }
+    async applyCriteria(tableName, options, criteria, allTrue, searchIn) {
         const tablePath = join(this.databasePath, tableName);
-        let RETURN = {}, RETURN_LineNumbers = null;
+        let RETURN = {};
         if (!criteria)
             return [null, null];
         if (criteria.and && Utils.isObject(criteria.and)) {
-            const [searchResult, lineNumbers] = await this.applyCriteria(tableName, schema, options, criteria.and, true);
+            const [searchResult, lineNumbers] = await this.applyCriteria(tableName, options, criteria.and, true, searchIn);
             if (searchResult) {
-                RETURN = Utils.deepMerge(RETURN, Object.fromEntries(Object.entries(searchResult).filter(([_k, v], _i) => Object.keys(v).length ===
-                    Object.keys(criteria.and ?? {}).length)));
+                RETURN = Utils.deepMerge(RETURN, Object.fromEntries(Object.entries(searchResult).filter(([_k, v], _i) => Object.keys(v).filter((key) => Object.keys(criteria.and).includes(key)).length)));
                 delete criteria.and;
-                RETURN_LineNumbers = lineNumbers;
+                searchIn = lineNumbers;
             }
             else
                 return [null, null];
         }
-        if (criteria.or && Utils.isObject(criteria.or)) {
-            const [searchResult, lineNumbers] = await this.applyCriteria(tableName, schema, options, criteria.or, false);
+        const criteriaOR = criteria.or;
+        if (criteriaOR)
             delete criteria.or;
-            if (searchResult) {
-                RETURN = Utils.deepMerge(RETURN, searchResult);
-                RETURN_LineNumbers = lineNumbers;
-            }
-        }
         if (Object.keys(criteria).length > 0) {
             if (allTrue === undefined)
                 allTrue = true;
             let index = -1;
             for await (const [key, value] of Object.entries(criteria)) {
-                const field = Utils.getField(key, schema);
+                const field = Utils.getField(key, this.tablesMap.get(tableName).schema);
                 index++;
                 let searchOperator = undefined, searchComparedAtValue = undefined, searchLogicalOperator = undefined;
                 if (Utils.isObject(value)) {
@@ -784,27 +916,40 @@ export default class Inibase {
                     searchOperator = "=";
                     searchComparedAtValue = value;
                 }
-                const [searchResult, totalLines, linesNumbers] = await File.search(join(tablePath, `${key}${this.getFileExtension(tableName)}`), 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}${this.getFileExtension(tableName)}`), searchOperator ?? "=", searchComparedAtValue ?? null, searchLogicalOperator, allTrue ? searchIn : undefined, 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,
-                        {
-                            [key]: value,
-                        },
-                    ])));
-                    this.totalItems[`${tableName}-${key}`] = totalLines;
-                    RETURN_LineNumbers = linesNumbers;
-                }
-                if (allTrue && index > 0) {
-                    if (!Object.keys(RETURN).length)
-                        RETURN = {};
-                    RETURN = Object.fromEntries(Object.entries(RETURN).filter(([_index, item]) => Object.keys(item).length > index));
-                    if (!Object.keys(RETURN).length)
-                        RETURN = {};
+                    RETURN = Utils.deepMerge(RETURN, Object.fromEntries(Object.entries(searchResult).map(([id, value]) => {
+                        const nestedObj = {};
+                        this._setNestedKey(nestedObj, key, value);
+                        return [id, nestedObj];
+                    })));
+                    this.totalItems.set(`${tableName}-${key}`, totalLines);
+                    if (linesNumbers?.size) {
+                        if (searchIn) {
+                            for (const lineNumber of linesNumbers)
+                                searchIn.add(lineNumber);
+                        }
+                        else
+                            searchIn = linesNumbers;
+                    }
                 }
+                else if (allTrue)
+                    return [null, null];
+            }
+        }
+        if (criteriaOR && Utils.isObject(criteriaOR)) {
+            const [searchResult, lineNumbers] = await this.applyCriteria(tableName, options, criteriaOR, false, searchIn);
+            if (searchResult) {
+                RETURN = Utils.deepMerge(RETURN, searchResult);
+                if (!Object.keys(RETURN).length)
+                    RETURN = {};
+                RETURN = Object.fromEntries(Object.entries(RETURN).filter(([_index, item]) => Object.keys(item).filter((key) => Object.keys(criteriaOR).includes(key)).length));
+                if (!Object.keys(RETURN).length)
+                    RETURN = {};
+                searchIn = lineNumbers;
             }
         }
-        return [Object.keys(RETURN).length ? RETURN : null, RETURN_LineNumbers];
+        return [Object.keys(RETURN).length ? RETURN : null, searchIn];
     }
     _filterSchemaByColumns(schema, columns) {
         return schema
@@ -834,9 +979,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,
@@ -855,10 +999,15 @@ export default class Inibase {
         options.page = options.page || 1;
         options.perPage = options.perPage || 15;
         let RETURN;
-        let schema = (await this.getTable(tableName)).schema;
+        let schema = structuredClone((await this.getTable(tableName)).schema);
         if (!schema)
-            throw this.Error("NO_SCHEMA", tableName);
-        if (!(await File.isExists(join(tablePath, `id${this.getFileExtension(tableName)}`))))
+            throw this.createError("NO_SCHEMA", tableName);
+        let pagination;
+        for await (const paginationFileName of glob("*.pagination", {
+            cwd: tablePath,
+        }))
+            pagination = parse(paginationFileName).name.split("-").map(Number);
+        if (!pagination[1])
             return null;
         if (options.columns?.length)
             schema = this._filterSchemaByColumns(schema, options.columns);
@@ -881,7 +1030,7 @@ export default class Inibase {
                     .map((column) => [column, true]);
             let cacheKey = "";
             // Criteria
-            if (this.tables[tableName].config.cache)
+            if (this.tablesMap.get(tableName).config.cache)
                 cacheKey = UtilsServer.hashString(inspect(sortArray, { sorted: true }));
             if (where) {
                 const lineNumbers = await this.get(tableName, where, undefined, undefined, true);
@@ -901,7 +1050,7 @@ export default class Inibase {
                 if (!(await File.isExists(path)))
                     return null;
             // Construct the paste command to merge files and filter lines by IDs
-            const pasteCommand = `paste ${filesPathes.join(" ")}`;
+            const pasteCommand = `paste '${filesPathes.join("' '")}'`;
             // Construct the sort command dynamically based on the number of files for sorting
             const index = 2;
             const sortColumns = sortArray
@@ -914,15 +1063,15 @@ export default class Inibase {
                 return "";
             })
                 .join(" ");
-            const sortCommand = `sort ${sortColumns} -T=${join(tablePath, ".tmp")}`;
+            const sortCommand = `sort ${sortColumns} -T='${join(tablePath, ".tmp")}'`;
             try {
                 if (cacheKey)
                     await File.lock(join(tablePath, ".tmp"), cacheKey);
                 // Combine && Execute the commands synchronously
-                let lines = (await UtilsServer.exec(this.tables[tableName].config.cache
+                let lines = (await UtilsServer.exec(this.tablesMap.get(tableName).config.cache
                     ? (await File.isExists(join(tablePath, ".cache", `${cacheKey}${this.fileExtension}`)))
-                        ? `${awkCommand} ${join(tablePath, ".cache", `${cacheKey}${this.fileExtension}`)}`
-                        : `${pasteCommand} | ${sortCommand} -o ${join(tablePath, ".cache", `${cacheKey}${this.fileExtension}`)} && ${awkCommand} ${join(tablePath, ".cache", `${cacheKey}${this.fileExtension}`)}`
+                        ? `${awkCommand} '${join(tablePath, ".cache", `${cacheKey}${this.fileExtension}`)}'`
+                        : `${pasteCommand} | ${sortCommand} -o '${join(tablePath, ".cache", `${cacheKey}${this.fileExtension}`)}' && ${awkCommand} '${join(tablePath, ".cache", `${cacheKey}${this.fileExtension}`)}'`
                     : `${pasteCommand} | ${sortCommand} | ${awkCommand}`, {
                     encoding: "utf-8",
                 })).stdout
@@ -930,8 +1079,8 @@ export default class Inibase {
                     .split("\n");
                 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)}`));
+                else if (!this.totalItems.has(`${tableName}-*`))
+                    this.totalItems.set(`${tableName}-*`, pagination[1]);
                 if (!lines.length)
                     return null;
                 // Parse the result and extract the specified lines
@@ -961,19 +1110,11 @@ export default class Inibase {
         }
         if (!where) {
             // Display all data
-            RETURN = Object.values(await this.getItemsFromSchema(tableName, schema, Array.from({ length: options.perPage }, (_, index) => (options.page - 1) * options.perPage +
+            RETURN = Object.values(await this.processSchemaData(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.has(`${tableName}-*`))
+                this.totalItems.set(`${tableName}-*`, pagination[1]);
         }
         else if ((Array.isArray(where) && where.every(Utils.isNumber)) ||
             Utils.isNumber(where)) {
@@ -981,12 +1122,12 @@ export default class Inibase {
             let lineNumbers = where;
             if (!Array.isArray(lineNumbers))
                 lineNumbers = [lineNumbers];
-            if (!this.totalItems[`${tableName}-*`])
-                this.totalItems[`${tableName}-*`] = lineNumbers.length;
+            if (!this.totalItems.has(`${tableName}-*`))
+                this.totalItems.set(`${tableName}-*`, lineNumbers.length);
             // useless
             if (onlyLinesNumbers)
                 return lineNumbers;
-            RETURN = Object.values((await this.getItemsFromSchema(tableName, schema, lineNumbers, options)) ?? {});
+            RETURN = Object.values((await this.processSchemaData(tableName, schema, lineNumbers, options)) ?? {});
             if (RETURN?.length && !Array.isArray(where))
                 RETURN = RETURN[0];
         }
@@ -995,11 +1136,11 @@ export default class Inibase {
             let Ids = where;
             if (!Array.isArray(Ids))
                 Ids = [Ids];
-            const [lineNumbers, countItems] = await File.search(join(tablePath, `id${this.getFileExtension(tableName)}`), "[]", Ids.map((id) => Utils.isNumber(id) ? Number(id) : UtilsServer.decodeID(id, this.salt)), undefined, "number", undefined, Ids.length, 0, !this.totalItems[`${tableName}-*`], this.salt);
+            const [lineNumbers, countItems] = await File.search(join(tablePath, `id${this.getFileExtension(tableName)}`), "[]", Ids.map((id) => Utils.isNumber(id) ? Number(id) : UtilsServer.decodeID(id, this.salt)), undefined, undefined, "number", undefined, Ids.length, 0, !this.totalItems.has(`${tableName}-*`), this.salt);
             if (!lineNumbers)
                 return null;
-            if (!this.totalItems[`${tableName}-*`])
-                this.totalItems[`${tableName}-*`] = countItems;
+            if (!this.totalItems.has(`${tableName}-*`))
+                this.totalItems.set(`${tableName}-*`, countItems);
             if (onlyLinesNumbers)
                 return Object.keys(lineNumbers).length
                     ? Object.keys(lineNumbers).map(Number)
@@ -1009,41 +1150,40 @@ export default class Inibase {
                 if (!options.columns?.length)
                     options.columns = undefined;
             }
-            RETURN = Object.values((await this.getItemsFromSchema(tableName, schema, Object.keys(lineNumbers).map(Number), options)) ?? {});
+            RETURN = Object.values((await this.processSchemaData(tableName, schema, Object.keys(lineNumbers).map(Number), options)) ?? {});
             if (RETURN?.length && !Array.isArray(where))
                 RETURN = RETURN[0];
         }
         else if (Utils.isObject(where)) {
             let cachedFilePath = "";
             // Criteria
-            if (this.tables[tableName].config.cache)
+            if (this.tablesMap.get(tableName).config.cache)
                 cachedFilePath = join(tablePath, ".cache", `${UtilsServer.hashString(inspect(where, { sorted: true }))}${this.fileExtension}`);
-            if (this.tables[tableName].config.cache &&
+            if (this.tablesMap.get(tableName).config.cache &&
                 (await File.isExists(cachedFilePath))) {
                 const cachedItems = (await readFile(cachedFilePath, "utf8")).split(",");
-                if (!this.totalItems[`${tableName}-*`])
-                    this.totalItems[`${tableName}-*`] = cachedItems.length;
+                if (!this.totalItems.has(`${tableName}-*`))
+                    this.totalItems.set(`${tableName}-*`, cachedItems.length);
                 if (onlyLinesNumbers)
                     return onlyOne ? Number(cachedItems[0]) : cachedItems.map(Number);
                 return this.get(tableName, cachedItems
                     .slice((options.page - 1) * options.perPage, options.page * options.perPage)
                     .map(Number), options, onlyOne);
             }
-            let linesNumbers = null;
-            [RETURN, linesNumbers] = await this.applyCriteria(tableName, schema, options, where);
-            if (RETURN && linesNumbers?.size) {
-                if (!this.totalItems[`${tableName}-*`])
-                    this.totalItems[`${tableName}-*`] = linesNumbers.size;
+            const [LineNumberDataMap, linesNumbers] = await this.applyCriteria(tableName, options, where);
+            if (LineNumberDataMap && linesNumbers?.size) {
+                if (!this.totalItems.has(`${tableName}-*`))
+                    this.totalItems.set(`${tableName}-*`, linesNumbers.size);
                 if (onlyLinesNumbers)
                     return onlyOne
                         ? linesNumbers.values().next().value
                         : Array.from(linesNumbers);
-                const alreadyExistsColumns = Object.keys(Object.values(RETURN)[0]), alreadyExistsColumnsIDs = Utils.flattenSchema(schema)
+                const alreadyExistsColumns = Object.keys(Object.values(LineNumberDataMap)[0]), alreadyExistsColumnsIDs = Utils.flattenSchema(schema)
                     .filter(({ key }) => alreadyExistsColumns.includes(key))
                     .map(({ id }) => id);
-                RETURN = Object.values(Utils.deepMerge(RETURN, await this.getItemsFromSchema(tableName, Utils.filterSchema(schema, ({ id, type, children }) => !alreadyExistsColumnsIDs.includes(id) ||
-                    Utils.isFieldType("table", type, children)), Object.keys(RETURN).map(Number), options)));
-                if (this.tables[tableName].config.cache)
+                RETURN = Object.values(Utils.deepMerge(LineNumberDataMap, await this.processSchemaData(tableName, Utils.filterSchema(schema, ({ id, type, children }) => !alreadyExistsColumnsIDs.includes(id) ||
+                    Utils.isFieldType("table", type, children)), Object.keys(LineNumberDataMap).map(Number), options)));
+                if (this.tablesMap.get(tableName).config.cache)
                     await writeFile(cachedFilePath, Array.from(linesNumbers).join(","));
             }
         }
@@ -1051,8 +1191,9 @@ export default class Inibase {
             (Utils.isObject(RETURN) && !Object.keys(RETURN).length) ||
             (Array.isArray(RETURN) && !RETURN.length))
             return null;
-        const greatestTotalItems = this.totalItems[`${tableName}-*`] ??
-            Math.max(...Object.entries(this.totalItems)
+        const greatestTotalItems = this.totalItems.has(`${tableName}-*`)
+            ? this.totalItems.get(`${tableName}-*`)
+            : Math.max(...[...this.totalItems.entries()]
                 .filter(([k]) => k.startsWith(`${tableName}-`))
                 .map(([, v]) => v));
         this.pageInfo[tableName] = {
@@ -1069,70 +1210,64 @@ export default class Inibase {
                 page: 1,
                 perPage: 15,
             };
-        const tablePath = join(this.databasePath, tableName), schema = (await this.getTable(tableName)).schema;
-        if (!schema)
-            throw this.Error("NO_SCHEMA", tableName);
+        const tablePath = join(this.databasePath, tableName);
+        await this.getTable(tableName);
+        if (!this.tablesMap.get(tableName).schema)
+            throw this.createError("NO_SCHEMA", tableName);
         if (!returnPostedData)
             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 = [];
+        let clonedData = structuredClone(data);
+        const keys = UtilsServer.hashString(Object.keys(Array.isArray(clonedData) ? clonedData[0] : clonedData).join("."));
+        await this.validateData(tableName, clonedData);
+        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;
-            if (Utils.isArrayOfObjects(data))
-                for (let index = 0; index < data.length; index++) {
-                    const element = data[index];
+            let paginationFilePath;
+            for await (const fileName of glob("*.pagination", { cwd: tablePath }))
+                paginationFilePath = join(tablePath, fileName);
+            let [lastId, _totalItems] = parse(paginationFilePath)
+                .name.split("-")
+                .map(Number);
+            this.totalItems.set(`${tableName}-*`, _totalItems);
+            if (Utils.isArrayOfObjects(clonedData))
+                for (let index = 0; index < clonedData.length; index++) {
+                    const element = clonedData[index];
                     element.id = ++lastId;
                     element.createdAt = Date.now();
                     element.updatedAt = undefined;
                 }
             else {
-                data.id = ++lastId;
-                data.createdAt = Date.now();
-                data.updatedAt = undefined;
+                clonedData.id = ++lastId;
+                clonedData.createdAt = Date.now();
+                clonedData.updatedAt = undefined;
             }
-            await this.checkUnique(tableName, schema);
-            data = this.formatData(data, schema);
-            const pathesContents = this.joinPathesContents(tableName, this.tables[tableName].config.prepend
-                ? Array.isArray(data)
-                    ? data.toReversed()
-                    : data
-                : data);
-            await Promise.all(Object.entries(pathesContents).map(async ([path, content]) => renameList.push(this.tables[tableName].config.prepend
+            clonedData = this.formatData(clonedData, this.tablesMap.get(tableName).schema, false);
+            const pathesContents = this.joinPathesContents(tableName, this.tablesMap.get(tableName).config.prepend
+                ? Array.isArray(clonedData)
+                    ? clonedData.toReversed()
+                    : clonedData
+                : clonedData);
+            await Promise.allSettled(Object.entries(pathesContents).map(async ([path, content]) => renameList.push(this.tablesMap.get(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 = [];
-            if (this.tables[tableName].config.cache)
+            await Promise.allSettled(renameList
+                .filter(([_, filePath]) => filePath)
+                .map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
+            if (this.tablesMap.get(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}-*`]}`);
+            const currentValue = this.totalItems.get(`${tableName}-*`) || 0;
+            this.totalItems.set(`${tableName}-*`, currentValue + (Array.isArray(data) ? data.length : 1));
+            await rename(paginationFilePath, join(tablePath, `${lastId}-${this.totalItems.get(`${tableName}-*`)}.pagination`));
             if (returnPostedData)
-                return this.get(tableName, this.tables[tableName].config.prepend
-                    ? Array.isArray(data)
-                        ? data.map((_, index) => index + 1).toReversed()
+                return this.get(tableName, this.tablesMap.get(tableName).config.prepend
+                    ? Array.isArray(clonedData)
+                        ? clonedData.map((_, index) => index + 1).toReversed()
                         : 1
-                    : Array.isArray(data)
-                        ? data
-                            .map((_, index) => this.totalItems[`${tableName}-*`] - index)
+                    : Array.isArray(clonedData)
+                        ? clonedData
+                            .map((_, index) => this.totalItems.get(`${tableName}-*`) - index)
                             .toReversed()
-                        : this.totalItems[`${tableName}-*`], options, !Utils.isArrayOfObjects(data));
+                        : this.totalItems.get(`${tableName}-*`), options, !Utils.isArrayOfObjects(clonedData));
         }
         finally {
             if (renameList.length)
@@ -1144,45 +1279,38 @@ 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;
+        await this.throwErrorIfTableEmpty(tableName);
+        let clonedData = structuredClone(data);
         if (!where) {
-            if (Utils.isArrayOfObjects(data)) {
-                if (!data.every((item) => Object.hasOwn(item, "id") && Utils.isValidID(item.id)))
-                    throw this.Error("INVALID_ID");
-                return this.put(tableName, data, data.map(({ id }) => id), options, returnUpdatedData || undefined);
+            if (Utils.isArrayOfObjects(clonedData)) {
+                if (!clonedData.every((item) => Object.hasOwn(item, "id") && Utils.isValidID(item.id)))
+                    throw this.createError("INVALID_ID");
+                return this.put(tableName, clonedData, clonedData.map(({ id }) => id), options, returnUpdatedData);
             }
-            if (Object.hasOwn(data, "id")) {
-                if (!Utils.isValidID(data.id))
-                    throw this.Error("INVALID_ID", data.id);
-                return this.put(tableName, data, data.id, options, returnUpdatedData || undefined);
+            if (Object.hasOwn(clonedData, "id")) {
+                if (!Utils.isValidID(clonedData.id))
+                    throw this.createError("INVALID_ID", clonedData.id);
+                return this.put(tableName, clonedData, clonedData.id, options, returnUpdatedData);
             }
-            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);
+            await this.validateData(tableName, clonedData, true);
+            clonedData = this.formatData(clonedData, this.tablesMap.get(tableName).schema, true);
             const pathesContents = this.joinPathesContents(tableName, {
-                ...(({ id, ...restOfData }) => restOfData)(data),
+                ...(({ id, ...restOfData }) => restOfData)(clonedData),
                 updatedAt: Date.now(),
             });
             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)));
-                if (this.tables[tableName].config.cache)
+                for await (const paginationFileName of glob("*.pagination", {
+                    cwd: tablePath,
+                }))
+                    this.totalItems.set(`${tableName}-*`, parse(paginationFileName).name.split("-").map(Number)[1]);
+                await Promise.allSettled(Object.entries(pathesContents).map(async ([path, content]) => renameList.push(await File.replace(path, content, this.totalItems.get(`${tableName}-*`)))));
+                await Promise.allSettled(renameList
+                    .filter(([_, filePath]) => filePath)
+                    .map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
+                if (this.tablesMap.get(tableName).config.cache)
                     await this.clearCache(join(tablePath, ".cache"));
                 if (returnUpdatedData)
                     return await this.get(tableName, undefined, options);
@@ -1196,20 +1324,19 @@ export default class Inibase {
         else if ((Array.isArray(where) && where.every(Utils.isValidID)) ||
             Utils.isValidID(where)) {
             const lineNumbers = await this.get(tableName, where, undefined, undefined, true);
-            return this.put(tableName, data, lineNumbers, options, returnUpdatedData || undefined);
+            return this.put(tableName, clonedData, lineNumbers, options, false);
         }
         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)
-            this.validateData(data, schema, true);
-            await this.checkUnique(tableName, schema);
-            data = this.formatData(data, schema, true);
-            const pathesContents = Object.fromEntries(Object.entries(this.joinPathesContents(tableName, Utils.isArrayOfObjects(data)
-                ? data.map((item) => ({
+            await this.validateData(tableName, clonedData, true);
+            clonedData = this.formatData(clonedData, this.tablesMap.get(tableName).schema, true);
+            const pathesContents = Object.fromEntries(Object.entries(this.joinPathesContents(tableName, Utils.isArrayOfObjects(clonedData)
+                ? clonedData.map((item) => ({
                     ...item,
                     updatedAt: Date.now(),
                 }))
-                : { ...data, updatedAt: Date.now() })).map(([path, content]) => [
+                : { ...clonedData, updatedAt: Date.now() })).map(([path, content]) => [
                 path,
                 [...(Array.isArray(where) ? where : [where])].reduce((obj, lineNum, index) => Object.assign(obj, {
                     [lineNum]: Array.isArray(content) ? content[index] : content,
@@ -1220,10 +1347,11 @@ 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 = [];
-                if (this.tables[tableName].config.cache)
+                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.tablesMap.get(tableName).config.cache)
                     await this.clearCache(tableName);
                 if (returnUpdatedData)
                     return this.get(tableName, where, options, !Array.isArray(where));
@@ -1236,10 +1364,11 @@ 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, clonedData, lineNumbers, options, returnUpdatedData);
         }
         else
-            throw this.Error("INVALID_PARAMETERS");
+            throw this.createError("INVALID_PARAMETERS");
     }
     /**
      * Delete item(s) in a table
@@ -1249,17 +1378,27 @@ export default class Inibase {
      * @return {boolean | null}  {(Promise<boolean | null>)}
      */
     async delete(tableName, where, _id) {
-        const renameList = [];
         const tablePath = join(this.databasePath, tableName);
         await this.throwErrorIfTableEmpty(tableName);
         if (!where) {
             try {
                 await File.lock(join(tablePath, ".tmp"));
+                let paginationFilePath;
+                let pagination;
+                for await (const paginationFileName of glob("*.pagination", {
+                    cwd: tablePath,
+                })) {
+                    paginationFilePath = join(tablePath, paginationFileName);
+                    pagination = parse(paginationFileName)
+                        .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)
+                if (this.tablesMap.get(tableName).config.cache)
                     await this.clearCache(tableName);
+                await rename(paginationFilePath, join(tablePath, `${pagination[0]}-0.pagination`));
                 return true;
             }
             finally {
@@ -1276,18 +1415,33 @@ export default class Inibase {
             // "where" in this case, is the line(s) number(s) and not id(s)
             const files = (await readdir(tablePath))?.filter((fileName) => fileName.endsWith(this.getFileExtension(tableName)));
             if (files.length) {
+                const renameList = [];
                 try {
                     await File.lock(join(tablePath, ".tmp"));
-                    await Promise.all(files.map(async (file) => renameList.push(await File.remove(join(tablePath, file), where))));
-                    await Promise.all(renameList.map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
-                    if (this.tables[tableName].config.cache)
-                        await this.clearCache(tableName);
-                    if (await File.isExists(join(tablePath, ".cache", ".pagination"))) {
-                        const [lastId, totalItems] = (await readFile(join(tablePath, ".cache", ".pagination"), "utf8"))
-                            .split(",")
+                    let paginationFilePath;
+                    let pagination;
+                    for await (const paginationFileName of glob("*.pagination", {
+                        cwd: tablePath,
+                    })) {
+                        paginationFilePath = join(tablePath, paginationFileName);
+                        pagination = parse(paginationFileName)
+                            .name.split("-")
                             .map(Number);
-                        await writeFile(join(tablePath, ".cache", ".pagination"), `${lastId},${totalItems - (Array.isArray(where) ? where.length : 1)}`);
                     }
+                    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
+                            .filter(([_, filePath]) => filePath)
+                            .map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
+                    }
+                    else
+                        await Promise.all((await readdir(tablePath))
+                            ?.filter((fileName) => fileName.endsWith(this.getFileExtension(tableName)))
+                            .map(async (file) => unlink(join(tablePath, file))));
+                    if (this.tablesMap.get(tableName).config.cache)
+                        await this.clearCache(tableName);
+                    await rename(paginationFilePath, join(tablePath, `${pagination[0]}-${pagination[1] - (Array.isArray(where) ? where.length : 1)}.pagination`));
                     return true;
                 }
                 finally {
@@ -1299,10 +1453,11 @@ 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");
+            throw this.createError("INVALID_PARAMETERS");
         return false;
     }
     async sum(tableName, columns, where) {