inibase 1.0.0-rc.85 → 1.0.0-rc.87

package/README.md

@@ -1,11 +1,11 @@
-[![Inibase banner](./.github/assets/banner.jpg)](https://github.com/inicontent/inibase)
-
 # Inibase :pencil:
 
-[![npmjs](https://img.shields.io/npm/dm/inibase.svg?style=flat)](https://www.npmjs.org/package/inibase) [![License](https://img.shields.io/github/license/inicontent/inibase.svg?style=flat&colorA=18181B&colorB=28CF8D)](./LICENSE) [![Activity](https://img.shields.io/github/commit-activity/m/inicontent/inibase)](https://github.com/inicontent/inibase/pulse) [![GitHub stars](https://img.shields.io/github/stars/inicontent/inibase?style=social)](https://github.com/inicontent/inibase)
-
 > A file-based & memory-efficient, serverless, ACID compliant, relational database management system :fire:
 
+[![Inibase banner](./.github/assets/banner.jpg)](https://github.com/inicontent/inibase)
+
+[![npmjs](https://img.shields.io/npm/dm/inibase.svg?style=flat)](https://www.npmjs.org/package/inibase) [![License](https://img.shields.io/github/license/inicontent/inibase.svg?style=flat&colorA=18181B&colorB=28CF8D)](./LICENSE) [![Activity](https://img.shields.io/github/commit-activity/m/inicontent/inibase)](https://github.com/inicontent/inibase/pulse) [![GitHub stars](https://img.shields.io/github/stars/inicontent/inibase?style=social)](https://github.com/inicontent/inibase)
+
 ## Features
 
 - **Lightweight** 🪶
@@ -13,7 +13,7 @@
 - **100% TypeScript** :large_blue_diamond:
 - **Super-Fast** :zap: (built-in caching system)
 - **ATOMIC** :lock: File lock for writing
-- **Built-in form-validation** included :sunglasses:
+- **Built-in** form validation (+unique values :new: ) :sunglasses:
 - **Suitable for large data** :page_with_curl: (tested with 4M records)
 - **Support Compression** :eight_spoked_asterisk: (using built-in nodejs zlib)
 - **Support Table Joins** :link:
@@ -42,6 +42,7 @@ const users = await db.get("user", undefined, {
 // Get items from "user" table where "favoriteFoods" does not includes "Pizza" or "Burger"
 const users = await db.get("user", { favoriteFoods: "![]Pizza,Burger" });
 ```
+
 > [!NOTE]
 > Enjoy using Inibase? Consider sponsoring us via [PayPal](https://paypal.me/KarimAmahtil) <br>
 > Your support helps us maintain and improve our services. <br>
@@ -50,12 +51,12 @@ const users = await db.get("user", { favoriteFoods: "![]Pizza,Burger" });
 ## Install
 
 ```js
-<npm|pnpm|yarn> install inibase
+<npm|pnpm|yarn|bun> install inibase
 ```
 
 ## How it works?
 
-`Inibase` organizes data into databases, tables, and columns, each stored in separate files. 
+`Inibase` organizes data into databases, tables, and columns, each stored in separate files.
 
 - **POST**: New data is appended to column files efficiently.
 - **GET**: Data retrieval is optimized by reading files line-by-line.
@@ -88,6 +89,7 @@ interface {
   prepend: boolean;
 }
 ```
+
 </blockquote>
 </details>
 
@@ -125,6 +127,7 @@ interface ObjectOrArrayOfObjects {
   children: Schema;
 }
 ```
+
 </blockquote>
 </details>
 
@@ -210,6 +213,7 @@ const userTableSchema = [
 
 await db.createTable("user", userTableSchema, userTableConfig);
 ```
+
 </blockquote>
 </details>
 
@@ -218,18 +222,17 @@ await db.createTable("user", userTableSchema, userTableConfig);
 <blockquote>
   
 <details>
-<summary>Add field</summary>
+<summary>Change Name</summary>
 <blockquote>
 
 ```js
 import Inibase from "inibase";
 const db = new Inibase("/databaseName");
 
-const userTableSchema = (await db.getTable("user")).schema;
-const newUserTableSchema = [...userTableSchema, {key: "phone2", type: "number", required: false}];
-
-await db.updateTable("user", newUserTableSchema);
+// this will change table name also in joined tables
+await db.updateTable("user", undefined, {name: "userV2"});
 ```
+
 </blockquote>
 </details>
 
@@ -247,6 +250,7 @@ const userTableSchema = (await db.getTable("user")).schema;
 setField("username", userTableSchema, {key: "fullName"});
 await db.updateTable("user", newUserTableSchema);
 ```
+
 </blockquote>
 </details>
 
@@ -264,6 +268,7 @@ const userTableSchema = (await db.getTable("user")).schema;
 unsetField("fullName", userTableSchema);
 await db.updateTable("user", newUserTableSchema);
 ```
+
 </blockquote>
 </details>
 
@@ -336,12 +341,17 @@ const product = await db.post("product", productTableData);
 //   }
 // ]
 ```
+
 </blockquote>
 </details>
 
 </blockquote>
 </details>
 
+<details>
+<summary>Methods</summary>
+<blockquote>
+
 <details>
 <summary>POST</summary>
 <blockquote>
@@ -467,6 +477,7 @@ const user = await db.get("user", "1d88385d4b1581f8fb059334dec30f4c");
 //     }
 // }
 ```
+
 </blockquote>
 </details>
 
@@ -510,6 +521,7 @@ const users = await db.get("user", { favoriteFoods: "[]Pizza" });
 //   ...
 // ]
 ```
+
 </blockquote>
 </details>
 
@@ -526,6 +538,7 @@ const users = await db.get("user", undefined, {
   columns: ["!username", "!address.street"],
 });
 ```
+
 </blockquote>
 </details>
 
@@ -549,6 +562,7 @@ await db.put("user", { isActive: false }, "1d88385d4b1581f8fb059334dec30f4c");
 // set "isActive" to "true" in table "user" by criteria (where "isActive" is equal to "true")
 await db.put("user", { isActive: false }, { isActive: true });
 ```
+
 </blockquote>
 </details>
 
@@ -569,6 +583,7 @@ await db.put("user", "1d88385d4b1581f8fb059334dec30f4c");
 // delete "user" by criteria (where "isActive" is equal to "false")
 await db.put("user", { isActive: false });
 ```
+
 </blockquote>
 </details>
 
@@ -586,6 +601,7 @@ await db.sum("user", "age");
 // get the sum of column "age" by criteria (where "isActive" is equal to "false") in "user" table
 await db.sum("user", ["age", ...], { isActive: false });
 ```
+
 </blockquote>
 </details>
 
@@ -603,6 +619,7 @@ await db.max("user", "age");
 // get the biggest number of column "age" by criteria (where "isActive" is equal to "false") in "user" table
 await db.max("user", ["age", ...], { isActive: false });
 ```
+
 </blockquote>
 </details>
 
@@ -620,6 +637,7 @@ await db.min("user", "age");
 // get the smallest number of column "age" by criteria (where "isActive" is equal to "false") in "user" table
 await db.min("user", ["age", ...], { isActive: false });
 ```
+
 </blockquote>
 </details>
 
@@ -638,6 +656,10 @@ await db.get("user", undefined, { sort: "age" });
 await db.get("user", undefined, { sort: ["age", "username"] });
 await db.get("user", undefined, { sort: {age: -1, username: "asc"} });
 ```
+
+</blockquote>
+</details>
+
 </blockquote>
 </details>
 
@@ -661,8 +683,8 @@ await db.get("user", undefined, { sort: {age: -1, username: "asc"} });
 | PUT    | 33 ms (10.29 mb)  | 312 ms (11.06 mb)  | 3539 ms (14.87 mb) |
 | DELETE | 134 ms (13.50 mb) | 1224 ms (16.57 mb) | 7339 ms (11.46 mb) |
 
-> Testing by default with `user` table, with username, email, password fields _so results include password encryption process_ <br>
-> To run benchmarks, install *typescript* & *[tsx](https://github.com/privatenumber/tsx)* globally and run `benchmark` `benchmark:bulk` `benchmark:single`
+> Default testing uses a table with username, email, and password fields, ensuring password encryption is included in the process<br>
+> To run benchmarks, install _typescript_ & _[tsx](https://github.com/privatenumber/tsx)_ globally and run `benchmark` by default bulk, for single use `benchmark --single|-s`
 
 ## Roadmap
 
@@ -678,7 +700,7 @@ await db.get("user", undefined, { sort: {age: -1, username: "asc"} });
   - [x] SUM
   - [x] MAX
   - [x] MIN
-- [ ] Schema supported types:
+- [x] Schema supported types:
   - [x] String
   - [x] Number
   - [x] Boolean
@@ -694,9 +716,10 @@ await db.get("user", undefined, { sort: {age: -1, username: "asc"} });
   - [x] Id
   - [x] JSON
 - [ ] TO-DO:
-  - [x] Improve caching
+  - [ ] Ability to search in JSON fields
+  - [ ] Re-check used exec functions
+  - [ ] Use smart caching (based on N° of queries)
   - [ ] Commenting the code
-  - [x] Add property "unique" for schema fields
   - [ ] Add Backup feature (generate a tar.gz)
   - [ ] Add Custom field validation property to schema (using RegEx?)
 - [ ] Features:
@@ -707,4 +730,4 @@ await db.get("user", undefined, { sort: {age: -1, username: "asc"} });
 
 ## License
 
-[MIT](./LICENSE)
+[MIT](./LICENSE)

package/dist/cli.js

@@ -6,7 +6,7 @@ import { createInterface } from "node:readline/promises";
 import { parseArgs } from "node:util";
 import Inison from "inison";
 import { isExists } from "./file.js";
-import Inibase from "./index.js";
+import Inibase, {} from "./index.js";
 import { isJSON, isNumber, setField, unsetField } from "./utils.js";
 const textGreen = (input) => `\u001b[1;32m${input}\u001b[0m`;
 const textRed = (input) => `\u001b[1;31m${input}\u001b[0m`;

package/dist/file.js

@@ -16,7 +16,7 @@ export const lock = async (folderPath, prefix) => {
     }
     catch ({ message }) {
         if (message.split(":")[0] === "EEXIST")
-            return await new Promise((resolve, reject) => setTimeout(() => resolve(lock(folderPath, prefix)), 13));
+            return await new Promise((resolve) => setTimeout(() => resolve(lock(folderPath, prefix)), 13));
     }
     finally {
         await lockFile?.close();
@@ -250,7 +250,7 @@ export const replace = async (filePath, replacements) => {
             fileTempHandle = await open(fileTempPath, "w");
             const rl = createReadLineInternface(filePath, fileHandle);
             await _pipeline(filePath, rl, fileTempHandle.createWriteStream(), new Transform({
-                transform(line, encoding, callback) {
+                transform(line, _, callback) {
                     linesCount++;
                     const replacement = isObject(replacements)
                         ? Object.hasOwn(replacements, linesCount)

package/dist/index.d.ts

@@ -41,15 +41,15 @@ export type Criteria = ({
 } & {
     [key: string]: string | number | boolean | undefined | Criteria;
 }) | null;
+type Entries<T> = {
+    [K in keyof T]: [K, T[K]];
+}[keyof T][];
 declare global {
-    type Entries<T> = {
-        [K in keyof T]: [K, T[K]];
-    }[keyof T][];
     interface ObjectConstructor {
         entries<T extends object>(o: T): Entries<T>;
     }
 }
-export type ErrorCodes = "FIELD_UNIQUE" | "FIELD_REQUIRED" | "NO_SCHEMA" | "NO_ITEMS" | "NO_RESULTS" | "INVALID_ID" | "INVALID_TYPE" | "INVALID_PARAMETERS" | "NO_ENV" | "TABLE_EXISTS" | "TABLE_NOT_EXISTS";
+export type ErrorCodes = "FIELD_UNIQUE" | "FIELD_REQUIRED" | "NO_SCHEMA" | "NO_ITEMS" | "INVALID_ID" | "INVALID_TYPE" | "INVALID_PARAMETERS" | "NO_ENV" | "TABLE_EXISTS" | "TABLE_NOT_EXISTS";
 export type ErrorLang = "en";
 export default class Inibase {
     pageInfo: Record<string, pageInfo>;
@@ -66,27 +66,31 @@ export default class Inibase {
     /**
      * Create a new table inside database, with predefined schema and config
      *
-     * @param {(string|number)} tableName
+     * @param {string} tableName
      * @param {Schema} [schema]
      * @param {Config} [config]
      */
-    createTable(tableName: string | number, schema?: Schema, config?: Config): Promise<void>;
+    createTable(tableName: string, schema?: Schema, config?: Config): Promise<void>;
+    private replaceStringInFile;
+    private replaceStringInSchemas;
     /**
      * Update table schema or config
      *
-     * @param {(string|number)} tableName
+     * @param {string} tableName
      * @param {Schema} [schema]
-     * @param {Config} [config]
+     * @param {(Config&{name?: string})} [config]
      */
-    updateTable(tableName: string | number, schema?: Schema, config?: Config): Promise<void>;
+    updateTable(tableName: string, schema?: Schema, config?: Config & {
+        name?: string;
+    }): Promise<void>;
     /**
      * Get table schema and config
      *
-     * @param {(string|number)} tableName
+     * @param {string} tableName
      * @return {*}  {Promise<TableObject>}
      */
-    getTable(tableName: string | number): Promise<TableObject>;
-    getTableSchema(tableName: string | number, encodeIDs?: boolean): Promise<Schema | undefined>;
+    getTable(tableName: string): Promise<TableObject>;
+    getTableSchema(tableName: string, encodeIDs?: boolean): Promise<Schema | undefined>;
     private throwErrorIfTableEmpty;
     private validateData;
     private formatField;
@@ -103,85 +107,86 @@ export default class Inibase {
     /**
      * Clear table cache
      *
-     * @param {(string|number)} tableName
+     * @param {string} tableName
      */
-    clearCache(tableName: string | number): Promise<void>;
+    clearCache(tableName: string): Promise<void>;
     /**
      * Retrieve item(s) from a table
      *
-     * @param {(string|number)} tableName
+     * @param {string} tableName
      * @param {(string | number | (string | number)[] | Criteria)} [where]
      * @param {Options} [options]
      * @param {boolean} [onlyOne]
      * @param {boolean} [onlyLinesNumbers]
      * @return {*}  {(Promise<Data | number | (Data | number)[] | null>)}
      */
-    get(tableName: string | number, where: string | number | (string | number)[] | Criteria | undefined, options: Options | undefined, onlyOne: true, onlyLinesNumbers?: false): Promise<Data | null>;
-    get(tableName: string | number, where: string | number, options?: Options, onlyOne?: boolean, onlyLinesNumbers?: false): Promise<Data | null>;
-    get(tableName: string | number, where?: string | number | (string | number)[] | Criteria, options?: Options, onlyOne?: boolean, onlyLinesNumbers?: false): Promise<Data[] | null>;
-    get(tableName: string | number, where: string | number | (string | number)[] | Criteria | undefined, options: Options | undefined, onlyOne: false | undefined, onlyLinesNumbers: true): Promise<number[] | null>;
-    get(tableName: string | number, where: string | number | (string | number)[] | Criteria | undefined, options: Options | undefined, onlyOne: true, onlyLinesNumbers: true): Promise<number | null>;
+    get(tableName: string, where: string | number | (string | number)[] | Criteria | undefined, options: Options | undefined, onlyOne: true, onlyLinesNumbers?: false): Promise<Data | null>;
+    get(tableName: string, where: string | number, options?: Options, onlyOne?: boolean, onlyLinesNumbers?: false): Promise<Data | null>;
+    get(tableName: string, where?: string | number | (string | number)[] | Criteria, options?: Options, onlyOne?: boolean, onlyLinesNumbers?: false): Promise<Data[] | null>;
+    get(tableName: string, where: string | number | (string | number)[] | Criteria | undefined, options: Options | undefined, onlyOne: false | undefined, onlyLinesNumbers: true): Promise<number[] | null>;
+    get(tableName: string, where: string | number | (string | number)[] | Criteria | undefined, options: Options | undefined, onlyOne: true, onlyLinesNumbers: true): Promise<number | null>;
     /**
      * Create new item(s) in a table
      *
-     * @param {(string|number)} tableName
+     * @param {string} tableName
      * @param {(Data | Data[])} data Can be array of objects or a single object
      * @param {Options} [options] Pagination options, useful when the returnPostedData param is true
      * @param {boolean} [returnPostedData] By default function returns void, if you want to get the posted data, set this param to true
      * @return {*}  {Promise<Data | Data[] | null | void>}
      */
-    post(tableName: string | number, data: Data | Data[], options?: Options, returnPostedData?: boolean): Promise<void>;
-    post(tableName: string | number, data: Data, options: Options | undefined, returnPostedData: true): Promise<Data | null>;
-    post(tableName: string | number, data: Data[], options: Options | undefined, returnPostedData: true): Promise<Data[] | null>;
+    post(tableName: string, data: Data | Data[], options?: Options, returnPostedData?: boolean): Promise<void>;
+    post(tableName: string, data: Data, options: Options | undefined, returnPostedData: true): Promise<Data | null>;
+    post(tableName: string, data: Data[], options: Options | undefined, returnPostedData: true): Promise<Data[] | null>;
     /**
      * Update item(s) in a table
      *
-     * @param {(string|number)} tableName
+     * @param {string} tableName
      * @param {(Data | Data[])} data
      * @param {(number | string | (number | string)[] | Criteria)} [where]
      * @param {Options} [options]
      * @param {false} [returnUpdatedData]
      * @return {*}  {Promise<Data | Data[] | null | undefined | void>}
      */
-    put(tableName: string | number, data: Data | Data[], where?: number | string | (number | string)[] | Criteria, options?: Options, returnUpdatedData?: false): Promise<void>;
-    put(tableName: string | number, data: Data, where: number | string | (number | string)[] | Criteria | undefined, options: Options | undefined, returnUpdatedData: true): Promise<Data | null>;
-    put(tableName: string | number, data: Data[], where: number | string | (number | string)[] | Criteria | undefined, options: Options | undefined, returnUpdatedData: true): Promise<Data[] | null>;
+    put(tableName: string, data: Data | Data[], where?: number | string | (number | string)[] | Criteria, options?: Options, returnUpdatedData?: false): Promise<void>;
+    put(tableName: string, data: Data, where: number | string | (number | string)[] | Criteria | undefined, options: Options | undefined, returnUpdatedData: true): Promise<Data | null>;
+    put(tableName: string, data: Data[], where: number | string | (number | string)[] | Criteria | undefined, options: Options | undefined, returnUpdatedData: true): Promise<Data[] | null>;
     /**
      * Delete item(s) in a table
      *
-     * @param {(string|number)} tableName
+     * @param {string} tableName
      * @param {(number | string | (number | string)[] | Criteria)} [where]
      * @return {boolean | null}  {(Promise<boolean | null>)}
      */
-    delete(tableName: string | number, where?: number | string | (number | string)[] | Criteria, _id?: string | string[]): Promise<boolean | null>;
+    delete(tableName: string, where?: number | string | (number | string)[] | Criteria, _id?: string | string[]): Promise<boolean | null>;
     /**
      * Generate sum of column(s) in a table
      *
-     * @param {(string|number)} tableName
+     * @param {string} tableName
      * @param {string} columns
      * @param {(number | string | (number | string)[] | Criteria)} [where]
      * @return {*}  {Promise<number | Record<string, number>>}
      */
-    sum(tableName: string | number, columns: string, where?: number | string | (number | string)[] | Criteria): Promise<number>;
-    sum(tableName: string | number, columns: string[], where?: number | string | (number | string)[] | Criteria): Promise<Record<string, number>>;
+    sum(tableName: string, columns: string, where?: number | string | (number | string)[] | Criteria): Promise<number>;
+    sum(tableName: string, columns: string[], where?: number | string | (number | string)[] | Criteria): Promise<Record<string, number>>;
     /**
      * Generate max of column(s) in a table
      *
-     * @param {(string|number)} tableName
+     * @param {string} tableName
      * @param {string} columns
      * @param {(number | string | (number | string)[] | Criteria)} [where]
      * @return {*}  {Promise<number>}
      */
-    max(tableName: string | number, columns: string, where?: number | string | (number | string)[] | Criteria): Promise<number>;
-    max(tableName: string | number, columns: string[], where?: number | string | (number | string)[] | Criteria): Promise<Record<string, number>>;
+    max(tableName: string, columns: string, where?: number | string | (number | string)[] | Criteria): Promise<number>;
+    max(tableName: string, columns: string[], where?: number | string | (number | string)[] | Criteria): Promise<Record<string, number>>;
     /**
      * Generate min of column(s) in a table
      *
-     * @param {(string|number)} tableName
+     * @param {string} tableName
      * @param {string} columns
      * @param {(number | string | (number | string)[] | Criteria)} [where]
      * @return {*}  {Promise<number>}
      */
-    min(tableName: string | number, columns: string, where?: number | string | (number | string)[] | Criteria): Promise<number>;
-    min(tableName: string | number, columns: string[], where?: number | string | (number | string)[] | Criteria): Promise<Record<string, number>>;
+    min(tableName: string, columns: string, where?: number | string | (number | string)[] | Criteria): Promise<number>;
+    min(tableName: string, columns: string[], where?: number | string | (number | string)[] | Criteria): Promise<Record<string, number>>;
 }
+export {};

package/dist/index.js

@@ -1,7 +1,7 @@
 import "dotenv/config";
 import { randomBytes, scryptSync } from "node:crypto";
 import { appendFileSync, existsSync, readFileSync } from "node:fs";
-import { mkdir, readFile, readdir, rename, unlink, writeFile, } from "node:fs/promises";
+import { mkdir, readFile, readdir, rename, stat, unlink, writeFile, } from "node:fs/promises";
 import { join, parse } from "node:path";
 import { inspect } from "node:util";
 import Inison from "inison";
@@ -41,7 +41,6 @@ export default class Inibase {
                 TABLE_NOT_EXISTS: "Table {variable} doesn't exist",
                 NO_SCHEMA: "Table {variable} does't have a schema",
                 NO_ITEMS: "Table {variable} is empty",
-                NO_RESULTS: "No results found for table {variable}",
                 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",
@@ -84,14 +83,14 @@ export default class Inibase {
     /**
      * Create a new table inside database, with predefined schema and config
      *
-     * @param {(string|number)} tableName
+     * @param {string} tableName
      * @param {Schema} [schema]
      * @param {Config} [config]
      */
     async createTable(tableName, schema, config) {
-        const tablePath = join(this.databasePath, tableName.toString());
+        const tablePath = join(this.databasePath, tableName);
         if (await File.isExists(tablePath))
-            throw this.throwError("TABLE_EXISTS", tableName.toString());
+            throw this.throwError("TABLE_EXISTS", tableName);
         await mkdir(join(tablePath, ".tmp"), { recursive: true });
         await mkdir(join(tablePath, ".cache"));
         // if config not set => load default global env config
@@ -112,20 +111,63 @@ export default class Inibase {
         if (schema)
             await writeFile(join(tablePath, "schema.json"), JSON.stringify(UtilsServer.addIdToSchema(schema, 0, this.salt), null, 2));
     }
+    // Function to replace the string in one schema.json file
+    async replaceStringInFile(filePath, targetString, replaceString) {
+        const data = await readFile(filePath, "utf8");
+        if (data.includes(targetString)) {
+            const updatedContent = data.replaceAll(targetString, replaceString);
+            await writeFile(filePath, updatedContent, "utf8");
+        }
+    }
+    // Function to process schema files one by one (sequentially)
+    async replaceStringInSchemas(directoryPath, targetString, replaceString) {
+        const files = await readdir(directoryPath);
+        for (const file of files) {
+            const fullPath = join(directoryPath, file);
+            const fileStat = await stat(fullPath);
+            if (fileStat.isDirectory()) {
+                await this.replaceStringInSchemas(fullPath, targetString, replaceString);
+            }
+            else if (file === "schema.json") {
+                await this.replaceStringInFile(fullPath, targetString, replaceString);
+            }
+        }
+    }
     /**
      * Update table schema or config
      *
-     * @param {(string|number)} tableName
+     * @param {string} tableName
      * @param {Schema} [schema]
-     * @param {Config} [config]
+     * @param {(Config&{name?: string})} [config]
      */
     async updateTable(tableName, schema, config) {
-        const table = await this.getTable(tableName), tablePath = join(this.databasePath, tableName.toString());
+        const table = await this.getTable(tableName), tablePath = join(this.databasePath, tableName);
+        if (schema) {
+            // remove id from schema
+            schema = schema.filter(({ key }) => !["id", "createdAt", "updatedAt"].includes(key));
+            if (await File.isExists(join(tablePath, "schema.json"))) {
+                // update columns files names based on field id
+                schema = UtilsServer.addIdToSchema(schema, table.schema?.length
+                    ? UtilsServer.findLastIdNumber(table.schema, this.salt)
+                    : 0, this.salt);
+                if (table.schema?.length) {
+                    const replaceOldPathes = Utils.findChangedProperties(this._schemaToIdsPath(tableName, table.schema), this._schemaToIdsPath(tableName, schema));
+                    if (replaceOldPathes)
+                        await Promise.all(Object.entries(replaceOldPathes).map(async ([oldPath, newPath]) => {
+                            if (await File.isExists(join(tablePath, oldPath)))
+                                await rename(join(tablePath, oldPath), join(tablePath, newPath));
+                        }));
+                }
+            }
+            else
+                schema = UtilsServer.addIdToSchema(schema, 0, this.salt);
+            await writeFile(join(tablePath, "schema.json"), JSON.stringify(schema, null, 2));
+        }
         if (config) {
             if (config.compression !== undefined &&
                 config.compression !== table.config.compression) {
                 await UtilsServer.execFile("find", [
-                    tableName.toString(),
+                    tableName,
                     "-type",
                     "f",
                     "-name",
@@ -150,7 +192,7 @@ export default class Inibase {
             if (config.prepend !== undefined &&
                 config.prepend !== table.config.prepend) {
                 await UtilsServer.execFile("find", [
-                    tableName.toString(),
+                    tableName,
                     "-type",
                     "f",
                     "-name",
@@ -170,40 +212,23 @@ export default class Inibase {
                 else
                     await unlink(join(tablePath, ".prepend.config"));
             }
-        }
-        if (schema) {
-            // remove id from schema
-            schema = schema.filter(({ key }) => !["id", "createdAt", "updatedAt"].includes(key));
-            if (await File.isExists(join(tablePath, "schema.json"))) {
-                // update columns files names based on field id
-                schema = UtilsServer.addIdToSchema(schema, table.schema?.length
-                    ? UtilsServer.findLastIdNumber(table.schema, this.salt)
-                    : 0, this.salt);
-                if (table.schema?.length) {
-                    const replaceOldPathes = Utils.findChangedProperties(this._schemaToIdsPath(tableName, table.schema), this._schemaToIdsPath(tableName, schema));
-                    if (replaceOldPathes)
-                        await Promise.all(Object.entries(replaceOldPathes).map(async ([oldPath, newPath]) => {
-                            if (await File.isExists(join(tablePath, oldPath)))
-                                await rename(join(tablePath, oldPath), join(tablePath, newPath));
-                        }));
-                }
+            if (config.name) {
+                await this.replaceStringInSchemas(this.databasePath, `"table": "${tableName}"`, `"table": "${config.name}"`);
+                await rename(tablePath, join(this.databasePath, config.name));
             }
-            else
-                schema = UtilsServer.addIdToSchema(schema, 0, this.salt);
-            await writeFile(join(tablePath, "schema.json"), JSON.stringify(schema, null, 2));
         }
         delete this.tables[tableName];
     }
     /**
      * Get table schema and config
      *
-     * @param {(string|number)} tableName
+     * @param {string} tableName
      * @return {*}  {Promise<TableObject>}
      */
     async getTable(tableName) {
-        const tablePath = join(this.databasePath, tableName.toString());
+        const tablePath = join(this.databasePath, tableName);
         if (!(await File.isExists(tablePath)))
-            throw this.throwError("TABLE_NOT_EXISTS", tableName.toString());
+            throw this.throwError("TABLE_NOT_EXISTS", tableName);
         if (!this.tables[tableName])
             this.tables[tableName] = {
                 schema: await this.getTableSchema(tableName),
@@ -216,7 +241,7 @@ export default class Inibase {
         return this.tables[tableName];
     }
     async getTableSchema(tableName, encodeIDs = true) {
-        const tableSchemaPath = join(this.databasePath, tableName.toString(), "schema.json");
+        const tableSchemaPath = join(this.databasePath, tableName, "schema.json");
         if (!(await File.isExists(tableSchemaPath)))
             return undefined;
         const schemaFile = await readFile(tableSchemaPath, "utf8");
@@ -252,9 +277,9 @@ export default class Inibase {
     async throwErrorIfTableEmpty(tableName) {
         const table = await this.getTable(tableName);
         if (!table.schema)
-            throw this.throwError("NO_SCHEMA", tableName.toString());
-        if (!(await File.isExists(join(this.databasePath, tableName.toString(), `id${this.getFileExtension(tableName)}`))))
-            throw this.throwError("NO_ITEMS", tableName.toString());
+            throw this.throwError("NO_SCHEMA", tableName);
+        if (!(await File.isExists(join(this.databasePath, tableName, `id${this.getFileExtension(tableName)}`))))
+            throw this.throwError("NO_ITEMS", tableName);
         return table;
     }
     validateData(data, schema, skipRequiredField = false) {
@@ -364,7 +389,7 @@ export default class Inibase {
         return null;
     }
     async checkUnique(tableName, schema) {
-        const tablePath = join(this.databasePath, tableName.toString());
+        const tablePath = join(this.databasePath, tableName);
         for await (const [key, values] of Object.entries(this.checkIFunique)) {
             const field = Utils.getField(key, schema);
             if (!field)
@@ -456,7 +481,7 @@ export default class Inibase {
         return RETURN;
     };
     joinPathesContents(tableName, data) {
-        const tablePath = join(this.databasePath, tableName.toString()), combinedData = this._CombineData(data);
+        const tablePath = join(this.databasePath, tableName), combinedData = this._CombineData(data);
         const newCombinedData = {};
         for (const [key, value] of Object.entries(combinedData))
             newCombinedData[join(tablePath, `${key}${this.getFileExtension(tableName)}`)] = value;
@@ -504,7 +529,7 @@ export default class Inibase {
         }
     }
     async getItemsFromSchema(tableName, schema, linesNumber, options, prefix) {
-        const tablePath = join(this.databasePath, tableName.toString());
+        const tablePath = join(this.databasePath, tableName);
         const RETURN = {};
         for await (const field of schema) {
             if ((field.type === "array" ||
@@ -655,7 +680,7 @@ export default class Inibase {
         return RETURN;
     }
     async applyCriteria(tableName, schema, options, criteria, allTrue) {
-        const tablePath = join(this.databasePath, tableName.toString());
+        const tablePath = join(this.databasePath, tableName);
         let RETURN = {}, RETURN_LineNumbers = null;
         if (!criteria)
             return [null, null];
@@ -785,10 +810,10 @@ export default class Inibase {
     /**
      * Clear table cache
      *
-     * @param {(string|number)} tableName
+     * @param {string} tableName
      */
     async clearCache(tableName) {
-        const cacheFolderPath = join(this.databasePath, tableName.toString(), ".cache");
+        const cacheFolderPath = join(this.databasePath, tableName, ".cache");
         await Promise.all((await readdir(cacheFolderPath))
             .filter((file) => file !== ".pagination")
             .map((file) => unlink(join(cacheFolderPath, file))));
@@ -797,7 +822,7 @@ export default class Inibase {
         page: 1,
         perPage: 15,
     }, onlyOne, onlyLinesNumbers) {
-        const tablePath = join(this.databasePath, tableName.toString());
+        const tablePath = join(this.databasePath, tableName);
         // Ensure options.columns is an array
         if (options.columns) {
             options.columns = Array.isArray(options.columns)
@@ -812,7 +837,7 @@ export default class Inibase {
         let RETURN;
         let schema = (await this.getTable(tableName)).schema;
         if (!schema)
-            throw this.throwError("NO_SCHEMA", tableName.toString());
+            throw this.throwError("NO_SCHEMA", tableName);
         if (!(await File.isExists(join(tablePath, `id${this.getFileExtension(tableName)}`))))
             return null;
         if (options.columns?.length)
@@ -841,7 +866,7 @@ export default class Inibase {
             if (where) {
                 const lineNumbers = await this.get(tableName, where, undefined, undefined, true);
                 if (!lineNumbers?.length)
-                    throw this.throwError("NO_RESULTS", tableName.toString());
+                    return null;
                 const itemsIDs = Object.values((await File.get(join(tablePath, `id${this.getFileExtension(tableName)}`), lineNumbers, "number", undefined, this.salt)) ?? {}).map(Number);
                 awkCommand = `awk '${itemsIDs.map((id) => `$1 == ${id}`).join(" || ")}'`;
             }
@@ -952,7 +977,7 @@ export default class Inibase {
                 Ids = [Ids];
             const [lineNumbers, countItems] = await File.search(join(tablePath, `id${this.getFileExtension(tableName)}`), "[]", Ids.map((id) => Utils.isNumber(id) ? Number(id) : UtilsServer.decodeID(id, this.salt)), undefined, "number", undefined, Ids.length, 0, !this.totalItems[`${tableName}-*`], this.salt);
             if (!lineNumbers)
-                throw this.throwError("NO_RESULTS", tableName.toString());
+                return null;
             if (!this.totalItems[`${tableName}-*`])
                 this.totalItems[`${tableName}-*`] = countItems;
             if (onlyLinesNumbers)
@@ -1024,9 +1049,9 @@ export default class Inibase {
                 page: 1,
                 perPage: 15,
             };
-        const tablePath = join(this.databasePath, tableName.toString()), schema = (await this.getTable(tableName)).schema;
+        const tablePath = join(this.databasePath, tableName), schema = (await this.getTable(tableName)).schema;
         if (!schema)
-            throw this.throwError("NO_SCHEMA", tableName.toString());
+            throw this.throwError("NO_SCHEMA", tableName);
         if (!returnPostedData)
             returnPostedData = false;
         let RETURN;
@@ -1098,7 +1123,7 @@ export default class Inibase {
         perPage: 15,
     }, returnUpdatedData) {
         let renameList = [];
-        const tablePath = join(this.databasePath, tableName.toString()), schema = (await this.throwErrorIfTableEmpty(tableName)).schema;
+        const tablePath = join(this.databasePath, tableName), schema = (await this.throwErrorIfTableEmpty(tableName)).schema;
         this.validateData(data, schema, true);
         await this.checkUnique(tableName, schema);
         data = this.formatData(data, schema, true);
@@ -1197,13 +1222,13 @@ export default class Inibase {
     /**
      * Delete item(s) in a table
      *
-     * @param {(string|number)} tableName
+     * @param {string} tableName
      * @param {(number | string | (number | string)[] | Criteria)} [where]
      * @return {boolean | null}  {(Promise<boolean | null>)}
      */
     async delete(tableName, where, _id) {
         const renameList = [];
-        const tablePath = join(this.databasePath, tableName.toString());
+        const tablePath = join(this.databasePath, tableName);
         await this.throwErrorIfTableEmpty(tableName);
         if (!where) {
             try {
@@ -1260,7 +1285,7 @@ export default class Inibase {
     }
     async sum(tableName, columns, where) {
         const RETURN = {};
-        const tablePath = join(this.databasePath, tableName.toString());
+        const tablePath = join(this.databasePath, tableName);
         await this.throwErrorIfTableEmpty(tableName);
         if (!Array.isArray(columns))
             columns = [columns];
@@ -1281,7 +1306,7 @@ export default class Inibase {
     }
     async max(tableName, columns, where) {
         const RETURN = {};
-        const tablePath = join(this.databasePath, tableName.toString());
+        const tablePath = join(this.databasePath, tableName);
         await this.throwErrorIfTableEmpty(tableName);
         if (!Array.isArray(columns))
             columns = [columns];
@@ -1302,7 +1327,7 @@ export default class Inibase {
     }
     async min(tableName, columns, where) {
         const RETURN = {};
-        const tablePath = join(this.databasePath, tableName.toString());
+        const tablePath = join(this.databasePath, tableName);
         await this.throwErrorIfTableEmpty(tableName);
         if (!Array.isArray(columns))
             columns = [columns];

package/dist/utils.d.ts

@@ -179,7 +179,7 @@ export declare function FormatObjectCriteriaValue(value: string): [
  * @param {string} keyPath Support dot notation path
  * @param {Schema} schema
  */
-export declare function getField(keyPath: string, schema: Schema): Field | null;
+export declare function getField(keyPath: string, schema: Schema): Field;
 /**
  * Override a schema field, key, type or other properties
  *
@@ -194,7 +194,7 @@ export declare function getField(keyPath: string, schema: Schema): Field | null;
 export declare function setField(keyPath: string, schema: Schema, field: Omit<Field, "key" | "type"> & {
     key?: string;
     type?: FieldType | FieldType[];
-}): Field | null | undefined;
+}): Field;
 /**
  * Remove field from schema
  *
@@ -202,4 +202,4 @@ export declare function setField(keyPath: string, schema: Schema, field: Omit<Fi
  * @param {string} keyPath Support dot notation path
  * @param {Schema} schema
  */
-export declare function unsetField(keyPath: string, schema: Schema): Field | null | undefined;
+export declare function unsetField(keyPath: string, schema: Schema): Field;

package/dist/utils.server.d.ts

@@ -55,7 +55,7 @@ export declare const hashString: (str: string) => string;
  *
  * Note: Handles various data types and comparison logic, including special handling for passwords and regex patterns.
  */
-export declare const compare: (operator: ComparisonOperator, originalValue: string | number | boolean | null | (string | number | boolean | null)[], comparedValue: string | number | boolean | null | (string | number | boolean | null)[], fieldType?: FieldType | FieldType[], fieldChildrenType?: FieldType | FieldType[]) => Promise<boolean>;
+export declare const compare: (operator: ComparisonOperator, originalValue: string | number | boolean | null | (string | number | boolean | null)[], comparedValue: string | number | boolean | null | (string | number | boolean | null)[], fieldType?: FieldType | FieldType[]) => boolean;
 /**
  * Helper function to check equality based on the field type.
  *

package/dist/utils.server.js

@@ -141,15 +141,13 @@ export const hashString = (str) => createHash("sha256").update(str).digest("hex"
  *
  * Note: Handles various data types and comparison logic, including special handling for passwords and regex patterns.
  */
-export const compare = async (operator, originalValue, comparedValue, fieldType, fieldChildrenType) => {
+export const compare = (operator, originalValue, comparedValue, fieldType) => {
     // Determine the field type if it's an array of potential types.
-    if (Array.isArray(fieldType)) {
+    if (Array.isArray(fieldType))
         fieldType = detectFieldType(String(originalValue), fieldType);
-    }
     // Handle comparisons involving arrays.
-    if (Array.isArray(comparedValue) && !["[]", "![]"].includes(operator)) {
+    if (Array.isArray(comparedValue) && !["[]", "![]"].includes(operator))
         return comparedValue.some((value) => compare(operator, originalValue, value, fieldType));
-    }
     // Switch statement for different comparison operators.
     switch (operator) {
         // Equal (Case Insensitive for strings, specific handling for passwords and booleans).
@@ -223,16 +221,13 @@ export const isEqual = (originalValue, comparedValue, fieldType) => {
  * @returns boolean - Result of the array equality check.
  */
 export const isArrayEqual = (originalValue, comparedValue) => {
-    if (Array.isArray(originalValue) && Array.isArray(comparedValue)) {
+    if (Array.isArray(originalValue) && Array.isArray(comparedValue))
         return originalValue.some((v) => comparedValue.includes(v));
-    }
-    if (Array.isArray(originalValue)) {
+    if (Array.isArray(originalValue))
         return originalValue.includes(comparedValue);
-    }
-    if (Array.isArray(comparedValue)) {
+    if (Array.isArray(comparedValue))
         return comparedValue.includes(originalValue);
-    }
-    return originalValue === comparedValue;
+    return originalValue == comparedValue;
 };
 /**
  * Helper function to check wildcard pattern matching using regex.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inibase",
-  "version": "1.0.0-rc.85",
+  "version": "1.0.0-rc.87",
   "type": "module",
   "author": {
     "name": "Karim Amahtil",