inibase 1.2.9 → 1.2.11

package/dist/index.d.ts

@@ -122,6 +122,7 @@ export default class Inibase {
     private processObjectField;
     private isTableField;
     private processTableField;
+    private _setNestedKey;
     private applyCriteria;
     private _filterSchemaByColumns;
     /**

package/dist/index.js

@@ -696,19 +696,19 @@ export default class Inibase {
         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);
+                await this.processSimpleField(tableName, field, RETURN, linesNumber, prefix);
             }
             else if (this.isArrayField(field.type)) {
                 // Process array fields (recursive if needed)
-                await this.processArrayField(tableName, field, linesNumber, RETURN, options, prefix);
+                await this.processArrayField(tableName, field, RETURN, linesNumber, options, prefix);
             }
             else if (this.isObjectField(field.type)) {
                 // Process object fields (recursive if needed)
-                await this.processObjectField(tableName, field, linesNumber, RETURN, options, prefix);
+                await this.processObjectField(tableName, field, RETURN, linesNumber, options, prefix);
             }
             else if (this.isTableField(field.type)) {
                 // Process table reference fields
-                await this.processTableField(tableName, field, linesNumber, RETURN, options, prefix);
+                await this.processTableField(tableName, field, RETURN, linesNumber, options, prefix);
             }
         }
         return RETURN;
@@ -721,7 +721,7 @@ export default class Inibase {
         return !complexTypes.includes(fieldType);
     }
     // Process a simple field (non-recursive)
-    async processSimpleField(tableName, field, linesNumber, RETURN, _options, prefix) {
+    async processSimpleField(tableName, field, RETURN, linesNumber, 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, {
@@ -751,13 +751,13 @@ export default class Inibase {
             fieldType === "array");
     }
     // Process array fields (recursive if needed)
-    async processArrayField(tableName, field, linesNumber, RETURN, options, prefix) {
+    async processArrayField(tableName, field, RETURN, linesNumber, options, prefix) {
         if (Array.isArray(field.children)) {
             if (this.isSimpleField(field.children)) {
-                await this.processSimpleField(tableName, field, linesNumber, RETURN, options, prefix);
+                await this.processSimpleField(tableName, field, RETURN, linesNumber, prefix);
             }
             else if (this.isTableField(field.children)) {
-                await this.processTableField(tableName, field, linesNumber, RETURN, options, prefix);
+                await this.processTableField(tableName, field, RETURN, linesNumber, options, prefix);
             }
             else {
                 let _fieldChildren = field.children;
@@ -835,10 +835,10 @@ export default class Inibase {
         }
         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);
+            await this.processSimpleField(tableName, field, RETURN, linesNumber, prefix);
         }
         else if (this.isTableField(field.children)) {
-            await this.processTableField(tableName, field, linesNumber, RETURN, options, prefix);
+            await this.processTableField(tableName, field, RETURN, linesNumber, options, prefix);
         }
     }
     // Helper function to check if the field type is object
@@ -849,7 +849,7 @@ export default class Inibase {
                 fieldType.includes("object")));
     }
     // Process object fields (recursive if needed)
-    async processObjectField(tableName, field, linesNumber, RETURN, options, prefix) {
+    async processObjectField(tableName, field, RETURN, linesNumber, 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}.`);
@@ -873,7 +873,7 @@ export default class Inibase {
                 fieldType.includes("table")));
     }
     // Process table reference fields
-    async processTableField(tableName, field, linesNumber, RETURN, options, prefix) {
+    async processTableField(tableName, field, RETURN, linesNumber, 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)}`);
@@ -899,7 +899,7 @@ export default class Inibase {
                             .flat()
                             .filter((item) => item), {
                             ...options,
-                            perPage: Number.POSITIVE_INFINITY,
+                            perPage: -1,
                             columns: options.columns
                                 ?.filter((column) => column.includes(`${field.key}.`))
                                 .map((column) => column.replace(`${field.key}.`, "")),
@@ -927,47 +927,49 @@ export default class Inibase {
             }
         }
     }
+    _setNestedKey(obj, path, value) {
+        const keys = path.split(".");
+        const lastKey = keys.pop();
+        const target = keys.reduce((acc, key) => {
+            if (typeof acc[key] !== "object" || acc[key] === null) {
+                acc[key] = {};
+            }
+            return acc[key];
+        }, obj);
+        target[lastKey] = value;
+    }
     async applyCriteria(tableName, options, criteria, allTrue, searchIn) {
         const tablePath = join(this.databasePath, tableName);
-        /** result container – we mutate rows in-place instead of deep-merging */
-        const RETURN = {};
-        /* ---------- fast exit ---------- */
+        let RETURN = {};
         if (!criteria || Object.keys(criteria).length === 0)
             return null;
-        /* ---------- split top-level logical groups ---------- */
         const criteriaAND = criteria.and;
-        const criteriaOR = criteria.or;
         if (criteriaAND)
             delete criteria.and;
+        const criteriaOR = criteria.or;
         if (criteriaOR)
             delete criteria.or;
-        /** cache table schema once – Utils.getField() is cheap but we call it a lot */
         const schema = globalConfig[this.databasePath].tables.get(tableName).schema;
-        /* ---------- MAIN LOOP  (top-level criteria only) ---------- */
         if (Object.keys(criteria).length) {
             if (allTrue === undefined)
                 allTrue = true;
-            for (const [key, rawValue] of Object.entries(criteria)) {
-                /* bail early if no candidates left for an “AND” chain */
-                if (allTrue && searchIn && searchIn.size === 0)
-                    return null;
+            for await (let [key, value] of Object.entries(criteria)) {
                 const field = Utils.getField(key, schema);
                 if (!field)
                     continue;
-                let value = rawValue;
-                /* ----- resolve relational sub-queries ----- */
                 if (field.table && Utils.isObject(value)) {
-                    const rel = await this.get(field.table, value, {
+                    const items = await this.get(field.table, value, {
                         columns: "id",
+                        perPage: -1,
                     });
-                    value = rel?.length ? `[]${rel.map(({ id }) => id)}` : undefined; //  ⟵  no match → abort whole AND-chain
-                    if (value === undefined && allTrue)
+                    if (items?.length)
+                        value = `[]${items.map(({ id }) => id)}`;
+                    else if (allTrue)
                         return null;
                 }
-                /* ----- determine operator / compare value ----- */
-                let searchOperator;
-                let searchComparedAtValue;
-                let searchLogicalOperator;
+                let searchOperator = undefined;
+                let searchComparedAtValue = undefined;
+                let searchLogicalOperator = undefined;
                 if (Utils.isObject(value)) {
                     /* nested object with .and / .or inside */
                     const nestedAnd = value.and;
@@ -985,6 +987,7 @@ export default class Inibase {
                             searchComparedAtValue = crit.map((c) => c[1]);
                             searchLogicalOperator = logic;
                         }
+                        delete value[logic];
                     }
                 }
                 else if (Array.isArray(value)) {
@@ -1006,45 +1009,53 @@ export default class Inibase {
                     searchOperator = "=";
                     searchComparedAtValue = value;
                 }
-                /* ---------- disk search ---------- */
-                const [hitRows, totalLines, lineSet] = await File.search(join(tablePath, `${key}${this.getFileExtension(tableName)}`), searchOperator ?? "=", searchComparedAtValue ?? null, searchLogicalOperator, searchIn, {
+                const [searchResult, totalLines, linesNumbers] = await File.search(join(tablePath, `${key}${this.getFileExtension(tableName)}`), searchOperator ?? "=", searchComparedAtValue, searchLogicalOperator, searchIn, {
                     ...field,
                     databasePath: this.databasePath,
                     table: field.table ?? tableName,
-                }, options.perPage, (options.page - 1) * options.perPage +
-                    (options.page > 1 ? 1 : 0), true);
-                if (!hitRows) {
+                }, options.perPage < 0 ? undefined : options.perPage, options.perPage < 0
+                    ? undefined
+                    : (options.page - 1) * options.perPage +
+                        (options.page > 1 ? 1 : 0), true);
+                if (!searchResult) {
                     if (allTrue)
-                        return null; // AND-chain broken
-                    continue; // OR-chain: just skip
-                }
-                /* ---------- map rows into RETURN without deep-merge ---------- */
-                for (const [lnStr, val] of Object.entries(hitRows)) {
-                    const ln = +lnStr;
-                    const row = (RETURN[ln] ??= {});
-                    row[key] = val;
+                        return null;
+                    continue;
                 }
+                const formatedSearchResult = Object.fromEntries(Object.entries(searchResult).map(([id, value]) => {
+                    const nestedObj = {};
+                    this._setNestedKey(nestedObj, key, value);
+                    return [id, nestedObj];
+                }));
+                RETURN = allTrue
+                    ? formatedSearchResult
+                    : Utils.deepMerge(RETURN, formatedSearchResult);
                 this.totalItems.set(`${tableName}-${key}`, totalLines);
-                /* shrink search domain for next AND condition */
-                if (lineSet?.size && allTrue)
-                    searchIn = lineSet;
+                if (linesNumbers?.size && allTrue)
+                    searchIn = linesNumbers;
             }
         }
-        /* ---------- process nested .and / .or recursively (unchanged) ---------- */
         if (criteriaAND && Utils.isObject(criteriaAND)) {
-            const res = await this.applyCriteria(tableName, options, criteriaAND, true, searchIn);
-            if (!res)
+            const searchResult = await this.applyCriteria(tableName, options, criteriaAND, true, searchIn);
+            if (searchResult)
+                RETURN = Utils.deepMerge(RETURN, Object.fromEntries(Object.entries(searchResult).filter(([_k, v], _i) => Object.keys(v).filter((key) => Object.keys(criteriaAND).includes(key)).length)));
+            else
                 return null;
-            for (const [lnStr, data] of Object.entries(res))
-                (RETURN[+lnStr] ??= {}), Object.assign(RETURN[+lnStr], data);
         }
         if (criteriaOR && Utils.isObject(criteriaOR)) {
-            const res = await this.applyCriteria(tableName, options, criteriaOR, false, undefined);
-            if (res)
-                for (const [lnStr, data] of Object.entries(res))
-                    (RETURN[+lnStr] ??= {}), Object.assign(RETURN[+lnStr], data);
+            const searchResult = await this.applyCriteria(tableName, options, criteriaOR, false, searchIn);
+            if (searchResult) {
+                RETURN = Utils.deepMerge(RETURN, searchResult);
+                if (!Object.keys(RETURN).length)
+                    RETURN = {};
+                RETURN = Object.fromEntries(Object.entries(RETURN).filter(([_index, item]) => Object.keys(item).filter((key) => Object.keys(criteriaOR).includes(key) ||
+                    Object.keys(criteriaOR).some((criteriaKey) => criteriaKey.startsWith(`${key}.`))).length));
+                if (!Object.keys(RETURN).length)
+                    RETURN = {};
+            }
+            else
+                RETURN = {};
         }
-        /* ---------- final answer ---------- */
         return Object.keys(RETURN).length ? RETURN : null;
     }
     _filterSchemaByColumns(schema, columns) {
@@ -1214,9 +1225,11 @@ export default class Inibase {
         }
         if (!where) {
             // Display all data
-            RETURN = Object.values(await this.processSchemaData(tableName, schema, Array.from({ length: options.perPage }, (_, index) => (options.page - 1) * options.perPage +
-                index +
-                1), options));
+            RETURN = Object.values(await this.processSchemaData(tableName, schema, options.perPage < 0
+                ? undefined
+                : Array.from({ length: options.perPage }, (_, index) => (options.page - 1) * options.perPage +
+                    index +
+                    1), options));
             if (!this.totalItems.has(`${tableName}-*`))
                 this.totalItems.set(`${tableName}-*`, pagination[1]);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inibase",
-  "version": "1.2.9",
+  "version": "1.2.11",
   "type": "module",
   "author": {
     "name": "Karim Amahtil",