inibase 1.0.0-rc.74 → 1.0.0-rc.76

package/README.md

@@ -632,11 +632,11 @@ import Inibase from "inibase";
 const db = new Inibase("/databaseName");
 
 // order users by the age column
-await db.sort("user", "age");
+await db.get("user", undefined, { sort: "age" });
 
 // order users by the age and username columns
-await db.sort("user", ["age","username"]);
-await db.sort("user", {age: -1, username: "asc"});
+await db.get("user", undefined, { sort: ["age", "username"] });
+await db.get("user", undefined, { sort: {age: -1, username: "asc"} });
 ```
 </blockquote>
 </details>

package/dist/cli.js

@@ -196,7 +196,7 @@ rl.on("line", async (input) => {
                 console.log(`${textRed("  Err:")} Please specify table name`);
                 break;
             }
-            let where = undefined, page = undefined, perPage = undefined, columns = undefined, data = undefined;
+            let where = undefined, page = undefined, perPage = undefined, columns = undefined, sort = undefined, data = undefined;
             if (splitedInput.toSpliced(0, 1).length) {
                 const parsedArgs = parseArgs({
                     args: splitedInput.toSpliced(0, table ? 1 : 2),
@@ -204,6 +204,7 @@ rl.on("line", async (input) => {
                         where: { type: "string", short: "w" },
                         page: { type: "string", short: "p" },
                         perPage: { type: "string", short: "l" },
+                        sort: { type: "string", short: "s" },
                         columns: { type: "string", short: "c", multiple: true },
                         data: { type: "string", short: "d" },
                     },
@@ -216,6 +217,12 @@ rl.on("line", async (input) => {
                     else if (isJSON(parsedArgs.where))
                         where = Inison.unstringify(parsedArgs.where);
                 }
+                if (parsedArgs.sort) {
+                    if (isJSON(parsedArgs.sort))
+                        sort = Inison.unstringify(parsedArgs.sort);
+                    else
+                        sort = parsedArgs.sort;
+                }
                 page = Number(parsedArgs.page) ?? undefined;
                 perPage = Number(parsedArgs.perPage) ?? undefined;
                 columns = parsedArgs.columns;
@@ -229,6 +236,7 @@ rl.on("line", async (input) => {
                         page: Number(page) ?? 1,
                         perPage: Number(perPage) ?? 15,
                         columns,
+                        sort,
                     }));
                     break;
                 case "p":

package/dist/file.js

@@ -76,8 +76,11 @@ export const isExists = async (path) => {
 const secureString = (input) => {
     if (["true", "false"].includes(String(input)))
         return input ? 1 : 0;
-    if (typeof input !== "string")
+    if (typeof input !== "string") {
+        if (input === null || input === undefined)
+            return "";
         return input;
+    }
     let decodedInput = null;
     try {
         decodedInput = decodeURIComponent(input);

package/dist/index.d.ts

@@ -21,7 +21,7 @@ export interface Options {
     page?: number;
     perPage?: number;
     columns?: string[] | string;
-    order?: Record<string, "asc" | "desc">;
+    sort?: Record<string, 1 | -1 | "asc" | "ASC" | "desc" | "DESC"> | string[] | string;
 }
 export interface Config {
     compression?: boolean;
@@ -113,13 +113,14 @@ export default class Inibase {
      * @param {string} tableName
      * @param {(string | number | (string | number)[] | Criteria | undefined)} [where]
      * @param {(Options | undefined)} [options]
-     * @param {true} [onlyOne]
-     * @param {undefined} [onlyLinesNumbers]
-     * @param {boolean} [_skipIdColumn]
+     * @param {boolean} [onlyOne]
+     * @param {boolean} [onlyLinesNumbers]
      * @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[]>;
+    get(tableName: string, where: string | number | (string | number)[] | Criteria | undefined, options: Options | undefined, onlyOne: true, onlyLinesNumbers?: false): Promise<Data | null>;
+    get(tableName: string, where: string | number, options?: Options, onlyOne?: boolean, onlyLinesNumbers?: false): Promise<Data | null>;
+    get(tableName: string, where?: string | number | (string | number)[] | Criteria, options?: Options, onlyOne?: boolean, onlyLinesNumbers?: false): Promise<Data[] | null>;
+    get(tableName: string, where: string | number | (string | number)[] | Criteria | undefined, options: Options | undefined, onlyOne: boolean | undefined, onlyLinesNumbers: true): Promise<number[]>;
     /**
      * Create new item(s) in a table
      *
@@ -183,18 +184,4 @@ export default class Inibase {
      */
     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[]>;
 }

package/dist/index.js

@@ -794,16 +794,14 @@ export default class Inibase {
     async get(tableName, where, options = {
         page: 1,
         perPage: 15,
-    }, onlyOne, onlyLinesNumbers, _skipIdColumn) {
+    }, onlyOne, onlyLinesNumbers) {
         const tablePath = join(this.databasePath, tableName);
         // Ensure options.columns is an array
         if (options.columns) {
             options.columns = Array.isArray(options.columns)
                 ? options.columns
                 : [options.columns];
-            if (!_skipIdColumn &&
-                options.columns.length &&
-                !options.columns.includes("id"))
+            if (options.columns.length && !options.columns.includes("id"))
                 options.columns.push("id");
         }
         // Default values for page and perPage
@@ -821,6 +819,96 @@ export default class Inibase {
             ((Array.isArray(where) && !where.length) ||
                 (Utils.isObject(where) && !Object.keys(where).length)))
             where = undefined;
+        if (options.sort) {
+            let sortArray, isLineNumbers = true, keepItems = [];
+            if (Utils.isObject(options.sort) && !Array.isArray(options.sort)) {
+                // {name: "ASC", age: "DESC"}
+                sortArray = Object.entries(options.sort).map(([key, value]) => [
+                    key,
+                    typeof value === "string" ? value.toLowerCase() === "asc" : value > 0,
+                ]);
+            }
+            else
+                sortArray = []
+                    .concat(options.sort)
+                    .map((column) => [column, true]);
+            let cacheKey = "";
+            // Criteria
+            if (this.tables[tableName].config.cache)
+                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)
+                    throw this.throwError("NO_RESULTS", tableName);
+                keepItems = keepItems.slice((options.page - 1) * options.perPage, options.page * options.perPage);
+            }
+            if (!keepItems.length)
+                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]}${this.getFileExtension(tableName)}`));
+            for await (const path of filesPathes.slice(1))
+                if (!(await File.isExists(path)))
+                    return null;
+            // 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
+            const index = 2;
+            const sortColumns = sortArray
+                .map(([key, ascending], i) => {
+                const field = Utils.getField(key, schema);
+                if (field)
+                    return `-k${i + index},${i + index}${Utils.isFieldType(["id", "number", "date"], field.type, field.children)
+                        ? "n"
+                        : ""}${!ascending ? "r" : ""}`;
+                return "";
+            })
+                .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
+                    ? (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",
+                })).stdout
+                    .trim()
+                    .split("\n");
+                // Parse the result and extract the specified lines
+                const outputArray = lines.map((line) => {
+                    const splitedFileColumns = line.split("\t"); // Assuming tab-separated columns
+                    const outputObject = {};
+                    // Extract values for each file, including `id${this.getFileExtension(tableName)}`
+                    filesPathes.forEach((fileName, index) => {
+                        const field = Utils.getField(parse(fileName).name, schema);
+                        if (field)
+                            outputObject[field.key] = File.decode(splitedFileColumns[index], field?.type, field?.children, this.salt);
+                    });
+                    return outputObject;
+                });
+                const restOfColumns = await this.get(tableName, outputArray.map(({ id }) => id), (({ sort, ...rest }) => rest)(options));
+                return restOfColumns
+                    ? outputArray.map((item) => ({
+                        ...item,
+                        ...restOfColumns.find(({ id }) => id === item.id),
+                    }))
+                    : outputArray;
+            }
+            finally {
+                if (cacheKey)
+                    await File.unlock(join(tablePath, ".tmp"), cacheKey);
+            }
+        }
         if (!where) {
             // Display all data
             RETURN = Object.values(await this.getItemsFromSchema(tableName, schema, Array.from({ length: options.perPage }, (_, index) => (options.page - 1) * options.perPage +
@@ -861,6 +949,11 @@ export default class Inibase {
                 return Object.keys(lineNumbers).length
                     ? Object.keys(lineNumbers).map(Number)
                     : null;
+            if (options.columns) {
+                options.columns = options.columns.filter((column) => column !== "id");
+                if (!options.columns?.length)
+                    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;
@@ -1214,113 +1307,4 @@ 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,
-    }) {
-        const tablePath = join(this.databasePath, tableName), schema = (await this.throwErrorIfTableEmpty(tableName)).schema;
-        // Default values for page and perPage
-        options.page = options.page || 1;
-        options.perPage = options.perPage || 15;
-        let sortArray, isLineNumbers = true, keepItems = [];
-        if (Utils.isObject(columns) && !Array.isArray(columns)) {
-            // {name: "ASC", age: "DESC"}
-            sortArray = Object.entries(columns).map(([key, value]) => [
-                key,
-                typeof value === "string" ? value.toLowerCase() === "asc" : value > 0,
-            ]);
-        }
-        else {
-            if (!Array.isArray(columns))
-                columns = [columns];
-            sortArray = columns.map((column) => [column, true]);
-        }
-        let cacheKey = "";
-        // Criteria
-        if (this.tables[tableName].config.cache)
-            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)
-                throw this.throwError("NO_RESULTS", tableName);
-            keepItems = keepItems.slice((options.page - 1) * options.perPage, options.page * options.perPage);
-        }
-        if (!keepItems.length)
-            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]}${this.getFileExtension(tableName)}`));
-        // 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
-        const index = 2;
-        const sortColumns = sortArray
-            .map(([key, ascending], i) => {
-            const field = Utils.getField(key, schema);
-            if (field)
-                return `-k${i + index},${i + index}${field.type === "number" ? "n" : ""}${!ascending ? "r" : ""}`;
-            return "";
-        })
-            .join(" ");
-        const sortCommand = `sort ${sortColumns}`;
-        // Construct the awk command to keep only the specified lines after sorting
-        const awkCommand = isLineNumbers
-            ? `awk '${keepItems.map((line) => `NR==${line}`).join(" || ")}'`
-            : `awk 'NR==${keepItems[0]}${keepItems
-                .map((num) => `||NR==${num}`)
-                .join("")}'`;
-        try {
-            if (cacheKey)
-                await File.lock(join(tablePath, ".tmp"), cacheKey);
-            // Combine the commands
-            // Execute the command synchronously
-            const 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}`)}`
-                : `${pasteCommand} | ${sortCommand} | ${awkCommand}`, {
-                encoding: "utf-8",
-            })).stdout
-                .trim()
-                .split("\n");
-            // Parse the result and extract the specified lines
-            const outputArray = lines.map((line) => {
-                const splitedFileColumns = line.split("\t"); // Assuming tab-separated columns
-                const outputObject = {};
-                // Extract values for each file, including `id${this.getFileExtension(tableName)}`
-                filesPathes.forEach((fileName, index) => {
-                    const field = Utils.getField(parse(fileName).name, schema);
-                    if (field)
-                        outputObject[field.key] = File.decode(splitedFileColumns[index], field?.type, field?.children, this.salt);
-                });
-                return outputObject;
-            });
-            const restOfColumns = await this.get(tableName, outputArray.map(({ id }) => id), options, undefined, undefined, true);
-            return restOfColumns
-                ? outputArray.map((item, index) => ({
-                    ...item,
-                    ...restOfColumns[index],
-                }))
-                : outputArray;
-        }
-        finally {
-            if (cacheKey)
-                await File.unlock(join(tablePath, ".tmp"), cacheKey);
-        }
-    }
 }

package/dist/utils.js

@@ -417,10 +417,12 @@ export function FormatObjectCriteriaValue(value) {
  * @param {Schema} schema
  */
 export function getField(keyPath, schema) {
-    let RETURN = null;
+    let RETURN = schema;
     const keyPathSplited = keyPath.split(".");
     for (const [index, key] of keyPathSplited.entries()) {
-        const foundItem = schema.find((item) => item.key === key);
+        if (!isArrayOfObjects(RETURN))
+            return null;
+        const foundItem = RETURN.find((item) => item.key === key);
         if (!foundItem)
             return null;
         if (index === keyPathSplited.length - 1)

package/package.json

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