inibase 1.0.0-rc.12 → 1.0.0-rc.13

package/dist/index.js

@@ -0,0 +1,940 @@
+import { unlink, rename, readFile, writeFile, mkdir, readdir, } from "node:fs/promises";
+import { join, parse } from "node:path";
+import { scryptSync } from "node:crypto";
+import File from "./file";
+import Utils from "./utils";
+export default class Inibase {
+    folder;
+    database;
+    table;
+    pageInfo;
+    cache;
+    totalItems;
+    salt;
+    constructor(database, mainFolder = ".") {
+        this.database = database;
+        this.folder = mainFolder;
+        this.table = null;
+        this.cache = new Map();
+        this.totalItems = {};
+        this.pageInfo = { page: 1, per_page: 15 };
+        this.salt = scryptSync(process.env.INIBASE_SECRET ?? "inibase", (process.env.INIBASE_SECRET ?? "inibase") + "_salt", 32);
+    }
+    throwError(code, variable, language = "en") {
+        const errorMessages = {
+            en: {
+                FIELD_REQUIRED: "REQUIRED: {variable}",
+                NO_SCHEMA: "NO_SCHEMA: {variable}",
+                NO_ITEMS: "NO_ITEMS: {variable}",
+                NO_DATA: "NO_DATA: {variable}",
+                INVALID_ID: "INVALID_ID: {variable}",
+                INVALID_TYPE: "INVALID_TYPE: {variable}",
+                INVALID_OPERATOR: "INVALID_OPERATOR: {variable}",
+                INVALID_PARAMETERS: "PARAMETERS: {variable}",
+            },
+            // Add more languages and error messages as needed
+        };
+        let errorMessage = errorMessages[language][code] || code;
+        if (variable) {
+            if (typeof variable === "string" ||
+                typeof variable === "number" ||
+                Array.isArray(variable))
+                errorMessage = errorMessage.replaceAll(`{variable}`, Array.isArray(variable) ? variable.join(", ") : variable);
+            else
+                Object.keys(variable).forEach((variableKey) => (errorMessage = errorMessage.replaceAll(`{${variableKey}}`, variable[variableKey].toString())));
+        }
+        return new Error(errorMessage);
+    }
+    async setTableSchema(tableName, schema) {
+        const decodeIdFromSchema = (schema) => schema.map((field) => {
+            if (field.children && Utils.isArrayOfObjects(field.children))
+                field.children = decodeIdFromSchema(field.children);
+            if (!Utils.isNumber(field.id))
+                field.id = Utils.decodeID(field.id, this.salt);
+            return field;
+        });
+        // remove id from schema
+        schema = schema.filter(({ key }) => !["id", "createdAt", "updatedAt"].includes(key));
+        schema = Utils.addIdToSchema(schema, Utils.findLastIdNumber(schema, this.salt), this.salt);
+        const TablePath = join(this.folder, this.database, tableName), TableSchemaPath = join(TablePath, "schema.json");
+        if (!(await File.isExists(TablePath)))
+            await mkdir(TablePath, { recursive: true });
+        if (await File.isExists(TableSchemaPath)) {
+            // update columns files names based on field id
+            const schemaToIdsPath = (schema, prefix = "") => {
+                let RETURN = {};
+                for (const field of schema)
+                    if (field.children && Utils.isArrayOfObjects(field.children)) {
+                        Utils.deepMerge(RETURN, schemaToIdsPath(field.children, (prefix ?? "") + field.key + "."));
+                    }
+                    else if (Utils.isValidID(field.id))
+                        RETURN[Utils.decodeID(field.id, this.salt)] =
+                            (prefix ?? "") + field.key + ".inib";
+                return RETURN;
+            }, replaceOldPathes = Utils.findChangedProperties(schemaToIdsPath(await this.getTableSchema(tableName)), schemaToIdsPath(schema));
+            if (replaceOldPathes)
+                for (const [oldPath, newPath] of Object.entries(replaceOldPathes))
+                    if (await File.isExists(join(TablePath, oldPath)))
+                        await rename(join(TablePath, oldPath), join(TablePath, newPath));
+        }
+        await writeFile(join(TablePath, "schema.json"), JSON.stringify(decodeIdFromSchema(schema)));
+    }
+    async getTableSchema(tableName) {
+        const TableSchemaPath = join(this.folder, this.database, tableName, "schema.json");
+        if (!(await File.isExists(TableSchemaPath)))
+            return undefined;
+        if (!this.cache.has(TableSchemaPath))
+            this.cache.set(TableSchemaPath, await readFile(TableSchemaPath, "utf8"));
+        if (!this.cache.get(TableSchemaPath))
+            return undefined;
+        const schema = JSON.parse(this.cache.get(TableSchemaPath)), lastIdNumber = Utils.findLastIdNumber(schema, this.salt);
+        return [
+            {
+                id: Utils.encodeID(0, this.salt),
+                key: "id",
+                type: "id",
+                required: true,
+            },
+            ...Utils.addIdToSchema(schema, lastIdNumber, this.salt),
+            {
+                id: Utils.encodeID(lastIdNumber + 1, this.salt),
+                key: "createdAt",
+                type: "date",
+                required: true,
+            },
+            {
+                id: Utils.encodeID(lastIdNumber + 2, this.salt),
+                key: "updatedAt",
+                type: "date",
+                required: false,
+            },
+        ];
+    }
+    getField(keyPath, schema, property) {
+        const keyPathSplited = keyPath.split(".");
+        for (const [index, key] of keyPathSplited.entries()) {
+            if (key === "*")
+                continue;
+            const foundItem = schema.find((item) => item.key === key);
+            if (!foundItem)
+                return null;
+            if (index === keyPathSplited.length - 1)
+                schema = foundItem;
+            if ((foundItem.type === "array" || foundItem.type === "object") &&
+                foundItem.children &&
+                Utils.isArrayOfObjects(foundItem.children))
+                schema = foundItem.children;
+        }
+        if (property) {
+            switch (property) {
+                case "type":
+                    return schema.type;
+                case "children":
+                    return schema.children;
+                default:
+                    return schema[property];
+            }
+        }
+        else
+            return schema;
+    }
+    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 { key, type, required, children } of schema) {
+                if (!data.hasOwnProperty(key) && required && !skipRequiredField)
+                    throw this.throwError("FIELD_REQUIRED", key);
+                if (data.hasOwnProperty(key) &&
+                    !Utils.validateFieldType(data[key], type, children && !Utils.isArrayOfObjects(children) ? children : undefined))
+                    throw this.throwError("INVALID_TYPE", key);
+                if ((type === "array" || type === "object") &&
+                    children &&
+                    Utils.isArrayOfObjects(children))
+                    this.validateData(data[key], children, skipRequiredField);
+            }
+        }
+    }
+    formatData(data, schema, formatOnlyAvailiableKeys) {
+        this.validateData(data, schema, formatOnlyAvailiableKeys);
+        const formatField = (value, field) => {
+            if (Array.isArray(field.type))
+                field.type = Utils.detectFieldType(value, field.type);
+            switch (field.type) {
+                case "array":
+                    if (!Array.isArray(value))
+                        value = [value];
+                    if (typeof field.children === "string") {
+                        if (field.type === "array" && field.children === "table") {
+                            if (Array.isArray(value)) {
+                                if (Utils.isArrayOfObjects(value)) {
+                                    if (value.every((item) => item.hasOwnProperty("id") &&
+                                        (Utils.isValidID(item.id) || Utils.isNumber(item.id))))
+                                        value.map((item) => Utils.isNumber(item.id)
+                                            ? Number(item.id)
+                                            : Utils.decodeID(item.id, this.salt));
+                                }
+                                else if (value.every(Utils.isValidID) ||
+                                    value.every(Utils.isNumber))
+                                    return value.map((item) => Utils.isNumber(item)
+                                        ? Number(item)
+                                        : Utils.decodeID(item, this.salt));
+                            }
+                            else if (Utils.isValidID(value))
+                                return [Utils.decodeID(value, this.salt)];
+                            else if (Utils.isNumber(value))
+                                return [Number(value)];
+                        }
+                        else if (data.hasOwnProperty(field.key))
+                            return value;
+                    }
+                    else if (Utils.isArrayOfObjects(field.children))
+                        return this.formatData(value, field.children, formatOnlyAvailiableKeys);
+                    else if (Array.isArray(field.children))
+                        return Array.isArray(value) ? value : [value];
+                    break;
+                case "object":
+                    if (Utils.isArrayOfObjects(field.children))
+                        return this.formatData(value, field.children, formatOnlyAvailiableKeys);
+                    break;
+                case "table":
+                    if (Array.isArray(value))
+                        value = value[0];
+                    if (Utils.isObject(value)) {
+                        if (value.hasOwnProperty("id") &&
+                            (Utils.isValidID(value.id) ||
+                                Utils.isNumber(value.id)))
+                            return Utils.isNumber(value.id)
+                                ? Number(value.id)
+                                : Utils.decodeID(value.id, this.salt);
+                    }
+                    else if (Utils.isValidID(value) || Utils.isNumber(value))
+                        return Utils.isNumber(value)
+                            ? Number(value)
+                            : Utils.decodeID(value, this.salt);
+                    break;
+                case "password":
+                    if (Array.isArray(value))
+                        value = value[0];
+                    return typeof value === "string" && value.length === 161
+                        ? value
+                        : Utils.hashPassword(String(value));
+                case "number":
+                    if (Array.isArray(value))
+                        value = value[0];
+                    return Utils.isNumber(value) ? Number(value) : null;
+                case "id":
+                    if (Array.isArray(value))
+                        value = value[0];
+                    return Utils.isNumber(value)
+                        ? value
+                        : Utils.decodeID(value, this.salt);
+                default:
+                    return value;
+            }
+            return null;
+        };
+        if (Utils.isArrayOfObjects(data))
+            return data.map((single_data) => this.formatData(single_data, schema, formatOnlyAvailiableKeys));
+        else if (Utils.isObject(data)) {
+            let RETURN = {};
+            for (const field of schema) {
+                if (!data.hasOwnProperty(field.key)) {
+                    if (formatOnlyAvailiableKeys || !field.required)
+                        continue;
+                    RETURN[field.key] = this.getDefaultValue(field);
+                    continue;
+                }
+                RETURN[field.key] = formatField(data[field.key], field);
+            }
+            return RETURN;
+        }
+        else
+            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":
+                return Utils.isArrayOfObjects(field.children)
+                    ? [
+                        this.getDefaultValue({
+                            ...field,
+                            type: "object",
+                            children: field.children,
+                        }),
+                    ]
+                    : [];
+            case "object":
+                return Utils.combineObjects(field.children.map((f) => ({
+                    [f.key]: this.getDefaultValue(f),
+                })));
+            case "boolean":
+                return false;
+            default:
+                return null;
+        }
+    }
+    joinPathesContentsReplacement(mainPath, data, startingtAt = 1) {
+        if (Utils.isArrayOfObjects(data)) {
+            return Utils.combineObjects(data.map((single_data) => this.joinPathesContentsReplacement(mainPath, single_data, startingtAt++)));
+        }
+        else {
+            return Object.fromEntries(Object.entries(Utils.objectToDotNotation(data)).map(([key, value]) => [
+                join(mainPath, key + ".inib"),
+                { [startingtAt]: value },
+            ]));
+        }
+    }
+    joinPathesContents(mainPath, data, startWith = 1) {
+        const CombineData = (_data, prefix) => {
+            let RETURN = {};
+            const combineObjectsToArray = (input) => input.reduce((r, c) => (Object.keys(c).map((k) => (r[k] = [...(r[k] || []), c[k]])), r), {});
+            if (Utils.isArrayOfObjects(_data))
+                RETURN = combineObjectsToArray(_data.map((single_data) => CombineData(single_data)));
+            else {
+                for (const [key, value] of Object.entries(_data)) {
+                    if (Utils.isObject(value))
+                        Object.assign(RETURN, CombineData(value, `${key}.`));
+                    else if (Utils.isArrayOfObjects(value)) {
+                        Object.assign(RETURN, CombineData(combineObjectsToArray(value), (prefix ?? "") + key + "."));
+                    }
+                    else if (Utils.isArrayOfArrays(value) &&
+                        value.every(Utils.isArrayOfObjects))
+                        Object.assign(RETURN, CombineData(combineObjectsToArray(value.map(combineObjectsToArray)), (prefix ?? "") + key + "."));
+                    else
+                        RETURN[(prefix ?? "") + key] = File.encode(value);
+                }
+            }
+            return RETURN;
+        };
+        const addPathToKeys = (obj, path) => {
+            const newObject = {};
+            for (const key in obj)
+                newObject[join(path, key + ".inib")] = obj[key];
+            return newObject;
+        };
+        return addPathToKeys(CombineData(data), mainPath);
+    }
+    async get(tableName, where, options = {
+        page: 1,
+        per_page: 15,
+    }, onlyOne, onlyLinesNumbers) {
+        if (!options.columns)
+            options.columns = [];
+        else if (!Array.isArray(options.columns))
+            options.columns = [options.columns];
+        if (options.columns.length && !options.columns.includes("id"))
+            options.columns.push("id");
+        if (!options.page)
+            options.page = 1;
+        if (!options.per_page)
+            options.per_page = 15;
+        let RETURN;
+        let schema = await this.getTableSchema(tableName);
+        if (!schema)
+            throw this.throwError("NO_SCHEMA", tableName);
+        const idFilePath = join(this.folder, this.database, tableName, "id.inib");
+        if (!(await File.isExists(idFilePath)))
+            return null;
+        const filterSchemaByColumns = (schema, columns) => 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 = 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);
+        if (options.columns.length)
+            schema = filterSchemaByColumns(schema, options.columns);
+        const getItemsFromSchema = async (path, schema, linesNumber, prefix) => {
+            let RETURN = {};
+            for (const field of schema) {
+                if ((field.type === "array" ||
+                    (Array.isArray(field.type) &&
+                        field.type.includes("array"))) &&
+                    field
+                        .children) {
+                    if (Utils.isArrayOfObjects(field
+                        .children)) {
+                        if (field
+                            .children.filter((children) => children.type === "array" &&
+                            Utils.isArrayOfObjects(children.children)).length) {
+                            // one of children has array field type and has children array of object = Schema
+                            Object.entries((await getItemsFromSchema(path, field.children.filter((children) => children.type === "array" &&
+                                Utils.isArrayOfObjects(children.children)), linesNumber, (prefix ?? "") + field.key + ".")) ?? {}).forEach(([index, item]) => {
+                                if (Utils.isObject(item)) {
+                                    if (!RETURN[index])
+                                        RETURN[index] = {};
+                                    if (!RETURN[index][field.key])
+                                        RETURN[index][field.key] = [];
+                                    for (const child_field of field.children.filter((children) => children.type === "array" &&
+                                        Utils.isArrayOfObjects(children.children))) {
+                                        if (Utils.isObject(item[child_field.key])) {
+                                            Object.entries(item[child_field.key]).forEach(([key, value]) => {
+                                                for (let _i = 0; _i < value.length; _i++) {
+                                                    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] =
+                                                            [];
+                                                    value[_i].forEach((_element, _index) => {
+                                                        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;
+                                                    });
+                                                }
+                                            });
+                                        }
+                                    }
+                                }
+                            });
+                            field.children = field
+                                .children.filter((children) => children.type !== "array" ||
+                                !Utils.isArrayOfObjects(children.children));
+                        }
+                        Object.entries((await getItemsFromSchema(path, field
+                            .children, linesNumber, (prefix ?? "") + field.key + ".")) ?? {}).forEach(([index, item]) => {
+                            if (!RETURN[index])
+                                RETURN[index] = {};
+                            if (Utils.isObject(item)) {
+                                if (!Object.values(item).every((i) => i === null)) {
+                                    if (RETURN[index][field.key])
+                                        Object.entries(item).forEach(([key, value], _index) => {
+                                            RETURN[index][field.key] = RETURN[index][field.key].map((_obj, _i) => ({
+                                                ..._obj,
+                                                [key]: value[_i],
+                                            }));
+                                        });
+                                    else if (Object.values(item).every(Utils.isArrayOfArrays))
+                                        RETURN[index][field.key] = item;
+                                    else {
+                                        RETURN[index][field.key] = [];
+                                        Object.entries(item).forEach(([key, value]) => {
+                                            for (let _i = 0; _i < value.length; _i++) {
+                                                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 (field
+                        .children === "table" ||
+                        (Array.isArray(field
+                            .children) &&
+                            field
+                                .children.includes("table"))) {
+                        if (options.columns)
+                            options.columns = options.columns
+                                .filter((column) => column.includes(`${field.key}.`))
+                                .map((column) => column.replace(`${field.key}.`, ""));
+                        const [items, total_lines] = await File.get(join(path, (prefix ?? "") + field.key + ".inib"), linesNumber, field.type, field
+                            .children, this.salt);
+                        this.totalItems[tableName + "-" + field.key] = total_lines;
+                        for (const [index, item] of Object.entries(items)) {
+                            if (!RETURN[index])
+                                RETURN[index] = {};
+                            RETURN[index][field.key] = item
+                                ? await this.get(field.key, item, options)
+                                : this.getDefaultValue(field);
+                        }
+                    }
+                    else if (await File.isExists(join(path, (prefix ?? "") + field.key + ".inib"))) {
+                        const [items, total_lines] = await File.get(join(path, (prefix ?? "") + field.key + ".inib"), linesNumber, field.type, field?.children, this.salt);
+                        this.totalItems[tableName + "-" + field.key] = total_lines;
+                        for (const [index, item] of Object.entries(items)) {
+                            if (!RETURN[index])
+                                RETURN[index] = {};
+                            RETURN[index][field.key] = item ?? this.getDefaultValue(field);
+                        }
+                    }
+                }
+                else if (field.type === "object") {
+                    for (const [index, item] of Object.entries((await getItemsFromSchema(path, field.children, linesNumber, (prefix ?? "") + field.key + ".")) ?? {})) {
+                        if (!RETURN[index])
+                            RETURN[index] = {};
+                        if (Utils.isObject(item)) {
+                            if (!Object.values(item).every((i) => i === null))
+                                RETURN[index][field.key] = item;
+                            else
+                                RETURN[index][field.key] = null;
+                        }
+                        else
+                            RETURN[index][field.key] = null;
+                    }
+                }
+                else if (field.type === "table") {
+                    if ((await File.isExists(join(this.folder, this.database, field.key))) &&
+                        (await File.isExists(join(path, (prefix ?? "") + field.key + ".inib")))) {
+                        if (options.columns)
+                            options.columns = options.columns
+                                .filter((column) => column.includes(`${field.key}.`) &&
+                                !column.includes(`${field.key}.`))
+                                .map((column) => column.replace(`${field.key}.`, ""));
+                        const [items, total_lines] = await File.get(join(path, (prefix ?? "") + field.key + ".inib"), linesNumber, "number", undefined, this.salt);
+                        this.totalItems[tableName + "-" + field.key] = total_lines;
+                        for (const [index, item] of Object.entries(items)) {
+                            if (!RETURN[index])
+                                RETURN[index] = {};
+                            RETURN[index][field.key] = item
+                                ? await this.get(field.key, item, options)
+                                : this.getDefaultValue(field);
+                        }
+                    }
+                }
+                else if (await File.isExists(join(path, (prefix ?? "") + field.key + ".inib"))) {
+                    const [items, total_lines] = await File.get(join(path, (prefix ?? "") + field.key + ".inib"), linesNumber, field.type, field?.children, this.salt);
+                    this.totalItems[tableName + "-" + field.key] = total_lines;
+                    for (const [index, item] of Object.entries(items)) {
+                        if (!RETURN[index])
+                            RETURN[index] = {};
+                        RETURN[index][field.key] = item ?? this.getDefaultValue(field);
+                    }
+                }
+            }
+            return RETURN;
+        };
+        if (!where) {
+            // Display all data
+            RETURN = Object.values(await getItemsFromSchema(join(this.folder, this.database, tableName), schema, Array.from({ length: options.per_page }, (_, index) => (options.page - 1) * options.per_page +
+                index +
+                1)));
+        }
+        else if ((Array.isArray(where) &&
+            (where.every(Utils.isValidID) || where.every(Utils.isNumber))) ||
+            Utils.isValidID(where) ||
+            Utils.isNumber(where)) {
+            let Ids = where;
+            if (!Array.isArray(Ids))
+                Ids = [Ids];
+            const [lineNumbers, countItems] = await File.search(idFilePath, "[]", Ids.map((id) => Utils.isNumber(id) ? Number(id) : Utils.decodeID(id, this.salt)), undefined, "number", undefined, Ids.length, 0, false, this.salt);
+            if (!lineNumbers || !Object.keys(lineNumbers).length)
+                throw this.throwError("INVALID_ID", where);
+            if (onlyLinesNumbers)
+                return Object.keys(lineNumbers).map(Number);
+            RETURN = Object.values((await getItemsFromSchema(join(this.folder, this.database, tableName), schema, Object.keys(lineNumbers).map(Number))) ?? {});
+            if (RETURN.length && !Array.isArray(where))
+                RETURN = RETURN[0];
+        }
+        else if (Utils.isObject(where)) {
+            // Criteria
+            const FormatObjectCriteriaValue = (value, isParentArray = false) => {
+                switch (value[0]) {
+                    case ">":
+                    case "<":
+                    case "[":
+                        return ["=", "]", "*"].includes(value[1])
+                            ? [
+                                value.slice(0, 2),
+                                value.slice(2),
+                            ]
+                            : [
+                                value.slice(0, 1),
+                                value.slice(1),
+                            ];
+                    case "!":
+                        return ["=", "*"].includes(value[1])
+                            ? [
+                                value.slice(0, 2),
+                                value.slice(2),
+                            ]
+                            : value[1] === "["
+                                ? [
+                                    value.slice(0, 3),
+                                    value.slice(3),
+                                ]
+                                : [
+                                    (value.slice(0, 1) + "="),
+                                    value.slice(1),
+                                ];
+                    case "=":
+                        return isParentArray
+                            ? [
+                                value.slice(0, 1),
+                                value.slice(1),
+                            ]
+                            : [
+                                value.slice(0, 1),
+                                (value.slice(1) + ","),
+                            ];
+                    case "*":
+                        return [
+                            value.slice(0, 1),
+                            value.slice(1),
+                        ];
+                    default:
+                        return ["=", value];
+                }
+            };
+            const applyCriteria = async (criteria, allTrue) => {
+                let RETURN = {};
+                if (!criteria)
+                    return null;
+                if (criteria.and && Utils.isObject(criteria.and)) {
+                    const searchResult = await applyCriteria(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;
+                    }
+                    else
+                        return null;
+                }
+                if (criteria.or && Utils.isObject(criteria.or)) {
+                    const searchResult = await applyCriteria(criteria.or, false);
+                    delete criteria.or;
+                    if (searchResult)
+                        RETURN = Utils.deepMerge(RETURN, searchResult);
+                }
+                if (Object.keys(criteria).length > 0) {
+                    if (allTrue === undefined)
+                        allTrue = true;
+                    let index = -1;
+                    for (const [key, value] of Object.entries(criteria)) {
+                        const field = this.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"
+                                    ? 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"
+                                    ? 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"
+                                ? 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 = FormatObjectCriteriaValue(value);
+                            if (ComparisonOperatorValue) {
+                                searchOperator = ComparisonOperatorValue[0];
+                                searchComparedAtValue = ComparisonOperatorValue[1];
+                            }
+                        }
+                        else {
+                            searchOperator = "=";
+                            searchComparedAtValue = value;
+                        }
+                        const [searchResult, total_lines] = await File.search(join(this.folder, this.database, tableName, key + ".inib"), searchOperator, searchComparedAtValue, searchLogicalOperator, field?.type, field?.children, options.per_page, options.page - 1 * options.per_page + 1, true, this.salt);
+                        if (searchResult) {
+                            RETURN = Utils.deepMerge(RETURN, searchResult);
+                            this.totalItems[tableName + "-" + key] = total_lines;
+                        }
+                        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 = await applyCriteria(where);
+            if (RETURN) {
+                if (onlyLinesNumbers)
+                    return Object.keys(RETURN).map(Number);
+                const alreadyExistsColumns = Object.keys(Object.values(RETURN)[0]).map((key) => parse(key).name);
+                RETURN = Object.values(Utils.deepMerge(RETURN, await getItemsFromSchema(join(this.folder, this.database, tableName), schema.filter((field) => !alreadyExistsColumns.includes(field.key)), Object.keys(RETURN).map(Number))));
+            }
+        }
+        if (!RETURN ||
+            (Utils.isObject(RETURN) && !Object.keys(RETURN).length) ||
+            (Array.isArray(RETURN) && !RETURN.length))
+            return null;
+        const greatestTotalItems = Math.max(...Object.entries(this.totalItems)
+            .filter(([k]) => k.startsWith(tableName + "-"))
+            .map(([, v]) => v));
+        this.pageInfo = {
+            ...(({ columns, ...restOfOptions }) => restOfOptions)(options),
+            total_pages: Math.ceil(greatestTotalItems / options.per_page),
+            total: greatestTotalItems,
+        };
+        return onlyOne ? RETURN[0] : RETURN;
+    }
+    async post(tableName, data, options = {
+        page: 1,
+        per_page: 15,
+    }, returnPostedData = true) {
+        const schema = await this.getTableSchema(tableName);
+        let RETURN;
+        if (!schema)
+            throw this.throwError("NO_SCHEMA", tableName);
+        const idFilePath = join(this.folder, this.database, tableName, "id.inib");
+        let [last_line_number, last_id] = (await File.isExists(idFilePath))
+            ? Object.entries((await File.get(idFilePath, -1, "number", undefined, this.salt))[0])[0] ?? [0, 0]
+            : [0, 0];
+        if (Utils.isArrayOfObjects(data))
+            RETURN = data.map(({ id, updatedAt, createdAt, ...rest }) => ({
+                id: ++last_id,
+                ...rest,
+                createdAt: new Date(),
+            }));
+        else
+            RETURN = (({ id, updatedAt, createdAt, ...rest }) => ({
+                id: ++last_id,
+                ...rest,
+                createdAt: new Date(),
+            }))(data);
+        if (!RETURN)
+            throw this.throwError("NO_DATA");
+        RETURN = this.formatData(RETURN, schema);
+        const pathesContents = this.joinPathesContentsReplacement(join(this.folder, this.database, tableName), RETURN, ++last_line_number);
+        for await (const [path, content] of Object.entries(pathesContents))
+            await File.replace(path, content, this.salt);
+        if (returnPostedData)
+            return this.get(tableName, Utils.isArrayOfObjects(RETURN)
+                ? RETURN.map((data) => data.id)
+                : RETURN.id, options, !Utils.isArrayOfObjects(data) // return only one item if data is not array of objects
+            );
+    }
+    async put(tableName, data, where, options = {
+        page: 1,
+        per_page: 15,
+    }, returnPostedData) {
+        const schema = await this.getTableSchema(tableName);
+        if (!schema)
+            throw this.throwError("NO_SCHEMA", tableName);
+        const idFilePath = join(this.folder, this.database, tableName, "id.inib");
+        if (!(await File.isExists(idFilePath)))
+            throw this.throwError("NO_ITEMS", tableName);
+        data = this.formatData(data, schema, true);
+        if (!where) {
+            if (Utils.isArrayOfObjects(data)) {
+                if (!data.every((item) => item.hasOwnProperty("id") && Utils.isValidID(item.id)))
+                    throw this.throwError("INVALID_ID");
+                return this.put(tableName, data, data.map((item) => item.id));
+            }
+            else if (data.hasOwnProperty("id")) {
+                if (!Utils.isValidID(data.id))
+                    throw this.throwError("INVALID_ID", data.id);
+                return this.put(tableName, data, Utils.decodeID(data.id, this.salt));
+            }
+            else {
+                const pathesContents = this.joinPathesContents(join(this.folder, this.database, tableName), Utils.isArrayOfObjects(data)
+                    ? data.map((item) => ({
+                        ...(({ id, ...restOfData }) => restOfData)(item),
+                        updatedAt: new Date(),
+                    }))
+                    : {
+                        ...(({ id, ...restOfData }) => restOfData)(data),
+                        updatedAt: new Date(),
+                    });
+                for await (const [path, content] of Object.entries(pathesContents))
+                    await File.replace(path, content, this.salt);
+                if (returnPostedData)
+                    return this.get(tableName, where, options);
+            }
+        }
+        else if ((Array.isArray(where) &&
+            (where.every(Utils.isValidID) || where.every(Utils.isNumber))) ||
+            Utils.isValidID(where) ||
+            Utils.isNumber(where)) {
+            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);
+            }
+            else if ((Array.isArray(where) && where.every(Utils.isNumber)) ||
+                Utils.isNumber(where)) {
+                // "where" in this case, is the line(s) number(s) and not id(s)
+                const pathesContents = Object.fromEntries(Object.entries(this.joinPathesContents(join(this.folder, this.database, tableName), Utils.isArrayOfObjects(data)
+                    ? data.map((item) => ({
+                        ...item,
+                        updatedAt: new Date(),
+                    }))
+                    : { ...data, updatedAt: new Date() })).map(([key, value]) => [
+                    key,
+                    [...(Array.isArray(where) ? where : [where])].reduce((obj, key, index) => ({
+                        ...obj,
+                        [key]: Array.isArray(value) ? value[index] : value,
+                    }), {}),
+                ]));
+                for await (const [path, content] of Object.entries(pathesContents))
+                    await File.replace(path, content, this.salt);
+                if (returnPostedData)
+                    return this.get(tableName, where, options, !Array.isArray(where));
+            }
+        }
+        else if (typeof where === "object") {
+            const lineNumbers = this.get(tableName, where, undefined, undefined, true);
+            if (!lineNumbers || !Array.isArray(lineNumbers) || !lineNumbers.length)
+                throw this.throwError("NO_ITEMS", tableName);
+            return this.put(tableName, data, lineNumbers);
+        }
+        else
+            throw this.throwError("INVALID_PARAMETERS", tableName);
+    }
+    async delete(tableName, where, _id) {
+        const schema = await this.getTableSchema(tableName);
+        if (!schema)
+            throw this.throwError("NO_SCHEMA", tableName);
+        const idFilePath = join(this.folder, this.database, tableName, "id.inib");
+        if (!(await File.isExists(idFilePath)))
+            throw this.throwError("NO_ITEMS", tableName);
+        if (!where) {
+            const files = await readdir(join(this.folder, this.database, tableName));
+            if (files.length) {
+                for (const file in files.filter((fileName) => fileName !== "schema.json"))
+                    await unlink(join(this.folder, this.database, tableName, file));
+            }
+            return "*";
+        }
+        else if ((Array.isArray(where) &&
+            (where.every(Utils.isValidID) || where.every(Utils.isNumber))) ||
+            Utils.isValidID(where) ||
+            Utils.isNumber(where)) {
+            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);
+            }
+            else if ((Array.isArray(where) && where.every(Utils.isNumber)) ||
+                Utils.isNumber(where)) {
+                // "where" in this case, is the line(s) number(s) and not id(s)
+                const files = await readdir(join(this.folder, this.database, tableName));
+                if (files.length) {
+                    if (!_id)
+                        _id = Object.values((await File.get(join(this.folder, this.database, tableName, "id.inib"), where, "number", undefined, this.salt))[0]).map((id) => Utils.encodeID(Number(id), this.salt));
+                    for (const file of files.filter((fileName) => fileName.endsWith(".inib")))
+                        await File.remove(join(this.folder, this.database, tableName, file), where);
+                    return Array.isArray(_id) && _id.length === 1 ? _id[0] : _id;
+                }
+            }
+        }
+        else if (typeof where === "object" && !Array.isArray(where)) {
+            const lineNumbers = this.get(tableName, where, undefined, undefined, true);
+            if (!lineNumbers || !Array.isArray(lineNumbers) || !lineNumbers.length)
+                throw this.throwError("NO_ITEMS", tableName);
+            return this.delete(tableName, lineNumbers);
+        }
+        else
+            throw this.throwError("INVALID_PARAMETERS", tableName);
+        return null;
+    }
+    async sum(tableName, columns, where) {
+        let RETURN;
+        const schema = await this.getTableSchema(tableName);
+        if (!schema)
+            throw this.throwError("NO_SCHEMA", tableName);
+        if (!(await File.isExists(join(this.folder, this.database, tableName, "id.inib"))))
+            throw this.throwError("NO_ITEMS", tableName);
+        if (!Array.isArray(columns))
+            columns = [columns];
+        for await (const column of columns) {
+            const columnPath = join(this.folder, this.database, tableName, column + ".inib");
+            if (await File.isExists(columnPath)) {
+                if (where) {
+                    const lineNumbers = await this.get(tableName, where, undefined, undefined, true);
+                    RETURN[column] = await File.sum(columnPath, lineNumbers);
+                }
+                else
+                    RETURN[column] = await File.sum(columnPath);
+            }
+        }
+        return Array.isArray(columns) ? RETURN : Object.values(RETURN)[0];
+    }
+    async max(tableName, columns, where) {
+        let RETURN;
+        const schema = await this.getTableSchema(tableName);
+        if (!schema)
+            throw this.throwError("NO_SCHEMA", tableName);
+        if (!(await File.isExists(join(this.folder, this.database, tableName, "id.inib"))))
+            throw this.throwError("NO_ITEMS", tableName);
+        if (!Array.isArray(columns))
+            columns = [columns];
+        for await (const column of columns) {
+            const columnPath = join(this.folder, this.database, tableName, column + ".inib");
+            if (await File.isExists(columnPath)) {
+                if (where) {
+                    const lineNumbers = await this.get(tableName, where, undefined, undefined, true);
+                    RETURN[column] = await File.max(columnPath, lineNumbers);
+                }
+                else
+                    RETURN[column] = await File.max(columnPath);
+            }
+        }
+        return RETURN;
+    }
+    async min(tableName, columns, where) {
+        let RETURN;
+        const schema = await this.getTableSchema(tableName);
+        if (!schema)
+            throw this.throwError("NO_SCHEMA", tableName);
+        if (!(await File.isExists(join(this.folder, this.database, tableName, "id.inib"))))
+            throw this.throwError("NO_ITEMS", tableName);
+        if (!Array.isArray(columns))
+            columns = [columns];
+        for await (const column of columns) {
+            const columnPath = join(this.folder, this.database, tableName, column + ".inib");
+            if (await File.isExists(columnPath)) {
+                if (where) {
+                    const lineNumbers = await this.get(tableName, where, undefined, undefined, true);
+                    RETURN[column] = await File.min(columnPath, lineNumbers);
+                }
+                else
+                    RETURN[column] = await File.min(columnPath);
+            }
+        }
+        return RETURN;
+    }
+}