inibase 1.0.0-rc.76 → 1.0.0-rc.78

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import "dotenv/config";
 import { readFileSync } from "node:fs";
-import { basename, join } from "node:path";
+import { join } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { parseArgs } from "node:util";
 import Inison from "inison";
@@ -12,10 +12,11 @@ const textGreen = (input) => `\u001b[1;32m${input}\u001b[0m`;
 const textRed = (input) => `\u001b[1;31m${input}\u001b[0m`;
 const textBlue = (input) => `\u001b[1;34m${input}\u001b[0m`;
 const textMagenta = (input) => `\u001b[1;35m${input}\u001b[0m`;
-let { path, version } = parseArgs({
+let { path, version, table } = parseArgs({
     options: {
         path: { type: "string", short: "p" },
         version: { type: "boolean", short: "v" },
+        table: { type: "string", short: "t" },
     },
 }).values;
 if (version) {
@@ -30,16 +31,15 @@ const rl = createInterface({
 const setPath = async (firstTime) => {
     if (!path)
         path = await rl.question(firstTime ? "Database path: " : "Please type a valid database path: ");
-    if (!path || !(await isExists(basename(path))))
+    if (!path || !(await isExists(path)))
         await setPath();
 };
 console.clear();
 await setPath(true);
-const db = new Inibase(basename(path));
+const db = new Inibase(path);
 process.stdout.write("\u001b[3J\u001b[2J\u001b[1J");
 console.clear();
 rl.prompt();
-let table;
 rl.on("line", async (input) => {
     const splitedInput = input
         .trim()
@@ -70,6 +70,7 @@ rl.on("line", async (input) => {
 	${textMagenta("--page")} | ${textMagenta("-p")}  number?	
 	${textMagenta("--per-page")} | ${textMagenta("-l")}  number?
 	${textMagenta("--columns")} | ${textMagenta("-c")}  columnName[]?
+	${textMagenta("--sort")} | ${textMagenta("-s")}  (string|string[]|Inison.stringify(sortObject))?
 	${textMagenta("--data")} | ${textMagenta("-d")}  Inison.stringify(Data) ${textRed("* POST & PUT")}`);
             break;
         }

package/dist/file.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 import type { ComparisonOperator, FieldType, Schema } from "./index.js";
 export declare const lock: (folderPath: string, prefix?: string) => Promise<void>;
 export declare const unlock: (folderPath: string, prefix?: string) => Promise<void>;
@@ -107,11 +106,7 @@ export declare const remove: (filePath: string, linesToDelete: number | number[]
  *
  * Note: Decodes each line for comparison and can handle complex queries with multiple conditions.
  */
-export declare const search: (filePath: string, operator: ComparisonOperator | ComparisonOperator[], comparedAtValue: string | number | boolean | null | (string | number | boolean | null)[], logicalOperator?: "and" | "or", fieldType?: FieldType | FieldType[], fieldChildrenType?: FieldType | FieldType[] | Schema, limit?: number, offset?: number, readWholeFile?: boolean, secretKey?: string | Buffer) => Promise<[
-    Record<number, string | number | boolean | null | (string | number | boolean | null)[]> | null,
-    number,
-    Set<number> | null
-]>;
+export declare const search: (filePath: string, operator: ComparisonOperator | ComparisonOperator[], comparedAtValue: string | number | boolean | null | (string | number | boolean | null)[], logicalOperator?: "and" | "or", fieldType?: FieldType | FieldType[], fieldChildrenType?: FieldType | FieldType[] | Schema, limit?: number, offset?: number, readWholeFile?: boolean, secretKey?: string | Buffer) => Promise<[Record<number, string | number | boolean | null | (string | number | boolean | null)[]> | null, number, Set<number> | null]>;
 /**
  * Asynchronously counts the number of lines in a file.
  *

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 import "dotenv/config";
 export interface Data {
     id?: number | string;

package/dist/index.js

@@ -222,30 +222,32 @@ export default class Inibase {
         const schemaFile = await readFile(tableSchemaPath, "utf8");
         if (!schemaFile)
             return undefined;
-        const schema = JSON.parse(schemaFile), lastIdNumber = UtilsServer.findLastIdNumber(schema, this.salt);
-        if (!encodeIDs)
-            return schema;
-        return [
+        let schema = JSON.parse(schemaFile);
+        const lastIdNumber = UtilsServer.findLastIdNumber(schema, this.salt);
+        schema = [
             {
-                id: UtilsServer.encodeID(0, this.salt),
+                id: 0,
                 key: "id",
                 type: "id",
                 required: true,
             },
-            ...UtilsServer.encodeSchemaID(schema, this.salt),
+            ...schema,
             {
-                id: UtilsServer.encodeID(lastIdNumber + 1, this.salt),
+                id: lastIdNumber + 1,
                 key: "createdAt",
                 type: "date",
                 required: true,
             },
             {
-                id: UtilsServer.encodeID(lastIdNumber + 2, this.salt),
+                id: lastIdNumber + 2,
                 key: "updatedAt",
                 type: "date",
                 required: false,
             },
         ];
+        if (!encodeIDs)
+            return schema;
+        return UtilsServer.encodeSchemaID(schema, this.salt);
     }
     async throwErrorIfTableEmpty(tableName) {
         const table = await this.getTable(tableName);
@@ -820,7 +822,7 @@ export default class Inibase {
                 (Utils.isObject(where) && !Object.keys(where).length)))
             where = undefined;
         if (options.sort) {
-            let sortArray, isLineNumbers = true, keepItems = [];
+            let sortArray, awkCommand = "";
             if (Utils.isObject(options.sort) && !Array.isArray(options.sort)) {
                 // {name: "ASC", age: "DESC"}
                 sortArray = Object.entries(options.sort).map(([key, value]) => [
@@ -838,16 +840,17 @@ export default class Inibase {
                 cacheKey = UtilsServer.hashString(inspect(sortArray, { sorted: true }));
             if (where) {
                 const lineNumbers = await this.get(tableName, where, undefined, undefined, true);
-                keepItems = Object.values((await File.get(join(tablePath, `id${this.getFileExtension(tableName)}`), lineNumbers, "number", undefined, this.salt)) ?? {}).map(Number);
-                isLineNumbers = false;
-                if (!keepItems.length)
+                if (!lineNumbers.length)
                     throw this.throwError("NO_RESULTS", tableName);
-                keepItems = keepItems.slice((options.page - 1) * options.perPage, options.page * options.perPage);
+                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(" || ")}'`;
             }
-            if (!keepItems.length)
-                keepItems = Array.from({ length: options.perPage }, (_, index) => (options.page - 1) * options.perPage +
+            else
+                awkCommand = `awk '${Array.from({ length: options.perPage }, (_, index) => (options.page - 1) * options.perPage +
                     index +
-                    1);
+                    1)
+                    .map((lineNumber) => `NR==${lineNumber}`)
+                    .join(" || ")}'`;
             const filesPathes = [["id", true], ...sortArray].map((column) => join(tablePath, `${column[0]}${this.getFileExtension(tableName)}`));
             for await (const path of filesPathes.slice(1))
                 if (!(await File.isExists(path)))
@@ -867,15 +870,11 @@ export default class Inibase {
             })
                 .join(" ");
             const sortCommand = `sort ${sortColumns} -T=${join(tablePath, ".tmp")}`;
-            // Construct the awk command to keep only the specified lines after sorting
-            const awkCommand = isLineNumbers
-                ? `awk '${keepItems.map((lineNumber) => `NR==${lineNumber}`).join(" || ")}'`
-                : `awk '${keepItems.map((id) => `$1 ~ /^${id} */`).join(" || ")}'`;
             try {
                 if (cacheKey)
                     await File.lock(join(tablePath, ".tmp"), cacheKey);
                 // Combine && Execute the commands synchronously
-                const lines = (await UtilsServer.exec(this.tables[tableName].config.cache
+                let lines = (await UtilsServer.exec(this.tables[tableName].config.cache
                     ? (await File.isExists(join(tablePath, ".cache", `${cacheKey}${this.fileExtension}`)))
                         ? `${awkCommand} ${join(tablePath, ".cache", `${cacheKey}${this.fileExtension}`)}`
                         : `${pasteCommand} | ${sortCommand} -o ${join(tablePath, ".cache", `${cacheKey}${this.fileExtension}`)} && ${awkCommand} ${join(tablePath, ".cache", `${cacheKey}${this.fileExtension}`)}`
@@ -884,6 +883,12 @@ export default class Inibase {
                 })).stdout
                     .trim()
                     .split("\n");
+                if (where)
+                    lines = lines.slice((options.page - 1) * options.perPage, options.page * options.perPage);
+                else if (!this.totalItems[`${tableName}-*`])
+                    this.totalItems[`${tableName}-*`] = await File.count(join(tablePath, `id${this.getFileExtension(tableName)}`));
+                if (!lines.length)
+                    return null;
                 // Parse the result and extract the specified lines
                 const outputArray = lines.map((line) => {
                     const splitedFileColumns = line.split("\t"); // Assuming tab-separated columns
@@ -914,11 +919,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 (await File.isExists(join(tablePath, ".cache", ".pagination")))
-                this.totalItems[`${tableName}-*`] = Number((await readFile(join(tablePath, ".cache", ".pagination"), "utf8")).split(",")[1]);
+            if (await File.isExists(join(tablePath, ".cache", ".pagination"))) {
+                if (!this.totalItems[`${tableName}-*`])
+                    this.totalItems[`${tableName}-*`] = Number((await readFile(join(tablePath, ".cache", ".pagination"), "utf8")).split(",")[1]);
+            }
             else {
                 const lastId = Number(Object.keys((await File.get(join(tablePath, `id${this.getFileExtension(tableName)}`), -1, "number", undefined, this.salt, true))?.[0] ?? 0));
-                this.totalItems[`${tableName}-*`] = await File.count(join(tablePath, `id${this.getFileExtension(tableName)}`));
+                if (!this.totalItems[`${tableName}-*`])
+                    this.totalItems[`${tableName}-*`] = await File.count(join(tablePath, `id${this.getFileExtension(tableName)}`));
                 await writeFile(join(tablePath, ".cache", ".pagination"), `${lastId},${this.totalItems[`${tableName}-*`]}`);
             }
         }
@@ -928,12 +936,12 @@ export default class Inibase {
             let lineNumbers = where;
             if (!Array.isArray(lineNumbers))
                 lineNumbers = [lineNumbers];
+            if (!this.totalItems[`${tableName}-*`])
+                this.totalItems[`${tableName}-*`] = lineNumbers.length;
             // useless
             if (onlyLinesNumbers)
                 return lineNumbers;
             RETURN = Object.values((await this.getItemsFromSchema(tableName, schema, lineNumbers, options)) ?? {});
-            if (!this.totalItems[`${tableName}-*`])
-                this.totalItems[`${tableName}-*`] = lineNumbers.length;
             if (RETURN?.length && !Array.isArray(where))
                 RETURN = RETURN[0];
         }
@@ -945,6 +953,8 @@ export default class Inibase {
             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);
+            if (!this.totalItems[`${tableName}-*`])
+                this.totalItems[`${tableName}-*`] = countItems;
             if (onlyLinesNumbers)
                 return Object.keys(lineNumbers).length
                     ? Object.keys(lineNumbers).map(Number)
@@ -955,8 +965,6 @@ export default class Inibase {
                     options.columns = undefined;
             }
             RETURN = Object.values((await this.getItemsFromSchema(tableName, schema, Object.keys(lineNumbers).map(Number), options)) ?? {});
-            if (!this.totalItems[`${tableName}-*`])
-                this.totalItems[`${tableName}-*`] = countItems;
             if (RETURN?.length && !Array.isArray(where))
                 RETURN = RETURN[0];
         }
@@ -968,7 +976,8 @@ export default class Inibase {
             if (this.tables[tableName].config.cache &&
                 (await File.isExists(cachedFilePath))) {
                 const cachedItems = (await readFile(cachedFilePath, "utf8")).split(",");
-                this.totalItems[`${tableName}-*`] = cachedItems.length;
+                if (!this.totalItems[`${tableName}-*`])
+                    this.totalItems[`${tableName}-*`] = cachedItems.length;
                 if (onlyLinesNumbers)
                     return cachedItems.map(Number);
                 return this.get(tableName, cachedItems
@@ -978,8 +987,10 @@ export default class Inibase {
             let linesNumbers = null;
             [RETURN, linesNumbers] = await this.applyCriteria(tableName, schema, options, where);
             if (RETURN && linesNumbers) {
+                if (!this.totalItems[`${tableName}-*`])
+                    this.totalItems[`${tableName}-*`] = linesNumbers.size;
                 if (onlyLinesNumbers)
-                    return Object.keys(RETURN).map(Number);
+                    return Array.from(linesNumbers);
                 const alreadyExistsColumns = Object.keys(Object.values(RETURN)[0]), alreadyExistsColumnsIDs = Utils.flattenSchema(schema)
                     .filter(({ key }) => alreadyExistsColumns.includes(key))
                     .map(({ id }) => id);
@@ -1028,7 +1039,8 @@ export default class Inibase {
                         .map(Number);
                 else {
                     lastId = Number(Object.keys((await File.get(join(tablePath, `id${this.getFileExtension(tableName)}`), -1, "number", undefined, this.salt, true))?.[0] ?? 0));
-                    this.totalItems[`${tableName}-*`] = await File.count(join(tablePath, `id${this.getFileExtension(tableName)}`));
+                    if (!this.totalItems[`${tableName}-*`])
+                        this.totalItems[`${tableName}-*`] = await File.count(join(tablePath, `id${this.getFileExtension(tableName)}`));
                 }
             }
             else

package/dist/utils.server.d.ts

@@ -1,6 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
 import { exec as execAsync, execFile as execFileAsync } from "node:child_process";
 import { gunzip as gunzipAsync, gzip as gzipAsync } from "node:zlib";
 import type { ComparisonOperator, Field, FieldType, Schema } from "./index.js";

package/package.json

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