inibase 1.0.0-rc.106 → 1.0.0-rc.108

package/README.md

@@ -667,21 +667,22 @@ await db.get("user", undefined, { sort: {age: -1, username: "asc"} });
 
 ### Bulk
 
-|        | 10              | 100             | 1000            |
-|--------|-----------------|-----------------|-----------------|
-| POST   | 11 ms (0.65 mb) | 19 ms (1.00 mb) | 85 ms (4.58 mb) |
-| GET    | 14 ms (2.77 mb) | 12 ms (3.16 mb) | 34 ms (1.38 mb) |
-| PUT    | 6 ms (1.11 mb)  | 5 ms (1.37 mb)  | 10 ms (1.12 mb) |
-| DELETE | 17 ms (1.68 mb) | 14 ms (5.45 mb) | 25 ms (5.94 mb) |
+|        | 10                | 100               | 1000              |
+|--------|-------------------|-------------------|-------------------|
+| POST   | 11 ms (0.66 mb)   | 5 ms (1.02 mb)    | 24 ms (1.44 mb)   |
+| GET    | 29 ms (2.86 mb)   | 24 ms (2.81 mb)   | 36 ms (0.89 mb)   |
+| PUT    | 21 ms (2.68 mb)   | 16 ms (2.90 mb)   | 12 ms (0.63 mb)   |
+| DELETE | 14 ms (0.82 mb)   | 13 ms (0.84 mb)   | 2 ms (0.17 mb)    |
+
 
 ### Single
 
