inibase 1.0.0-rc.75 → 1.0.0-rc.77

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/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

@@ -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);
@@ -794,16 +796,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 +821,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 +951,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 +1309,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/package.json

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