inibase 1.0.0-rc.61 → 1.0.0-rc.63

package/dist/cli.js

@@ -2,10 +2,10 @@
 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";
+import Inibase from "./index.js";
+import { isJSON, isNumber } from "./utils.js";
 const { path } = parseArgs({
     options: {
         path: { type: "string", short: "p" },
@@ -17,18 +17,18 @@ const db = new Inibase(basename(path));
 const rl = createInterface({
     input: process.stdin,
     output: process.stdout,
+    prompt: "\u001b[1;36m>  \u001b[0m",
 });
+console.clear();
 rl.prompt();
 rl.on("line", async (input) => {
     const trimedInput = input.trim();
     if (trimedInput === "clear") {
-        console.clear();
+        process.stdout.write("\x1Bc");
         rl.prompt();
     }
-    if (trimedInput === "info") {
-        console.warn("war");
-        console.error("err");
-    }
+    if (trimedInput === "exit")
+        process.exit();
     const splitedInput = trimedInput.match(/[^\s"']+|"([^"]*)"|'([^']*)'/g);
     if (["get", "post", "delete", "put"].includes(splitedInput[0].toLocaleLowerCase())) {
         const table = splitedInput[1];
@@ -45,14 +45,16 @@ rl.on("line", async (input) => {
             },
         }).values;
         if (where) {
-            if (isNumber(where))
+            if (where === "'-1'" || where === '"-1"')
+                where = -1;
+            else if (isNumber(where))
                 where = Number(where);
             else if (isJSON(where))
                 where = Inison.unstringify(where);
         }
         if (data) {
             if (isJSON(data))
-                where = Inison.unstringify(data);
+                data = Inison.unstringify(data);
             else
                 data = undefined;
         }
@@ -85,4 +87,5 @@ rl.on("line", async (input) => {
                 break;
         }
     }
+    rl.prompt();
 });

package/dist/file.js

@@ -178,11 +178,9 @@ export const decode = (input, fieldType, fieldChildrenType, secretKey) => {
 };
 export async function get(filePath, lineNumbers, fieldType, fieldChildrenType, secretKey, readWholeFile = false) {
     let fileHandle = null;
-    let rl = null;
     try {
         fileHandle = await open(filePath, "r");
-        rl = createReadLineInternface(filePath, fileHandle);
-        const lines = {};
+        const rl = createReadLineInternface(filePath, fileHandle), lines = {};
         let linesCount = 0;
         if (!lineNumbers) {
             for await (const line of rl) {
@@ -225,7 +223,6 @@ export async function get(filePath, lineNumbers, fieldType, fieldChildrenType, s
     }
     finally {
         // Ensure that file handles are closed, even if an error occurred
-        rl?.close();
         await fileHandle?.close();
     }
 }
@@ -244,12 +241,11 @@ export const replace = async (filePath, replacements) => {
     if (await isExists(filePath)) {
         let fileHandle = null;
         let fileTempHandle = null;
-        let rl = null;
         try {
             let linesCount = 0;
             fileHandle = await open(filePath, "r");
             fileTempHandle = await open(fileTempPath, "w");
-            rl = createReadLineInternface(filePath, fileHandle);
+            const rl = createReadLineInternface(filePath, fileHandle);
             await _pipeline(filePath, rl, fileTempHandle.createWriteStream(), new Transform({
                 transform(line, encoding, callback) {
                     linesCount++;
@@ -265,7 +261,6 @@ export const replace = async (filePath, replacements) => {
         }
         finally {
             // Ensure that file handles are closed, even if an error occurred
-            rl?.close();
             await fileHandle?.close();
             await fileTempHandle?.close();
         }
@@ -303,11 +298,10 @@ export const append = async (filePath, data, prepend) => {
         else {
             let fileHandle = null;
             let fileTempHandle = null;
-            let rl = null;
             try {
                 fileHandle = await open(filePath, "r");
                 fileTempHandle = await open(fileTempPath, "w");
-                rl = createReadLineInternface(filePath, fileHandle);
+                const rl = createReadLineInternface(filePath, fileHandle);
                 let isAppended = false;
                 await _pipeline(filePath, rl, fileTempHandle.createWriteStream(), new Transform({
                     transform(line, _, callback) {
@@ -321,7 +315,6 @@ export const append = async (filePath, data, prepend) => {
             }
             finally {
                 // Ensure that file handles are closed, even if an error occurred
-                rl?.close();
                 await fileHandle?.close();
                 await fileTempHandle?.close();
             }
@@ -347,37 +340,10 @@ export const remove = async (filePath, linesToDelete) => {
     if (linesToDelete.some(Number.isNaN))
         throw new Error("UNVALID_LINE_NUMBERS");
     const fileTempPath = filePath.replace(/([^/]+)\/?$/, ".tmp/$1");
-    if (linesToDelete.length < 1000) {
-        const command = filePath.endsWith(".gz")
-            ? `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 = createReadLineInternface(filePath, fileHandle);
-        await _pipeline(filePath, 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();
-            },
-        }));
-        await fileTempHandle.close();
-        await fileHandle.close();
-    }
+    const command = filePath.endsWith(".gz")
+        ? `zcat ${filePath} | sed "${linesToDelete.join("d;")}d" | gzip > ${fileTempPath}`
+        : `sed "${linesToDelete.join("d;")}d" ${filePath} > ${fileTempPath}`;
+    await exec(command);
     return [fileTempPath, filePath];
 };
 /**
@@ -407,12 +373,11 @@ export const search = async (filePath, operator, comparedAtValue, logicalOperato
     let foundItems = 0;
     const linesNumbers = new Set();
     let fileHandle = null;
-    let rl = null;
     try {
         // Open the file for reading.
         fileHandle = await open(filePath, "r");
         // Create a Readline interface to read the file line by line.
-        rl = createReadLineInternface(filePath, fileHandle);
+        const rl = createReadLineInternface(filePath, fileHandle);
         // Iterate through each line in the file.
         for await (const line of rl) {
             // Increment the line count for each line.
@@ -452,7 +417,6 @@ export const search = async (filePath, operator, comparedAtValue, logicalOperato
     }
     finally {
         // Close the file handle in the finally block to ensure it is closed even if an error occurs.
-        rl?.close();
         await fileHandle?.close();
     }
 };
@@ -469,15 +433,13 @@ export const count = async (filePath) => {
     let linesCount = 0;
     if (await isExists(filePath)) {
         let fileHandle = null;
-        let rl = null;
         try {
             fileHandle = await open(filePath, "r");
-            rl = createReadLineInternface(filePath, fileHandle);
+            const rl = createReadLineInternface(filePath, fileHandle);
             for await (const _ of rl)
                 linesCount++;
         }
         finally {
-            rl?.close();
             await fileHandle?.close();
         }
     }
@@ -493,27 +455,31 @@ export const count = async (filePath) => {
  * Note: Decodes each line as a number using the 'decode' function. Non-numeric lines contribute 0 to the sum.
  */
 export const sum = async (filePath, lineNumbers) => {
-    let sum = 0;
-    const fileHandle = await open(filePath, "r");
-    const rl = createReadLineInternface(filePath, fileHandle);
-    if (lineNumbers) {
-        let linesCount = 0;
-        const lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
-        for await (const line of rl) {
-            linesCount++;
-            if (!lineNumbersArray.has(linesCount))
-                continue;
-            sum += +(decode(line, "number") ?? 0);
-            lineNumbersArray.delete(linesCount);
-            if (!lineNumbersArray.size)
-                break;
+    let sum = 0, fileHandle = null;
+    try {
+        fileHandle = await open(filePath, "r");
+        const rl = createReadLineInternface(filePath, fileHandle);
+        if (lineNumbers) {
+            let linesCount = 0;
+            const lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
+            for await (const line of rl) {
+                linesCount++;
+                if (!lineNumbersArray.has(linesCount))
+                    continue;
+                sum += +(decode(line, "number") ?? 0);
+                lineNumbersArray.delete(linesCount);
+                if (!lineNumbersArray.size)
+                    break;
+            }
         }
+        else
+            for await (const line of rl)
+                sum += +(decode(line, "number") ?? 0);
+        return sum;
+    }
+    finally {
+        await fileHandle?.close();
     }
-    else
-        for await (const line of rl)
-            sum += +(decode(line, "number") ?? 0);
-    await fileHandle.close();
-    return sum;
 };
 /**
  * Asynchronously finds the maximum numerical value from specified lines in a file.
@@ -525,32 +491,36 @@ export const sum = async (filePath, lineNumbers) => {
  * Note: Decodes each line as a number using the 'decode' function. Considers only numerical values for determining the maximum.
  */
 export const max = async (filePath, lineNumbers) => {
-    let max = 0;
-    const fileHandle = await open(filePath, "r");
-    const rl = createReadLineInternface(filePath, fileHandle);
-    if (lineNumbers) {
-        let linesCount = 0;
-        const lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
-        for await (const line of rl) {
-            linesCount++;
-            if (!lineNumbersArray.has(linesCount))
-                continue;
-            const lineContentNum = +(decode(line, "number") ?? 0);
-            if (lineContentNum > max)
-                max = lineContentNum;
-            lineNumbersArray.delete(linesCount);
-            if (!lineNumbersArray.size)
-                break;
+    let max = 0, fileHandle = null, rl = null;
+    try {
+        fileHandle = await open(filePath, "r");
+        rl = createReadLineInternface(filePath, fileHandle);
+        if (lineNumbers) {
+            let linesCount = 0;
+            const lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
+            for await (const line of rl) {
+                linesCount++;
+                if (!lineNumbersArray.has(linesCount))
+                    continue;
+                const lineContentNum = +(decode(line, "number") ?? 0);
+                if (lineContentNum > max)
+                    max = lineContentNum;
+                lineNumbersArray.delete(linesCount);
+                if (!lineNumbersArray.size)
+                    break;
+            }
         }
+        else
+            for await (const line of rl) {
+                const lineContentNum = +(decode(line, "number") ?? 0);
+                if (lineContentNum > max)
+                    max = lineContentNum;
+            }
+        return max;
+    }
+    finally {
+        await fileHandle?.close();
     }
-    else
-        for await (const line of rl) {
-            const lineContentNum = +(decode(line, "number") ?? 0);
-            if (lineContentNum > max)
-                max = lineContentNum;
-        }
-    await fileHandle.close();
-    return max;
 };
 /**
  * Asynchronously finds the minimum numerical value from specified lines in a file.
@@ -562,30 +532,34 @@ export const max = async (filePath, lineNumbers) => {
  * Note: Decodes each line as a number using the 'decode' function. Considers only numerical values for determining the minimum.
  */
 export const min = async (filePath, lineNumbers) => {
-    let min = 0;
-    const fileHandle = await open(filePath, "r");
-    const rl = createReadLineInternface(filePath, fileHandle);
-    if (lineNumbers) {
-        let linesCount = 0;
-        const lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
-        for await (const line of rl) {
-            linesCount++;
-            if (!lineNumbersArray.has(linesCount))
-                continue;
-            const lineContentNum = +(decode(line, "number") ?? 0);
-            if (lineContentNum < min)
-                min = lineContentNum;
-            lineNumbersArray.delete(linesCount);
-            if (!lineNumbersArray.size)
-                break;
+    let min = 0, fileHandle = null;
+    try {
+        fileHandle = await open(filePath, "r");
+        const rl = createReadLineInternface(filePath, fileHandle);
+        if (lineNumbers) {
+            let linesCount = 0;
+            const lineNumbersArray = new Set(Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers]);
+            for await (const line of rl) {
+                linesCount++;
+                if (!lineNumbersArray.has(linesCount))
+                    continue;
+                const lineContentNum = +(decode(line, "number") ?? 0);
+                if (lineContentNum < min)
+                    min = lineContentNum;
+                lineNumbersArray.delete(linesCount);
+                if (!lineNumbersArray.size)
+                    break;
+            }
         }
+        else
+            for await (const line of rl) {
+                const lineContentNum = +(decode(line, "number") ?? 0);
+                if (lineContentNum < min)
+                    min = lineContentNum;
+            }
+        return min;
+    }
+    finally {
+        await fileHandle?.close();
     }
-    else
-        for await (const line of rl) {
-            const lineContentNum = +(decode(line, "number") ?? 0);
-            if (lineContentNum < min)
-                min = lineContentNum;
-        }
-    await fileHandle.close();
-    return min;
 };

package/dist/index.d.ts

@@ -64,8 +64,28 @@ export default class Inibase {
     private throwError;
     private getFileExtension;
     private _schemaToIdsPath;
+    /**
+     * Create a new table inside database, with predefined schema and config
+     *
+     * @param {string} tableName
+     * @param {Schema} [schema]
+     * @param {Config} [config]
+     */
     createTable(tableName: string, schema?: Schema, config?: Config): Promise<void>;
+    /**
+     * Update table schema or config
+     *
+     * @param {string} tableName
+     * @param {Schema} [schema]
+     * @param {Config} [config]
+     */
     updateTable(tableName: string, schema?: Schema, config?: Config): Promise<void>;
+    /**
+     * Get table schema and config
+     *
+     * @param {string} tableName
+     * @return {*}  {Promise<TableObject>}
+     */
     getTable(tableName: string): Promise<TableObject>;
     getTableSchema(tableName: string, encodeIDs?: boolean): Promise<Schema | undefined>;
     private throwErrorIfTableEmpty;
@@ -81,25 +101,105 @@ export default class Inibase {
     private getItemsFromSchema;
     private applyCriteria;
     private _filterSchemaByColumns;
-    clearCache(tablePath: string): Promise<void>;
+    /**
+     * Clear table cache
+     *
+     * @param {string} tableName
+     */
+    clearCache(tableName: string): Promise<void>;
+    /**
+     * Retrieve item(s) from a table
+     *
+     * @param {string} tableName
+     * @param {(string | number | (string | number)[] | Criteria | undefined)} [where]
+     * @param {(Options | undefined)} [options]
+     * @param {true} [onlyOne]
+     * @param {undefined} [onlyLinesNumbers]
+     * @param {boolean} [_skipIdColumn]
+     * @return {*}  {(Promise<Data[] | Data | number[] | null>)}
+     */
     get(tableName: string, where?: string | number | (string | number)[] | Criteria | undefined, options?: Options | undefined, onlyOne?: true, onlyLinesNumbers?: undefined, _skipIdColumn?: boolean): Promise<Data | null>;
     get(tableName: string, where?: string | number | (string | number)[] | Criteria | undefined, options?: Options | undefined, onlyOne?: boolean | undefined, onlyLinesNumbers?: true, _skipIdColumn?: boolean): Promise<number[]>;
+    /**
+     * Create new item(s) in a table
+     *
+     * @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, 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} 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, 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} tableName
+     * @param {(number | string)} [where]
+     * @param {(string | string[])} [_id]
+     * @return {*}  {(Promise<string | number | (string | number)[] | 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>;
+    /**
+     * Generate sum of column(s) in a table
+     *
+     * @param {string} tableName
+     * @param {string} columns
+     * @param {(number | string | (number | string)[] | Criteria)} [where]
+     * @return {*}  {Promise<number | 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} tableName
+     * @param {string} columns
+     * @param {(number | string | (number | string)[] | Criteria)} [where]
+     * @return {*}  {Promise<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} tableName
+     * @param {string} columns
+     * @param {(number | string | (number | string)[] | Criteria)} [where]
+     * @return {*}  {Promise<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>>;
+    /**
+     * Sort column(s) of a table
+     *
+     * @param {string} tableName
+     * @param {(string
+     * 			| string[]
+     * 			| Record<string, 1 | -1 | "asc" | "ASC" | "desc" | "DESC">)} columns
+     * @param {(string | number | (string | number)[] | Criteria)} [where]
+     * @param {Options} [options={
+     * 			page: 1,
+     * 			perPage: 15,
+     * 		}]
+     */
     sort(tableName: string, columns: string | string[] | Record<string, 1 | -1 | "asc" | "ASC" | "desc" | "DESC">, where?: string | number | (string | number)[] | Criteria, options?: Options): Promise<any[]>;
 }
 export {};

package/dist/index.js

@@ -1,5 +1,5 @@
 import "dotenv/config";
-import { unlink, rename, mkdir, readdir, open, writeFile, readFile, } from "node:fs/promises";
+import { unlink, rename, mkdir, readdir, writeFile, readFile, } from "node:fs/promises";
 import { existsSync, appendFileSync, readFileSync } from "node:fs";
 import { join, parse } from "node:path";
 import { scryptSync, randomBytes } from "node:crypto";
@@ -81,54 +81,65 @@ export default class Inibase {
                 RETURN[field.id] = `${(prefix ?? "") + field.key}${this.getFileExtension(tableName)}`;
         return RETURN;
     };
+    /**
+     * Create a new table inside database, with predefined schema and config
+     *
+     * @param {string} tableName
+     * @param {Schema} [schema]
+     * @param {Config} [config]
+     */
     async createTable(tableName, schema, config) {
         const tablePath = join(this.databasePath, tableName);
         if (await File.isExists(tablePath))
             this.throwError("TABLE_EXISTS", tableName);
-        await Promise.all([
-            mkdir(tablePath, { recursive: true }),
-            mkdir(join(tablePath, ".tmp")),
-            mkdir(join(tablePath, ".cache")),
-        ]);
+        await mkdir(join(tablePath, ".tmp"), { recursive: true });
+        await mkdir(join(tablePath, ".cache"));
         if (config) {
             if (config.compression)
-                await open(join(tablePath, ".compression.config"), "w");
+                await writeFile(join(tablePath, ".compression.config"), "");
             if (config.cache)
-                await open(join(tablePath, ".cache.config"), "w");
+                await writeFile(join(tablePath, ".cache.config"), "");
             if (config.prepend)
-                await open(join(tablePath, ".prepend.config"), "w");
+                await writeFile(join(tablePath, ".prepend.config"), "");
         }
         if (schema)
             await writeFile(join(tablePath, "schema.json"), JSON.stringify(UtilsServer.addIdToSchema(schema, 0, this.salt, false), null, 2));
     }
+    /**
+     * Update table schema or config
+     *
+     * @param {string} tableName
+     * @param {Schema} [schema]
+     * @param {Config} [config]
+     */
     async updateTable(tableName, schema, config) {
         const table = await this.getTable(tableName), tablePath = join(this.databasePath, tableName);
         if (config) {
             if (config.compression !== undefined) {
                 if (!config.compression && table.config.compression) {
                     try {
-                        await UtilsServer.exec(`gunzip -r ${tablePath}/*.txt.gz 2>/dev/null`);
+                        await UtilsServer.exec(`gunzip ${tablePath}/*.${this.fileExtension}.gz 2>/dev/null`);
                         await unlink(join(tablePath, ".compression.config"));
                     }
                     catch { }
                 }
                 else if (config.compression && !table.config.compression) {
                     try {
-                        await UtilsServer.exec(`gzip -r ${tablePath}/*.txt 2>/dev/null`);
-                        await open(join(tablePath, ".compression.config"), "w");
+                        await UtilsServer.exec(`gzip ${tablePath}/*.${this.fileExtension} 2>/dev/null`);
+                        await writeFile(join(tablePath, ".compression.config"), "");
                     }
                     catch { }
                 }
             }
             if (config.cache !== undefined) {
                 if (config.cache && !table.config.cache)
-                    await open(join(tablePath, ".cache.config"), "w");
+                    await writeFile(join(tablePath, ".cache.config"), "");
                 else if (!config.cache && table.config.cache)
                     await unlink(join(tablePath, ".cache.config"));
             }
             if (config.prepend !== undefined) {
                 if (config.prepend && !table.config.prepend)
-                    await open(join(tablePath, ".prepend.config"), "w");
+                    await writeFile(join(tablePath, ".prepend.config"), "");
                 else if (!config.prepend && table.config.prepend)
                     await unlink(join(tablePath, ".prepend.config"));
             }
@@ -157,6 +168,12 @@ export default class Inibase {
             delete this.tables[tableName];
         }
     }
+    /**
+     * Get table schema and config
+     *
+     * @param {string} tableName
+     * @return {*}  {Promise<TableObject>}
+     */
     async getTable(tableName) {
         const tablePath = join(this.databasePath, tableName);
         if (!(await File.isExists(tablePath)))
@@ -749,10 +766,13 @@ export default class Inibase {
         })
             .filter((i) => i);
     }
-    async clearCache(tablePath) {
-        await Promise.all((await readdir(join(tablePath, ".cache")))
-            ?.filter((fileName) => fileName !== `pagination${this.fileExtension}`)
-            .map(async (file) => unlink(join(tablePath, ".cache", file))));
+    /**
+     * Clear table cache
+     *
+     * @param {string} tableName
+     */
+    async clearCache(tableName) {
+        await Promise.all((await readdir(join(this.databasePath, tableName, ".cache"))).map((file) => unlink(join(this.databasePath, tableName, ".cache", file))));
     }
     async get(tableName, where, options = {
         page: 1,
@@ -924,7 +944,7 @@ export default class Inibase {
             renameList = [];
             totalItems += Array.isArray(RETURN) ? RETURN.length : 1;
             if (this.tables[tableName].config.cache)
-                await this.clearCache(tablePath);
+                await this.clearCache(tableName);
             await writeFile(join(tablePath, ".pagination"), `${lastId},${totalItems}`);
             if (returnPostedData)
                 return this.get(tableName, this.tables[tableName].config.prepend
@@ -954,6 +974,7 @@ export default class Inibase {
             if (Utils.isArrayOfObjects(data)) {
                 if (!data.every((item) => Object.hasOwn(item, "id") && Utils.isValidID(item.id)))
                     throw this.throwError("INVALID_ID");
+                // TODO: Reduce I/O
                 return this.put(tableName, data, data
                     .filter(({ id }) => id !== undefined)
                     .map(({ id }) => id));
@@ -1022,7 +1043,7 @@ export default class Inibase {
                 await Promise.all(renameList.map(async ([tempPath, filePath]) => rename(tempPath, filePath)));
                 renameList = [];
                 if (this.tables[tableName].config.cache)
-                    await this.clearCache(tablePath);
+                    await this.clearCache(tableName);
                 if (returnUpdatedData)
                     return this.get(tableName, where, options, !Array.isArray(where));
             }
@@ -1052,7 +1073,7 @@ export default class Inibase {
                     ?.filter((fileName) => fileName.endsWith(".inib"))
                     .map(async (file) => unlink(join(tablePath, file))));
                 if (this.tables[tableName].config.cache)
-                    await this.clearCache(tablePath);
+                    await this.clearCache(tableName);
             }
             finally {
                 await File.unlock(join(tablePath, ".tmp"));
@@ -1074,7 +1095,7 @@ export default class Inibase {
                     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 (this.tables[tableName].config.cache)
-                        await this.clearCache(tablePath);
+                        await this.clearCache(tableName);
                     if (await File.isExists(join(tablePath, ".pagination"))) {
                         const [lastId, totalItems] = (await readFile(join(tablePath, ".pagination"), "utf8"))
                             .split(",")
@@ -1163,6 +1184,19 @@ export default class Inibase {
         }
         return RETURN;
     }
+    /**
+     * Sort column(s) of a table
+     *
+     * @param {string} tableName
+     * @param {(string
+     * 			| string[]
+     * 			| Record<string, 1 | -1 | "asc" | "ASC" | "desc" | "DESC">)} columns
+     * @param {(string | number | (string | number)[] | Criteria)} [where]
+     * @param {Options} [options={
+     * 			page: 1,
+     * 			perPage: 15,
+     * 		}]
+     */
     async sort(tableName, columns, where, options = {
         page: 1,
         perPage: 15,

package/dist/utils.d.ts

@@ -169,9 +169,34 @@ export declare function FormatObjectCriteriaValue(value: string, isParentArray?:
     ComparisonOperator,
     string | number | boolean | null | (string | number | null)[]
 ];
+/**
+ * Get field from schema
+ *
+ * @export
+ * @param {string} keyPath Support dot notation path
+ * @param {Schema} schema
+ */
 export declare function getField(keyPath: string, schema: Schema): Field | null;
+/**
+ * Override a schema field, key, type or other properties
+ *
+ * @export
+ * @param {string} keyPath Support dot notation path
+ * @param {Schema} schema
+ * @param {(Omit<Field, "key" | "type"> & {
+ * 		key?: string;
+ * 		type?: FieldType | FieldType[];
+ * 	})} field
+ */
 export declare function setField(keyPath: string, schema: Schema, field: Omit<Field, "key" | "type"> & {
     key?: string;
     type?: FieldType | FieldType[];
 }): Field | null | undefined;
+/**
+ * Remove field from schema
+ *
+ * @export
+ * @param {string} keyPath Support dot notation path
+ * @param {Schema} schema
+ */
 export declare function unsetField(keyPath: string, schema: Schema): Field | null | undefined;

package/dist/utils.js

@@ -346,6 +346,13 @@ export function FormatObjectCriteriaValue(value, isParentArray = false) {
             return ["=", value];
     }
 }
+/**
+ * Get field from schema
+ *
+ * @export
+ * @param {string} keyPath Support dot notation path
+ * @param {Schema} schema
+ */
 export function getField(keyPath, schema) {
     let RETURN = null;
     const keyPathSplited = keyPath.split(".");
@@ -364,6 +371,17 @@ export function getField(keyPath, schema) {
         return null;
     return isArrayOfObjects(RETURN) ? RETURN[0] : RETURN;
 }
+/**
+ * Override a schema field, key, type or other properties
+ *
+ * @export
+ * @param {string} keyPath Support dot notation path
+ * @param {Schema} schema
+ * @param {(Omit<Field, "key" | "type"> & {
+ * 		key?: string;
+ * 		type?: FieldType | FieldType[];
+ * 	})} field
+ */
 export function setField(keyPath, schema, field) {
     const keyPathSplited = keyPath.split(".");
     for (const [index, key] of keyPathSplited.entries()) {
@@ -380,6 +398,13 @@ export function setField(keyPath, schema, field) {
             schema = foundItem.children;
     }
 }
+/**
+ * Remove field from schema
+ *
+ * @export
+ * @param {string} keyPath Support dot notation path
+ * @param {Schema} schema
+ */
 export function unsetField(keyPath, schema) {
     const keyPathSplited = keyPath.split(".");
     let parent = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inibase",
-  "version": "1.0.0-rc.61",
+  "version": "1.0.0-rc.63",
   "author": {
     "name": "Karim Amahtil",
     "email": "karim.amahtil@gmail.com"
@@ -10,7 +10,6 @@
   "exports": {
     ".": "./dist/index.js",
     "./file": "./dist/file.js",
-    "./config": "./dist/config.js",
     "./utils": "./dist/utils.js",
     "./utils.server": "./dist/utils.server.js"
   },
@@ -63,9 +62,6 @@
       "utils": [
         "./dist/utils.d.ts"
       ],
-      "config": [
-        "./dist/config.d.ts"
-      ],
       "utils.server": [
         "./dist/utils.server.d.ts"
       ]

package/dist/config.d.ts

@@ -1,3 +0,0 @@
-export declare const isCompressionEnabled: boolean;
-export declare const isCacheEnabled: boolean;
-export declare const isReverseEnabled: boolean;

package/dist/config.js

@@ -1,3 +0,0 @@
-export const isCompressionEnabled = process.env.INIBASE_COMPRESSION === "true";
-export const isCacheEnabled = process.env.INIBASE_CACHE === "true";
-export const isReverseEnabled = process.env.INIBASE_REVERSE === "true";