-|        | 10                | 100                | 1000               |
-|--------|-------------------|--------------------|--------------------|
-| POST   | 43 ms (4.70 mb)   | 387 ms (6.36 mb)   | 5341 ms (24.73 mb) |
-| GET    | 99 ms (12.51 mb)  | 846 ms (30.68 mb)  | 7103 ms (30.86 mb) |
-| PUT    | 33 ms (10.29 mb)  | 312 ms (11.06 mb)  | 3539 ms (14.87 mb) |
-| DELETE | 134 ms (13.50 mb) | 1224 ms (16.57 mb) | 7339 ms (11.46 mb) |
+|        | 10                  | 100                | 1000               |
+|--------|---------------------|--------------------|--------------------|
+| POST   | 45 ms (1.07 mb)     | 12 ms (0.52 mb)    | 11 ms (0.37 mb)    |
+| GET    | 200 ms (2.15 mb)    | 192 ms (2.72 mb)   | 190 ms (2.31 mb)   |
+| PUT    | 49 ms (3.22 mb)     | 17 ms (2.98 mb)    | 17 ms (3.06 mb)    |
+| DELETE | 118 ms (0.59 mb)    | 113 ms (0.51 mb)   | 103 ms (3.14 mb)   |
 
 > Default testing uses a table with username, email, and password fields, ensuring password encryption is included in the process<br>
 > To run benchmarks, install _typescript_ & _[tsx](https://github.com/privatenumber/tsx)_ globally and run `benchmark` by default bulk, for single use `benchmark --single|-s`

package/dist/file.d.ts

@@ -108,15 +108,6 @@ 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]>;
-/**
- * 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.
  *

package/dist/file.js

@@ -176,7 +176,7 @@ export const decode = (input, fieldType, fieldChildrenType, secretKey) => {
     if (!fieldType)
         return null;
     if (input === null || input === "")
-        return null;
+        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);
@@ -187,6 +187,29 @@ export const decode = (input, fieldType, fieldChildrenType, secretKey) => {
             : unSecureString(input)
         : input, fieldType, fieldChildrenType, secretKey);
 };
+function _groupIntoRanges(arr, action = "p") {
+    if (arr.length === 0)
+        return [];
+    arr.sort((a, b) => a - b); // Ensure the array is sorted
+    const ranges = [];
+    let start = arr[0];
+    let end = arr[0];
+    for (let i = 1; i < arr.length; i++) {
+        if (arr[i] === end + 1) {
+            // Continue the range
+            end = arr[i];
+        }
+        else {
+            // End the current range and start a new one
+            ranges.push(start === end ? `${start}` : `${start},${end}`);
+            start = arr[i];
+            end = arr[i];
+        }
+    }
+    // Push the last range
+    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) {
     let fileHandle = null;
     try {
@@ -224,8 +247,8 @@ export async function get(filePath, lineNumbers, fieldType, fieldChildrenType, s
             }
             const escapedFilePath = `${escapeShellPath(filePath)}`;
             const command = filePath.endsWith(".gz")
-                ? `zcat "${escapedFilePath}" | sed -n '${lineNumbers.join("p;")}p'`
-                : `sed -n '${lineNumbers.join("p;")}p' "${escapedFilePath}"`, foundedLines = (await exec(command)).stdout.trimEnd().split("\n");
+                ? `zcat "${escapedFilePath}" | sed -n '${_groupIntoRanges(lineNumbers)}'`
+                : `sed -n '${_groupIntoRanges(lineNumbers)}' "${escapedFilePath}"`, foundedLines = (await exec(command)).stdout.trimEnd().split("\n");
             let index = 0;
             for (const line of foundedLines) {
                 lines[lineNumbers[index]] = decode(line, fieldType, fieldChildrenType, secretKey);
@@ -454,8 +477,8 @@ export const remove = async (filePath, linesToDelete) => {
         const escapedFilePath = `${escapeShellPath(filePath)}`;
         const escapedFileTempPath = `${escapeShellPath(fileTempPath)}`;
         const command = filePath.endsWith(".gz")
-            ? `zcat ${escapedFilePath} | sed "${linesToDelete.join("d;")}d" | gzip > ${fileTempPath}`
-            : `sed "${linesToDelete.join("d;")}d" ${escapedFilePath} > ${escapedFileTempPath}`;
+            ? `zcat ${escapedFilePath} | sed '${_groupIntoRanges(linesToDelete, "d")}' | gzip > ${fileTempPath}`
+            : `sed '${_groupIntoRanges(linesToDelete, "d")}' ${escapedFilePath} > ${escapedFileTempPath}`;
         await exec(command);
         return [fileTempPath, filePath];
     }
@@ -535,31 +558,6 @@ export const search = async (filePath, operator, comparedAtValue, logicalOperato
         await fileHandle?.close();
     }
 };
-/**
- * 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 const count = async (filePath) => {
-    // Number((await exec(`wc -l < ${filePath}`)).stdout.trimEnd());
-    let linesCount = 0;
-    if (await isExists(filePath)) {
-        let fileHandle = null;
-        try {
-            fileHandle = await open(filePath, "r");
-            const rl = createReadLineInternface(filePath, fileHandle);
-            for await (const _ of rl)
-                linesCount++;
-        }
-        finally {
-            await fileHandle?.close();
-        }
-    }
-    return linesCount;
-};
 /**
  * Asynchronously calculates the sum of numerical values from specified lines in a file.
  *

package/dist/index.d.ts

@@ -100,8 +100,16 @@ export default class Inibase {
     private _combineObjectsToArray;
     private _CombineData;
     private joinPathesContents;
-    private _getItemsFromSchemaHelper;
-    private getItemsFromSchema;
+    private _processSchemaDataHelper;
+    private processSchemaData;
+    private isSimpleField;
+    private processSimpleField;
+    private isArrayField;
+    private processArrayField;
+    private isObjectField;
+    private processObjectField;
+    private isTableField;
+    private processTableField;
     private applyCriteria;
     private _filterSchemaByColumns;
     /**

package/dist/index.js

@@ -142,7 +142,9 @@ export default class Inibase {
             let schemaIdFilePath;
             for await (const filePath of glob("*.schema", { cwd: this.databasePath }))
                 schemaIdFilePath = filePath;
-            const lastSchemaId = Number(parse(schemaIdFilePath).name);
+            const lastSchemaId = schemaIdFilePath
+                ? Number(parse(schemaIdFilePath).name)
+                : 0;
             if (await File.isExists(join(tablePath, "schema.json"))) {
                 // update columns files names based on field id
                 schema = UtilsServer.addIdToSchema(schema, lastSchemaId, this.salt);
@@ -158,7 +160,10 @@ export default class Inibase {
             else
                 schema = UtilsServer.addIdToSchema(schema, lastSchemaId, this.salt);
             await writeFile(join(tablePath, "schema.json"), JSON.stringify(schema, null, 2));
-            await rename(schemaIdFilePath, join(tablePath, `${lastSchemaId}.schema`));
+            if (schemaIdFilePath)
+                await rename(schemaIdFilePath, join(tablePath, `${lastSchemaId}.schema`));
+            else
+                await writeFile(join(tablePath, `${lastSchemaId}.schema`), "");
         }
         if (config) {
             if (config.compression !== undefined &&
@@ -433,15 +438,6 @@ export default class Inibase {
             });
         switch (field.type) {
             case "array":
-                return Utils.isArrayOfObjects(field.children)
-                    ? [
-                        this.getDefaultValue({
-                            ...field,
-                            type: "object",
-                            children: field.children,
-                        }),
-                    ]
-                    : null;
             case "object": {
                 if (!field.children || !Utils.isArrayOfObjects(field.children))
                     return null;
@@ -491,12 +487,14 @@ export default class Inibase {
             newCombinedData[join(tablePath, `${key}${this.getFileExtension(tableName)}`)] = value;
         return newCombinedData;
     }
-    _getItemsFromSchemaHelper(RETURN, item, index, field) {
+    _processSchemaDataHelper(RETURN, item, index, field) {
+        // If the item is an object, we need to process its children
         if (Utils.isObject(item)) {
             if (!RETURN[index])
-                RETURN[index] = {};
+                RETURN[index] = {}; // Ensure the index exists
             if (!RETURN[index][field.key])
                 RETURN[index][field.key] = [];
+            // Process children fields (recursive if needed)
             for (const child_field of field.children.filter((children) => children.type === "array" &&
                 Utils.isArrayOfObjects(children.children))) {
                 if (Utils.isObject(item[child_field.key])) {
@@ -517,8 +515,8 @@ export default class Inibase {
                             }
                             else {
                                 value[_i].forEach((_element, _index) => {
-                                    // Recursive call
-                                    this._getItemsFromSchemaHelper(RETURN[index][field.key][_i][child_field.key][_index], _element, _index, child_field);
+                                    // Recursive call to handle nested structure
+                                    this._processSchemaDataHelper(RETURN, _element, _index, child_field);
                                     // Perform property assignments
                                     if (!RETURN[index][field.key][_i][child_field.key][_index])
                                         RETURN[index][field.key][_i][child_field.key][_index] = {};
@@ -532,175 +530,228 @@ export default class Inibase {
             }
         }
     }
-    async getItemsFromSchema(tableName, schema, linesNumber, options, prefix) {
-        const tablePath = join(this.databasePath, tableName);
+    async processSchemaData(tableName, schema, linesNumber, options, prefix) {
         const RETURN = {};
-        for await (const field of schema) {
-            if ((field.type === "array" ||
-                (Array.isArray(field.type) && field.type.includes("array"))) &&
-                field.children) {
-                if (Utils.isArrayOfObjects(field.children)) {
-                    if (field.children.filter((children) => children.type === "array" &&
-                        Utils.isArrayOfObjects(children.children)).length) {
-                        // one of children has array field type and has children array of object = Schema
-                        const childItems = await this.getItemsFromSchema(tableName, field.children.filter((children) => children.type === "array" &&
-                            Utils.isArrayOfObjects(children.children)), linesNumber, options, `${(prefix ?? "") + field.key}.`);
-                        if (childItems)
-                            for (const [index, item] of Object.entries(childItems))
-                                this._getItemsFromSchemaHelper(RETURN, item, index, field);
-                        field.children = field.children.filter((children) => children.type !== "array" ||
-                            !Utils.isArrayOfObjects(children.children));
-                    }
-                    const fieldItems = await this.getItemsFromSchema(tableName, field.children, linesNumber, options, `${(prefix ?? "") + field.key}.`);
-                    if (fieldItems)
-                        for (const [index, item] of Object.entries(fieldItems)) {
-                            if (!RETURN[index])
-                                RETURN[index] = {};
-                            if (Utils.isObject(item)) {
-                                if (!Utils.isArrayOfNulls(Object.values(item))) {
-                                    if (RETURN[index][field.key])
-                                        Object.entries(item).forEach(([key, value], _index) => {
-                                            for (let _index = 0; _index < value.length; _index++)
-                                                if (RETURN[index][field.key][_index])
-                                                    Object.assign(RETURN[index][field.key][_index], {
-                                                        [key]: value[_index],
-                                                    });
-                                                else
-                                                    RETURN[index][field.key][_index] = {
-                                                        [key]: value[_index],
-                                                    };
-                                        });
-                                    else if (Object.values(item).every((_i) => Utils.isArrayOfArrays(_i) || Array.isArray(_i)) &&
-                                        prefix)
-                                        RETURN[index][field.key] = item;
-                                    else {
-                                        RETURN[index][field.key] = [];
-                                        Object.entries(item).forEach(([key, value], _ind) => {
-                                            if (!Array.isArray(value)) {
-                                                RETURN[index][field.key][_ind] = {};
-                                                RETURN[index][field.key][_ind][key] = value;
-                                            }
+        for (const field of schema) {
+            // If the field is of simple type (non-recursive), process it directly
+            if (this.isSimpleField(field.type)) {
+                await this.processSimpleField(tableName, field, linesNumber, RETURN, options, prefix);
+            }
+            else if (this.isArrayField(field.type)) {
+                // Process array fields (recursive if needed)
+                await this.processArrayField(tableName, field, linesNumber, RETURN, options, prefix);
+            }
+            else if (this.isObjectField(field.type)) {
+                // Process object fields (recursive if needed)
+                await this.processObjectField(tableName, field, linesNumber, RETURN, options, prefix);
+            }
+            else if (this.isTableField(field.type)) {
+                // Process table reference fields
+                await this.processTableField(tableName, field, linesNumber, RETURN, options, prefix);
+            }
+        }
+        return RETURN;
+    }
+    // Helper function to determine if a field is simple
+    isSimpleField(fieldType) {
+        const simpleTypes = [
+            "string",
+            "number",
+            "boolean",
+            "date",
+            "email",
+            "password",
+            "html",
+            "ip",
+            "json",
+            "id",
+        ];
+        if (Array.isArray(fieldType))
+            return fieldType.every((type) => typeof type === "string" && simpleTypes.includes(type));
+        return simpleTypes.includes(fieldType);
+    }
+    // Process a simple field (non-recursive)
+    async processSimpleField(tableName, field, linesNumber, RETURN, _options, prefix) {
+        const fieldPath = join(this.databasePath, tableName, `${prefix ?? ""}${field.key}${this.getFileExtension(tableName)}`);
+        if (await File.isExists(fieldPath)) {
+            const items = await File.get(fieldPath, linesNumber, field.type, field.children, this.salt);
+            if (items) {
+                for (const [index, item] of Object.entries(items)) {
+                    if (typeof item === "undefined")
+                        continue; // Skip undefined items
+                    if (!RETURN[index])
+                        RETURN[index] = {}; // Ensure the index exists
+                    RETURN[index][field.key] = item; // Assign item to the RETURN object
+                }
+            }
+        }
+    }
+    // Helper function to check if the field type is array
+    isArrayField(fieldType) {
+        return ((Array.isArray(fieldType) &&
+            fieldType.every((type) => typeof type === "string") &&
+            fieldType.includes("array")) ||
+            fieldType === "array");
+    }
+    // Process array fields (recursive if needed)
+    async processArrayField(tableName, field, linesNumber, RETURN, options, prefix) {
+        if (Array.isArray(field.children)) {
+            if (this.isSimpleField(field.children)) {
+                await this.processSimpleField(tableName, field, linesNumber, RETURN, options, prefix);
+            }
+            else if (this.isTableField(field.children)) {
+                await this.processTableField(tableName, field, linesNumber, RETURN, options, prefix);
+            }
+            else {
+                // Handling array of objects and filtering nested arrays
+                const nestedArrayFields = field.children.filter((child) => child.type === "array" &&
+                    Utils.isArrayOfObjects(child.children));
+                if (nestedArrayFields.length > 0) {
+                    // one of children has array field type and has children array of object = Schema
+                    const childItems = await this.processSchemaData(tableName, field.children.filter((children) => children.type === "array" &&
+                        Utils.isArrayOfObjects(children.children)), linesNumber, options, `${(prefix ?? "") + field.key}.`);
+                    if (childItems)
+                        for (const [index, item] of Object.entries(childItems))
+                            this._processSchemaDataHelper(RETURN, item, index, field);
+                    // Remove nested arrays after processing
+                    field.children = field.children.filter((child) => child.type === "array" &&
+                        Utils.isArrayOfObjects(child.children));
+                }
+                // Process remaining items for the field's children
+                const items = await this.processSchemaData(tableName, field.children, linesNumber, options, `${(prefix ?? "") + field.key}.`);
+                // Process the items after retrieval
+                if (items) {
+                    for (const [index, item] of Object.entries(items)) {
+                        if (typeof item === "undefined")
+                            continue; // Skip undefined items
+                        if (!RETURN[index])
+                            RETURN[index] = {};
+                        if (Utils.isObject(item)) {
+                            if (!Utils.isArrayOfNulls(Object.values(item))) {
+                                if (RETURN[index][field.key])
+                                    Object.entries(item).forEach(([key, value], _index) => {
+                                        for (let _index = 0; _index < value.length; _index++)
+                                            if (RETURN[index][field.key][_index])
+                                                Object.assign(RETURN[index][field.key][_index], {
+                                                    [key]: value[_index],
+                                                });
                                             else
-                                                for (let _i = 0; _i < value.length; _i++) {
-                                                    if (value[_i] === null ||
-                                                        (Array.isArray(value[_i]) &&
-                                                            Utils.isArrayOfNulls(value[_i])))
-                                                        continue;
-                                                    if (!RETURN[index][field.key][_i])
-                                                        RETURN[index][field.key][_i] = {};
-                                                    RETURN[index][field.key][_i][key] = value[_i];
-                                                }
-                                        });
-                                    }
+                                                RETURN[index][field.key][_index] = {
+                                                    [key]: value[_index],
+                                                };
+                                    });
+                                else if (Object.values(item).every((_i) => Utils.isArrayOfArrays(_i) || Array.isArray(_i)) &&
+                                    prefix)
+                                    RETURN[index][field.key] = item;
+                                else {
+                                    RETURN[index][field.key] = [];
+                                    Object.entries(item).forEach(([key, value], _ind) => {
+                                        if (!Array.isArray(value)) {
+                                            RETURN[index][field.key][_ind] = {};
+                                            RETURN[index][field.key][_ind][key] = value;
+                                        }
+                                        else
+                                            for (let _i = 0; _i < value.length; _i++) {
+                                                if (value[_i] === null ||
+                                                    (Array.isArray(value[_i]) &&
+                                                        Utils.isArrayOfNulls(value[_i])))
+                                                    continue;
+                                                if (!RETURN[index][field.key][_i])
+                                                    RETURN[index][field.key][_i] = {};
+                                                RETURN[index][field.key][_i][key] = value[_i];
+                                            }
+                                    });
                                 }
-                                else
-                                    RETURN[index][field.key] = null;
                             }
                             else
-                                RETURN[index][field.key] = item;
-                        }
-                }
-                else if (field.children === "table" ||
-                    (Array.isArray(field.type) && field.type.includes("table")) ||
-                    (Array.isArray(field.children) && field.children.includes("table"))) {
-                    if (field.table &&
-                        (await File.isExists(join(this.databasePath, field.table))) &&
-                        (await File.isExists(join(tablePath, `${(prefix ?? "") + field.key}${this.getFileExtension(tableName)}`)))) {
-                        const itemsIDs = await File.get(join(tablePath, `${(prefix ?? "") + field.key}${this.getFileExtension(tableName)}`), linesNumber, field.type, field.children, this.salt);
-                        if (itemsIDs) {
-                            const searchableIDs = new Map();
-                            for (const [lineNumber, lineContent] of Object.entries(itemsIDs)) {
-                                if (!RETURN[lineNumber])
-                                    RETURN[lineNumber] = {};
-                                if (lineContent !== null && lineContent !== undefined)
-                                    searchableIDs.set(lineNumber, lineContent);
-                            }
-                            if (searchableIDs.size) {
-                                const items = await this.get(field.table, Array.from(new Set(Array.from(searchableIDs.values()).flat())), {
-                                    ...options,
-                                    perPage: Number.POSITIVE_INFINITY,
-                                    columns: options.columns
-                                        ?.filter((column) => column.includes(`${field.key}.`))
-                                        .map((column) => column.replace(`${field.key}.`, "")),
-                                });
-                                if (items) {
-                                    for (const [lineNumber, lineContent,] of searchableIDs.entries()) {
-                                        const foundedItems = items.filter(({ id }) => lineContent.includes(id));
-                                        if (foundedItems)
-                                            RETURN[lineNumber][field.key] = foundedItems;
-                                    }
-                                }
-                            }
+                                RETURN[index][field.key] = null;
                         }
+                        else
+                            RETURN[index][field.key] = item;
                     }
                 }
-                else if (await File.isExists(join(tablePath, `${(prefix ?? "") + field.key}${this.getFileExtension(tableName)}`))) {
-                    const items = await File.get(join(tablePath, `${(prefix ?? "") + field.key}${this.getFileExtension(tableName)}`), linesNumber, field.type, field.children, this.salt);
-                    if (items)
-                        for (const [index, item] of Object.entries(items)) {
-                            if (!RETURN[index])
-                                RETURN[index] = {};
-                            if (item !== null && item !== undefined)
-                                RETURN[index][field.key] = item;
-                        }
+            }
+        }
+        else if (this.isSimpleField(field.children)) {
+            // If `children` is FieldType, handle it as an array of simple types (no recursion needed here)
+            await this.processSimpleField(tableName, field, linesNumber, RETURN, options, prefix);
+        }
+        else if (this.isTableField(field.children)) {
+            await this.processTableField(tableName, field, linesNumber, RETURN, options, prefix);
+        }
+    }
+    // Helper function to check if the field type is object
+    isObjectField(fieldType) {
+        return (fieldType === "object" ||
+            (Array.isArray(fieldType) &&
+                fieldType.every((type) => typeof type === "string") &&
+                fieldType.includes("object")));
+    }
+    // Process object fields (recursive if needed)
+    async processObjectField(tableName, field, linesNumber, RETURN, options, prefix) {
+        if (Array.isArray(field.children)) {
+            // If `children` is a Schema (array of Field objects), recurse
+            const items = await this.processSchemaData(tableName, field.children, linesNumber, options, `${prefix ?? ""}${field.key}.`);
+            for (const [index, item] of Object.entries(items)) {
+                if (typeof item === "undefined")
+                    continue; // Skip undefined items
+                if (!RETURN[index])
+                    RETURN[index] = {};
+                if (Utils.isObject(item)) {
+                    if (!Object.values(item).every((i) => i === null))
+                        RETURN[index][field.key] = item;
                 }
             }
-            else if (field.type === "object") {
-                const fieldItems = await this.getItemsFromSchema(tableName, field.children, linesNumber, options, `${(prefix ?? "") + field.key}.`);
-                if (fieldItems)
-                    for (const [index, item] of Object.entries(fieldItems)) {
-                        if (!RETURN[index])
-                            RETURN[index] = {};
-                        if (Utils.isObject(item)) {
-                            if (!Object.values(item).every((i) => i === null))
-                                RETURN[index][field.key] = item;
-                        }
+        }
+    }
+    // Helper function to check if the field type is table
+    isTableField(fieldType) {
+        return (fieldType === "table" ||
+            (Array.isArray(fieldType) &&
+                fieldType.every((type) => typeof type === "string") &&
+                fieldType.includes("table")));
+    }
+    // Process table reference fields
+    async processTableField(tableName, field, linesNumber, RETURN, options, prefix) {
+        if (field.table &&
+            (await File.isExists(join(this.databasePath, field.table)))) {
+            const fieldPath = join(this.databasePath, tableName, `${prefix ?? ""}${field.key}${this.getFileExtension(tableName)}`);
+            if (await File.isExists(fieldPath)) {
+                const itemsIDs = await File.get(fieldPath, linesNumber, field.type, field.children, this.salt);
+                const isArrayField = this.isArrayField(field.type);
+                if (itemsIDs) {
+                    const searchableIDs = new Map();
+                    for (const [lineNumber, lineContent] of Object.entries(itemsIDs)) {
+                        if (typeof lineContent === "undefined")
+                            continue; // Skip undefined items
+                        if (!RETURN[lineNumber])
+                            RETURN[lineNumber] = {};
+                        if (lineContent !== null && lineContent !== undefined)
+                            searchableIDs.set(lineNumber, lineContent);
                     }
-            }
-            else if (field.type === "table") {
-                if (field.table &&
-                    (await File.isExists(join(this.databasePath, field.table))) &&
-                    (await File.isExists(join(tablePath, `${(prefix ?? "") + field.key}${this.getFileExtension(tableName)}`)))) {
-                    const itemsIDs = await File.get(join(tablePath, `${(prefix ?? "") + field.key}${this.getFileExtension(tableName)}`), linesNumber, field.type, field.children, this.salt);
-                    if (itemsIDs) {
-                        const searchableIDs = new Map();
-                        for (const [lineNumber, lineContent] of Object.entries(itemsIDs)) {
-                            if (!RETURN[lineNumber])
-                                RETURN[lineNumber] = {};
-                            if (lineContent !== null && lineContent !== undefined)
-                                searchableIDs.set(lineNumber, lineContent);
-                        }
-                        if (searchableIDs.size) {
-                            const items = await this.get(field.table, Array.from(new Set(searchableIDs.values())), {
-                                ...options,
-                                perPage: Number.POSITIVE_INFINITY,
-                                columns: options.columns
-                                    ?.filter((column) => column.includes(`${field.key}.`))
-                                    .map((column) => column.replace(`${field.key}.`, "")),
-                            });
-                            if (items) {
-                                for (const [lineNumber, lineContent,] of searchableIDs.entries()) {
-                                    const foundedItem = items.find(({ id }) => id === lineContent);
-                                    if (foundedItem)
-                                        RETURN[lineNumber][field.key] = foundedItem;
-                                }
+                    if (searchableIDs.size) {
+                        const items = await this.get(field.table, isArrayField
+                            ? Array.from(new Set(Array.from(searchableIDs.values()).flat()))
+                            : Array.from(new Set(searchableIDs.values())), {
+                            ...options,
+                            perPage: Number.POSITIVE_INFINITY,
+                            columns: options.columns
+                                ?.filter((column) => column.includes(`${field.key}.`))
+                                .map((column) => column.replace(`${field.key}.`, "")),
+                        });
+                        if (items) {
+                            for (const [lineNumber, lineContent] of searchableIDs.entries()) {
+                                const foundedItem = isArrayField
+                                    ? items.filter(({ id }) => lineContent.includes(id))
+                                    : items.find(({ id }) => id === lineContent);
+                                if (foundedItem)
+                                    RETURN[lineNumber][field.key] = foundedItem;
                             }
                         }
                     }
                 }
             }
-            else if (await File.isExists(join(tablePath, `${(prefix ?? "") + field.key}${this.getFileExtension(tableName)}`))) {
-                const items = await File.get(join(tablePath, `${(prefix ?? "") + field.key}${this.getFileExtension(tableName)}`), linesNumber, field.type, field.children, this.salt);
-                if (items)
-                    for (const [index, item] of Object.entries(items)) {
-                        if (!RETURN[index])
-                            RETURN[index] = {};
-                        if (item !== null && item !== undefined)
-                            RETURN[index][field.key] = item;
-                    }
-            }
         }
-        return RETURN;
     }
     async applyCriteria(tableName, schema, options, criteria, allTrue) {
         const tablePath = join(this.databasePath, tableName);
@@ -968,7 +1019,7 @@ export default class Inibase {
         }
         if (!where) {
             // Display all data
-            RETURN = Object.values(await this.getItemsFromSchema(tableName, schema, Array.from({ length: options.perPage }, (_, index) => (options.page - 1) * options.perPage +
+            RETURN = Object.values(await this.processSchemaData(tableName, schema, Array.from({ length: options.perPage }, (_, index) => (options.page - 1) * options.perPage +
                 index +
                 1), options));
             if (!this.totalItems[`${tableName}-*`])
@@ -985,7 +1036,7 @@ export default class Inibase {
             // useless
             if (onlyLinesNumbers)
                 return lineNumbers;
-            RETURN = Object.values((await this.getItemsFromSchema(tableName, schema, lineNumbers, options)) ?? {});
+            RETURN = Object.values((await this.processSchemaData(tableName, schema, lineNumbers, options)) ?? {});
             if (RETURN?.length && !Array.isArray(where))
                 RETURN = RETURN[0];
         }
@@ -1008,7 +1059,7 @@ export default class Inibase {
                 if (!options.columns?.length)
                     options.columns = undefined;
             }
-            RETURN = Object.values((await this.getItemsFromSchema(tableName, schema, Object.keys(lineNumbers).map(Number), options)) ?? {});
+            RETURN = Object.values((await this.processSchemaData(tableName, schema, Object.keys(lineNumbers).map(Number), options)) ?? {});
             if (RETURN?.length && !Array.isArray(where))
                 RETURN = RETURN[0];
         }
@@ -1040,7 +1091,7 @@ export default class Inibase {
                 const alreadyExistsColumns = Object.keys(Object.values(RETURN)[0]), alreadyExistsColumnsIDs = Utils.flattenSchema(schema)
                     .filter(({ key }) => alreadyExistsColumns.includes(key))
                     .map(({ id }) => id);
-                RETURN = Object.values(Utils.deepMerge(RETURN, await this.getItemsFromSchema(tableName, Utils.filterSchema(schema, ({ id, type, children }) => !alreadyExistsColumnsIDs.includes(id) ||
+                RETURN = Object.values(Utils.deepMerge(RETURN, await this.processSchemaData(tableName, Utils.filterSchema(schema, ({ id, type, children }) => !alreadyExistsColumnsIDs.includes(id) ||
                     Utils.isFieldType("table", type, children)), Object.keys(RETURN).map(Number), options)));
                 if (this.tables[tableName].config.cache)
                     await writeFile(cachedFilePath, Array.from(linesNumbers).join(","));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inibase",
-  "version": "1.0.0-rc.106",
+  "version": "1.0.0-rc.108",
   "type": "module",
   "author": {
     "name": "Karim Amahtil",
@@ -75,7 +75,7 @@
   },
   "dependencies": {
     "dotenv": "^16.4.5",
-    "inison": "1.0.0-rc.4"
+    "inison": "latest"
   },
   "scripts": {
     "prepublish": "npx tsc",