inibase 1.0.0-rc.9 → 1.0.0-rc.90

package/dist/cli.js

@@ -0,0 +1,272 @@
+#!/usr/bin/env node
+import "dotenv/config";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { parseArgs } from "node:util";
+import Inison from "inison";
+import { isExists } from "./file.js";
+import Inibase, {} from "./index.js";
+import { isJSON, isNumber, setField, unsetField } from "./utils.js";
+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, table } = parseArgs({
+    options: {
+        path: { type: "string", short: "p" },
+        version: { type: "boolean", short: "v" },
+        table: { type: "string", short: "t" },
+    },
+}).values;
+if (version) {
+    console.log(JSON.parse(readFileSync("package.json", "utf8")).version);
+    process.exit();
+}
+const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: textBlue(">  "),
+});
+const setPath = async (firstTime) => {
+    if (!path)
+        path = await rl.question(firstTime ? "Database path: " : "Please type a valid database path: ");
+    if (!path || !(await isExists(path)))
+        await setPath();
+};
+console.clear();
+await setPath(true);
+const db = new Inibase(path);
+process.stdout.write("\u001b[3J\u001b[2J\u001b[1J");
+console.clear();
+rl.prompt();
+rl.on("line", async (input) => {
+    const splitedInput = input
+        .trim()
+        .match(/[^\s"']+|"([^"]*)"|'([^']*)'/g);
+    switch (splitedInput[0].toLocaleLowerCase()) {
+        case "clear":
+            process.stdout.write("\u001b[3J\u001b[2J\u001b[1J");
+            console.clear();
+            rl.prompt();
+            break;
+        case "exit":
+            return process.exit();
+        // biome-ignore format:
+        case "help": {
+            if (!table)
+                console.log(` ${textBlue("table")} | ${textBlue("t")} ${textRed("<")}tableName${textRed(">*")}`);
+            console.log(`   ${textGreen("config")} | ${textGreen("c")}
+   	${textMagenta("get")} | ${textMagenta("g")} (compression|cache|prepend)?
+   	${textMagenta("set")} | ${textMagenta("s")} (compression true|false)? (cache true|false)? (prepend true|false)?
+   ${textGreen("schema")} | ${textGreen("s")}
+   	${textMagenta("get")} | ${textMagenta("g")}  ${textRed("<")}keyName${textRed(">*")}	
+	${textMagenta("set")} | ${textMagenta("s")}  ${textRed("<")}keyName${textRed(">*")} {{ Inison.stringify(Field) }}
+   ${textGreen("get")} | ${textGreen("g")}
+   ${textGreen("delete")} | ${textGreen("d")}
+   ${textGreen("post")} | ${textGreen("p")}
+   ${textGreen("put")} | ${textGreen("pu")}
+	${textMagenta("--where")} | ${textMagenta("-w")}  (ID|Inison.stringify(Criteria)|LineNumber)?
+	${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;
+        }
+        case "c":
+        case "config": {
+            if (!table) {
+                console.log(`${textRed("  Err:")} Please specify table name`);
+                break;
+            }
+            const config = (await db.getTable(table)).config;
+            if (!splitedInput[1]) {
+                console.log(JSON.stringify(config, undefined, 2));
+                break;
+            }
+            switch (splitedInput[1].toLocaleLowerCase()) {
+                case "g":
+                case "get": {
+                    if (!splitedInput[2])
+                        console.log(JSON.stringify(config, undefined, 2));
+                    else
+                        console.log(JSON.stringify(config[splitedInput[2]], undefined, 2));
+                    break;
+                }
+                case "s":
+                case "set": {
+                    const newConfigObject = {};
+                    splitedInput.splice(0, 2);
+                    for (let index = 0; index < splitedInput.length; index++) {
+                        const configName = splitedInput[index].toLocaleLowerCase();
+                        if (["true", "false"].includes(configName))
+                            continue;
+                        if (!["compression", "cache", "prepend"].includes(configName)) {
+                            console.log(`${textRed("  Err:")} '${configName}' is not a valid config`);
+                            break;
+                        }
+                        newConfigObject[configName] =
+                            splitedInput[index + 1].trim() === "true";
+                    }
+                    await db.updateTable(table, undefined, newConfigObject);
+                    break;
+                }
+                default:
+                    break;
+            }
+            break;
+        }
+        case "s":
+        case "schema": {
+            if (!table) {
+                console.log(`${textRed("  Err:")} Please specify table name`);
+                break;
+            }
+            const schema = (await db.getTable(table)).schema;
+            if (!splitedInput[1] || !splitedInput[2]) {
+                console.log(JSON.stringify(schema, undefined, 2));
+                break;
+            }
+            const key = splitedInput[2];
+            if (!key) {
+                console.log(`${textRed("  Err:")} Please specify key name`);
+                break;
+            }
+            const field = {};
+            field.key = key;
+            switch (splitedInput[1].toLocaleLowerCase()) {
+                case "p":
+                case "push":
+                    await db.updateTable(table, [...(schema ?? []), field]);
+                    break;
+                case "u":
+                case "unset":
+                case "s":
+                case "set": {
+                    if (!schema) {
+                        console.log(`${textRed("  Err:")} Schema is empty, please push first`);
+                        break;
+                    }
+                    if (["set", "s"].includes(splitedInput[1].toLocaleLowerCase())) {
+                        if (!splitedInput[2]) {
+                            console.log(`${textRed("  Err:")} Give the field a schema`);
+                            break;
+                        }
+                        try {
+                            Object.assign(field, Inison.unstringify(splitedInput[2]));
+                            setField(key, schema, field);
+                        }
+                        catch {
+                            console.log(`${textRed("  Err:")} Give the field a valid schema`);
+                            break;
+                        }
+                    }
+                    else
+                        unsetField(key, schema);
+                    await db.updateTable(table, schema);
+                    break;
+                }
+                default:
+                    break;
+            }
+            break;
+        }
+        case "t":
+        case "table":
+            if (!splitedInput[1]) {
+                console.log(`${textRed("  Err:")} Please specify table name`);
+                break;
+            }
+            if (!(await isExists(join(path, splitedInput[1]))))
+                console.log(`${textRed("  Err:")} Table doesn't exist`);
+            else {
+                table = splitedInput[1];
+                rl.setPrompt(textBlue(`${table} >  `));
+            }
+            break;
+        case "p":
+        case "post":
+        case "g":
+        case "get":
+        case "pu":
+        case "put":
+        case "d":
+        case "delete": {
+            if (!table) {
+                console.log(`${textRed("  Err:")} Please specify table name`);
+                break;
+            }
+            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),
+                    options: {
+                        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" },
+                    },
+                }).values;
+                if (parsedArgs.where) {
+                    if (parsedArgs.where === "'-1'" || parsedArgs.where === '"-1"')
+                        where = -1;
+                    else if (isNumber(parsedArgs.where))
+                        where = Number(parsedArgs.where);
+                    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;
+                if (parsedArgs.data && isJSON(parsedArgs.data))
+                    data = Inison.unstringify(parsedArgs.data);
+            }
+            switch (splitedInput[0].toLocaleLowerCase()) {
+                case "g":
+                case "get":
+                    console.log(await db.get(table, where, {
+                        page: Number(page) ?? 1,
+                        perPage: Number(perPage) ?? 15,
+                        columns,
+                        sort,
+                    }));
+                    break;
+                case "p":
+                case "post":
+                    console.log(await db.post(table, data, {
+                        page: Number(page) ?? 1,
+                        perPage: Number(perPage) ?? 15,
+                        columns,
+                    }, true));
+                    break;
+                case "pu":
+                case "put":
+                    console.log(await db.put(table, data, where, {
+                        page: Number(page) ?? 1,
+                        perPage: Number(perPage) ?? 15,
+                        columns,
+                    }, true));
+                    break;
+                case "d":
+                case "delete":
+                    console.log(await db.delete(table, where));
+                    break;
+                default:
+                    break;
+            }
+            break;
+        }
+        default:
+            break;
+    }
+    rl.prompt();
+});

package/dist/file.d.ts

@@ -0,0 +1,148 @@
+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>;
+export declare const write: (filePath: string, data: any) => Promise<void>;
+export declare const read: (filePath: string) => Promise<string>;
+/**
+ * Checks if a file or directory exists at the specified path.
+ *
+ * @param path - The path to the file or directory.
+ * @returns A Promise that resolves to true if the file/directory exists, false otherwise.
+ */
+export declare const isExists: (path: string) => Promise<boolean>;
+/**
+ * Encodes the input using 'secureString' and 'Inison.stringify' functions.
+ * If the input is an array, it is first secured and then joined into a string.
+ * If the input is a single value, it is directly secured.
+ *
+ * @param input - A value or array of values (string, number, boolean, null).
+ * @returns The secured and/or joined string.
+ */
+export declare const encode: (input: string | number | boolean | null | (string | number | boolean | null)[]) => string | number | boolean | null;
+/**
+ * Decodes the input based on the specified field type(s) and an optional secret key.
+ * Handles different formats of input, including strings, numbers, and their array representations.
+ *
+ * @param input - The input to be decoded, can be a string, number, or null.
+ * @param fieldType - Optional type of the field to guide decoding (e.g., 'number', 'boolean').
+ * @param fieldChildrenType - Optional type for child elements in array inputs.
+ * @param secretKey - Optional secret key for decoding, can be a string or Buffer.
+ * @returns Decoded value as a string, number, boolean, or array of these, or null if no fieldType or input is null/empty.
+ */
+export declare const decode: (input: string | null | number, fieldType?: FieldType | FieldType[], fieldChildrenType?: FieldType | FieldType[] | Schema, secretKey?: string | Buffer) => string | number | boolean | null | (string | number | null | boolean)[];
+/**
+ * Asynchronously reads and decodes data from a file at specified line numbers.
+ * Decodes each line based on specified field types and an optional secret key.
+ *
+ * @param filePath - Path of the file to be read.
+ * @param lineNumbers - Optional line number(s) to read from the file. If -1, reads the last line.
+ * @param fieldType - Optional type of the field to guide decoding (e.g., 'number', 'boolean').
+ * @param fieldChildrenType - Optional type for child elements in array inputs.
+ * @param secretKey - Optional secret key for decoding, can be a string or Buffer.
+ * @returns Promise resolving to a tuple:
+ *   1. Record of line numbers and their decoded content or null if no lines are read.
+ *   2. Total count of lines processed.
+ */
+export declare function get(filePath: string, lineNumbers?: number | number[], fieldType?: FieldType | FieldType[], fieldChildrenType?: FieldType | FieldType[] | Schema, secretKey?: string | Buffer, readWholeFile?: false): Promise<Record<number, string | number | boolean | null | (string | number | boolean | (string | number | boolean)[] | null)[]> | null>;
+export declare function get(filePath: string, lineNumbers: undefined | number | number[], fieldType: undefined | FieldType | FieldType[], fieldChildrenType: undefined | FieldType | FieldType[], secretKey: undefined | string | Buffer, readWholeFile: true): Promise<[
+    Record<number, string | number | boolean | null | (string | number | boolean | (string | number | boolean)[] | null)[]> | null,
+    number
+]>;
+/**
+ * Asynchronously replaces specific lines in a file based on the provided replacements map or string.
+ *
+ * @param filePath - Path of the file to modify.
+ * @param replacements - Map of line numbers to replacement values, or a single replacement value for all lines.
+ *   Can be a string, number, boolean, null, array of these types, or a Record/Map of line numbers to these types.
+ * @returns Promise<string[]>
+ *
+ * Note: If the file doesn't exist and replacements is an object, it creates a new file with the specified replacements.
+ */
+export declare const replace: (filePath: string, replacements: string | number | boolean | null | (string | number | boolean | null)[] | Record<number, string | boolean | number | null | (string | boolean | number | null)[]>) => Promise<string[]>;
+/**
+ * Asynchronously appends data to the end of a file.
+ *
+ * @param filePath - Path of the file to append to.
+ * @param data - Data to append. Can be a string, number, or an array of strings/numbers.
+ * @returns Promise<string[]>. Modifies the file by appending data.
+ *
+ */
+export declare const append: (filePath: string, data: string | number | (string | number)[]) => Promise<string[]>;
+/**
+ * Asynchronously prepends data to the beginning of a file.
+ *
+ * @param filePath - Path of the file to append to.
+ * @param data - Data to append. Can be a string, number, or an array of strings/numbers.
+ * @returns Promise<string[]>. Modifies the file by appending data.
+ *
+ */
+export declare const prepend: (filePath: string, data: string | number | (string | number)[]) => Promise<string[]>;
+/**
+ * Asynchronously removes specified lines from a file.
+ *
+ * @param filePath - Path of the file from which lines are to be removed.
+ * @param linesToDelete - A single line number or an array of line numbers to be deleted.
+ * @returns Promise<string[]>. Modifies the file by removing specified lines.
+ *
+ * Note: Creates a temporary file during the process and replaces the original file with it after removing lines.
+ */
+export declare const remove: (filePath: string, linesToDelete: number | number[]) => Promise<string[]>;
+/**
+ * Asynchronously searches a file for lines matching specified criteria, using comparison and logical operators.
+ *
+ * @param filePath - Path of the file to search.
+ * @param operator - Comparison operator(s) for evaluation (e.g., '=', '!=', '>', '<').
+ * @param comparedAtValue - Value(s) to compare each line against.
+ * @param logicalOperator - Optional logical operator ('and' or 'or') for combining multiple comparisons.
+ * @param fieldType - Optional type of the field to guide comparison.
+ * @param fieldChildrenType - Optional type for child elements in array inputs.
+ * @param limit - Optional limit on the number of results to return.
+ * @param offset - Optional offset to start returning results from.
+ * @param readWholeFile - Flag to indicate whether to continue reading the file after reaching the limit.
+ * @param secretKey - Optional secret key for decoding, can be a string or Buffer.
+ * @returns Promise resolving to a tuple:
+ *   1. Record of line numbers and their content that match the criteria or null if none.
+ *   2. The count of found items or processed items based on the 'readWholeFile' flag.
+ *
+ * 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]>;
+/**
+ * Asynchronously counts the number of lines in a file.
+ *
+ * @param filePath - Path of the file to count lines in.
+ * @returns Promise<number>. The number of lines in the file.
+ *
+ * Note: Reads through the file line by line to count the total number of lines.
+ */
+export declare const count: (filePath: string) => Promise<number>;
+/**
+ * Asynchronously calculates the sum of numerical values from specified lines in a file.
+ *
+ * @param filePath - Path of the file to read.
+ * @param lineNumbers - Optional specific line number(s) to include in the sum. If not provided, sums all lines.
+ * @returns Promise<number>. The sum of numerical values from the specified lines.
+ *
+ * Note: Decodes each line as a number using the 'decode' function. Non-numeric lines contribute 0 to the sum.
+ */
+export declare const sum: (filePath: string, lineNumbers?: number | number[]) => Promise<number>;
+/**
+ * Asynchronously finds the maximum numerical value from specified lines in a file.
+ *
+ * @param filePath - Path of the file to read.
+ * @param lineNumbers - Optional specific line number(s) to consider for finding the maximum value. If not provided, considers all lines.
+ * @returns Promise<number>. The maximum numerical value found in the specified lines.
+ *
+ * Note: Decodes each line as a number using the 'decode' function. Considers only numerical values for determining the maximum.
+ */
+export declare const max: (filePath: string, lineNumbers?: number | number[]) => Promise<number>;
+/**
+ * Asynchronously finds the minimum numerical value from specified lines in a file.
+ *
+ * @param filePath - Path of the file to read.
+ * @param lineNumbers - Optional specific line number(s) to consider for finding the minimum value. If not provided, considers all lines.
+ * @returns Promise<number>. The minimum numerical value found in the specified lines.
+ *
+ * Note: Decodes each line as a number using the 'decode' function. Considers only numerical values for determining the minimum.
+ */
+export declare const min: (filePath: string, lineNumbers?: number | number[]) => Promise<number>;