inibase 1.0.0-rc.11 → 1.0.0-rc.111

package/dist/index.js

@@ -0,0 +1,1425 @@
+import "dotenv/config";
+import { randomBytes, scryptSync } from "node:crypto";
+import { appendFileSync, existsSync, readFileSync } from "node:fs";
+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;
+    totalItems;
+    constructor(database, mainFolder = ".") {
+        this.databasePath = join(mainFolder, database);
+        this.tables = {};
+        this.totalItems = {};
+        this.pageInfo = {};
+        this.checkIFunique = {};
+        if (!process.env.INIBASE_SECRET) {
+            if (existsSync(".env") &&
+                readFileSync(".env").includes("INIBASE_SECRET="))
+                throw this.Error("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: {
+                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",
+                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];
+        if (!errorMessage)
+            return new Error("ERR");
+        return new Error(variable
+            ? Array.isArray(variable)
+                ? errorMessage.replace(/\{variable\}/g, () => variable.shift()?.toString() ?? "")
+                : errorMessage.replaceAll("{variable}", `'${variable.toString()}'`)
+            : errorMessage.replaceAll("{variable}", ""));
+    }
+    getFileExtension = (tableName) => {
+        let mainExtension = this.fileExtension;
+        // TODO: ADD ENCRYPTION
+        // if(this.tables[tableName].config.encryption)
+        // 	mainExtension += ".enc"
+        if (this.tables[tableName].config.compression)
+            mainExtension += ".gz";
+        return mainExtension;
+    };
+    _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(tableName, field.children, `${(prefix ?? "") + field.key}.`));
+            }
+            else if (field.id)
+                RETURN[field.id] = `${(prefix ?? "") + field.key}${this.getFileExtension(tableName)}`;
+        return RETURN;
+    };
+    /**
+     * Create a new table inside database, with predefined schema and config
+     *
+     * @param {string} tableName
+     * @param {Schema} [schema]
+     * @param {Config} [config]
+     */
+    async createTable(tableName, schema, config) {
+        const tablePath = join(this.databasePath, tableName);
+        if (await File.isExists(tablePath))
+            throw this.Error("TABLE_EXISTS", tableName);
+        await mkdir(join(tablePath, ".tmp"), { recursive: true });
+        await mkdir(join(tablePath, ".cache"));
+        // if config not set => load default global env config
+        if (!config)
+            config = {
+                compression: process.env.INIBASE_COMPRESSION == "true",
+                cache: process.env.INIBASE_CACHE === "true",
+                prepend: process.env.INIBASE_PREPEND === "true",
+            };
+        if (config) {
+            if (config.compression)
+                await writeFile(join(tablePath, ".compression.config"), "");
+            if (config.cache)
+                await writeFile(join(tablePath, ".cache.config"), "");
+            if (config.prepend)
+                await writeFile(join(tablePath, ".prepend.config"), "");
+        }
+        if (schema) {
+            const lastSchemaId = 0;
+            await writeFile(join(tablePath, "schema.json"), JSON.stringify(UtilsServer.addIdToSchema(schema, lastSchemaId, this.salt), null, 2));
+            await writeFile(join(tablePath, `${lastSchemaId}.schema`), "");
+        }
+        else
+            await writeFile(join(tablePath, "0.schema"), "");
+        await writeFile(join(tablePath, "0-0.pagination"), "");
+    }
+    // Function to replace the string in one schema.json file
+    async replaceStringInFile(filePath, targetString, replaceString) {
+        const data = await readFile(filePath, "utf8");
+        if (data.includes(targetString)) {
+            const updatedContent = data.replaceAll(targetString, replaceString);
+            await writeFile(filePath, updatedContent, "utf8");
+        }
+    }
+    /**
+     * Update table schema or config
+     *
+     * @param {string} tableName
+     * @param {Schema} [schema]
+     * @param {(Config&{name?: string})} [config]
+     */
+    async updateTable(tableName, schema, config) {
+        const table = await this.getTable(tableName), 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 filePath of glob("*.schema", { cwd: this.databasePath }))
+                schemaIdFilePath = filePath;
+            const lastSchemaId = 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, lastSchemaId, this.salt);
+                if (table.schema?.length) {
+                    const replaceOldPathes = Utils.findChangedProperties(this._schemaToIdsPath(tableName, table.schema), 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, lastSchemaId, this.salt);
+            await writeFile(join(tablePath, "schema.json"), JSON.stringify(schema, null, 2));
+            if (schemaIdFilePath)
+                await rename(schemaIdFilePath, join(tablePath, `${lastSchemaId}.schema`));
+            else
+                await writeFile(join(tablePath, `${lastSchemaId}.schema`), "");
+        }
+        if (config) {
+            if (config.compression !== undefined &&
+                config.compression !== table.config.compression) {
+                await UtilsServer.execFile("find", [
+                    tableName,
+                    "-type",
+                    "f",
+                    "-name",
+                    `*${this.fileExtension}${config.compression ? "" : ".gz"}`,
+                    "-exec",
+                    config.compression ? "gzip" : "gunzip",
+                    "-f",
+                    "{}",
+                    "+",
+                ], { cwd: this.databasePath });
+                if (config.compression)
+                    await writeFile(join(tablePath, ".compression.config"), "");
+                else
+                    await unlink(join(tablePath, ".compression.config"));
+            }
+            if (config.cache !== undefined && config.cache !== table.config.cache) {
+                if (config.cache)
+                    await writeFile(join(tablePath, ".cache.config"), "");
+                else {
+                    await this.clearCache(tableName);
+                    await unlink(join(tablePath, ".cache.config"));
+                }
+            }
+            if (config.prepend !== undefined &&
+                config.prepend !== table.config.prepend) {
+                await UtilsServer.execFile("find", [
+                    tableName,
+                    "-type",
+                    "f",
+                    "-name",
+                    `*${this.fileExtension}${config.compression ? ".gz" : ""}`,
+                    "-exec",
+                    "sh",
+                    "-c",
+                    `for file; do ${config.compression
+                        ? 'zcat "$file" | tac | gzip > "$file.reversed" && mv "$file.reversed" "$file"'
+                        : 'tac "$file" > "$file.reversed" && mv "$file.reversed" "$file"'}; done`,
+                    "_",
+                    "{}",
+                    "+",
+                ], { cwd: this.databasePath });
+                if (config.prepend)
+                    await writeFile(join(tablePath, ".prepend.config"), "");
+                else
+                    await unlink(join(tablePath, ".prepend.config"));
+            }
+            if (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];
+    }
+    /**
+     * Get table schema and config
+     *
+     * @param {string} tableName
+     * @return {*}  {Promise<TableObject>}
+     */
+    async getTable(tableName) {
+        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),
+                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 tablePath = join(this.databasePath, tableName);
+        if (!(await File.isExists(join(tablePath, "schema.json"))))
+            return undefined;
+        const schemaFile = await readFile(join(tablePath, "schema.json"), "utf8");
+        if (!schemaFile)
+            return undefined;
+        let schema = JSON.parse(schemaFile);
+        schema = [
+            {
+                id: 0,
+                key: "id",
+                type: "id",
+                required: true,
+            },
+            ...schema,
+            {
+                id: -1,
+                key: "createdAt",
+                type: "date",
+                required: true,
+            },
+            {
+                id: -2,
+                key: "updatedAt",
+                type: "date",
+            },
+        ];
+        if (!encodeIDs)
+            return schema;
+        return UtilsServer.encodeSchemaID(schema, this.salt);
+    }
+    async throwErrorIfTableEmpty(tableName) {
+        const table = await this.getTable(tableName);
+        if (!table.schema)
+            throw this.Error("NO_SCHEMA", tableName);
+        if (!(await File.isExists(join(this.databasePath, tableName, `id${this.getFileExtension(tableName)}`))))
+            throw this.Error("TABLE_EMPTY", tableName);
+        return table;
+    }
+    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)) {
+            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;
+                }
+                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", [
+                        field.key,
+                        Array.isArray(field.type) ? field.type.join(", ") : field.type,
+                        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]);
+                }
+            }
+        }
+    }
+    cleanObject(obj) {
+        const cleanedObject = Object.entries(obj).reduce((acc, [key, value]) => {
+            if (value !== undefined && value !== null && value !== "")
+                acc[key] = value;
+            return acc;
+        }, {});
+        return Object.keys(cleanedObject).length > 0 ? cleanedObject : null;
+    }
+    formatField(value, fieldType, fieldChildrenType, _formatOnlyAvailiableKeys) {
+        if (Array.isArray(fieldType))
+            fieldType = Utils.detectFieldType(value, fieldType) ?? fieldType[0];
+        if (!value)
+            return null;
+        if (Array.isArray(value) && !["array", "json"].includes(fieldType))
+            value = value[0];
+        switch (fieldType) {
+            case "array":
+                if (!fieldChildrenType)
+                    return null;
+                if (!Array.isArray(value))
+                    value = [value];
+                if (Utils.isArrayOfObjects(fieldChildrenType))
+                    return this.formatData(value, fieldChildrenType);
+                if (!value.length)
+                    return null;
+                return value.map((_value) => this.formatField(_value, fieldChildrenType));
+            case "object":
+                if (Utils.isArrayOfObjects(fieldChildrenType))
+                    return this.formatData(value, fieldChildrenType, _formatOnlyAvailiableKeys);
+                break;
+            case "table":
+                if (Utils.isObject(value)) {
+                    if (Object.hasOwn(value, "id") &&
+                        (Utils.isValidID(value.id) ||
+                            Utils.isNumber(value.id)))
+                        return Utils.isNumber(value.id)
+                            ? Number(value.id)
+                            : UtilsServer.decodeID(value.id, this.salt);
+                }
+                else if (Utils.isValidID(value) || Utils.isNumber(value))
+                    return Utils.isNumber(value)
+                        ? Number(value)
+                        : UtilsServer.decodeID(value, this.salt);
+                break;
+            case "password":
+                return Utils.isPassword(value)
+                    ? value
+                    : UtilsServer.hashPassword(String(value));
+            case "number":
+                return Utils.isNumber(value) ? Number(value) : null;
+            case "id":
+                return Utils.isNumber(value)
+                    ? value
+                    : UtilsServer.decodeID(value, this.salt);
+            case "json": {
+                if (typeof value === "string" && Utils.isStringified(value))
+                    return value;
+                if (Utils.isObject(value)) {
+                    const cleanedObject = this.cleanObject(value);
+                    if (cleanedObject)
+                        return Inison.stringify(cleanedObject);
+                }
+                else
+                    return Inison.stringify(value);
+                return null;
+            }
+            default:
+                return value;
+        }
+        return null;
+    }
+    async checkUnique(tableName, schema) {
+        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(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 = {};
+    }
+    formatData(data, schema, formatOnlyAvailiableKeys) {
+        if (Utils.isArrayOfObjects(data))
+            return data.map((single_data) => this.formatData(single_data, schema, formatOnlyAvailiableKeys));
+        if (Utils.isObject(data)) {
+            for (const field of schema) {
+                if (!Object.hasOwn(data, field.key)) {
+                    if (formatOnlyAvailiableKeys)
+                        continue;
+                    data[field.key] = this.getDefaultValue(field);
+                    continue;
+                }
+                data[field.key] = this.formatField(data[field.key], field.type, field.children, formatOnlyAvailiableKeys);
+            }
+            return data;
+        }
+        return [];
+    }
+    getDefaultValue(field) {
+        if (Array.isArray(field.type))
+            return this.getDefaultValue({
+                ...field,
+                type: field.type.sort((a, b) => Number(b === "array") - Number(a === "array") ||
+                    Number(a === "string") - Number(b === "string") ||
+                    Number(a === "number") - Number(b === "number"))[0],
+            });
+        switch (field.type) {
+            case "array":
+            case "object": {
+                if (!field.children || !Utils.isArrayOfObjects(field.children))
+                    return null;
+                const RETURN = {};
+                for (const f of field.children)
+                    RETURN[f.key] = this.getDefaultValue(f);
+                return RETURN;
+            }
+            case "boolean":
+                return false;
+            default:
+                return null;
+        }
+    }
+    _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 = {};
+        for (const [key, value] of Object.entries(data)) {
+            if (Utils.isObject(value))
+                Object.assign(RETURN, this._CombineData(value, `${key}.`));
+            else if (Utils.isArrayOfObjects(value)) {
+                Object.assign(RETURN, this._CombineData(this._combineObjectsToArray(value), `${(prefix ?? "") + key}.`));
+            }
+            else if (Utils.isArrayOfArrays(value) &&
+                value.every(Utils.isArrayOfObjects))
+                Object.assign(RETURN, this._CombineData(this._combineObjectsToArray(value.map(this._combineObjectsToArray)), `${(prefix ?? "") + key}.`));
+            else
+                RETURN[(prefix ?? "") + key] = File.encode(value);
+        }
+        return RETURN;
+    }
+    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;
+    }
+    _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] = {}; // 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)
+                                continue;
+                            if (!RETURN[index][field.key][_i])
+                                RETURN[index][field.key][_i] = {};
+                            if (!RETURN[index][field.key][_i][child_field.key])
+                                RETURN[index][field.key][_i][child_field.key] = [];
+                            if (!Array.isArray(value[_i])) {
+                                if (!RETURN[index][field.key][_i][child_field.key][0])
+                                    RETURN[index][field.key][_i][child_field.key][0] = {};
+                                RETURN[index][field.key][_i][child_field.key][0][key] =
+                                    value[_i];
+                            }
+                            else {
+                                value[_i].forEach((_element, _index) => {
+                                    // 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;
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    async processSchemaData(tableName, schema, linesNumber, options, prefix) {
+        const RETURN = {};
+        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((child) => child.type === "array" &&
+                    Utils.isArrayOfObjects(child.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, 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._processSchemaDataHelper(RETURN, item, index, field);
+                    // Remove nested arrays after processing
+                    field.children = field.children.filter((child) => child.type === "array" &&
+                        Utils.isArrayOfObjects(child.children));
+                }
+                // 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)) {
+                            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;
+                                        }
+                                        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] = null;
+                        }
+                        else
+                            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;
+                }
+            }
+        }
+    }
+    // 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);
+                    }
+                    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;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    async applyCriteria(tableName, schema, options, criteria, allTrue) {
+        const tablePath = join(this.databasePath, tableName);
+        let RETURN = {}, RETURN_LineNumbers = null;
+        if (!criteria)
+            return [null, null];
+        if (criteria.and && Utils.isObject(criteria.and)) {
+            const [searchResult, lineNumbers] = await this.applyCriteria(tableName, schema, options, criteria.and, true);
+            if (searchResult) {
+                RETURN = Utils.deepMerge(RETURN, Object.fromEntries(Object.entries(searchResult).filter(([_k, v], _i) => Object.keys(v).length ===
+                    Object.keys(criteria.and ?? {}).length)));
+                delete criteria.and;
+                RETURN_LineNumbers = lineNumbers;
+            }
+            else
+                return [null, null];
+        }
+        if (criteria.or && Utils.isObject(criteria.or)) {
+            const [searchResult, lineNumbers] = await this.applyCriteria(tableName, schema, options, criteria.or, false);
+            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);
+                index++;
+                let searchOperator = undefined, searchComparedAtValue = undefined, searchLogicalOperator = undefined;
+                if (Utils.isObject(value)) {
+                    if (value?.or &&
+                        Array.isArray(value?.or)) {
+                        const searchCriteria = (value?.or)
+                            .map((single_or) => typeof single_or === "string"
+                            ? Utils.FormatObjectCriteriaValue(single_or)
+                            : ["=", single_or])
+                            .filter((a) => a);
+                        if (searchCriteria.length > 0) {
+                            searchOperator = searchCriteria.map((single_or) => single_or[0]);
+                            searchComparedAtValue = searchCriteria.map((single_or) => single_or[1]);
+                            searchLogicalOperator = "or";
+                        }
+                        delete value.or;
+                    }
+                    if (value?.and &&
+                        Array.isArray(value?.and)) {
+                        const searchCriteria = (value?.and)
+                            .map((single_and) => typeof single_and === "string"
+                            ? Utils.FormatObjectCriteriaValue(single_and)
+                            : ["=", single_and])
+                            .filter((a) => a);
+                        if (searchCriteria.length > 0) {
+                            searchOperator = searchCriteria.map((single_and) => single_and[0]);
+                            searchComparedAtValue = searchCriteria.map((single_and) => single_and[1]);
+                            searchLogicalOperator = "and";
+                        }
+                        delete value.and;
+                    }
+                }
+                else if (Array.isArray(value)) {
+                    const searchCriteria = value
+                        .map((single) => typeof single === "string"
+                        ? Utils.FormatObjectCriteriaValue(single)
+                        : ["=", single])
+                        .filter((a) => a);
+                    if (searchCriteria.length > 0) {
+                        searchOperator = searchCriteria.map((single) => single[0]);
+                        searchComparedAtValue = searchCriteria.map((single) => single[1]);
+                        searchLogicalOperator = "and";
+                    }
+                }
+                else if (typeof value === "string") {
+                    const ComparisonOperatorValue = Utils.FormatObjectCriteriaValue(value);
+                    if (ComparisonOperatorValue) {
+                        searchOperator = ComparisonOperatorValue[0];
+                        searchComparedAtValue = ComparisonOperatorValue[1];
+                    }
+                }
+                else {
+                    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);
+                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 [Object.keys(RETURN).length ? RETURN : null, RETURN_LineNumbers];
+    }
+    _filterSchemaByColumns(schema, columns) {
+        return schema
+            .map((field) => {
+            if (columns.some((column) => column.startsWith("!")))
+                return columns.includes(`!${field.key}`) ? null : field;
+            if (columns.includes(field.key) || columns.includes("*"))
+                return field;
+            if ((field.type === "array" || field.type === "object") &&
+                Utils.isArrayOfObjects(field.children) &&
+                columns.filter((column) => column.startsWith(`${field.key}.`) ||
+                    column.startsWith(`!${field.key}.`)).length) {
+                field.children = this._filterSchemaByColumns(field.children, columns
+                    .filter((column) => column.startsWith(`${field.key}.`) ||
+                    column.startsWith(`!${field.key}.`))
+                    .map((column) => column.replace(`${field.key}.`, "")));
+                return field;
+            }
+            return null;
+        })
+            .filter((i) => i);
+    }
+    /**
+     * Clear table cache
+     *
+     * @param {string} tableName
+     */
+    async clearCache(tableName) {
+        const cacheFolderPath = join(this.databasePath, tableName, ".cache");
+        await rm(cacheFolderPath, { recursive: true, force: true });
+        await mkdir(cacheFolderPath);
+    }
+    async get(tableName, where, options = {
+        page: 1,
+        perPage: 15,
+    }, onlyOne, onlyLinesNumbers) {
+        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 (options.columns.length && !options.columns.includes("id"))
+                options.columns.push("id");
+        }
+        // Default values for page and perPage
+        options.page = options.page || 1;
+        options.perPage = options.perPage || 15;
+        let RETURN;
+        let schema = (await this.getTable(tableName)).schema;
+        if (!schema)
+            throw this.Error("NO_SCHEMA", tableName);
+        let pagination;
+        for await (const paginationFilePath of glob("*.pagination", {
+            cwd: tablePath,
+        }))
+            pagination = parse(paginationFilePath).name.split("-").map(Number);
+        if (!pagination[1])
+            return null;
+        if (options.columns?.length)
+            schema = this._filterSchemaByColumns(schema, options.columns);
+        if (where &&
+            ((Array.isArray(where) && !where.length) ||
+                (Utils.isObject(where) && !Object.keys(where).length)))
+            where = undefined;
+        if (options.sort) {
+            let sortArray, awkCommand = "";
+            if (Utils.isObject(options.sort) && !Array.isArray(options.sort)) {
+                // {name: "ASC", age: "DESC"}
+                sortArray = Object.entries(options.sort).map(([key, value]) => [
+                    key,
+                    typeof value === "string" ? value.toLowerCase() === "asc" : value > 0,
+                ]);
+            }
+            else
+                sortArray = []
+                    .concat(options.sort)
+                    .map((column) => [column, true]);
+            let cacheKey = "";
+            // Criteria
+            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);
+                if (!lineNumbers?.length)
+                    return null;
+                const itemsIDs = Object.values((await File.get(join(tablePath, `id${this.getFileExtension(tableName)}`), lineNumbers, "number", undefined, this.salt)) ?? {}).map(Number);
+                awkCommand = `awk '${itemsIDs.map((id) => `$1 == ${id}`).join(" || ")}'`;
+            }
+            else
+                awkCommand = `awk '${Array.from({ length: options.perPage }, (_, index) => (options.page - 1) * options.perPage +
+                    index +
+                    1)
+                    .map((lineNumber) => `NR==${lineNumber}`)
+                    .join(" || ")}'`;
+            const filesPathes = [["id", true], ...sortArray].map((column) => join(tablePath, `${column[0]}${this.getFileExtension(tableName)}`));
+            for await (const path of filesPathes.slice(1))
+                if (!(await File.isExists(path)))
+                    return null;
+            // 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
+            const index = 2;
+            const sortColumns = sortArray
+                .map(([key, ascending], i) => {
+                const field = Utils.getField(key, schema);
+                if (field)
+                    return `-k${i + index},${i + index}${Utils.isFieldType(["id", "number", "date"], field.type, field.children)
+                        ? "n"
+                        : ""}${!ascending ? "r" : ""}`;
+                return "";
+            })
+                .join(" ");
+            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
+                    ? (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
+                    .trimEnd()
+                    .split("\n");
+                if (where)
+                    lines = lines.slice((options.page - 1) * options.perPage, options.page * options.perPage);
+                else if (!this.totalItems[`${tableName}-*`])
+                    this.totalItems[`${tableName}-*`] = pagination[1];
+                if (!lines.length)
+                    return null;
+                // Parse the result and extract the specified lines
+                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(tableName)}`
+                    filesPathes.forEach((fileName, index) => {
+                        const field = Utils.getField(parse(fileName).name, schema);
+                        if (field)
+                            outputObject[field.key] = File.decode(splitedFileColumns[index], field?.type, field?.children, this.salt);
+                    });
+                    return outputObject;
+                });
+                const restOfColumns = await this.get(tableName, outputArray.map(({ id }) => id), (({ sort, ...rest }) => rest)(options));
+                return restOfColumns
+                    ? outputArray.map((item) => ({
+                        ...item,
+                        ...restOfColumns.find(({ id }) => id === item.id),
+                    }))
+                    : outputArray;
+            }
+            finally {
+                if (cacheKey)
+                    await File.unlock(join(tablePath, ".tmp"), cacheKey);
+            }
+        }
+        if (!where) {
+            // Display all data
+            RETURN = Object.values(await this.processSchemaData(tableName, schema, Array.from({ length: options.perPage }, (_, index) => (options.page - 1) * options.perPage +
+                index +
+                1), options));
+            if (!this.totalItems[`${tableName}-*`])
+                this.totalItems[`${tableName}-*`] = pagination[1];
+        }
+        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)
+            let lineNumbers = where;
+            if (!Array.isArray(lineNumbers))
+                lineNumbers = [lineNumbers];
+            if (!this.totalItems[`${tableName}-*`])
+                this.totalItems[`${tableName}-*`] = lineNumbers.length;
+            // useless
+            if (onlyLinesNumbers)
+                return lineNumbers;
+            RETURN = Object.values((await this.processSchemaData(tableName, schema, lineNumbers, options)) ?? {});
+            if (RETURN?.length && !Array.isArray(where))
+                RETURN = RETURN[0];
+        }
+        else if ((Array.isArray(where) && where.every(Utils.isValidID)) ||
+            Utils.isValidID(where)) {
+            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);
+            if (!lineNumbers)
+                return null;
+            if (!this.totalItems[`${tableName}-*`])
+                this.totalItems[`${tableName}-*`] = countItems;
+            if (onlyLinesNumbers)
+                return Object.keys(lineNumbers).length
+                    ? Object.keys(lineNumbers).map(Number)
+                    : null;
+            if (options.columns) {
+                options.columns = options.columns.filter((column) => column !== "id");
+                if (!options.columns?.length)
+                    options.columns = undefined;
+            }
+            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)
+                cachedFilePath = join(tablePath, ".cache", `${UtilsServer.hashString(inspect(where, { sorted: true }))}${this.fileExtension}`);
+            if (this.tables[tableName].config.cache &&
+                (await File.isExists(cachedFilePath))) {
+                const cachedItems = (await readFile(cachedFilePath, "utf8")).split(",");
+                if (!this.totalItems[`${tableName}-*`])
+                    this.totalItems[`${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;
+                if (onlyLinesNumbers)
+                    return onlyOne
+                        ? linesNumbers.values().next().value
+                        : Array.from(linesNumbers);
+                const alreadyExistsColumns = Object.keys(Object.values(RETURN)[0]), alreadyExistsColumnsIDs = Utils.flattenSchema(schema)
+                    .filter(({ key }) => alreadyExistsColumns.includes(key))
+                    .map(({ id }) => id);
+                RETURN = Object.values(Utils.deepMerge(RETURN, await this.processSchemaData(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)
+                    await writeFile(cachedFilePath, Array.from(linesNumbers).join(","));
+            }
+        }
+        if (!RETURN ||
+            (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)
+                .filter(([k]) => k.startsWith(`${tableName}-`))
+                .map(([, v]) => v));
+        this.pageInfo[tableName] = {
+            ...(({ columns, ...restOfOptions }) => restOfOptions)(options),
+            perPage: Array.isArray(RETURN) ? RETURN.length : 1,
+            totalPages: Math.ceil(greatestTotalItems / options.perPage),
+            total: greatestTotalItems,
+        };
+        return onlyOne && Array.isArray(RETURN) ? RETURN[0] : RETURN;
+    }
+    async post(tableName, data, options, returnPostedData) {
+        if (!options)
+            options = {
+                page: 1,
+                perPage: 15,
+            };
+        const tablePath = join(this.databasePath, tableName), schema = (await this.getTable(tableName)).schema;
+        if (!schema)
+            throw this.Error("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;
+        const renameList = [];
+        try {
+            await File.lock(join(tablePath, ".tmp"), keys);
+            let paginationFilePath;
+            for await (const filePath of glob("*.pagination", { cwd: tablePath }))
+                paginationFilePath = filePath;
+            [lastId, this.totalItems[`${tableName}-*`]] = parse(paginationFilePath)
+                .name.split("-")
+                .map(Number);
+            if (Utils.isArrayOfObjects(data))
+                for (let index = 0; index < data.length; index++) {
+                    const element = data[index];
+                    element.id = ++lastId;
+                    element.createdAt = Date.now();
+                    element.updatedAt = undefined;
+                }
+            else {
+                data.id = ++lastId;
+                data.createdAt = Date.now();
+                data.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.allSettled(Object.entries(pathesContents).map(async ([path, content]) => renameList.push(this.tables[tableName].config.prepend
+                ? await File.prepend(path, content)
+                : await File.append(path, content))));
+            await Promise.allSettled(renameList
+                .filter(([_, filePath]) => filePath)
+                .map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
+            if (this.tables[tableName].config.cache)
+                await this.clearCache(tableName);
+            this.totalItems[`${tableName}-*`] += Array.isArray(data)
+                ? data.length
+                : 1;
+            await rename(join(tablePath, paginationFilePath), join(tablePath, `${lastId}-${this.totalItems[`${tableName}-*`]}.pagination`));
+            if (returnPostedData)
+                return this.get(tableName, this.tables[tableName].config.prepend
+                    ? Array.isArray(data)
+                        ? data.map((_, index) => index + 1).toReversed()
+                        : 1
+                    : Array.isArray(data)
+                        ? data
+                            .map((_, index) => this.totalItems[`${tableName}-*`] - index)
+                            .toReversed()
+                        : this.totalItems[`${tableName}-*`], options, !Utils.isArrayOfObjects(data));
+        }
+        finally {
+            if (renameList.length)
+                await Promise.allSettled(renameList.map(async ([tempPath, _]) => unlink(tempPath)));
+            await File.unlock(join(tablePath, ".tmp"), keys);
+        }
+    }
+    async put(tableName, data, where, options = {
+        page: 1,
+        perPage: 15,
+    }, returnUpdatedData) {
+        const renameList = [];
+        const tablePath = join(this.databasePath, tableName);
+        const schema = (await this.throwErrorIfTableEmpty(tableName))
+            .schema;
+        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 (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);
+            }
+            // Skip ID and (created|updated)At
+            this.validateData(data, schema.slice(1, -2), true);
+            await this.checkUnique(tableName, schema);
+            this.formatData(data, schema, true);
+            const pathesContents = this.joinPathesContents(tableName, {
+                ...(({ id, ...restOfData }) => restOfData)(data),
+                updatedAt: Date.now(),
+            });
+            try {
+                await File.lock(join(tablePath, ".tmp"));
+                for await (const paginationFilePath of glob("*.pagination", {
+                    cwd: tablePath,
+                }))
+                    this.totalItems[`${tableName}-*`] = parse(paginationFilePath)
+                        .name.split("-")
+                        .map(Number)[1];
+                await Promise.allSettled(Object.entries(pathesContents).map(async ([path, content]) => renameList.push(await File.replace(path, content, this.totalItems[`${tableName}-*`]))));
+                await Promise.allSettled(renameList
+                    .filter(([_, filePath]) => filePath)
+                    .map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
+                if (this.tables[tableName].config.cache)
+                    await this.clearCache(join(tablePath, ".cache"));
+                if (returnUpdatedData)
+                    return await this.get(tableName, undefined, options);
+            }
+            finally {
+                if (renameList.length)
+                    await Promise.allSettled(renameList.map(async ([tempPath, _]) => unlink(tempPath)));
+                await File.unlock(join(tablePath, ".tmp"));
+            }
+        }
+        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);
+        }
+        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.slice(1, -2), true);
+            await this.checkUnique(tableName, schema.slice(1, -2));
+            this.formatData(data, schema, true);
+            const pathesContents = Object.fromEntries(Object.entries(this.joinPathesContents(tableName, Utils.isArrayOfObjects(data)
+                ? data.map((item) => ({
+                    ...item,
+                    updatedAt: Date.now(),
+                }))
+                : { ...data, 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,
+                }), {}),
+            ]));
+            const keys = UtilsServer.hashString(Object.keys(pathesContents)
+                .map((path) => path.replaceAll(this.getFileExtension(tableName), ""))
+                .join("."));
+            try {
+                await File.lock(join(tablePath, ".tmp"), keys);
+                await Promise.allSettled(Object.entries(pathesContents).map(async ([path, content]) => renameList.push(await File.replace(path, content))));
+                await Promise.allSettled(renameList
+                    .filter(([_, filePath]) => filePath)
+                    .map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
+                if (this.tables[tableName].config.cache)
+                    await this.clearCache(tableName);
+                if (returnUpdatedData)
+                    return this.get(tableName, where, options, !Array.isArray(where));
+            }
+            finally {
+                if (renameList.length)
+                    await Promise.allSettled(renameList.map(async ([tempPath, _]) => unlink(tempPath)));
+                await File.unlock(join(tablePath, ".tmp"), keys);
+            }
+        }
+        else if (Utils.isObject(where)) {
+            const lineNumbers = await this.get(tableName, where, undefined, undefined, true);
+            if (lineNumbers)
+                return this.put(tableName, data, lineNumbers, options, returnUpdatedData || undefined);
+        }
+        else
+            throw this.Error("INVALID_PARAMETERS");
+    }
+    /**
+     * Delete item(s) in a table
+     *
+     * @param {string} tableName
+     * @param {(number | string | (number | string)[] | Criteria)} [where]
+     * @return {boolean | null}  {(Promise<boolean | null>)}
+     */
+    async delete(tableName, where, _id) {
+        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 filePath of glob("*.pagination", {
+                    cwd: tablePath,
+                })) {
+                    paginationFilePath = filePath;
+                    pagination = parse(filePath).name.split("-").map(Number);
+                }
+                await Promise.all((await readdir(tablePath))
+                    ?.filter((fileName) => fileName.endsWith(this.getFileExtension(tableName)))
+                    .map(async (file) => unlink(join(tablePath, file))));
+                if (this.tables[tableName].config.cache)
+                    await this.clearCache(tableName);
+                await rename(join(tablePath, paginationFilePath), join(tablePath, `${pagination[0]}-0.pagination`));
+                return true;
+            }
+            finally {
+                await File.unlock(join(tablePath, ".tmp"));
+            }
+        }
+        if ((Array.isArray(where) && where.every(Utils.isValidID)) ||
+            Utils.isValidID(where)) {
+            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(tableName)));
+            if (files.length) {
+                const renameList = [];
+                try {
+                    await File.lock(join(tablePath, ".tmp"));
+                    let paginationFilePath;
+                    let pagination;
+                    for await (const filePath of glob("*.pagination", {
+                        cwd: tablePath,
+                    })) {
+                        paginationFilePath = filePath;
+                        pagination = parse(filePath).name.split("-").map(Number);
+                    }
+                    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.tables[tableName].config.cache)
+                        await this.clearCache(tableName);
+                    await rename(join(tablePath, paginationFilePath), join(tablePath, `${pagination[0]}-${pagination[1] - (Array.isArray(where) ? where.length : 1)}.pagination`));
+                    return true;
+                }
+                finally {
+                    if (renameList.length)
+                        await Promise.allSettled(renameList.map(async ([tempPath, _]) => unlink(tempPath)));
+                    await File.unlock(join(tablePath, ".tmp"));
+                }
+            }
+        }
+        else if (Utils.isObject(where)) {
+            const lineNumbers = await this.get(tableName, where, undefined, undefined, true);
+            if (lineNumbers)
+                return this.delete(tableName, lineNumbers);
+        }
+        else
+            throw this.Error("INVALID_PARAMETERS");
+        return false;
+    }
+    async sum(tableName, columns, where) {
+        const RETURN = {};
+        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(tableName)}`);
+            if (await File.isExists(columnPath)) {
+                if (where) {
+                    const lineNumbers = await this.get(tableName, where, undefined, undefined, true);
+                    RETURN[column] = lineNumbers
+                        ? await File.sum(columnPath, lineNumbers)
+                        : 0;
+                }
+                else
+                    RETURN[column] = await File.sum(columnPath);
+            }
+        }
+        return Array.isArray(columns) ? RETURN : Object.values(RETURN)[0];
+    }
+    async max(tableName, columns, where) {
+        const RETURN = {};
+        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(tableName)}`);
+            if (await File.isExists(columnPath)) {
+                if (where) {
+                    const lineNumbers = await this.get(tableName, where, undefined, undefined, true);
+                    RETURN[column] = lineNumbers
+                        ? await File.max(columnPath, lineNumbers)
+                        : 0;
+                }
+                else
+                    RETURN[column] = await File.max(columnPath);
+            }
+        }
+        return RETURN;
+    }
+    async min(tableName, columns, where) {
+        const RETURN = {};
+        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(tableName)}`);
+            if (await File.isExists(columnPath)) {
+                if (where) {
+                    const lineNumbers = await this.get(tableName, where, undefined, undefined, true);
+                    RETURN[column] = lineNumbers
+                        ? await File.min(columnPath, lineNumbers)
+                        : 0;
+                }
+                else
+                    RETURN[column] = await File.min(columnPath);
+            }
+        }
+        return RETURN;
+    }
+}