inibase 1.2.9 → 1.2.10

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

@@ -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: Number.POSITIVE_INFINITY,
                     });
-                    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,51 @@ 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) {
+                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) {

package/package.json

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