@wxn0brp/db 0.6.0 → 0.7.1

package/dist/relation.d.ts

@@ -4,7 +4,7 @@ import { RelationTypes } from "./types/relation.js";
 declare class Relation {
     dbs: RelationTypes.DBS;
     constructor(dbs: RelationTypes.DBS);
-    findOne(path: RelationTypes.Path, search: Search, relations: RelationTypes.Relation, select?: RelationTypes.FieldPath[]): Promise<any>;
-    find(path: RelationTypes.Path, search: Search, relations: RelationTypes.Relation, select?: RelationTypes.FieldPath[], findOpts?: DbFindOpts): Promise<any[]>;
+    findOne(path: RelationTypes.Path, search: Search, relations: RelationTypes.Relation, select?: string[][] | Record<string, any>): Promise<any>;
+    find(path: RelationTypes.Path, search: Search, relations: RelationTypes.Relation, select?: string[][] | Record<string, any>, findOpts?: DbFindOpts): Promise<any[]>;
 }
 export default Relation;

package/dist/relation.js

@@ -1,85 +1,121 @@
-async function processRelations(dbs, cfg, data) {
-    if (!data)
+function pickByPath(obj, paths) {
+    const result = {};
+    for (const path of paths) {
+        let src = obj;
+        let dst = result;
+        for (let i = 0; i < path.length; i++) {
+            const k = path[i];
+            if (src == null)
+                break;
+            if (i === path.length - 1) {
+                dst[k] = src[k];
+            }
+            else {
+                dst[k] ||= {};
+                dst = dst[k];
+                src = src[k];
+            }
+        }
+    }
+    return result;
+}
+function convertSearchObjToSearchArray(obj, parentKeys = []) {
+    return Object.entries(obj).reduce((acc, [key, value]) => {
+        const currentPath = [...parentKeys, key];
+        if (!value) {
+            return acc;
+        }
+        else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+            return [...acc, ...convertSearchObjToSearchArray(value, currentPath)];
+        }
+        else {
+            return [...acc, currentPath];
+        }
+    }, []);
+}
+async function processRelations(dbs, cfg, data, parentList = null) {
+    if (!data && !parentList)
         return;
-    for (const [key, relation] of Object.entries(cfg)) {
-        const { pk = "_id", fk = "_id", type = "1" } = relation;
+    const batchMode = Array.isArray(parentList);
+    const targets = batchMode ? parentList : [data];
+    for (const key in cfg) {
+        if (!cfg.hasOwnProperty(key))
+            continue;
+        const rel = cfg[key];
+        const { pk = "_id", fk = "_id", type = "1", path, as = key, select, findOpts, through } = rel;
+        const [dbKey, coll] = path;
+        const db = dbs[dbKey];
         if (type === "1") {
-            const db = dbs[relation.path[0]];
-            const collection = relation.path[1];
-            const item = await db.findOne(collection, { [fk]: data[pk] }, {}, { select: relation.select || null });
-            const field = relation.as || key;
-            if (!item) {
-                data[field] = null;
-                continue;
-            }
-            if (relation.relations) {
-                await processRelations(dbs, relation.relations, item);
+            for (const item of targets) {
+                const result = await db.findOne(coll, { [fk]: item[pk] }, { projection: select });
+                if (result && rel.relations) {
+                    await processRelations(dbs, rel.relations, result);
+                }
+                item[as] = result || null;
             }
-            data[field] = item;
         }
         else if (type === "1n") {
-            const db = dbs[relation.path[0]];
-            const collection = relation.path[1];
-            const items = await db.find(collection, { [fk]: data[pk] }, {}, relation.findOpts || {}, { select: relation.select || null });
-            const field = relation.as || key;
-            if (relation.relations) {
-                await Promise.all(items.map(item => processRelations(dbs, relation.relations, item)));
+            const ids = targets.map(i => i[pk]);
+            const results = await db.find(coll, { $in: { [fk]: ids } }, { ...findOpts, projection: select });
+            const grouped = results.reduce((acc, row) => {
+                const id = row[fk];
+                (acc[id] ||= []).push(row);
+                return acc;
+            }, {});
+            for (const item of targets) {
+                item[as] = grouped[item[pk]] || [];
+            }
+            if (rel.relations) {
+                await Promise.all(results.map(row => processRelations(dbs, rel.relations, row)));
             }
-            data[field] = items;
         }
         else if (type === "nm") {
-            const db = dbs[relation.path[0]];
-            const collection = relation.path[1];
-            const items = await db.find(collection, {}, {}, {}, { select: relation.select || null });
-            const field = relation.as || key;
-            if (relation.relations) {
-                await Promise.all(items.map(item => processRelations(dbs, relation.relations, item)));
+            if (!through || !through.table || !through.pk || !through.fk) {
+                throw new Error(`Relation type "nm" requires a defined 'through' in '${key}'`);
+            }
+            for (const item of targets) {
+                const pivotDb = dbs[through.db || dbKey];
+                const pivots = await pivotDb.find(through.table, { [through.pk]: item[pk] });
+                const ids = pivots.map(p => p[through.fk]);
+                const related = await db.find(coll, { [fk]: { $in: ids } }, { projection: select });
+                item[as] = related;
+                if (rel.relations) {
+                    await Promise.all(related.map(row => processRelations(dbs, rel.relations, row)));
+                }
             }
-            data[field] = items;
         }
         else {
-            throw new Error(`Unknown relation type: ${relation.type}`);
+            throw new Error(`Unknown relation type: ${type}`);
         }
     }
 }
-function selectDataSelf(data, select) {
-    if (!data)
-        return null;
-    if (!select || select.length === 0)
-        return data;
-    if (Array.isArray(data))
-        return data.map(item => selectDataSelf(item, select));
-    return selectDataSelf(data[select[0]], select.slice(1));
-}
-function selectData(data, select) {
-    if (!select)
-        return data;
-    if (!data && select.length === 0)
-        return null;
-    const newData = {};
-    for (const field of select) {
-        const key = field.map(f => f.replaceAll(".", "\\.")).join(".");
-        newData[key] = selectDataSelf(data, field);
-    }
-    return newData;
-}
 class Relation {
     dbs;
     constructor(dbs) {
         this.dbs = dbs;
     }
     async findOne(path, search, relations, select) {
-        const db = this.dbs[path[0]];
-        const data = await db.findOne(path[1], search);
+        const [dbKey, coll] = path;
+        const db = this.dbs[dbKey];
+        const data = await db.findOne(coll, search);
+        if (!data)
+            return null;
+        if (typeof select === "object" && !Array.isArray(select)) {
+            select = convertSearchObjToSearchArray(select);
+        }
         await processRelations(this.dbs, relations, data);
-        const result = selectData(data, select);
-        return Object.keys(result).length === 0 ? null : result;
+        return select ? pickByPath(data, select) : data;
     }
     async find(path, search, relations, select, findOpts = {}) {
-        const db = this.dbs[path[0]];
-        const data = await db.find(path[1], search, {}, findOpts);
-        await Promise.all(data.map(item => processRelations(this.dbs, relations, item)));
-        return data.map(item => selectData(item, select));
+        const [dbKey, coll] = path;
+        const db = this.dbs[dbKey];
+        const data = await db.find(coll, search, findOpts);
+        if (relations)
+            await processRelations(this.dbs, relations, null, data);
+        if (typeof select === "object" && !Array.isArray(select)) {
+            select = convertSearchObjToSearchArray(select);
+        }
+        return select ? data.map(d => pickByPath(d, select)) : data;
     }
 }
 export default Relation;

package/dist/types/relation.d.ts

@@ -18,5 +18,11 @@ export declare namespace RelationTypes {
         findOpts?: DbFindOpts;
         type?: "1" | "1n" | "nm";
         relations?: Relation;
+        through?: {
+            table: string;
+            db?: string;
+            pk: string;
+            fk: string;
+        };
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wxn0brp/db",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "description": "A simple file-based database management system with support for CRUD operations, custom queries, and graph structures.",