inibase 1.0.0-rc.120 → 1.0.0-rc.121

package/README.md

@@ -726,13 +726,13 @@ await db.get("user", undefined, { sort: {age: -1, username: "asc"} });
   - [x] Id
   - [x] JSON
 - [ ] TO-DO:
-  - [ ] Use new Map() instead of Object
+  - [x] Use new Map() instead of Object
   - [ ] Ability to search in JSON fields
-  - [ ] Re-check used exec functions
+  - [x] Re-check used exec functions
   - [ ] Use smart caching (based on N° of queries)
   - [ ] Commenting the code
   - [ ] Add Backup feature (generate a tar.gz)
-  - [ ] Add Custom field validation property to schema (using RegEx?)
+  - [x] Add Custom field validation property to schema (using RegEx?)
 - [ ] Features:
   - [ ] Encryption
   - [x] Data Compression

package/dist/file.js

@@ -542,7 +542,7 @@ export const search = async (filePath, operator, comparedAtValue, logicalOperato
             // Increment the line count for each line.
             linesCount++;
             // Search only in provided linesNumbers
-            if (searchIn && !searchIn.has(linesCount))
+            if ((searchIn && !searchIn.has(linesCount)) || searchIn.has(-linesCount))
                 continue;
             // Decode the line for comparison.
             const decodedLine = decode(line, fieldType, fieldChildrenType, secretKey);

package/dist/index.d.ts

@@ -12,8 +12,9 @@ export type Field = {
     type: FieldType | FieldType[];
     required?: boolean;
     table?: string;
-    unique?: boolean;
+    unique?: boolean | number | string;
     children?: FieldType | FieldType[] | Schema;
+    regex?: string;
 };
 export type Schema = Field[];
 export interface Options {
@@ -49,18 +50,19 @@ declare global {
         entries<T extends object>(o: T): Entries<T>;
     }
 }
-export type ErrorCodes = "FIELD_UNIQUE" | "FIELD_REQUIRED" | "NO_SCHEMA" | "TABLE_EMPTY" | "INVALID_ID" | "INVALID_TYPE" | "INVALID_PARAMETERS" | "NO_ENV" | "TABLE_EXISTS" | "TABLE_NOT_EXISTS";
+export type ErrorCodes = "FIELD_UNIQUE" | "FIELD_REQUIRED" | "NO_SCHEMA" | "TABLE_EMPTY" | "INVALID_ID" | "INVALID_TYPE" | "INVALID_PARAMETERS" | "NO_ENV" | "TABLE_EXISTS" | "TABLE_NOT_EXISTS" | "INVALID_REGEX_MATCH";
 export type ErrorLang = "en";
 export default class Inibase {
     pageInfo: Record<string, pageInfo>;
     salt: Buffer;
     private databasePath;
-    private tables;
     private fileExtension;
-    private checkIFunique;
+    private tablesMap;
+    private uniqueMap;
     private totalItems;
     constructor(database: string, mainFolder?: string);
-    private Error;
+    private static errorMessages;
+    createError(code: ErrorCodes, variable?: string | number | (string | number)[], language?: ErrorLang): Error;
     clear(): void;
     private getFileExtension;
     private _schemaToIdsPath;
@@ -89,13 +91,15 @@ export default class Inibase {
      * @param {string} tableName
      * @return {*}  {Promise<TableObject>}
      */
-    getTable(tableName: string): Promise<TableObject>;
+    getTable(tableName: string, encodeIDs?: boolean): Promise<TableObject>;
     getTableSchema(tableName: string, encodeIDs?: boolean): Promise<Schema | undefined>;
     private throwErrorIfTableEmpty;
+    private _validateData;
     private validateData;
     private cleanObject;
     private formatField;
     private checkUnique;
+    private _formatData;
     private formatData;
     private getDefaultValue;
     private _combineObjectsToArray;

package/dist/index.js

@@ -1,5 +1,5 @@
 import "dotenv/config";
-import { randomBytes, scryptSync } from "node:crypto";
+import { randomBytes, randomInt, 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";
@@ -14,45 +14,45 @@ export default class Inibase {
     pageInfo;
     salt;
     databasePath;
-    tables;
     fileExtension = ".txt";
-    checkIFunique;
+    tablesMap;
+    uniqueMap;
     totalItems;
     constructor(database, mainFolder = ".") {
         this.databasePath = join(mainFolder, database);
-        this.tables = {};
-        this.totalItems = {};
+        this.tablesMap = new Map();
+        this.totalItems = new Map();
         this.pageInfo = {};
-        this.checkIFunique = {};
+        this.uniqueMap = new Map();
         if (!process.env.INIBASE_SECRET) {
             if (existsSync(".env") &&
                 readFileSync(".env").includes("INIBASE_SECRET="))
-                throw this.Error("NO_ENV");
+                throw this.createError("NO_ENV");
             this.salt = scryptSync(randomBytes(16), randomBytes(16), 32);
             appendFileSync(".env", `\nINIBASE_SECRET=${this.salt.toString("hex")}\n`);
         }
         else
             this.salt = Buffer.from(process.env.INIBASE_SECRET, "hex");
     }
-    Error(code, variable, language = "en") {
-        const errorMessages = {
-            en: {
-                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];
+    static errorMessages = {
+        en: {
+            TABLE_EMPTY: "Table {variable} is empty",
+            TABLE_EXISTS: "Table {variable} already exists",
+            TABLE_NOT_EXISTS: "Table {variable} doesn't exist",
+            NO_SCHEMA: "Table {variable} does't have a schema",
+            FIELD_UNIQUE: "Field {variable} should be unique, got {variable} instead",
+            FIELD_REQUIRED: "Field {variable} is required",
+            INVALID_ID: "The given ID(s) is/are not valid(s)",
+            INVALID_TYPE: "Expect {variable} to be {variable}, got {variable} instead",
+            INVALID_PARAMETERS: "The given parameters are not valid",
+            INVALID_REGEX_MATCH: "Field {variable} does not match the expected pattern",
+            NO_ENV: Number(process.versions.node.split(".").reduce((a, b) => a + b)) >= 26
+                ? "please run with '--env-file=.env'"
+                : "please use dotenv",
+        },
+    };
+    createError(code, variable, language = "en") {
+        const errorMessage = Inibase.errorMessages[language]?.[code];
         if (!errorMessage)
             return new Error("ERR");
         return new Error(variable
@@ -62,17 +62,17 @@ export default class Inibase {
             : errorMessage.replaceAll("{variable}", ""));
     }
     clear() {
-        this.tables = {};
-        this.totalItems = {};
+        this.tablesMap = new Map();
+        this.totalItems = new Map();
         this.pageInfo = {};
-        this.checkIFunique = {};
+        this.uniqueMap = new Map();
     }
     getFileExtension(tableName) {
         let mainExtension = this.fileExtension;
         // TODO: ADD ENCRYPTION
-        // if(this.tables[tableName].config.encryption)
+        // if(this.tablesMap.get(tableName).config.encryption)
         // 	mainExtension += ".enc"
-        if (this.tables[tableName].config.compression)
+        if (this.tablesMap.get(tableName).config.compression)
             mainExtension += ".gz";
         return mainExtension;
     }
@@ -99,7 +99,7 @@ export default class Inibase {
     async createTable(tableName, schema, config) {
         const tablePath = join(this.databasePath, tableName);
         if (await File.isExists(tablePath))
-            throw this.Error("TABLE_EXISTS", tableName);
+            throw this.createError("TABLE_EXISTS", tableName);
         await mkdir(join(tablePath, ".tmp"), { recursive: true });
         await mkdir(join(tablePath, ".cache"));
         // if config not set => load default global env config
@@ -142,7 +142,8 @@ export default class Inibase {
      * @param {(Config&{name?: string})} [config]
      */
     async updateTable(tableName, schema, config) {
-        const table = await this.getTable(tableName), tablePath = join(this.databasePath, tableName);
+        const table = await this.getTable(tableName);
+        const tablePath = join(this.databasePath, tableName);
         if (schema) {
             // remove id from schema
             schema = schema.filter(({ key }) => !["id", "createdAt", "updatedAt"].includes(key));
@@ -232,7 +233,7 @@ export default class Inibase {
                     await this.replaceStringInFile(schemaPath, `"table": "${tableName}"`, `"table": "${config.name}"`);
             }
         }
-        delete this.tables[tableName];
+        this.tablesMap.delete(tableName);
     }
     /**
      * Get table schema and config
@@ -240,20 +241,20 @@ export default class Inibase {
      * @param {string} tableName
      * @return {*}  {Promise<TableObject>}
      */
-    async getTable(tableName) {
+    async getTable(tableName, encodeIDs = true) {
         const tablePath = join(this.databasePath, tableName);
         if (!(await File.isExists(tablePath)))
-            throw this.Error("TABLE_NOT_EXISTS", tableName);
-        if (!this.tables[tableName])
-            this.tables[tableName] = {
-                schema: await this.getTableSchema(tableName),
+            throw this.createError("TABLE_NOT_EXISTS", tableName);
+        if (!this.tablesMap.has(tableName))
+            this.tablesMap.set(tableName, {
+                schema: await this.getTableSchema(tableName, encodeIDs),
                 config: {
                     compression: await File.isExists(join(tablePath, ".compression.config")),
                     cache: await File.isExists(join(tablePath, ".cache.config")),
                     prepend: await File.isExists(join(tablePath, ".prepend.config")),
                 },
-            };
-        return this.tables[tableName];
+            });
+        return this.tablesMap.get(tableName);
     }
     async getTableSchema(tableName, encodeIDs = true) {
         const tablePath = join(this.databasePath, tableName);
@@ -288,17 +289,16 @@ export default class Inibase {
         return UtilsServer.encodeSchemaID(schema, this.salt);
     }
     async throwErrorIfTableEmpty(tableName) {
-        const table = await this.getTable(tableName);
+        const table = await this.getTable(tableName, false);
         if (!table.schema)
-            throw this.Error("NO_SCHEMA", tableName);
+            throw this.createError("NO_SCHEMA", tableName);
         if (!(await File.isExists(join(this.databasePath, tableName, `id${this.getFileExtension(tableName)}`))))
-            throw this.Error("TABLE_EMPTY", tableName);
-        return table;
+            throw this.createError("TABLE_EMPTY", tableName);
     }
-    validateData(data, schema, skipRequiredField = false) {
+    _validateData(data, schema, skipRequiredField = false) {
         if (Utils.isArrayOfObjects(data))
             for (const single_data of data)
-                this.validateData(single_data, schema, skipRequiredField);
+                this._validateData(single_data, schema, skipRequiredField);
         else if (Utils.isObject(data)) {
             for (const field of schema) {
                 if (!Object.hasOwn(data, field.key) ||
@@ -306,7 +306,7 @@ export default class Inibase {
                     data[field.key] === undefined ||
                     data[field.key] === "") {
                     if (field.required && !skipRequiredField)
-                        throw this.Error("FIELD_REQUIRED", field.key);
+                        throw this.createError("FIELD_REQUIRED", field.key);
                     return;
                 }
                 if (!Utils.validateFieldType(data[field.key], field.type, (field.type === "array" || field.type === "object") &&
@@ -314,7 +314,7 @@ export default class Inibase {
                     !Utils.isArrayOfObjects(field.children)
                     ? field.children
                     : undefined))
-                    throw this.Error("INVALID_TYPE", [
+                    throw this.createError("INVALID_TYPE", [
                         field.key,
                         Array.isArray(field.type) ? field.type.join(", ") : field.type,
                         data[field.key],
@@ -322,15 +322,46 @@ export default class Inibase {
                 if ((field.type === "array" || field.type === "object") &&
                     field.children &&
                     Utils.isArrayOfObjects(field.children))
-                    this.validateData(data[field.key], field.children, skipRequiredField);
-                else if (field.unique) {
-                    if (!this.checkIFunique[field.key])
-                        this.checkIFunique[field.key] = [];
-                    this.checkIFunique[`${field.key}`].push(data[field.key]);
+                    this._validateData(data[field.key], field.children, skipRequiredField);
+                else {
+                    if (field.regex) {
+                        const regex = UtilsServer.getCachedRegex(field.regex);
+                        if (!regex.test(data[field.key]))
+                            throw this.createError("INVALID_REGEX_MATCH", [field.key]);
+                    }
+                    if (field.unique) {
+                        let uniqueKey;
+                        if (typeof field.unique === "boolean")
+                            uniqueKey = randomInt(55);
+                        else
+                            uniqueKey = field.unique;
+                        if (!this.uniqueMap.has(uniqueKey))
+                            this.uniqueMap.set(uniqueKey, {
+                                exclude: new Set(),
+                                columnsValues: new Map(),
+                            });
+                        if (!this.uniqueMap
+                            .get(uniqueKey)
+                            .columnsValues.has(field.id))
+                            this.uniqueMap
+                                .get(uniqueKey)
+                                .columnsValues.set(field.id, new Set());
+                        if (data.id)
+                            this.uniqueMap.get(uniqueKey).exclude.add(-data.id);
+                        this.uniqueMap
+                            .get(uniqueKey)
+                            .columnsValues.get(field.id)
+                            .add(data[field.key]);
+                    }
                 }
             }
         }
     }
+    async validateData(tableName, data, skipRequiredField = false) {
+        // Skip ID and (created|updated)At
+        this._validateData(data, this.tablesMap.get(tableName).schema.slice(1, -2), skipRequiredField);
+        await this.checkUnique(tableName);
+    }
     cleanObject(obj) {
         const cleanedObject = Object.entries(obj).reduce((acc, [key, value]) => {
             if (value !== undefined && value !== null && value !== "")
@@ -353,13 +384,13 @@ export default class Inibase {
                 if (!Array.isArray(value))
                     value = [value];
                 if (Utils.isArrayOfObjects(fieldChildrenType))
-                    return this.formatData(value, 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);
+                    return this._formatData(value, fieldChildrenType, _formatOnlyAvailiableKeys);
                 break;
             case "table":
                 if (Utils.isObject(value)) {
@@ -402,25 +433,30 @@ export default class Inibase {
         }
         return null;
     }
-    async checkUnique(tableName, schema) {
+    async checkUnique(tableName) {
         const tablePath = join(this.databasePath, tableName);
-        for await (const [key, values] of Object.entries(this.checkIFunique)) {
-            const field = Utils.getField(key, schema);
-            if (!field)
-                continue;
-            const [searchResult, totalLines] = await File.search(join(tablePath, `${key}${this.getFileExtension(tableName)}`), Array.isArray(values) ? "=" : "[]", values, undefined, 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,
-                ]);
+        const flattenSchema = Utils.flattenSchema(this.tablesMap.get(tableName).schema);
+        for await (const [_uniqueID, valueObject] of this.uniqueMap) {
+            let valueExisted = false;
+            for await (const [columnID, values] of valueObject.columnsValues) {
+                const field = flattenSchema.find(({ id }) => id === columnID);
+                const [searchResult, totalLines] = await File.search(join(tablePath, `${columnID}${this.getFileExtension(tableName)}`), "[]", values, undefined, valueObject.exclude, field.type, field.children, 1, undefined, false, this.salt);
+                if (searchResult && totalLines > 0) {
+                    if (valueExisted)
+                        throw this.createError("FIELD_UNIQUE", [
+                            field.key,
+                            Array.isArray(values) ? values.join(", ") : values,
+                        ]);
+                    valueExisted = true;
+                }
+            }
         }
-        this.checkIFunique = {};
+        this.uniqueMap = new Map();
     }
-    formatData(data, schema, formatOnlyAvailiableKeys) {
+    _formatData(data, schema, formatOnlyAvailiableKeys) {
         const clonedData = JSON.parse(JSON.stringify(data));
         if (Utils.isArrayOfObjects(clonedData))
-            return clonedData.map((singleData) => this.formatData(singleData, schema, formatOnlyAvailiableKeys));
+            return clonedData.map((singleData) => this._formatData(singleData, schema, formatOnlyAvailiableKeys));
         if (Utils.isObject(clonedData)) {
             const RETURN = {};
             for (const field of schema) {
@@ -436,6 +472,9 @@ export default class Inibase {
         }
         return [];
     }
+    formatData(tableName, data, formatOnlyAvailiableKeys) {
+        data = this._formatData(data, this.tablesMap.get(tableName).schema, formatOnlyAvailiableKeys);
+    }
     getDefaultValue(field) {
         if (Array.isArray(field.type))
             return this.getDefaultValue({
@@ -835,7 +874,7 @@ export default class Inibase {
                             [key]: value,
                         },
                     ])));
-                    this.totalItems[`${tableName}-${key}`] = totalLines;
+                    this.totalItems.set(`${tableName}-${key}`, totalLines);
                     if (linesNumbers?.size) {
                         if (searchIn) {
                             for (const lineNumber of linesNumbers)
@@ -911,9 +950,10 @@ export default class Inibase {
         options.page = options.page || 1;
         options.perPage = options.perPage || 15;
         let RETURN;
+        await this.getTable(tableName);
         let schema = (await this.getTable(tableName)).schema;
         if (!schema)
-            throw this.Error("NO_SCHEMA", tableName);
+            throw this.createError("NO_SCHEMA", tableName);
         let pagination;
         for await (const paginationFileName of glob("*.pagination", {
             cwd: tablePath,
@@ -942,7 +982,7 @@ export default class Inibase {
                     .map((column) => [column, true]);
             let cacheKey = "";
             // Criteria
-            if (this.tables[tableName].config.cache)
+            if (this.tablesMap.get(tableName).config.cache)
                 cacheKey = UtilsServer.hashString(inspect(sortArray, { sorted: true }));
             if (where) {
                 const lineNumbers = await this.get(tableName, where, undefined, undefined, true);
@@ -980,7 +1020,7 @@ export default class Inibase {
                 if (cacheKey)
                     await File.lock(join(tablePath, ".tmp"), cacheKey);
                 // Combine && Execute the commands synchronously
-                let lines = (await UtilsServer.exec(this.tables[tableName].config.cache
+                let lines = (await UtilsServer.exec(this.tablesMap.get(tableName).config.cache
                     ? (await File.isExists(join(tablePath, ".cache", `${cacheKey}${this.fileExtension}`)))
                         ? `${awkCommand} '${join(tablePath, ".cache", `${cacheKey}${this.fileExtension}`)}'`
                         : `${pasteCommand} | ${sortCommand} -o '${join(tablePath, ".cache", `${cacheKey}${this.fileExtension}`)}' && ${awkCommand} '${join(tablePath, ".cache", `${cacheKey}${this.fileExtension}`)}'`
@@ -991,8 +1031,8 @@ export default class Inibase {
                     .split("\n");
                 if (where)
                     lines = lines.slice((options.page - 1) * options.perPage, options.page * options.perPage);
-                else if (!this.totalItems[`${tableName}-*`])
-                    this.totalItems[`${tableName}-*`] = pagination[1];
+                else if (!this.totalItems.has(`${tableName}-*`))
+                    this.totalItems.set(`${tableName}-*`, pagination[1]);
                 if (!lines.length)
                     return null;
                 // Parse the result and extract the specified lines
@@ -1025,8 +1065,8 @@ export default class Inibase {
             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];
+            if (!this.totalItems.has(`${tableName}-*`))
+                this.totalItems.set(`${tableName}-*`, pagination[1]);
         }
         else if ((Array.isArray(where) && where.every(Utils.isNumber)) ||
             Utils.isNumber(where)) {
@@ -1034,8 +1074,8 @@ export default class Inibase {
             let lineNumbers = where;
             if (!Array.isArray(lineNumbers))
                 lineNumbers = [lineNumbers];
-            if (!this.totalItems[`${tableName}-*`])
-                this.totalItems[`${tableName}-*`] = lineNumbers.length;
+            if (!this.totalItems.has(`${tableName}-*`))
+                this.totalItems.set(`${tableName}-*`, lineNumbers.length);
             // useless
             if (onlyLinesNumbers)
                 return lineNumbers;
@@ -1048,11 +1088,11 @@ export default class Inibase {
             let Ids = where;
             if (!Array.isArray(Ids))
                 Ids = [Ids];
-            const [lineNumbers, countItems] = await File.search(join(tablePath, `id${this.getFileExtension(tableName)}`), "[]", Ids.map((id) => Utils.isNumber(id) ? Number(id) : UtilsServer.decodeID(id, this.salt)), undefined, undefined, "number", undefined, Ids.length, 0, !this.totalItems[`${tableName}-*`], this.salt);
+            const [lineNumbers, countItems] = await File.search(join(tablePath, `id${this.getFileExtension(tableName)}`), "[]", Ids.map((id) => Utils.isNumber(id) ? Number(id) : UtilsServer.decodeID(id, this.salt)), undefined, undefined, "number", undefined, Ids.length, 0, !this.totalItems.has(`${tableName}-*`), this.salt);
             if (!lineNumbers)
                 return null;
-            if (!this.totalItems[`${tableName}-*`])
-                this.totalItems[`${tableName}-*`] = countItems;
+            if (!this.totalItems.has(`${tableName}-*`))
+                this.totalItems.set(`${tableName}-*`, countItems);
             if (onlyLinesNumbers)
                 return Object.keys(lineNumbers).length
                     ? Object.keys(lineNumbers).map(Number)
@@ -1069,13 +1109,13 @@ export default class Inibase {
         else if (Utils.isObject(where)) {
             let cachedFilePath = "";
             // Criteria
-            if (this.tables[tableName].config.cache)
+            if (this.tablesMap.get(tableName).config.cache)
                 cachedFilePath = join(tablePath, ".cache", `${UtilsServer.hashString(inspect(where, { sorted: true }))}${this.fileExtension}`);
-            if (this.tables[tableName].config.cache &&
+            if (this.tablesMap.get(tableName).config.cache &&
                 (await File.isExists(cachedFilePath))) {
                 const cachedItems = (await readFile(cachedFilePath, "utf8")).split(",");
-                if (!this.totalItems[`${tableName}-*`])
-                    this.totalItems[`${tableName}-*`] = cachedItems.length;
+                if (!this.totalItems.has(`${tableName}-*`))
+                    this.totalItems.set(`${tableName}-*`, cachedItems.length);
                 if (onlyLinesNumbers)
                     return onlyOne ? Number(cachedItems[0]) : cachedItems.map(Number);
                 return this.get(tableName, cachedItems
@@ -1085,8 +1125,8 @@ export default class Inibase {
             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 (!this.totalItems.has(`${tableName}-*`))
+                    this.totalItems.set(`${tableName}-*`, linesNumbers.size);
                 if (onlyLinesNumbers)
                     return onlyOne
                         ? linesNumbers.values().next().value
@@ -1096,7 +1136,7 @@ export default class Inibase {
                     .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)
+                if (this.tablesMap.get(tableName).config.cache)
                     await writeFile(cachedFilePath, Array.from(linesNumbers).join(","));
             }
         }
@@ -1104,8 +1144,9 @@ export default class Inibase {
             (Utils.isObject(RETURN) && !Object.keys(RETURN).length) ||
             (Array.isArray(RETURN) && !RETURN.length))
             return null;
-        const greatestTotalItems = this.totalItems[`${tableName}-*`] ??
-            Math.max(...Object.entries(this.totalItems)
+        const greatestTotalItems = this.totalItems.has(`${tableName}-*`)
+            ? this.totalItems.get(`${tableName}-*`)
+            : Math.max(...[...this.totalItems.entries()]
                 .filter(([k]) => k.startsWith(`${tableName}-`))
                 .map(([, v]) => v));
         this.pageInfo[tableName] = {
@@ -1122,24 +1163,24 @@ export default class Inibase {
                 page: 1,
                 perPage: 15,
             };
-        const tablePath = join(this.databasePath, tableName), schema = (await this.getTable(tableName)).schema;
-        if (!schema)
-            throw this.Error("NO_SCHEMA", tableName);
+        const tablePath = join(this.databasePath, tableName);
+        await this.getTable(tableName);
+        if (!this.tablesMap.get(tableName).schema)
+            throw this.createError("NO_SCHEMA", tableName);
         if (!returnPostedData)
             returnPostedData = false;
         const keys = UtilsServer.hashString(Object.keys(Array.isArray(data) ? data[0] : data).join("."));
-        // Skip ID and (created|updated)At
-        this.validateData(data, schema.slice(1, -2));
-        let lastId = 0;
+        await this.validateData(tableName, data);
         const renameList = [];
         try {
             await File.lock(join(tablePath, ".tmp"), keys);
             let paginationFilePath;
             for await (const fileName of glob("*.pagination", { cwd: tablePath }))
                 paginationFilePath = join(tablePath, fileName);
-            [lastId, this.totalItems[`${tableName}-*`]] = parse(paginationFilePath)
+            let [lastId, _totalItems] = parse(paginationFilePath)
                 .name.split("-")
                 .map(Number);
+            this.totalItems.set(`${tableName}-*`, _totalItems);
             if (Utils.isArrayOfObjects(data))
                 for (let index = 0; index < data.length; index++) {
                     const element = data[index];
@@ -1152,35 +1193,33 @@ export default class Inibase {
                 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
+            this.formatData(tableName, data);
+            const pathesContents = this.joinPathesContents(tableName, this.tablesMap.get(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 Promise.allSettled(Object.entries(pathesContents).map(async ([path, content]) => renameList.push(this.tablesMap.get(tableName).config.prepend
                 ? await File.prepend(path, content)
                 : await File.append(path, content))));
             await Promise.allSettled(renameList
                 .filter(([_, filePath]) => filePath)
                 .map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
-            if (this.tables[tableName].config.cache)
+            if (this.tablesMap.get(tableName).config.cache)
                 await this.clearCache(tableName);
-            this.totalItems[`${tableName}-*`] += Array.isArray(data)
-                ? data.length
-                : 1;
-            await rename(paginationFilePath, join(tablePath, `${lastId}-${this.totalItems[`${tableName}-*`]}.pagination`));
+            const currentValue = this.totalItems.get(`${tableName}-*`) || 0;
+            this.totalItems.set(`${tableName}-*`, currentValue + (Array.isArray(data) ? data.length : 1));
+            await rename(paginationFilePath, join(tablePath, `${lastId}-${this.totalItems.get(`${tableName}-*`)}.pagination`));
             if (returnPostedData)
-                return this.get(tableName, this.tables[tableName].config.prepend
+                return this.get(tableName, this.tablesMap.get(tableName).config.prepend
                     ? Array.isArray(data)
                         ? data.map((_, index) => index + 1).toReversed()
                         : 1
                     : Array.isArray(data)
                         ? data
-                            .map((_, index) => this.totalItems[`${tableName}-*`] - index)
+                            .map((_, index) => this.totalItems.get(`${tableName}-*`) - index)
                             .toReversed()
-                        : this.totalItems[`${tableName}-*`], options, !Utils.isArrayOfObjects(data));
+                        : this.totalItems.get(`${tableName}-*`), options, !Utils.isArrayOfObjects(data));
         }
         finally {
             if (renameList.length)
@@ -1194,23 +1233,20 @@ export default class Inibase {
     }, returnUpdatedData) {
         const renameList = [];
         const tablePath = join(this.databasePath, tableName);
-        const schema = (await this.throwErrorIfTableEmpty(tableName))
-            .schema;
+        await this.throwErrorIfTableEmpty(tableName);
         if (!where) {
             if (Utils.isArrayOfObjects(data)) {
                 if (!data.every((item) => Object.hasOwn(item, "id") && Utils.isValidID(item.id)))
-                    throw this.Error("INVALID_ID");
+                    throw this.createError("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);
+                    throw this.createError("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);
-            data = this.formatData(data, schema, true);
+            await this.validateData(tableName, data, true);
+            this.formatData(tableName, data, true);
             const pathesContents = this.joinPathesContents(tableName, {
                 ...(({ id, ...restOfData }) => restOfData)(data),
                 updatedAt: Date.now(),
@@ -1220,14 +1256,12 @@ export default class Inibase {
                 for await (const paginationFileName of glob("*.pagination", {
                     cwd: tablePath,
                 }))
-                    this.totalItems[`${tableName}-*`] = parse(paginationFileName)
-                        .name.split("-")
-                        .map(Number)[1];
-                await Promise.allSettled(Object.entries(pathesContents).map(async ([path, content]) => renameList.push(await File.replace(path, content, this.totalItems[`${tableName}-*`]))));
+                    this.totalItems.set(`${tableName}-*`, parse(paginationFileName).name.split("-").map(Number)[1]);
+                await Promise.allSettled(Object.entries(pathesContents).map(async ([path, content]) => renameList.push(await File.replace(path, content, this.totalItems.get(`${tableName}-*`)))));
                 await Promise.allSettled(renameList
                     .filter(([_, filePath]) => filePath)
                     .map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
-                if (this.tables[tableName].config.cache)
+                if (this.tablesMap.get(tableName).config.cache)
                     await this.clearCache(join(tablePath, ".cache"));
                 if (returnUpdatedData)
                     return await this.get(tableName, undefined, options);
@@ -1246,9 +1280,8 @@ export default class Inibase {
         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));
-            data = this.formatData(data, schema, true);
+            await this.validateData(tableName, data, true);
+            this.formatData(tableName, data, true);
             const pathesContents = Object.fromEntries(Object.entries(this.joinPathesContents(tableName, Utils.isArrayOfObjects(data)
                 ? data.map((item) => ({
                     ...item,
@@ -1269,7 +1302,7 @@ export default class Inibase {
                 await Promise.allSettled(renameList
                     .filter(([_, filePath]) => filePath)
                     .map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
-                if (this.tables[tableName].config.cache)
+                if (this.tablesMap.get(tableName).config.cache)
                     await this.clearCache(tableName);
                 if (returnUpdatedData)
                     return this.get(tableName, where, options, !Array.isArray(where));
@@ -1286,7 +1319,7 @@ export default class Inibase {
                 return this.put(tableName, data, lineNumbers, options, returnUpdatedData || undefined);
         }
         else
-            throw this.Error("INVALID_PARAMETERS");
+            throw this.createError("INVALID_PARAMETERS");
     }
     /**
      * Delete item(s) in a table
@@ -1314,7 +1347,7 @@ export default class Inibase {
                 await Promise.all((await readdir(tablePath))
                     ?.filter((fileName) => fileName.endsWith(this.getFileExtension(tableName)))
                     .map(async (file) => unlink(join(tablePath, file))));
-                if (this.tables[tableName].config.cache)
+                if (this.tablesMap.get(tableName).config.cache)
                     await this.clearCache(tableName);
                 await rename(paginationFilePath, join(tablePath, `${pagination[0]}-0.pagination`));
                 return true;
@@ -1357,7 +1390,7 @@ export default class Inibase {
                         await Promise.all((await readdir(tablePath))
                             ?.filter((fileName) => fileName.endsWith(this.getFileExtension(tableName)))
                             .map(async (file) => unlink(join(tablePath, file))));
-                    if (this.tables[tableName].config.cache)
+                    if (this.tablesMap.get(tableName).config.cache)
                         await this.clearCache(tableName);
                     await rename(paginationFilePath, join(tablePath, `${pagination[0]}-${pagination[1] - (Array.isArray(where) ? where.length : 1)}.pagination`));
                     return true;
@@ -1375,7 +1408,7 @@ export default class Inibase {
                 return this.delete(tableName, lineNumbers);
         }
         else
-            throw this.Error("INVALID_PARAMETERS");
+            throw this.createError("INVALID_PARAMETERS");
         return false;
     }
     async sum(tableName, columns, where) {

package/dist/utils.server.d.ts

@@ -1,6 +1,7 @@
 import { exec as execSync, execFile as execFileSync } from "node:child_process";
 import { gunzip as gunzipSync, gzip as gzipSync } from "node:zlib";
 import type { ComparisonOperator, Field, FieldType, Schema } from "./index.js";
+import RE2 from "re2";
 export declare const exec: typeof execSync.__promisify__;
 export declare const execFile: typeof execFileSync.__promisify__;
 export declare const gzip: typeof gzipSync.__promisify__;
@@ -83,3 +84,15 @@ export declare const isArrayEqual: (originalValue: string | number | boolean | n
  * @returns boolean - Result of the wildcard pattern matching.
  */
 export declare const isWildcardMatch: (originalValue: string | number | boolean | null | (string | number | boolean | null)[], comparedValue: string | number | boolean | null | (string | number | boolean | null)[]) => boolean;
+/**
+ * Retrieves a cached compiled regex or compiles and caches a new one.
+ *
+ * This function checks if a given regex pattern is already compiled and cached.
+ * If it is, the cached instance is returned. If not, the function attempts to compile
+ * the regex using RE2, caches the compiled instance, and then returns it. If the pattern
+ * is invalid, it returns a fallback object with a `test` method that always returns `false`.
+ *
+ * @param {string} pattern - The regex pattern to compile or retrieve from the cache.
+ * @returns {RE2} - The compiled regex instance or a fallback object on error.
+ */
+export declare const getCachedRegex: (pattern: string) => RE2;

package/dist/utils.server.js

@@ -3,6 +3,7 @@ import { createCipheriv, createDecipheriv, createHash, randomBytes, scryptSync,
 import { gunzip as gunzipSync, gzip as gzipSync } from "node:zlib";
 import { promisify } from "node:util";
 import { detectFieldType, isArrayOfObjects, isNumber, isPassword, isValidID, } from "./utils.js";
+import RE2 from "re2";
 export const exec = promisify(execSync);
 export const execFile = promisify(execFileSync);
 export const gzip = promisify(gzipSync);
@@ -247,3 +248,28 @@ export const isWildcardMatch = (originalValue, comparedValue) => {
     const wildcardPattern = `^${(comparedValueStr.includes("%") ? comparedValueStr : `%${comparedValueStr}%`).replace(/%/g, ".*")}$`;
     return new RegExp(wildcardPattern, "i").test(originalValueStr);
 };
+const regexCache = new Map();
+/**
+ * Retrieves a cached compiled regex or compiles and caches a new one.
+ *
+ * This function checks if a given regex pattern is already compiled and cached.
+ * If it is, the cached instance is returned. If not, the function attempts to compile
+ * the regex using RE2, caches the compiled instance, and then returns it. If the pattern
+ * is invalid, it returns a fallback object with a `test` method that always returns `false`.
+ *
+ * @param {string} pattern - The regex pattern to compile or retrieve from the cache.
+ * @returns {RE2} - The compiled regex instance or a fallback object on error.
+ */
+export const getCachedRegex = (pattern) => {
+    if (regexCache.has(pattern)) {
+        return regexCache.get(pattern);
+    }
+    try {
+        const compiledRegex = new RE2(pattern);
+        regexCache.set(pattern, compiledRegex);
+        return compiledRegex;
+    }
+    catch {
+        return { test: (_str) => false };
+    }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inibase",
-  "version": "1.0.0-rc.120",
+  "version": "1.0.0-rc.121",
   "type": "module",
   "author": {
     "name": "Karim Amahtil",
@@ -70,12 +70,13 @@
   "devDependencies": {
     "@types/bun": "^1.1.10",
     "@types/node": "^22.7.4",
-    "tinybench": "^2.6.0",
-    "typescript": "^5.6.2"
+    "tinybench": "^3.0.7",
+    "typescript": "^5.7.2"
   },
   "dependencies": {
     "dotenv": "^16.4.5",
-    "inison": "latest"
+    "inison": "latest",
+    "re2": "^1.21.4"
   },
   "scripts": {
     "prepublish": "npx tsc",