inibase 1.1.21 → 1.1.23

package/dist/cli.js

@@ -7,7 +7,7 @@ import { parseArgs } from "node:util";
 import Inison from "inison";
 import { isExists } from "./file.js";
 import Inibase, {} from "./index.js";
-import { isStringified, isNumber, setField, unsetField } from "./utils.js";
+import { isNumber, isStringified, 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`;
@@ -197,7 +197,12 @@ rl.on("line", async (input) => {
                 console.log(`${textRed("  Err:")} Please specify table name`);
                 break;
             }
-            let where = undefined, page = undefined, perPage = undefined, columns = undefined, sort = undefined, data = undefined;
+            let where = undefined;
+            let page = undefined;
+            let perPage = undefined;
+            let columns = undefined;
+            let sort = undefined;
+            let data = undefined;
             if (splitedInput.toSpliced(0, 1).length) {
                 const parsedArgs = parseArgs({
                     args: splitedInput.toSpliced(0, table ? 1 : 2),

package/dist/file.d.ts

@@ -1,4 +1,4 @@
-import type { ComparisonOperator, FieldType, Schema } from "./index.js";
+import { type ComparisonOperator, type Field } 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>;
@@ -25,27 +25,30 @@ export declare const encode: (input: string | number | boolean | null | (string
  * 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.
+ * @param field - Field object config.
  * @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)[];
+export declare const decode: (input: string | null | number, field: Field & {
+    databasePath?: string;
+}) => 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.
+ * @param field - Field object config.
+ * @param readWholeFile - Optional Flag to indicate whether to continue reading the file after reaching the limit.
  * @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<[
+export declare function get(filePath: string, lineNumbers?: number | number[], field?: Field & {
+    databasePath?: string;
+}, 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[], field: undefined | (Field & {
+    databasePath?: string;
+}), readWholeFile: true): Promise<[
     Record<number, string | number | boolean | null | (string | number | boolean | (string | number | boolean)[] | null)[]> | null,
     number
 ]>;
@@ -95,19 +98,19 @@ export declare const remove: (filePath: string, linesToDelete: number | number[]
  * @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 field - Field object config.
  * @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", searchIn?: Set<number>, 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", searchIn?: Set<number>, field?: Field & {
+    databasePath?: string;
+}, limit?: number, offset?: number, readWholeFile?: boolean) => Promise<[Record<number, string | number | boolean | null | (string | number | boolean | null)[]> | null, number, Set<number> | null]>;
 /**
  * Asynchronously calculates the sum of numerical values from specified lines in a file.
  *

package/dist/file.js

@@ -5,6 +5,7 @@ import { Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { createGunzip, createGzip } from "node:zlib";
 import Inison from "inison";
+import { globalConfig, } from "./index.js";
 import { detectFieldType, isArrayOfObjects, isNumber, isObject, isStringified, } from "./utils.js";
 import { compare, encodeID, exec, gunzip, gzip } from "./utils.server.js";
 export const lock = async (folderPath, prefix) => {
@@ -131,34 +132,38 @@ const unSecureString = (input) => {
  * Handles different data types and structures, including nested arrays.
  *
  * @param value - The value to be decoded, can be string, number, or array.
- * @param fieldType - Optional type of the field to guide decoding (e.g., 'number', 'boolean').
- * @param fieldChildrenType - Optional type for children elements, used for arrays.
- * @param secretKey - Optional secret key for decoding, can be string or Buffer.
+ * @param field - Field object config.
  * @returns Decoded value, transformed according to the specified field type(s).
  */
-const decodeHelper = (value, fieldType, fieldChildrenType, secretKey) => {
-    if (Array.isArray(value) && fieldType !== "array")
-        return value.map((v) => decodeHelper(v, fieldType, fieldChildrenType, secretKey));
-    switch (fieldType) {
+const decodeHelper = (value, field) => {
+    if (Array.isArray(value) && field.type !== "array")
+        return value.map((v) => decodeHelper(v, field));
+    switch (field.type) {
         case "number":
             return isNumber(value) ? Number(value) : null;
         case "boolean":
             return typeof value === "string" ? value === "true" : Boolean(value);
         case "array":
             if (!Array.isArray(value))
-                return [value];
-            if (fieldChildrenType && !isArrayOfObjects(fieldChildrenType))
-                return fieldChildrenType
-                    ? value.map((v) => decode(v, Array.isArray(fieldChildrenType)
-                        ? detectFieldType(v, fieldChildrenType)
-                        : fieldChildrenType, undefined, secretKey))
-                    : value;
+                value = [value];
+            if (field.children && !isArrayOfObjects(field.children))
+                return value.map((v) => decode(v, {
+                    ...field,
+                    type: Array.isArray(field.children)
+                        ? detectFieldType(v, field.children)
+                        : field.children,
+                }));
             break;
         case "table":
-        case "id":
-            return isNumber(value) && secretKey
-                ? encodeID(value, secretKey)
+            return isNumber(value) &&
+                (!field.table ||
+                    !field.databasePath ||
+                    !globalConfig[field.databasePath].tables?.get(field.table)?.config
+                        .decodeID)
+                ? encodeID(value)
                 : value;
+        case "id":
+            return isNumber(value) ? encodeID(value) : value;
         default:
             return value;
     }
@@ -168,25 +173,21 @@ const decodeHelper = (value, fieldType, fieldChildrenType, secretKey) => {
  * 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.
+ * @param field - Field object config.
  * @returns Decoded value as a string, number, boolean, or array of these, or null if no fieldType or input is null/empty.
  */
-export const decode = (input, fieldType, fieldChildrenType, secretKey) => {
-    if (!fieldType)
-        return null;
+export const decode = (input, field) => {
     if (input === null || input === "")
         return undefined;
     // Detect the fieldType based on the input and the provided array of possible types.
-    if (Array.isArray(fieldType))
-        fieldType = detectFieldType(String(input), fieldType);
+    if (Array.isArray(field.type))
+        field.type = detectFieldType(String(input), field.type);
     // Decode the input using the decodeHelper function.
     return decodeHelper(typeof input === "string"
         ? isStringified(input)
             ? Inison.unstringify(input)
             : unSecureString(input)
-        : input, fieldType, fieldChildrenType, secretKey);
+        : input, field);
 };
 function _groupIntoRanges(arr, action = "p") {
     if (arr.length === 0)
@@ -211,25 +212,27 @@ function _groupIntoRanges(arr, action = "p") {
     ranges.push(start === end ? `${start}` : `${start},${end}`);
     return ranges.map((range) => `${range}${action}`).join(";");
 }
-export async function get(filePath, lineNumbers, fieldType, fieldChildrenType, secretKey, readWholeFile = false) {
+export async function get(filePath, lineNumbers, field, readWholeFile = false) {
     let fileHandle = null;
     try {
         fileHandle = await open(filePath, "r");
-        const rl = createReadLineInternface(filePath, fileHandle), lines = {};
+        const rl = createReadLineInternface(filePath, fileHandle);
+        const lines = {};
         let linesCount = 0;
         if (!lineNumbers) {
             for await (const line of rl) {
                 linesCount++;
-                lines[linesCount] = decode(line, fieldType, fieldChildrenType, secretKey);
+                lines[linesCount] = decode(line, field);
             }
         }
         else if (lineNumbers == -1) {
             const escapedFilePath = escapeShellPath(filePath);
             const command = filePath.endsWith(".gz")
                 ? `zcat ${escapedFilePath} | sed -n '$p'`
-                : `sed -n '$p' ${escapedFilePath}`, foundedLine = (await exec(command)).stdout.trimEnd();
+                : `sed -n '$p' ${escapedFilePath}`;
+            const foundedLine = (await exec(command)).stdout.trimEnd();
             if (foundedLine)
-                lines[linesCount] = decode(foundedLine, fieldType, fieldChildrenType, secretKey);
+                lines[linesCount] = decode(foundedLine, field);
         }
         else {
             lineNumbers = Array.isArray(lineNumbers) ? lineNumbers : [lineNumbers];
@@ -241,7 +244,7 @@ export async function get(filePath, lineNumbers, fieldType, fieldChildrenType, s
                     linesCount++;
                     if (!lineNumbersArray.has(linesCount))
                         continue;
-                    lines[linesCount] = decode(line, fieldType, fieldChildrenType, secretKey);
+                    lines[linesCount] = decode(line, field);
                     lineNumbersArray.delete(linesCount);
                 }
                 return [lines, linesCount];
@@ -249,10 +252,11 @@ export async function get(filePath, lineNumbers, fieldType, fieldChildrenType, s
             const escapedFilePath = escapeShellPath(filePath);
             const command = filePath.endsWith(".gz")
                 ? `zcat ${escapedFilePath} | sed -n '${_groupIntoRanges(lineNumbers)}'`
-                : `sed -n '${_groupIntoRanges(lineNumbers)}' ${escapedFilePath}`, foundedLines = (await exec(command)).stdout.trimEnd().split("\n");
+                : `sed -n '${_groupIntoRanges(lineNumbers)}' ${escapedFilePath}`;
+            const foundedLines = (await exec(command)).stdout.trimEnd().split("\n");
             let index = 0;
             for (const line of foundedLines) {
-                lines[lineNumbers[index]] = decode(line, fieldType, fieldChildrenType, secretKey);
+                lines[lineNumbers[index]] = decode(line, field);
                 index++;
             }
         }
@@ -504,19 +508,17 @@ export const remove = async (filePath, linesToDelete) => {
  * @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 field - Field object config.
  * @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 const search = async (filePath, operator, comparedAtValue, logicalOperator, searchIn, fieldType, fieldChildrenType, limit, offset, readWholeFile, secretKey) => {
+export const search = async (filePath, operator, comparedAtValue, logicalOperator, searchIn, field, limit, offset, readWholeFile) => {
     // Initialize a Map to store the matching lines with their line numbers.
     const matchingLines = {};
     // Initialize counters for line number, found items, and processed items.
@@ -526,10 +528,10 @@ export const search = async (filePath, operator, comparedAtValue, logicalOperato
     const meetsConditions = (value) => (Array.isArray(operator) &&
         Array.isArray(comparedAtValue) &&
         ((logicalOperator === "or" &&
-            operator.some((single_operator, index) => compare(single_operator, value, comparedAtValue[index], fieldType))) ||
-            operator.every((single_operator, index) => compare(single_operator, value, comparedAtValue[index], fieldType)))) ||
+            operator.some((single_operator, index) => compare(single_operator, value, comparedAtValue[index], field.type))) ||
+            operator.every((single_operator, index) => compare(single_operator, value, comparedAtValue[index], field.type)))) ||
         (!Array.isArray(operator) &&
-            compare(operator, value, comparedAtValue, fieldType));
+            compare(operator, value, comparedAtValue, field.type));
     try {
         // Open the file for reading.
         fileHandle = await open(filePath, "r");
@@ -544,7 +546,7 @@ export const search = async (filePath, operator, comparedAtValue, logicalOperato
                 (!searchIn.has(linesCount) || searchIn.has(-linesCount)))
                 continue;
             // Decode the line for comparison.
-            const decodedLine = decode(line, fieldType, fieldChildrenType, secretKey);
+            const decodedLine = decode(line, field);
             // Check if the line meets the specified conditions based on comparison and logical operators.
             const doesMeetCondition = (Array.isArray(decodedLine) &&
                 decodedLine.flat().some(meetsConditions)) ||
@@ -589,7 +591,8 @@ export const search = async (filePath, operator, comparedAtValue, logicalOperato
  * 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, fileHandle = null;
+    let sum = 0;
+    let fileHandle = null;
     try {
         fileHandle = await open(filePath, "r");
         const rl = createReadLineInternface(filePath, fileHandle);
@@ -600,7 +603,7 @@ export const sum = async (filePath, lineNumbers) => {
                 linesCount++;
                 if (!lineNumbersArray.has(linesCount))
                     continue;
-                sum += +(decode(line, "number") ?? 0);
+                sum += +(decode(line, { key: "BLABLA", type: "number" }) ?? 0);
                 lineNumbersArray.delete(linesCount);
                 if (!lineNumbersArray.size)
                     break;
@@ -608,7 +611,7 @@ export const sum = async (filePath, lineNumbers) => {
         }
         else
             for await (const line of rl)
-                sum += +(decode(line, "number") ?? 0);
+                sum += +(decode(line, { key: "BLABLA", type: "number" }) ?? 0);
         return sum;
     }
     finally {
@@ -625,7 +628,9 @@ 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, fileHandle = null, rl = null;
+    let max = 0;
+    let fileHandle = null;
+    let rl = null;
     try {
         fileHandle = await open(filePath, "r");
         rl = createReadLineInternface(filePath, fileHandle);
@@ -636,7 +641,7 @@ export const max = async (filePath, lineNumbers) => {
                 linesCount++;
                 if (!lineNumbersArray.has(linesCount))
                     continue;
-                const lineContentNum = +(decode(line, "number") ?? 0);
+                const lineContentNum = +(decode(line, { key: "BLABLA", type: "number" }) ?? 0);
                 if (lineContentNum > max)
                     max = lineContentNum;
                 lineNumbersArray.delete(linesCount);
@@ -646,7 +651,7 @@ export const max = async (filePath, lineNumbers) => {
         }
         else
             for await (const line of rl) {
-                const lineContentNum = +(decode(line, "number") ?? 0);
+                const lineContentNum = +(decode(line, { key: "BLABLA", type: "number" }) ?? 0);
                 if (lineContentNum > max)
                     max = lineContentNum;
             }
@@ -666,7 +671,8 @@ 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, fileHandle = null;
+    let min = 0;
+    let fileHandle = null;
     try {
         fileHandle = await open(filePath, "r");
         const rl = createReadLineInternface(filePath, fileHandle);
@@ -677,7 +683,7 @@ export const min = async (filePath, lineNumbers) => {
                 linesCount++;
                 if (!lineNumbersArray.has(linesCount))
                     continue;
-                const lineContentNum = +(decode(line, "number") ?? 0);
+                const lineContentNum = +(decode(line, { key: "BLABLA", type: "number" }) ?? 0);
                 if (lineContentNum < min)
                     min = lineContentNum;
                 lineNumbersArray.delete(linesCount);
@@ -687,7 +693,7 @@ export const min = async (filePath, lineNumbers) => {
         }
         else
             for await (const line of rl) {
-                const lineContentNum = +(decode(line, "number") ?? 0);
+                const lineContentNum = +(decode(line, { key: "BLABLA", type: "number" }) ?? 0);
                 if (lineContentNum < min)
                     min = lineContentNum;
             }

package/dist/index.d.ts

@@ -53,13 +53,18 @@ declare global {
 }
 export type ErrorCodes = "GROUP_UNIQUE" | "FIELD_UNIQUE" | "FIELD_REQUIRED" | "NO_SCHEMA" | "TABLE_EMPTY" | "INVALID_ID" | "INVALID_TYPE" | "INVALID_PARAMETERS" | "NO_ENV" | "TABLE_EXISTS" | "TABLE_NOT_EXISTS" | "INVALID_REGEX_MATCH";
 export type ErrorLang = "en" | "ar" | "fr" | "es";
+export declare const globalConfig: {
+    [database: string]: {
+        tables?: Map<string, TableObject>;
+    };
+} & {
+    salt?: string | Buffer;
+};
 export default class Inibase {
     pageInfo: Record<string, pageInfo>;
     language: ErrorLang;
-    salt: Buffer;
+    fileExtension: string;
     private databasePath;
-    private fileExtension;
-    private tablesMap;
     private uniqueMap;
     private totalItems;
     constructor(database: string, mainFolder?: string, language?: ErrorLang);