inibase 1.0.0-rc.60 → 1.0.0-rc.62

package/dist/index.js

@@ -1,5 +1,5 @@
 import "dotenv/config";
-import { unlink, rename, mkdir, readdir } from "node:fs/promises";
+import { unlink, rename, mkdir, readdir, open, writeFile, readFile, } from "node:fs/promises";
 import { existsSync, appendFileSync, readFileSync } from "node:fs";
 import { join, parse } from "node:path";
 import { scryptSync, randomBytes } from "node:crypto";
@@ -8,22 +8,19 @@ import Inison from "inison";
 import * as File from "./file.js";
 import * as Utils from "./utils.js";
 import * as UtilsServer from "./utils.server.js";
-import * as Config from "./config.js";
 export default class Inibase {
-    folder;
-    database;
-    table;
     pageInfo;
+    salt;
+    databasePath;
+    tables;
     fileExtension = ".txt";
     checkIFunique;
     totalItems;
-    salt;
-    constructor(database, mainFolder = ".", _table = null, _totalItems = {}, _pageInfo = {}, _isThreadEnabled = false) {
-        this.database = database;
-        this.folder = mainFolder;
-        this.table = _table;
-        this.totalItems = _totalItems;
-        this.pageInfo = _pageInfo;
+    constructor(database, mainFolder = ".") {
+        this.databasePath = join(mainFolder, database);
+        this.tables = {};
+        this.totalItems = {};
+        this.pageInfo = {};
         this.checkIFunique = {};
         if (!process.env.INIBASE_SECRET) {
             if (existsSync(".env") &&
@@ -34,25 +31,14 @@ export default class Inibase {
         }
         else
             this.salt = Buffer.from(process.env.INIBASE_SECRET, "hex");
-        // try {
-        // 	if (Config.isCompressionEnabled)
-        // 		execSync(
-        // 			`gzip -r ${join(this.folder, this.database)}/*/*.txt 2>/dev/null`,
-        // 		);
-        // 	else
-        // 		execSync(
-        // 			`gunzip -r ${join(
-        // 				this.folder,
-        // 				this.database,
-        // 			)}/*/*.txt.gz 2>/dev/null`,
-        // 		);
-        // } catch {}
     }
     throwError(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",
                 NO_RESULTS: "No results found for table {variable}",
@@ -74,61 +60,120 @@ export default class Inibase {
                 : errorMessage.replaceAll("{variable}", `'${variable.toString()}'`)
             : errorMessage.replaceAll("{variable}", ""));
     }
-    getFileExtension = () => {
+    getFileExtension = (tableName) => {
         let mainExtension = this.fileExtension;
         // TODO: ADD ENCRYPTION
-        // if(Config.isEncryptionEnabled)
+        // if(this.tables[tableName].config.encryption)
         // 	mainExtension += ".enc"
-        if (Config.isCompressionEnabled)
+        if (this.tables[tableName].config.compression)
             mainExtension += ".gz";
         return mainExtension;
     };
-    _schemaToIdsPath = (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.deepMerge(RETURN, this._schemaToIdsPath(field.children, `${(prefix ?? "") + field.key}.`));
+                Utils.deepMerge(RETURN, this._schemaToIdsPath(tableName, field.children, `${(prefix ?? "") + field.key}.`));
             }
             else if (field.id)
-                RETURN[field.id] = `${(prefix ?? "") + field.key}${this.getFileExtension()}`;
+                RETURN[field.id] = `${(prefix ?? "") + field.key}${this.getFileExtension(tableName)}`;
         return RETURN;
     };
-    async setTableSchema(tableName, schema) {
-        const tablePath = join(this.folder, this.database, tableName), tableSchemaPath = join(tablePath, "schema.json"), isTablePathExists = await File.isExists(tablePath);
-        // remove id from schema
-        schema = schema.filter(({ key }) => !["id", "createdAt", "updatedAt"].includes(key));
-        if (!isTablePathExists)
-            await mkdir(tablePath, { recursive: true });
-        if (!(await File.isExists(join(tablePath, ".tmp"))))
-            await mkdir(join(tablePath, ".tmp"));
-        if (!(await File.isExists(join(tablePath, ".cache"))))
-            await mkdir(join(tablePath, ".cache"));
-        if (await File.isExists(tableSchemaPath)) {
-            // update columns files names based on field id
-            const currentSchema = await this.getTableSchema(tableName, false);
-            schema = UtilsServer.addIdToSchema(schema, currentSchema?.length
-                ? UtilsServer.findLastIdNumber(currentSchema, this.salt)
-                : 0, this.salt, false);
-            if (currentSchema?.length) {
-                const replaceOldPathes = Utils.findChangedProperties(this._schemaToIdsPath(currentSchema), this._schemaToIdsPath(schema));
-                if (replaceOldPathes)
-                    await Promise.all(Object.entries(replaceOldPathes).map(async ([oldPath, newPath]) => {
-                        if (await File.isExists(join(tablePath, oldPath)))
-                            await rename(join(tablePath, oldPath), join(tablePath, newPath));
-                    }));
+    async createTable(tableName, schema, config) {
+        const tablePath = join(this.databasePath, tableName);
+        if (await File.isExists(tablePath))
+            this.throwError("TABLE_EXISTS", tableName);
+        await mkdir(join(tablePath, ".tmp"), { recursive: true });
+        await mkdir(join(tablePath, ".cache"));
+        if (config) {
+            if (config.compression)
+                await open(join(tablePath, ".compression.config"), "w");
+            if (config.cache)
+                await open(join(tablePath, ".cache.config"), "w");
+            if (config.prepend)
+                await open(join(tablePath, ".prepend.config"), "w");
+        }
+        if (schema)
+            await writeFile(join(tablePath, "schema.json"), JSON.stringify(UtilsServer.addIdToSchema(schema, 0, this.salt, false), null, 2));
+    }
+    async updateTable(tableName, schema, config) {
+        const table = await this.getTable(tableName), tablePath = join(this.databasePath, tableName);
+        if (config) {
+            if (config.compression !== undefined) {
+                if (!config.compression && table.config.compression) {
+                    try {
+                        await UtilsServer.exec(`gunzip -r ${tablePath}/*.txt.gz 2>/dev/null`);
+                        await unlink(join(tablePath, ".compression.config"));
+                    }
+                    catch { }
+                }
+                else if (config.compression && !table.config.compression) {
+                    try {
+                        await UtilsServer.exec(`gzip -r ${tablePath}/*.txt 2>/dev/null`);
+                        await open(join(tablePath, ".compression.config"), "w");
+                    }
+                    catch { }
+                }
+            }
+            if (config.cache !== undefined) {
+                if (config.cache && !table.config.cache)
+                    await open(join(tablePath, ".cache.config"), "w");
+                else if (!config.cache && table.config.cache)
+                    await unlink(join(tablePath, ".cache.config"));
+            }
+            if (config.prepend !== undefined) {
+                if (config.prepend && !table.config.prepend)
+                    await open(join(tablePath, ".prepend.config"), "w");
+                else if (!config.prepend && table.config.prepend)
+                    await unlink(join(tablePath, ".prepend.config"));
             }
         }
-        else
-            schema = UtilsServer.addIdToSchema(schema, 0, this.salt, false);
-        await File.write(join(tablePath, "schema.json"), JSON.stringify(schema, null, 2), true);
+        if (schema) {
+            // remove id from schema
+            schema = schema.filter(({ key }) => !["id", "createdAt", "updatedAt"].includes(key));
+            if (await File.isExists(join(tablePath, "schema.json"))) {
+                // update columns files names based on field id
+                const currentSchema = await this.getTableSchema(tableName, false);
+                schema = UtilsServer.addIdToSchema(schema, currentSchema?.length
+                    ? UtilsServer.findLastIdNumber(currentSchema, this.salt)
+                    : 0, this.salt, false);
+                if (currentSchema?.length) {
+                    const replaceOldPathes = Utils.findChangedProperties(this._schemaToIdsPath(tableName, currentSchema), this._schemaToIdsPath(tableName, schema));
+                    if (replaceOldPathes)
+                        await Promise.all(Object.entries(replaceOldPathes).map(async ([oldPath, newPath]) => {
+                            if (await File.isExists(join(tablePath, oldPath)))
+                                await rename(join(tablePath, oldPath), join(tablePath, newPath));
+                        }));
+                }
+            }
+            else
+                schema = UtilsServer.addIdToSchema(schema, 0, this.salt, false);
+            await writeFile(join(tablePath, "schema.json"), JSON.stringify(schema, null, 2));
+            delete this.tables[tableName];
+        }
+    }
+    async getTable(tableName) {
+        const tablePath = join(this.databasePath, tableName);
+        if (!(await File.isExists(tablePath)))
+            this.throwError("TABLE_NOT_EXISTS", tableName);
+        if (!this.tables[tableName])
+            this.tables[tableName] = {
+                schema: await this.getTableSchema(tableName),
+                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];
     }
     async getTableSchema(tableName, encodeIDs = true) {
-        const tableSchemaPath = join(this.folder, this.database, tableName, "schema.json");
+        const tableSchemaPath = join(this.databasePath, tableName, "schema.json");
         if (!(await File.isExists(tableSchemaPath)))
             return undefined;
-        const schemaFile = await File.read(tableSchemaPath, true);
+        const schemaFile = await readFile(tableSchemaPath, "utf8");
         if (!schemaFile)
             return undefined;
         const schema = JSON.parse(schemaFile), lastIdNumber = UtilsServer.findLastIdNumber(schema, this.salt);
@@ -156,15 +201,13 @@ export default class Inibase {
             },
         ];
     }
-    async getSchemaWhenTableNotEmpty(tableName, schema) {
-        const tablePath = join(this.folder, this.database, tableName);
-        if (!schema)
-            schema = await this.getTableSchema(tableName);
-        if (!schema)
+    async throwErrorIfTableEmpty(tableName) {
+        const table = await this.getTable(tableName);
+        if (!table.schema)
             throw this.throwError("NO_SCHEMA", tableName);
-        if (!(await File.isExists(join(tablePath, `id${this.getFileExtension()}`))))
+        if (!(await File.isExists(join(this.databasePath, tableName, `id${this.getFileExtension(tableName)}`))))
             throw this.throwError("NO_ITEMS", tableName);
-        return schema;
+        return table;
     }
     validateData(data, schema, skipRequiredField = false) {
         if (Utils.isArrayOfObjects(data))
@@ -285,12 +328,12 @@ export default class Inibase {
         return null;
     }
     async checkUnique(tableName, schema) {
-        const tablePath = join(this.folder, this.database, 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)
                 continue;
-            const [searchResult, totalLines] = await File.search(join(tablePath, `${key}${this.getFileExtension()}`), Array.isArray(values) ? "=" : "[]", values, undefined, field.type, field.children, 1, undefined, false, this.salt);
+            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.throwError("FIELD_UNIQUE", [
                     field.key,
@@ -376,14 +419,12 @@ export default class Inibase {
         }
         return RETURN;
     };
-    _addPathToKeys = (obj, path) => {
-        const newObject = {};
-        for (const key in obj)
-            newObject[join(path, `${key}${this.getFileExtension()}`)] = obj[key];
-        return newObject;
-    };
-    joinPathesContents(mainPath, data) {
-        return this._addPathToKeys(this._CombineData(data), mainPath);
+    joinPathesContents(tableName, data) {
+        const tablePath = join(this.databasePath, tableName), combinedData = this._CombineData(data);
+        const newCombinedData = {};
+        for (const [key, value] of Object.entries(combinedData))
+            newCombinedData[join(tablePath, `${key}${this.getFileExtension(tableName)}`)] = value;
+        return newCombinedData;
     }
     _getItemsFromSchemaHelper(RETURN, item, index, field) {
         if (Utils.isObject(item)) {
@@ -427,7 +468,7 @@ export default class Inibase {
         }
     }
     async getItemsFromSchema(tableName, schema, linesNumber, options, prefix) {
-        const tablePath = join(this.folder, this.database, tableName);
+        const tablePath = join(this.databasePath, tableName);
         let RETURN = {};
         for await (const field of schema) {
             if ((field.type === "array" ||
@@ -498,13 +539,13 @@ export default class Inibase {
                     (Array.isArray(field.type) && field.type.includes("table")) ||
                     (Array.isArray(field.children) && field.children.includes("table"))) {
                     if (field.table &&
-                        (await File.isExists(join(this.folder, this.database, field.table))) &&
-                        (await File.isExists(join(tablePath, `${(prefix ?? "") + field.key}${this.getFileExtension()}`)))) {
+                        (await File.isExists(join(this.databasePath, field.table))) &&
+                        (await File.isExists(join(tablePath, `${(prefix ?? "") + field.key}${this.getFileExtension(tableName)}`)))) {
                         if (options.columns)
                             options.columns = options.columns
                                 .filter((column) => column.includes(`${field.key}.`))
                                 .map((column) => column.replace(`${field.key}.`, ""));
-                        const items = await File.get(join(tablePath, `${(prefix ?? "") + field.key}${this.getFileExtension()}`), linesNumber, field.type, field.children, this.salt);
+                        const items = await File.get(join(tablePath, `${(prefix ?? "") + field.key}${this.getFileExtension(tableName)}`), linesNumber, field.type, field.children, this.salt);
                         if (items)
                             for await (const [index, item] of Object.entries(items)) {
                                 if (!RETURN[index])
@@ -515,8 +556,8 @@ export default class Inibase {
                             }
                     }
                 }
-                else if (await File.isExists(join(tablePath, `${(prefix ?? "") + field.key}${this.getFileExtension()}`))) {
-                    const items = await File.get(join(tablePath, `${(prefix ?? "") + field.key}${this.getFileExtension()}`), linesNumber, field.type, field.children, this.salt);
+                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])
@@ -543,13 +584,13 @@ export default class Inibase {
             }
             else if (field.type === "table") {
                 if (field.table &&
-                    (await File.isExists(join(this.folder, this.database, field.table))) &&
-                    (await File.isExists(join(tablePath, `${(prefix ?? "") + field.key}${this.getFileExtension()}`)))) {
+                    (await File.isExists(join(this.databasePath, field.table))) &&
+                    (await File.isExists(join(tablePath, `${(prefix ?? "") + field.key}${this.getFileExtension(tableName)}`)))) {
                     if (options.columns)
                         options.columns = options.columns
                             .filter((column) => column.includes(`${field.key}.`))
                             .map((column) => column.replace(`${field.key}.`, ""));
-                    const items = await File.get(join(tablePath, `${(prefix ?? "") + field.key}${this.getFileExtension()}`), linesNumber, "number", undefined, this.salt);
+                    const items = await File.get(join(tablePath, `${(prefix ?? "") + field.key}${this.getFileExtension(tableName)}`), linesNumber, "number", undefined, this.salt);
                     if (items)
                         for await (const [index, item] of Object.entries(items)) {
                             if (!RETURN[index])
@@ -560,8 +601,8 @@ export default class Inibase {
                         }
                 }
             }
-            else if (await File.isExists(join(tablePath, `${(prefix ?? "") + field.key}${this.getFileExtension()}`))) {
-                const items = await File.get(join(tablePath, `${(prefix ?? "") + field.key}${this.getFileExtension()}`), linesNumber, field.type, field.children, this.salt);
+            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])
@@ -578,7 +619,7 @@ export default class Inibase {
         return RETURN;
     }
     async applyCriteria(tableName, schema, options, criteria, allTrue) {
-        const tablePath = join(this.folder, this.database, tableName);
+        const tablePath = join(this.databasePath, tableName);
         let RETURN = {}, RETURN_LineNumbers = null;
         if (!criteria)
             return [null, null];
@@ -662,7 +703,7 @@ export default class Inibase {
                     searchOperator = "=";
                     searchComparedAtValue = value;
                 }
-                const [searchResult, totalLines, linesNumbers] = await File.search(join(tablePath, `${key}${this.getFileExtension()}`), 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, 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,
@@ -713,14 +754,14 @@ export default class Inibase {
     async get(tableName, where, options = {
         page: 1,
         perPage: 15,
-    }, onlyOne, onlyLinesNumbers, tableSchema, skipIdColumn) {
-        const tablePath = join(this.folder, this.database, tableName);
+    }, onlyOne, onlyLinesNumbers, _skipIdColumn) {
+        const tablePath = join(this.databasePath, tableName);
         // Ensure options.columns is an array
         if (options.columns) {
             options.columns = Array.isArray(options.columns)
                 ? options.columns
                 : [options.columns];
-            if (!skipIdColumn &&
+            if (!_skipIdColumn &&
                 options.columns.length &&
                 !options.columns.includes("id"))
                 options.columns.push("id");
@@ -729,7 +770,8 @@ export default class Inibase {
         options.page = options.page || 1;
         options.perPage = options.perPage || 15;
         let RETURN;
-        let schema = await this.getSchemaWhenTableNotEmpty(tableName, tableSchema);
+        let schema = (await this.throwErrorIfTableEmpty(tableName))
+            .schema;
         if (options.columns?.length)
             schema = this._filterSchemaByColumns(schema, options.columns);
         if (where &&
@@ -741,14 +783,14 @@ export default class Inibase {
             RETURN = Object.values(await this.getItemsFromSchema(tableName, schema, Array.from({ length: options.perPage }, (_, index) => (options.page - 1) * options.perPage +
                 index +
                 1), options));
-            if (await File.isExists(join(tablePath, ".cache", `pagination${this.fileExtension}`)))
-                this.totalItems[`${tableName}-*`] = Number((await File.read(join(tablePath, ".cache", `pagination${this.fileExtension}`), true)).split(",")[1]);
+            if (await File.isExists(join(tablePath, ".pagination")))
+                this.totalItems[`${tableName}-*`] = Number((await readFile(join(tablePath, ".pagination"), "utf8")).split(",")[1]);
             else {
-                let [lastId, totalItems] = await File.get(join(tablePath, `id${this.getFileExtension()}`), -1, "number", undefined, this.salt, true);
+                let [lastId, totalItems] = await File.get(join(tablePath, `id${this.getFileExtension(tableName)}`), -1, "number", undefined, this.salt, true);
                 if (lastId)
                     lastId = Number(Object.keys(lastId)?.[0] ?? 0);
                 this.totalItems[`${tableName}-*`] = totalItems;
-                await File.write(join(tablePath, ".cache", `pagination${this.fileExtension}`), `${lastId},${totalItems}`, true);
+                await writeFile(join(tablePath, ".pagination"), `${lastId},${totalItems}`);
             }
         }
         else if ((Array.isArray(where) && where.every(Utils.isNumber)) ||
@@ -771,7 +813,7 @@ export default class Inibase {
             let Ids = where;
             if (!Array.isArray(Ids))
                 Ids = [Ids];
-            const [lineNumbers, countItems] = await File.search(join(tablePath, `id${this.getFileExtension()}`), "[]", 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, "number", undefined, Ids.length, 0, !this.totalItems[`${tableName}-*`], this.salt);
             if (!lineNumbers)
                 throw this.throwError("NO_RESULTS", tableName);
             if (onlyLinesNumbers)
@@ -787,16 +829,17 @@ export default class Inibase {
         else if (Utils.isObject(where)) {
             let cachedFilePath = "";
             // Criteria
-            if (Config.isCacheEnabled)
+            if (this.tables[tableName].config.cache)
                 cachedFilePath = join(tablePath, ".cache", `${UtilsServer.hashString(inspect(where, { sorted: true }))}${this.fileExtension}`);
-            if (Config.isCacheEnabled && (await File.isExists(cachedFilePath))) {
-                const cachedItems = (await File.read(cachedFilePath, true)).split(",");
+            if (this.tables[tableName].config.cache &&
+                (await File.isExists(cachedFilePath))) {
+                const cachedItems = (await readFile(cachedFilePath, "utf8")).split(",");
                 this.totalItems[`${tableName}-*`] = cachedItems.length;
                 if (onlyLinesNumbers)
                     return cachedItems.map(Number);
                 return this.get(tableName, cachedItems
                     .slice((options.page - 1) * options.perPage, options.page * options.perPage)
-                    .map(Number), options, undefined, undefined, schema);
+                    .map(Number), options);
             }
             let linesNumbers = null;
             [RETURN, linesNumbers] = await this.applyCriteria(tableName, schema, options, where);
@@ -805,8 +848,8 @@ export default class Inibase {
                     return Object.keys(RETURN).map(Number);
                 const alreadyExistsColumns = Object.keys(Object.values(RETURN)[0]);
                 RETURN = Object.values(Utils.deepMerge(RETURN, await this.getItemsFromSchema(tableName, schema.filter(({ key }) => !alreadyExistsColumns.includes(key)), Object.keys(RETURN).map(Number), options)));
-                if (Config.isCacheEnabled)
-                    await File.write(cachedFilePath, Array.from(linesNumbers).join(","), true);
+                if (this.tables[tableName].config.cache)
+                    await writeFile(cachedFilePath, Array.from(linesNumbers).join(","));
             }
         }
         if (!RETURN ||
@@ -831,7 +874,7 @@ export default class Inibase {
                 page: 1,
                 perPage: 15,
             };
-        const tablePath = join(this.folder, this.database, tableName), schema = await this.getTableSchema(tableName);
+        const tablePath = join(this.databasePath, tableName), schema = (await this.getTable(tableName)).schema;
         if (!schema)
             throw this.throwError("NO_SCHEMA", tableName);
         if (!returnPostedData)
@@ -841,14 +884,14 @@ export default class Inibase {
         let lastId = 0, totalItems = 0, renameList = [];
         try {
             await File.lock(join(tablePath, ".tmp"), keys);
-            if (await File.isExists(join(tablePath, `id${this.getFileExtension()}`))) {
-                if (await File.isExists(join(tablePath, ".cache", `pagination${this.fileExtension}`)))
-                    [lastId, totalItems] = (await File.read(join(tablePath, ".cache", `pagination${this.fileExtension}`), true))
+            if (await File.isExists(join(tablePath, `id${this.getFileExtension(tableName)}`))) {
+                if (await File.isExists(join(tablePath, ".pagination")))
+                    [lastId, totalItems] = (await readFile(join(tablePath, ".pagination"), "utf8"))
                         .split(",")
                         .map(Number);
                 else {
                     let lastIdObj = null;
-                    [lastIdObj, totalItems] = await File.get(join(tablePath, `id${this.getFileExtension()}`), -1, "number", undefined, this.salt, true);
+                    [lastIdObj, totalItems] = await File.get(join(tablePath, `id${this.getFileExtension(tableName)}`), -1, "number", undefined, this.salt, true);
                     if (lastIdObj)
                         lastId = Number(Object.keys(lastIdObj)?.[0] ?? 0);
                 }
@@ -868,27 +911,26 @@ export default class Inibase {
             this.validateData(RETURN, schema);
             await this.checkUnique(tableName, schema);
             RETURN = this.formatData(RETURN, schema);
-            const pathesContents = this.joinPathesContents(tablePath, Config.isReverseEnabled
+            const pathesContents = this.joinPathesContents(tableName, this.tables[tableName].config.prepend
                 ? Array.isArray(RETURN)
                     ? RETURN.toReversed()
                     : RETURN
                 : RETURN);
-            await Promise.all(Object.entries(pathesContents).map(async ([path, content]) => renameList.push(await File.append(path, content))));
+            await Promise.all(Object.entries(pathesContents).map(async ([path, content]) => renameList.push(await File.append(path, content, this.tables[tableName].config.prepend))));
             await Promise.all(renameList.map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
             renameList = [];
             totalItems += Array.isArray(RETURN) ? RETURN.length : 1;
-            if (Config.isCacheEnabled)
+            if (this.tables[tableName].config.cache)
                 await this.clearCache(tablePath);
-            await File.write(join(tablePath, ".cache", `pagination${this.fileExtension}`), `${lastId},${totalItems}`, true);
+            await writeFile(join(tablePath, ".pagination"), `${lastId},${totalItems}`);
             if (returnPostedData)
-                return this.get(tableName, Config.isReverseEnabled
+                return this.get(tableName, this.tables[tableName].config.prepend
                     ? Array.isArray(RETURN)
                         ? RETURN.map((_, index) => index + 1)
                         : 1
                     : Array.isArray(RETURN)
                         ? RETURN.map((_, index) => totalItems - index)
-                        : totalItems, options, !Utils.isArrayOfObjects(data), // return only one item if data is not array of objects
-                undefined, schema);
+                        : totalItems, options, !Utils.isArrayOfObjects(data));
         }
         finally {
             if (renameList.length)
@@ -901,7 +943,7 @@ export default class Inibase {
         perPage: 15,
     }, returnUpdatedData) {
         let renameList = [];
-        const tablePath = join(this.folder, this.database, tableName), schema = await this.getSchemaWhenTableNotEmpty(tableName);
+        const tablePath = join(this.databasePath, tableName), schema = (await this.throwErrorIfTableEmpty(tableName)).schema;
         this.validateData(data, schema, true);
         await this.checkUnique(tableName, schema);
         data = this.formatData(data, schema, true);
@@ -919,13 +961,13 @@ export default class Inibase {
                 return this.put(tableName, data, data.id);
             }
             let totalItems;
-            if (await File.isExists(join(tablePath, ".cache", `pagination${this.fileExtension}`)))
-                totalItems = (await File.read(join(tablePath, ".cache", `pagination${this.fileExtension}`), true))
+            if (await File.isExists(join(tablePath, ".pagination")))
+                totalItems = (await readFile(join(tablePath, ".pagination"), "utf8"))
                     .split(",")
                     .map(Number)[1];
             else
-                totalItems = await File.count(join(tablePath, `id${this.getFileExtension()}`));
-            const pathesContents = this.joinPathesContents(tablePath, {
+                totalItems = await File.count(join(tablePath, `id${this.getFileExtension(tableName)}`));
+            const pathesContents = this.joinPathesContents(tableName, {
                 ...(({ id, ...restOfData }) => restOfData)(data),
                 updatedAt: Date.now(),
             });
@@ -938,10 +980,10 @@ export default class Inibase {
                     renameList.push(await File.replace(path, replacementObject));
                 }));
                 await Promise.all(renameList.map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
-                if (Config.isCacheEnabled)
+                if (this.tables[tableName].config.cache)
                     await this.clearCache(join(tablePath, ".cache"));
                 if (returnUpdatedData)
-                    return await this.get(tableName, where, options, undefined, undefined, schema);
+                    return await this.get(tableName, undefined, options);
             }
             finally {
                 if (renameList.length)
@@ -951,13 +993,13 @@ 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, schema);
+            const lineNumbers = await this.get(tableName, where, undefined, undefined, true);
             return this.put(tableName, data, lineNumbers);
         }
         else if ((Array.isArray(where) && where.every(Utils.isNumber)) ||
             Utils.isNumber(where)) {
             // "where" in this case, is the line(s) number(s) and not id(s)
-            const pathesContents = Object.fromEntries(Object.entries(this.joinPathesContents(tablePath, Utils.isArrayOfObjects(data)
+            const pathesContents = Object.fromEntries(Object.entries(this.joinPathesContents(tableName, Utils.isArrayOfObjects(data)
                 ? data.map((item) => ({
                     ...item,
                     updatedAt: Date.now(),
@@ -976,10 +1018,10 @@ export default class Inibase {
                 await Promise.all(Object.entries(pathesContents).map(async ([path, content]) => renameList.push(await File.replace(path, content))));
                 await Promise.all(renameList.map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
                 renameList = [];
-                if (Config.isCacheEnabled)
+                if (this.tables[tableName].config.cache)
                     await this.clearCache(tablePath);
                 if (returnUpdatedData)
-                    return this.get(tableName, where, options, !Array.isArray(where), undefined, schema);
+                    return this.get(tableName, where, options, !Array.isArray(where));
             }
             finally {
                 if (renameList.length)
@@ -988,7 +1030,7 @@ export default class Inibase {
             }
         }
         else if (Utils.isObject(where)) {
-            const lineNumbers = await this.get(tableName, where, undefined, undefined, true, schema);
+            const lineNumbers = await this.get(tableName, where, undefined, undefined, true);
             if (returnUpdatedData)
                 return this.put(tableName, data, lineNumbers, options, returnUpdatedData);
             await this.put(tableName, data, lineNumbers, options, returnUpdatedData);
@@ -998,14 +1040,15 @@ export default class Inibase {
     }
     async delete(tableName, where, _id) {
         const renameList = [];
-        const tablePath = join(this.folder, this.database, tableName), schema = await this.getSchemaWhenTableNotEmpty(tableName);
+        const tablePath = join(this.databasePath, tableName);
+        await this.throwErrorIfTableEmpty(tableName);
         if (!where) {
             try {
                 await File.lock(join(tablePath, ".tmp"));
                 await Promise.all((await readdir(tablePath))
                     ?.filter((fileName) => fileName.endsWith(".inib"))
                     .map(async (file) => unlink(join(tablePath, file))));
-                if (Config.isCacheEnabled)
+                if (this.tables[tableName].config.cache)
                     await this.clearCache(tablePath);
             }
             finally {
@@ -1015,25 +1058,25 @@ export default class Inibase {
         }
         if ((Array.isArray(where) && where.every(Utils.isValidID)) ||
             Utils.isValidID(where)) {
-            const lineNumbers = await this.get(tableName, where, undefined, undefined, true, schema);
+            const lineNumbers = await this.get(tableName, where, undefined, undefined, true);
             return this.delete(tableName, lineNumbers, where);
         }
         if ((Array.isArray(where) && where.every(Utils.isNumber)) ||
             Utils.isNumber(where)) {
             // "where" in this case, is the line(s) number(s) and not id(s)
-            const files = (await readdir(tablePath))?.filter((fileName) => fileName.endsWith(this.getFileExtension()));
+            const files = (await readdir(tablePath))?.filter((fileName) => fileName.endsWith(this.getFileExtension(tableName)));
             if (files.length) {
                 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 (Config.isCacheEnabled)
+                    if (this.tables[tableName].config.cache)
                         await this.clearCache(tablePath);
-                    if (await File.isExists(join(tablePath, ".cache", `pagination${this.fileExtension}`))) {
-                        const [lastId, totalItems] = (await File.read(join(tablePath, ".cache", `pagination${this.fileExtension}`), true))
+                    if (await File.isExists(join(tablePath, ".pagination"))) {
+                        const [lastId, totalItems] = (await readFile(join(tablePath, ".pagination"), "utf8"))
                             .split(",")
                             .map(Number);
-                        await File.write(join(tablePath, ".cache", `pagination${this.fileExtension}`), `${lastId},${totalItems - (Array.isArray(where) ? where.length : 1)}`, true);
+                        await writeFile(join(tablePath, ".pagination"), `${lastId},${totalItems - (Array.isArray(where) ? where.length : 1)}`);
                     }
                     if (_id)
                         return Array.isArray(_id) && _id.length === 1 ? _id[0] : _id;
@@ -1047,7 +1090,7 @@ export default class Inibase {
             }
         }
         else if (Utils.isObject(where)) {
-            const lineNumbers = await this.get(tableName, where, undefined, undefined, true, schema);
+            const lineNumbers = await this.get(tableName, where, undefined, undefined, true);
             return this.delete(tableName, lineNumbers);
         }
         else
@@ -1056,14 +1099,15 @@ export default class Inibase {
     }
     async sum(tableName, columns, where) {
         const RETURN = {};
-        const tablePath = join(this.folder, this.database, tableName), schema = await this.getSchemaWhenTableNotEmpty(tableName);
+        const tablePath = join(this.databasePath, tableName);
+        await this.throwErrorIfTableEmpty(tableName);
         if (!Array.isArray(columns))
             columns = [columns];
         for await (const column of columns) {
-            const columnPath = join(tablePath, `${column}${this.getFileExtension()}`);
+            const columnPath = join(tablePath, `${column}${this.getFileExtension(tableName)}`);
             if (await File.isExists(columnPath)) {
                 if (where) {
-                    const lineNumbers = await this.get(tableName, where, undefined, undefined, true, schema);
+                    const lineNumbers = await this.get(tableName, where, undefined, undefined, true);
                     RETURN[column] = lineNumbers
                         ? await File.sum(columnPath, lineNumbers)
                         : 0;
@@ -1076,14 +1120,15 @@ export default class Inibase {
     }
     async max(tableName, columns, where) {
         const RETURN = {};
-        const tablePath = join(this.folder, this.database, tableName), schema = await this.getSchemaWhenTableNotEmpty(tableName);
+        const tablePath = join(this.databasePath, tableName);
+        await this.throwErrorIfTableEmpty(tableName);
         if (!Array.isArray(columns))
             columns = [columns];
         for await (const column of columns) {
-            const columnPath = join(tablePath, `${column}${this.getFileExtension()}`);
+            const columnPath = join(tablePath, `${column}${this.getFileExtension(tableName)}`);
             if (await File.isExists(columnPath)) {
                 if (where) {
-                    const lineNumbers = await this.get(tableName, where, undefined, undefined, true, schema);
+                    const lineNumbers = await this.get(tableName, where, undefined, undefined, true);
                     RETURN[column] = lineNumbers
                         ? await File.max(columnPath, lineNumbers)
                         : 0;
@@ -1096,14 +1141,15 @@ export default class Inibase {
     }
     async min(tableName, columns, where) {
         const RETURN = {};
-        const tablePath = join(this.folder, this.database, tableName), schema = await this.getSchemaWhenTableNotEmpty(tableName);
+        const tablePath = join(this.databasePath, tableName);
+        await this.throwErrorIfTableEmpty(tableName);
         if (!Array.isArray(columns))
             columns = [columns];
         for await (const column of columns) {
-            const columnPath = join(tablePath, `${column}${this.getFileExtension()}`);
+            const columnPath = join(tablePath, `${column}${this.getFileExtension(tableName)}`);
             if (await File.isExists(columnPath)) {
                 if (where) {
-                    const lineNumbers = await this.get(tableName, where, undefined, undefined, true, schema);
+                    const lineNumbers = await this.get(tableName, where, undefined, undefined, true);
                     RETURN[column] = lineNumbers
                         ? await File.min(columnPath, lineNumbers)
                         : 0;
@@ -1118,7 +1164,7 @@ export default class Inibase {
         page: 1,
         perPage: 15,
     }) {
-        const tablePath = join(this.folder, this.database, tableName), schema = await this.getSchemaWhenTableNotEmpty(tableName);
+        const tablePath = join(this.databasePath, tableName), schema = (await this.throwErrorIfTableEmpty(tableName)).schema;
         // Default values for page and perPage
         options.page = options.page || 1;
         options.perPage = options.perPage || 15;
@@ -1137,11 +1183,11 @@ export default class Inibase {
         }
         let cacheKey = "";
         // Criteria
-        if (Config.isCacheEnabled)
+        if (this.tables[tableName].config.cache)
             cacheKey = UtilsServer.hashString(inspect(sortArray, { sorted: true }));
         if (where) {
-            const lineNumbers = await this.get(tableName, where, undefined, undefined, true, schema);
-            keepItems = Object.values((await File.get(join(tablePath, `id${this.getFileExtension()}`), lineNumbers, "number", undefined, this.salt)) ?? {}).map(Number);
+            const lineNumbers = await this.get(tableName, where, undefined, undefined, true);
+            keepItems = Object.values((await File.get(join(tablePath, `id${this.getFileExtension(tableName)}`), lineNumbers, "number", undefined, this.salt)) ?? {}).map(Number);
             isLineNumbers = false;
             if (!keepItems.length)
                 throw this.throwError("NO_RESULTS", tableName);
@@ -1151,7 +1197,7 @@ export default class Inibase {
             keepItems = Array.from({ length: options.perPage }, (_, index) => (options.page - 1) * options.perPage +
                 index +
                 1);
-        const filesPathes = [["id", true], ...sortArray].map((column) => join(tablePath, `${column[0]}${this.getFileExtension()}`));
+        const filesPathes = [["id", true], ...sortArray].map((column) => join(tablePath, `${column[0]}${this.getFileExtension(tableName)}`));
         // Construct the paste command to merge files and filter lines by IDs
         const pasteCommand = `paste ${filesPathes.join(" ")}`;
         // Construct the sort command dynamically based on the number of files for sorting
@@ -1176,19 +1222,20 @@ export default class Inibase {
                 await File.lock(join(tablePath, ".tmp"), cacheKey);
             // Combine the commands
             // Execute the command synchronously
-            const { stdout } = await UtilsServer.exec(Config.isCacheEnabled
+            const lines = (await UtilsServer.exec(this.tables[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}`)}`
                 : `${pasteCommand} | ${sortCommand} | ${awkCommand}`, {
                 encoding: "utf-8",
-            });
+            })).stdout
+                .trim()
+                .split("\n");
             // Parse the result and extract the specified lines
-            const lines = stdout.trim().split("\n");
             const outputArray = lines.map((line) => {
                 const splitedFileColumns = line.split("\t"); // Assuming tab-separated columns
                 const outputObject = {};
-                // Extract values for each file, including `id${this.getFileExtension()}`
+                // Extract values for each file, including `id${this.getFileExtension(tableName)}`
                 filesPathes.forEach((fileName, index) => {
                     const field = Utils.getField(parse(fileName).name, schema);
                     if (field)
@@ -1196,7 +1243,7 @@ export default class Inibase {
                 });
                 return outputObject;
             });
-            const restOfColumns = await this.get(tableName, outputArray.map(({ id }) => id), options, undefined, undefined, schema, true);
+            const restOfColumns = await this.get(tableName, outputArray.map(({ id }) => id), options, undefined, undefined, true);
             return restOfColumns
                 ? outputArray.map((item, index) => ({
                     ...item,