inibase 1.0.0-rc.57 → 1.0.0-rc.58

package/README.md

@@ -14,7 +14,7 @@
 - **Super-Fast** :zap: (built-in caching system)
 - **ATOMIC** :lock: File lock for writing
 - **Built-in form-validation** included :sunglasses:
-- **Suitable for large data** :page_with_curl: (tested with 200K row)
+- **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:
 - **Low memory-usage** :chart_with_downwards_trend: (3-5mb)
@@ -55,6 +55,21 @@ If you like Inibase, please sponsor: [GitHub Sponsors](https://github.com/sponso
 
 To simplify the idea, each database has tables, each table has columns, each column will be stored in a seperated file. When **POST**ing new data, it will be appended to the _head_ of each file as new line. When **GET**ing data, the file will be readed line-by-line so it can handle large data (without consuming a lot of resources), when **PUT**ing(updating) in a specific column, only one file will be opened and updated
 
+## Config (.env)
+
+The `.env` file supports the following parameters (make sure to run commands with flag --env-file=.env)
+
+```ini
+# Auto generated secret key, will be using for encrypting the IDs
+INIBASE_SECRET=
+
+INIBASE_COMPRESSION=true
+INIBASE_CACHE=true
+
+# Prepend new items to the beginning of file 
+INIBASE_REVERSE=true
+```
+
 ## Benchmark
 
 ### Bulk
@@ -77,22 +92,6 @@ To simplify the idea, each database has tables, each table has columns, each col
 
 Ps: Testing by default with `user` table, with username, email, password fields _so results include password encryption process_
 
-
-## Config (.env)
-
-The `.env` file supports the following parameters (make sure to run commands with flag --env-file=.env)
-
-```ini
-# Auto generated secret key, will be using for encrypting the IDs
-INIBASE_SECRET=
-
-INIBASE_COMPRESSION=true
-INIBASE_CACHE=true
-
-# Prepend new items to the beginning of file 
-INIBASE_REVERSE=true
-```
-
 ## Roadmap
 
 - [x] Actions:
@@ -100,7 +99,7 @@ INIBASE_REVERSE=true
     - [x] Pagination
     - [x] Criteria
     - [x] Columns
-    - [x] Order By (using UNIX commands)
+    - [x] Sort (using UNIX commands)
   - [x] POST
   - [x] PUT
   - [x] DELETE
@@ -512,6 +511,23 @@ await db.min("user", ["age", ...], { isActive: false });
 
 </details>
 
+<details>
+<summary>SORT</summary>
+
+```js
+import Inibase from "inibase";
+const db = new Inibase("/databaseName");
+
+// order users by the age column
+await db.sort("user", "age");
+
+// order users by the age and username columns
+await db.sort("user", ["age","username"]);
+await db.sort("user", {age: -1, username: "asc"});
+```
+
+</details>
+
 ## License
 
 [MIT](./LICENSE)

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "dotenv/config";

package/dist/cli.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+import "dotenv/config";
+import { createInterface } from "node:readline/promises";
+import { parseArgs } from "node:util";
+import Inibase from "./index.js";
+import { basename } from "node:path";
+import { isJSON, isNumber } from "./utils.js";
+import Inison from "inison";
+const { path } = parseArgs({
+    options: {
+        path: { type: "string", short: "p" },
+    },
+}).values;
+if (!path)
+    throw new Error("Please specify database folder path --path <databasePath> or -p <databasePath>");
+const db = new Inibase(basename(path));
+const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+});
+rl.prompt();
+rl.on("line", async (input) => {
+    const trimedInput = input.trim();
+    if (trimedInput === "clear") {
+        console.clear();
+        rl.prompt();
+    }
+    if (trimedInput === "info") {
+        console.warn("war");
+        console.error("err");
+    }
+    const splitedInput = trimedInput.match(/[^\s"']+|"([^"]*)"|'([^']*)'/g);
+    if (["get", "post", "delete", "put"].includes(splitedInput[0].toLocaleLowerCase())) {
+        const table = splitedInput[1];
+        if (!table)
+            throw new Error("Please specify table name");
+        let { where, page, perPage, columns, data, returnData } = parseArgs({
+            args: splitedInput.toSpliced(0, 2),
+            options: {
+                where: { type: "string", short: "w" },
+                page: { type: "string", short: "p" },
+                perPage: { type: "string", short: "l" },
+                columns: { type: "string", short: "c", multiple: true },
+                data: { type: "string", short: "d" },
+                returnData: { type: "boolean", short: "r" },
+            },
+        }).values;
+        if (where) {
+            if (isNumber(where))
+                where = Number(where);
+            else if (isJSON(where))
+                where = Inison.unstringify(where);
+        }
+        if (data) {
+            if (isJSON(data))
+                where = Inison.unstringify(data);
+            else
+                data = undefined;
+        }
+        switch (splitedInput[0].toLocaleLowerCase()) {
+            case "get":
+                console.log(await db.get(table, where, {
+                    page: Number(page) ?? 1,
+                    perPage: Number(perPage) ?? 15,
+                    columns,
+                }));
+                break;
+            case "post":
+                {
+                    const postReturn = await db.post(table, data, {
+                        page: Number(page) ?? 1,
+                        perPage: Number(perPage) ?? 15,
+                        columns,
+                    }, returnData);
+                    console.log(postReturn !== null && typeof postReturn === "object"
+                        ? "Item(s) Posted Successfully"
+                        : postReturn);
+                }
+                break;
+            case "put": {
+                const putReturn = await db.put(table, data, where, {
+                    page: Number(page) ?? 1,
+                    perPage: Number(perPage) ?? 15,
+                    columns,
+                }, returnData);
+                console.log(putReturn !== null && typeof putReturn === "object"
+                    ? "Item(s) Updated Successfully"
+                    : putReturn);
+                break;
+            }
+            case "delete":
+                console.log(await db.delete(table, where));
+                break;
+            default:
+                break;
+        }
+    }
+});

package/dist/file.js

@@ -1,11 +1,11 @@
-import { open, access, writeFile, readFile, constants as fsConstants, unlink, copyFile, appendFile, } from "node:fs/promises";
+import { open, access, writeFile, readFile, constants as fsConstants, unlink, copyFile, appendFile, mkdir, } from "node:fs/promises";
 import { createInterface } from "node:readline";
 import { Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { createGzip, createGunzip, gunzipSync, gzipSync } from "node:zlib";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import { detectFieldType, isArrayOfObjects, isJSON, isNumber, isObject, } from "./utils.js";
-import { encodeID, compare } from "./utils.server.js";
+import { encodeID, compare, exec } from "./utils.server.js";
 import * as Config from "./config.js";
 import Inison from "inison";
 export const lock = async (folderPath, prefix) => {
@@ -30,6 +30,7 @@ export const unlock = async (folderPath, prefix) => {
     catch { }
 };
 export const write = async (filePath, data, disableCompression = false) => {
+    await mkdir(dirname(filePath), { recursive: true });
     await writeFile(filePath, Config.isCompressionEnabled && !disableCompression
         ? gzipSync(String(data))
         : String(data));
@@ -203,18 +204,28 @@ export async function get(filePath, lineNumbers, fieldType, fieldChildrenType, s
                 lines[linesCount] = decode(lastLine, fieldType, fieldChildrenType, secretKey);
         }
         else {
-            const lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
-            for await (const line of rl) {
-                linesCount++;
-                if (!lineNumbersArray.has(linesCount))
-                    continue;
-                lines[linesCount] = decode(line, fieldType, fieldChildrenType, secretKey);
-                lineNumbersArray.delete(linesCount);
-                if (!lineNumbersArray.size && !readWholeFile)
-                    break;
+            lineNumbers = Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers];
+            if (readWholeFile) {
+                const lineNumbersArray = new Set(lineNumbers);
+                for await (const line of rl) {
+                    linesCount++;
+                    if (!lineNumbersArray.has(linesCount))
+                        continue;
+                    lines[linesCount] = decode(line, fieldType, fieldChildrenType, secretKey);
+                    lineNumbersArray.delete(linesCount);
+                }
+                return [lines, linesCount];
+            }
+            const command = Config.isCompressionEnabled
+                ? `zcat ${filePath} | sed -n '${lineNumbers.join("p;")}p'`
+                : `sed -n '${lineNumbers.join("p;")}p' ${filePath}`, foundedLines = (await exec(command)).stdout.trim().split(/\r?\n/);
+            let index = 0;
+            for (const line of foundedLines) {
+                lines[lineNumbers[index]] = decode(line, fieldType, fieldChildrenType, secretKey);
+                index++;
             }
         }
-        return readWholeFile ? [lines, linesCount] : lines;
+        return lines;
     }
     finally {
         // Ensure that file handles are closed, even if an error occurred
@@ -334,32 +345,41 @@ export const append = async (filePath, data) => {
  * Note: Creates a temporary file during the process and replaces the original file with it after removing lines.
  */
 export const remove = async (filePath, linesToDelete) => {
-    let linesCount = 0;
-    let deletedCount = 0;
-    const fileHandle = await open(filePath, "r");
-    const fileTempPath = filePath.replace(/([^/]+)\/?$/, ".tmp/$1");
-    const fileTempHandle = await open(fileTempPath, "w");
-    const linesToDeleteArray = new Set(Array.isArray(linesToDelete)
+    linesToDelete = Array.isArray(linesToDelete)
         ? linesToDelete.map(Number)
-        : [Number(linesToDelete)]);
-    const rl = readLineInternface(fileHandle);
-    await _pipeline(rl, fileTempHandle.createWriteStream(), new Transform({
-        transform(line, encoding, callback) {
-            linesCount++;
-            if (linesToDeleteArray.has(linesCount)) {
-                deletedCount++;
+        : [Number(linesToDelete)];
+    const fileTempPath = filePath.replace(/([^/]+)\/?$/, ".tmp/$1");
+    if (linesToDelete.length < 1000) {
+        const command = Config.isCompressionEnabled
+            ? `zcat ${filePath} | sed "${linesToDelete.join("d;")}d" | gzip > ${fileTempPath}`
+            : `sed "${linesToDelete.join("d;")}d" ${filePath} > ${fileTempPath}`;
+        await exec(command);
+    }
+    else {
+        let linesCount = 0;
+        let deletedCount = 0;
+        const fileHandle = await open(filePath, "r");
+        const fileTempHandle = await open(fileTempPath, "w");
+        const linesToDeleteArray = new Set(linesToDelete);
+        const rl = readLineInternface(fileHandle);
+        await _pipeline(rl, fileTempHandle.createWriteStream(), new Transform({
+            transform(line, _, callback) {
+                linesCount++;
+                if (linesToDeleteArray.has(linesCount)) {
+                    deletedCount++;
+                    return callback();
+                }
+                return callback(null, `${line}\n`);
+            },
+            final(callback) {
+                if (deletedCount === linesCount)
+                    this.push("\n");
                 return callback();
-            }
-            return callback(null, `${line}\n`);
-        },
-        final(callback) {
-            if (deletedCount === linesCount)
-                this.push("\n");
-            return callback();
-        },
-    }));
-    await fileTempHandle.close();
-    await fileHandle.close();
+            },
+        }));
+        await fileTempHandle.close();
+        await fileHandle.close();
+    }
     return [fileTempPath, filePath];
 };
 /**
@@ -447,7 +467,7 @@ export const search = async (filePath, operator, comparedAtValue, logicalOperato
  * Note: Reads through the file line by line to count the total number of lines.
  */
 export const count = async (filePath) => {
-    // return Number((await exec(`wc -l < ${filePath}`)).stdout.trim());
+    // Number((await exec(`wc -l < ${filePath}`)).stdout.trim());
     let linesCount = 0;
     if (await isExists(filePath)) {
         let fileHandle = null;

package/dist/index.d.ts

@@ -47,12 +47,13 @@ export default class Inibase {
     database: string;
     table: string | null;
     pageInfo: Record<string, pageInfo>;
+    private fileExtension;
     private checkIFunique;
-    private isThreadEnabled;
     private totalItems;
     salt: Buffer;
     constructor(database: string, mainFolder?: string, _table?: string | null, _totalItems?: Record<string, number>, _pageInfo?: Record<string, pageInfo>, _isThreadEnabled?: boolean);
     private throwError;
+    private getFileExtension;
     private _schemaToIdsPath;
     setTableSchema(tableName: string, schema: Schema): Promise<void>;
     getTableSchema(tableName: string, encodeIDs?: boolean): Promise<Schema | undefined>;
@@ -81,6 +82,8 @@ export default class Inibase {
     put(tableName: string, data: Data[], where: number | string | (number | string)[] | Criteria | undefined, options: Options | undefined, returnUpdatedData: true): Promise<Data[] | null>;
     delete(tableName: string, where?: number | string, _id?: string | string[]): Promise<string | null>;
     delete(tableName: string, where?: (number | string)[] | Criteria, _id?: string | string[]): Promise<string[] | null>;
+    delete(tableName: string, where?: number, _id?: string | string[]): Promise<number | null>;
+    delete(tableName: string, where?: number[], _id?: string | string[]): Promise<number[] | null>;
     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>>;
     max(tableName: string, columns: string, where?: number | string | (number | string)[] | Criteria): Promise<number>;

package/dist/index.js

@@ -13,8 +13,8 @@ export default class Inibase {
     database;
     table;
     pageInfo;
+    fileExtension = ".txt";
     checkIFunique;
-    isThreadEnabled = false;
     totalItems;
     salt;
     constructor(database, mainFolder = ".", _table = null, _totalItems = {}, _pageInfo = {}, _isThreadEnabled = false) {
@@ -23,7 +23,6 @@ export default class Inibase {
         this.table = _table;
         this.totalItems = _totalItems;
         this.pageInfo = _pageInfo;
-        this.isThreadEnabled = _isThreadEnabled;
         this.checkIFunique = {};
         if (!process.env.INIBASE_SECRET) {
             if (existsSync(".env") &&
@@ -34,6 +33,19 @@ export default class Inibase {
         }
         else
             this.salt = Buffer.from(process.env.INIBASE_SECRET, "hex");
+        // try {
+        // 	if (Config.isCompressionEnabled)
+        // 		execSync(
+        // 			`gzip -r ${join(this.folder, this.database)}/*/*.txt 2>/dev/null`,
+        // 		);
+        // 	else
+        // 		execSync(
+        // 			`gunzip -r ${join(
+        // 				this.folder,
+        // 				this.database,
+        // 			)}/*/*.txt.gz 2>/dev/null`,
+        // 		);
+        // } catch {}
     }
     throwError(code, variable, language = "en") {
         const errorMessages = {
@@ -61,6 +73,15 @@ export default class Inibase {
                 : errorMessage.replaceAll("{variable}", `'${variable.toString()}'`)
             : errorMessage.replaceAll("{variable}", ""));
     }
+    getFileExtension = () => {
+        let mainExtension = this.fileExtension;
+        // TODO: ADD ENCRYPTION
+        // if(Config.isEncryptionEnabled)
+        // 	mainExtension += ".enc"
+        if (Config.isCompressionEnabled)
+            mainExtension += ".gz";
+        return mainExtension;
+    };
     _schemaToIdsPath = (schema, prefix = "") => {
         const RETURN = {};
         for (const field of schema)
@@ -70,7 +91,7 @@ export default class Inibase {
                 Utils.deepMerge(RETURN, this._schemaToIdsPath(field.children, `${(prefix ?? "") + field.key}.`));
             }
             else if (field.id)
-                RETURN[field.id] = `${(prefix ?? "") + field.key}.inib`;
+                RETURN[field.id] = `${(prefix ?? "") + field.key}${this.getFileExtension()}`;
         return RETURN;
     };
     async setTableSchema(tableName, schema) {
@@ -140,7 +161,7 @@ export default class Inibase {
             schema = await this.getTableSchema(tableName);
         if (!schema)
             throw this.throwError("NO_SCHEMA", tableName);
-        if (!(await File.isExists(join(tablePath, "id.inib"))))
+        if (!(await File.isExists(join(tablePath, `id${this.getFileExtension()}`))))
             throw this.throwError("NO_ITEMS", tableName);
         return schema;
     }
@@ -268,7 +289,7 @@ export default class Inibase {
             const field = Utils.getField(key, schema);
             if (!field)
                 continue;
-            const [searchResult, totalLines] = await File.search(join(tablePath, `${key}.inib`), Array.isArray(values) ? "=" : "[]", values, undefined, field.type, field.children, 1, undefined, false, this.salt);
+            const [searchResult, totalLines] = await File.search(join(tablePath, `${key}${this.getFileExtension()}`), Array.isArray(values) ? "=" : "[]", values, undefined, field.type, field.children, 1, undefined, false, this.salt);
             if (searchResult && totalLines > 0)
                 throw this.throwError("FIELD_UNIQUE", [
                     field.key,
@@ -357,7 +378,7 @@ export default class Inibase {
     _addPathToKeys = (obj, path) => {
         const newObject = {};
         for (const key in obj)
-            newObject[join(path, `${key}.inib`)] = obj[key];
+            newObject[join(path, `${key}${this.getFileExtension()}`)] = obj[key];
         return newObject;
     };
     joinPathesContents(mainPath, data) {
@@ -407,7 +428,7 @@ export default class Inibase {
     async getItemsFromSchema(tableName, schema, linesNumber, options, prefix) {
         const tablePath = join(this.folder, this.database, tableName);
         let RETURN = {};
-        await Promise.all(schema.map(async (field) => {
+        for await (const field of schema) {
             if ((field.type === "array" ||
                 (Array.isArray(field.type) && field.type.includes("array"))) &&
                 field.children) {
@@ -415,82 +436,86 @@ export default class Inibase {
                     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
-                        for (const [index, item] of Object.entries((await this.getItemsFromSchema(tableName, field.children.filter((children) => children.type === "array" &&
-                            Utils.isArrayOfObjects(children.children)), linesNumber, options, `${(prefix ?? "") + field.key}.`)) ?? {}))
-                            this._getItemsFromSchemaHelper(RETURN, item, index, field);
+                        const childItems = await this.getItemsFromSchema(tableName, field.children.filter((children) => children.type === "array" &&
+                            Utils.isArrayOfObjects(children.children)), linesNumber, options, `${(prefix ?? "") + field.key}.`);
+                        if (childItems)
+                            for (const [index, item] of Object.entries(childItems))
+                                this._getItemsFromSchemaHelper(RETURN, item, index, field);
                         field.children = field.children.filter((children) => children.type !== "array" ||
                             !Utils.isArrayOfObjects(children.children));
                     }
-                    for (const [index, item] of Object.entries((await this.getItemsFromSchema(tableName, field.children, linesNumber, options, `${(prefix ?? "") + field.key}.`)) ?? {})) {
-                        if (!RETURN[index])
-                            RETURN[index] = {};
-                        if (Utils.isObject(item)) {
-                            if (!Utils.isArrayOfNulls(Object.values(item))) {
-                                if (RETURN[index][field.key])
-                                    Object.entries(item).forEach(([key, value], _index) => {
-                                        for (let _index = 0; _index < value.length; _index++)
-                                            if (RETURN[index][field.key][_index])
-                                                Object.assign(RETURN[index][field.key][_index], {
-                                                    [key]: value[_index],
-                                                });
-                                            else
-                                                RETURN[index][field.key][_index] = {
-                                                    [key]: value[_index],
-                                                };
-                                    });
-                                else if (Object.values(item).every((_i) => Utils.isArrayOfArrays(_i) || Array.isArray(_i)) &&
-                                    prefix)
-                                    RETURN[index][field.key] = item;
-                                else {
-                                    RETURN[index][field.key] = [];
-                                    Object.entries(item).forEach(([key, value], _ind) => {
-                                        if (!Array.isArray(value)) {
-                                            RETURN[index][field.key][_ind] = {};
-                                            RETURN[index][field.key][_ind][key] = value;
-                                        }
-                                        else
-                                            for (let _i = 0; _i < value.length; _i++) {
-                                                if (value[_i] === null ||
-                                                    (Array.isArray(value[_i]) &&
-                                                        Utils.isArrayOfNulls(value[_i])))
-                                                    continue;
-                                                if (!RETURN[index][field.key][_i])
-                                                    RETURN[index][field.key][_i] = {};
-                                                RETURN[index][field.key][_i][key] = value[_i];
+                    const fieldItems = await this.getItemsFromSchema(tableName, field.children, linesNumber, options, `${(prefix ?? "") + field.key}.`);
+                    if (fieldItems)
+                        for (const [index, item] of Object.entries(fieldItems)) {
+                            if (!RETURN[index])
+                                RETURN[index] = {};
+                            if (Utils.isObject(item)) {
+                                if (!Utils.isArrayOfNulls(Object.values(item))) {
+                                    if (RETURN[index][field.key])
+                                        Object.entries(item).forEach(([key, value], _index) => {
+                                            for (let _index = 0; _index < value.length; _index++)
+                                                if (RETURN[index][field.key][_index])
+                                                    Object.assign(RETURN[index][field.key][_index], {
+                                                        [key]: value[_index],
+                                                    });
+                                                else
+                                                    RETURN[index][field.key][_index] = {
+                                                        [key]: value[_index],
+                                                    };
+                                        });
+                                    else if (Object.values(item).every((_i) => Utils.isArrayOfArrays(_i) || Array.isArray(_i)) &&
+                                        prefix)
+                                        RETURN[index][field.key] = item;
+                                    else {
+                                        RETURN[index][field.key] = [];
+                                        Object.entries(item).forEach(([key, value], _ind) => {
+                                            if (!Array.isArray(value)) {
+                                                RETURN[index][field.key][_ind] = {};
+                                                RETURN[index][field.key][_ind][key] = value;
                                             }
-                                    });
+                                            else
+                                                for (let _i = 0; _i < value.length; _i++) {
+                                                    if (value[_i] === null ||
+                                                        (Array.isArray(value[_i]) &&
+                                                            Utils.isArrayOfNulls(value[_i])))
+                                                        continue;
+                                                    if (!RETURN[index][field.key][_i])
+                                                        RETURN[index][field.key][_i] = {};
+                                                    RETURN[index][field.key][_i][key] = value[_i];
+                                                }
+                                        });
+                                    }
                                 }
+                                else
+                                    RETURN[index][field.key] = null;
                             }
                             else
-                                RETURN[index][field.key] = null;
+                                RETURN[index][field.key] = item;
                         }
-                        else
-                            RETURN[index][field.key] = item;
-                    }
                 }
                 else if (field.children === "table" ||
                     (Array.isArray(field.type) && field.type.includes("table")) ||
                     (Array.isArray(field.children) && field.children.includes("table"))) {
                     if (field.table &&
                         (await File.isExists(join(this.folder, this.database, field.table))) &&
-                        (await File.isExists(join(tablePath, `${(prefix ?? "") + field.key}.inib`)))) {
+                        (await File.isExists(join(tablePath, `${(prefix ?? "") + field.key}${this.getFileExtension()}`)))) {
                         if (options.columns)
                             options.columns = options.columns
                                 .filter((column) => column.includes(`${field.key}.`))
                                 .map((column) => column.replace(`${field.key}.`, ""));
-                        const items = await File.get(join(tablePath, `${(prefix ?? "") + field.key}.inib`), linesNumber, field.type, field.children, this.salt);
+                        const items = await File.get(join(tablePath, `${(prefix ?? "") + field.key}${this.getFileExtension()}`), linesNumber, field.type, field.children, this.salt);
                         if (items)
-                            await Promise.allSettled(Object.entries(items).map(async ([index, item]) => {
+                            for await (const [index, item] of Object.entries(items)) {
                                 if (!RETURN[index])
                                     RETURN[index] = {};
                                 RETURN[index][field.key] = item
                                     ? await this.get(field.table, item, options)
                                     : this.getDefaultValue(field);
-                            }));
+                            }
                     }
                 }
-                else if (await File.isExists(join(tablePath, `${(prefix ?? "") + field.key}.inib`))) {
-                    const items = await File.get(join(tablePath, `${(prefix ?? "") + field.key}.inib`), linesNumber, field.type, field.children, this.salt);
+                else if (await File.isExists(join(tablePath, `${(prefix ?? "") + field.key}${this.getFileExtension()}`))) {
+                    const items = await File.get(join(tablePath, `${(prefix ?? "") + field.key}${this.getFileExtension()}`), linesNumber, field.type, field.children, this.salt);
                     if (items)
                         for (const [index, item] of Object.entries(items)) {
                             if (!RETURN[index])
@@ -500,40 +525,42 @@ export default class Inibase {
                 }
             }
             else if (field.type === "object") {
-                for await (const [index, item] of Object.entries((await this.getItemsFromSchema(tableName, field.children, linesNumber, options, `${(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;
+                const fieldItems = await this.getItemsFromSchema(tableName, field.children, linesNumber, options, `${(prefix ?? "") + field.key}.`);
+                if (fieldItems)
+                    for (const [index, item] of Object.entries(fieldItems)) {
+                        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
-                        RETURN[index][field.key] = null;
-                }
             }
             else if (field.type === "table") {
                 if (field.table &&
                     (await File.isExists(join(this.folder, this.database, field.table))) &&
-                    (await File.isExists(join(tablePath, `${(prefix ?? "") + field.key}.inib`)))) {
+                    (await File.isExists(join(tablePath, `${(prefix ?? "") + field.key}${this.getFileExtension()}`)))) {
                     if (options.columns)
                         options.columns = options.columns
                             .filter((column) => column.includes(`${field.key}.`))
                             .map((column) => column.replace(`${field.key}.`, ""));
-                    const items = await File.get(join(tablePath, `${(prefix ?? "") + field.key}.inib`), linesNumber, "number", undefined, this.salt);
+                    const items = await File.get(join(tablePath, `${(prefix ?? "") + field.key}${this.getFileExtension()}`), linesNumber, "number", undefined, this.salt);
                     if (items)
-                        await Promise.allSettled(Object.entries(items).map(async ([index, item]) => {
+                        for await (const [index, item] of Object.entries(items)) {
                             if (!RETURN[index])
                                 RETURN[index] = {};
                             RETURN[index][field.key] = item
                                 ? await this.get(field.table, item, options)
                                 : this.getDefaultValue(field);
-                        }));
+                        }
                 }
             }
-            else if (await File.isExists(join(tablePath, `${(prefix ?? "") + field.key}.inib`))) {
-                const items = await File.get(join(tablePath, `${(prefix ?? "") + field.key}.inib`), linesNumber, field.type, field.children, this.salt);
+            else if (await File.isExists(join(tablePath, `${(prefix ?? "") + field.key}${this.getFileExtension()}`))) {
+                const items = await File.get(join(tablePath, `${(prefix ?? "") + field.key}${this.getFileExtension()}`), linesNumber, field.type, field.children, this.salt);
                 if (items)
                     for (const [index, item] of Object.entries(items)) {
                         if (!RETURN[index])
@@ -546,7 +573,7 @@ export default class Inibase {
                         { ...data, [field.key]: this.getDefaultValue(field) },
                     ]));
             }
-        }));
+        }
         return RETURN;
     }
     async applyCriteria(tableName, schema, options, criteria, allTrue) {
@@ -634,7 +661,7 @@ export default class Inibase {
                     searchOperator = "=";
                     searchComparedAtValue = value;
                 }
-                const [searchResult, totalLines, linesNumbers] = await File.search(join(tablePath, `${key}.inib`), searchOperator ?? "=", searchComparedAtValue ?? null, searchLogicalOperator, field?.type, field?.children, options.perPage, options.page - 1 * options.perPage + 1, true, this.salt);
+                const [searchResult, totalLines, linesNumbers] = await File.search(join(tablePath, `${key}${this.getFileExtension()}`), searchOperator ?? "=", searchComparedAtValue ?? null, searchLogicalOperator, field?.type, field?.children, options.perPage, options.page - 1 * options.perPage + 1, true, this.salt);
                 if (searchResult) {
                     RETURN = Utils.deepMerge(RETURN, Object.fromEntries(Object.entries(searchResult).map(([id, value]) => [
                         id,
@@ -679,7 +706,7 @@ export default class Inibase {
     }
     async clearCache(tablePath) {
         await Promise.all((await readdir(join(tablePath, ".cache")))
-            ?.filter((fileName) => fileName !== "pagination.inib")
+            ?.filter((fileName) => fileName !== `pagination${this.fileExtension}`)
             .map(async (file) => unlink(join(tablePath, ".cache", file))));
     }
     async get(tableName, where, options = {
@@ -713,16 +740,14 @@ export default class Inibase {
             RETURN = Object.values(await this.getItemsFromSchema(tableName, schema, Array.from({ length: options.perPage }, (_, index) => (options.page - 1) * options.perPage +
                 index +
                 1), options));
-            if (Config.isCacheEnabled &&
-                (await File.isExists(join(tablePath, ".cache", "pagination.inib"))))
-                this.totalItems[`${tableName}-*`] = Number((await File.read(join(tablePath, ".cache", "pagination.inib"), true)).split(",")[1]);
+            if (await File.isExists(join(tablePath, ".cache", `pagination${this.fileExtension}`)))
+                this.totalItems[`${tableName}-*`] = Number((await File.read(join(tablePath, ".cache", `pagination${this.fileExtension}`), true)).split(",")[1]);
             else {
-                let [lastId, totalItems] = await File.get(join(tablePath, "id.inib"), -1, "number", undefined, this.salt, true);
+                let [lastId, totalItems] = await File.get(join(tablePath, `id${this.getFileExtension()}`), -1, "number", undefined, this.salt, true);
                 if (lastId)
                     lastId = Number(Object.keys(lastId)?.[0] ?? 0);
                 this.totalItems[`${tableName}-*`] = totalItems;
-                if (Config.isCacheEnabled)
-                    await File.write(join(tablePath, ".cache", "pagination.inib"), `${lastId},${totalItems}`, true);
+                await File.write(join(tablePath, ".cache", `pagination${this.fileExtension}`), `${lastId},${totalItems}`, true);
             }
         }
         else if ((Array.isArray(where) && where.every(Utils.isNumber)) ||
@@ -745,7 +770,7 @@ export default class Inibase {
             let Ids = where;
             if (!Array.isArray(Ids))
                 Ids = [Ids];
-            const [lineNumbers, countItems] = await File.search(join(tablePath, "id.inib"), "[]", Ids.map((id) => Utils.isNumber(id) ? Number(id) : UtilsServer.decodeID(id, this.salt)), undefined, "number", undefined, Ids.length, 0, !this.totalItems[`${tableName}-*`], this.salt);
+            const [lineNumbers, countItems] = await File.search(join(tablePath, `id${this.getFileExtension()}`), "[]", Ids.map((id) => Utils.isNumber(id) ? Number(id) : UtilsServer.decodeID(id, this.salt)), undefined, "number", undefined, Ids.length, 0, !this.totalItems[`${tableName}-*`], this.salt);
             if (!lineNumbers)
                 throw this.throwError("NO_RESULTS", tableName);
             if (onlyLinesNumbers)
@@ -762,7 +787,7 @@ export default class Inibase {
             let cachedFilePath = "";
             // Criteria
             if (Config.isCacheEnabled)
-                cachedFilePath = join(tablePath, ".cache", `${UtilsServer.hashString(inspect(where, { sorted: true }))}.inib`);
+                cachedFilePath = join(tablePath, ".cache", `${UtilsServer.hashString(inspect(where, { sorted: true }))}${this.fileExtension}`);
             if (Config.isCacheEnabled && (await File.isExists(cachedFilePath))) {
                 const cachedItems = (await File.read(cachedFilePath, true)).split(",");
                 this.totalItems[`${tableName}-*`] = cachedItems.length;
@@ -815,15 +840,14 @@ export default class Inibase {
         let lastId = 0, totalItems = 0, renameList = [];
         try {
             await File.lock(join(tablePath, ".tmp"), keys);
-            if (await File.isExists(join(tablePath, "id.inib"))) {
-                if (Config.isCacheEnabled &&
-                    (await File.isExists(join(tablePath, ".cache", "pagination.inib"))))
-                    [lastId, totalItems] = (await File.read(join(tablePath, ".cache", "pagination.inib"), true))
+            if (await File.isExists(join(tablePath, `id${this.getFileExtension()}`))) {
+                if (await File.isExists(join(tablePath, ".cache", `pagination${this.fileExtension}`)))
+                    [lastId, totalItems] = (await File.read(join(tablePath, ".cache", `pagination${this.fileExtension}`), true))
                         .split(",")
                         .map(Number);
                 else {
                     let lastIdObj = null;
-                    [lastIdObj, totalItems] = await File.get(join(tablePath, "id.inib"), -1, "number", undefined, this.salt, true);
+                    [lastIdObj, totalItems] = await File.get(join(tablePath, `id${this.getFileExtension()}`), -1, "number", undefined, this.salt, true);
                     if (lastIdObj)
                         lastId = Number(Object.keys(lastIdObj)?.[0] ?? 0);
                 }
@@ -852,10 +876,9 @@ export default class Inibase {
             await Promise.all(renameList.map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
             renameList = [];
             totalItems += Array.isArray(RETURN) ? RETURN.length : 1;
-            if (Config.isCacheEnabled) {
+            if (Config.isCacheEnabled)
                 await this.clearCache(tablePath);
-                await File.write(join(tablePath, ".cache", "pagination.inib"), `${lastId},${totalItems}`, true);
-            }
+            await File.write(join(tablePath, ".cache", `pagination${this.fileExtension}`), `${lastId},${totalItems}`, true);
             if (returnPostedData)
                 return this.get(tableName, Config.isReverseEnabled
                     ? Array.isArray(RETURN)
@@ -895,13 +918,12 @@ export default class Inibase {
                 return this.put(tableName, data, data.id);
             }
             let totalItems;
-            if (Config.isCacheEnabled &&
-                (await File.isExists(join(tablePath, ".cache", "pagination.inib"))))
-                totalItems = (await File.read(join(tablePath, ".cache", "pagination.inib"), true))
+            if (await File.isExists(join(tablePath, ".cache", `pagination${this.fileExtension}`)))
+                totalItems = (await File.read(join(tablePath, ".cache", `pagination${this.fileExtension}`), true))
                     .split(",")
                     .map(Number)[1];
             else
-                totalItems = await File.count(join(tablePath, "id.inib"));
+                totalItems = await File.count(join(tablePath, `id${this.getFileExtension()}`));
             const pathesContents = this.joinPathesContents(tablePath, {
                 ...(({ id, ...restOfData }) => restOfData)(data),
                 updatedAt: Date.now(),
@@ -998,26 +1020,23 @@ export default class Inibase {
         if ((Array.isArray(where) && where.every(Utils.isNumber)) ||
             Utils.isNumber(where)) {
             // "where" in this case, is the line(s) number(s) and not id(s)
-            const files = (await readdir(tablePath))?.filter((fileName) => fileName.endsWith(".inib"));
+            const files = (await readdir(tablePath))?.filter((fileName) => fileName.endsWith(this.getFileExtension()));
             if (files.length) {
-                if (!_id)
-                    _id = Object.entries((await File.get(join(tablePath, "id.inib"), where, "number", undefined, this.salt)) ?? {}).map(([_, id]) => UtilsServer.encodeID(id, this.salt));
-                if (!_id.length)
-                    throw this.throwError("NO_RESULTS", tableName);
                 try {
                     await File.lock(join(tablePath, ".tmp"));
                     await Promise.all(files.map(async (file) => renameList.push(await File.remove(join(tablePath, file), where))));
                     await Promise.all(renameList.map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
-                    if (Config.isCacheEnabled) {
+                    if (Config.isCacheEnabled)
                         await this.clearCache(tablePath);
-                        if (await File.isExists(join(tablePath, ".cache", "pagination.inib"))) {
-                            const [lastId, totalItems] = (await File.read(join(tablePath, ".cache", "pagination.inib"), true))
-                                .split(",")
-                                .map(Number);
-                            await File.write(join(tablePath, ".cache", "pagination.inib"), `${lastId},${totalItems - (Array.isArray(where) ? where.length : 1)}`, true);
-                        }
+                    if (await File.isExists(join(tablePath, ".cache", `pagination${this.fileExtension}`))) {
+                        const [lastId, totalItems] = (await File.read(join(tablePath, ".cache", `pagination${this.fileExtension}`), true))
+                            .split(",")
+                            .map(Number);
+                        await File.write(join(tablePath, ".cache", `pagination${this.fileExtension}`), `${lastId},${totalItems - (Array.isArray(where) ? where.length : 1)}`, true);
                     }
-                    return Array.isArray(_id) && _id.length === 1 ? _id[0] : _id;
+                    if (_id)
+                        return Array.isArray(_id) && _id.length === 1 ? _id[0] : _id;
+                    return where;
                 }
                 finally {
                     if (renameList.length)
@@ -1040,7 +1059,7 @@ export default class Inibase {
         if (!Array.isArray(columns))
             columns = [columns];
         for await (const column of columns) {
-            const columnPath = join(tablePath, `${column}.inib`);
+            const columnPath = join(tablePath, `${column}${this.getFileExtension()}`);
             if (await File.isExists(columnPath)) {
                 if (where) {
                     const lineNumbers = await this.get(tableName, where, undefined, undefined, true, schema);
@@ -1060,7 +1079,7 @@ export default class Inibase {
         if (!Array.isArray(columns))
             columns = [columns];
         for await (const column of columns) {
-            const columnPath = join(tablePath, `${column}.inib`);
+            const columnPath = join(tablePath, `${column}${this.getFileExtension()}`);
             if (await File.isExists(columnPath)) {
                 if (where) {
                     const lineNumbers = await this.get(tableName, where, undefined, undefined, true, schema);
@@ -1080,7 +1099,7 @@ export default class Inibase {
         if (!Array.isArray(columns))
             columns = [columns];
         for await (const column of columns) {
-            const columnPath = join(tablePath, `${column}.inib`);
+            const columnPath = join(tablePath, `${column}${this.getFileExtension()}`);
             if (await File.isExists(columnPath)) {
                 if (where) {
                     const lineNumbers = await this.get(tableName, where, undefined, undefined, true, schema);
@@ -1098,7 +1117,6 @@ export default class Inibase {
         page: 1,
         perPage: 15,
     }) {
-        // TO-DO: Cache Results based on "Columns and Sort Direction"
         const tablePath = join(this.folder, this.database, tableName), schema = await this.getSchemaWhenTableNotEmpty(tableName);
         // Default values for page and perPage
         options.page = options.page || 1;
@@ -1122,7 +1140,7 @@ export default class Inibase {
             cacheKey = UtilsServer.hashString(inspect(sortArray, { sorted: true }));
         if (where) {
             const lineNumbers = await this.get(tableName, where, undefined, undefined, true, schema);
-            keepItems = Object.values((await File.get(join(tablePath, "id.inib"), lineNumbers, "number", undefined, this.salt)) ?? {}).map(Number);
+            keepItems = Object.values((await File.get(join(tablePath, `id${this.getFileExtension()}`), lineNumbers, "number", undefined, this.salt)) ?? {}).map(Number);
             isLineNumbers = false;
             if (!keepItems.length)
                 throw this.throwError("NO_RESULTS", tableName);
@@ -1132,7 +1150,7 @@ export default class Inibase {
             keepItems = Array.from({ length: options.perPage }, (_, index) => (options.page - 1) * options.perPage +
                 index +
                 1);
-        const filesPathes = [["id", true], ...sortArray].map((column) => join(tablePath, `${column[0]}.inib`));
+        const filesPathes = [["id", true], ...sortArray].map((column) => join(tablePath, `${column[0]}${this.getFileExtension()}`));
         // Construct the paste command to merge files and filter lines by IDs
         const pasteCommand = `paste ${filesPathes.join(" ")}`;
         // Construct the sort command dynamically based on the number of files for sorting
@@ -1157,10 +1175,10 @@ export default class Inibase {
                 await File.lock(join(tablePath, ".tmp"), cacheKey);
             // Combine the commands
             // Execute the command synchronously
-            const { stdout, stderr } = await UtilsServer.exec(Config.isCacheEnabled
-                ? (await File.isExists(join(tablePath, ".cache", `${cacheKey}.inib`)))
-                    ? `${awkCommand} ${join(tablePath, ".cache", `${cacheKey}.inib`)}`
-                    : `${pasteCommand} | ${sortCommand} -o ${join(tablePath, ".cache", `${cacheKey}.inib`)} && ${awkCommand} ${join(tablePath, ".cache", `${cacheKey}.inib`)}`
+            const { stdout } = await UtilsServer.exec(Config.isCacheEnabled
+                ? (await File.isExists(join(tablePath, ".cache", `${cacheKey}${this.fileExtension}`)))
+                    ? `${awkCommand} ${join(tablePath, ".cache", `${cacheKey}${this.fileExtension}`)}`
+                    : `${pasteCommand} | ${sortCommand} -o ${join(tablePath, ".cache", `${cacheKey}${this.fileExtension}`)} && ${awkCommand} ${join(tablePath, ".cache", `${cacheKey}${this.fileExtension}`)}`
                 : `${pasteCommand} | ${sortCommand} | ${awkCommand}`, {
                 encoding: "utf-8",
             });
@@ -1169,7 +1187,7 @@ export default class Inibase {
             const outputArray = lines.map((line) => {
                 const splitedFileColumns = line.split("\t"); // Assuming tab-separated columns
                 const outputObject = {};
-                // Extract values for each file, including "id.inib"
+                // Extract values for each file, including `id${this.getFileExtension()}`
                 filesPathes.forEach((fileName, index) => {
                     const Field = Utils.getField(parse(fileName).name, schema);
                     if (Field)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inibase",
-  "version": "1.0.0-rc.57",
+  "version": "1.0.0-rc.58",
   "author": {
     "name": "Karim Amahtil",
     "email": "karim.amahtil@gmail.com"
@@ -47,6 +47,9 @@
     "pocketbase"
   ],
   "license": "MIT",
+  "bin": {
+    "inibase": "./dist/cli.js"
+  },
   "type": "module",
   "types": "./dist",
   "typesVersions": {
@@ -73,13 +76,14 @@
     "tinybench": "^2.6.0"
   },
   "dependencies": {
+    "commander": "^12.0.0",
+    "dotenv": "^16.4.5",
     "inison": "^1.0.0-rc.2"
   },
   "scripts": {
     "build": "tsc",
-    "test": "npx tsx watch --expose-gc --env-file=.env ./index.test",
-    "benchmark": "npx tsx --env-file=.env ./benchmark/index",
-    "benchmark:single": "npx tsx --expose-gc --env-file=.env ./benchmark/single",
-    "benchmark:bulk": "npx tsx --expose-gc --env-file=.env ./benchmark/bulk"
+    "benchmark": "tsx --env-file=.env ./benchmark/index",
+    "benchmark:single": "tsx --expose-gc --env-file=.env ./benchmark/single",
+    "benchmark:bulk": "tsx --expose-gc --env-file=.env ./benchmark/bulk"
   }
 }