@entity-access/entity-access 1.0.252 → 1.0.254

package/src/model/changes/ChangeEntry.ts

@@ -168,14 +168,16 @@ export default class ChangeEntry<T = any> implements IChanges {
             // this is tricky as we need to build inverse query...
             const { relatedRelation } = relation;
             const filter = [];
-            for (const iterator of this.type.keys) {
-                filter.push(`x.${relatedRelation.name}.${iterator.name} === p.${iterator.name}`);
+            for (const { fkColumn, relatedKeyColumn } of relatedRelation.fkMap) {
+                filter.push(`x.${relatedRelation.name}.${fkColumn.name} === p.${relatedKeyColumn.name}`);
             }
 
             await context.model.register(relatedEntity.typeClass)
                 .where(this.entity, `(p) => (x) => ${filter.join(" && ")}` as any)
                 .toArray();
 
+            return;
+
         }
 
         if (this.entity[relation.name]) {
@@ -183,9 +185,13 @@ export default class ChangeEntry<T = any> implements IChanges {
         }
 
 
-        const key = relatedEntity.keys[0];
+        // need to setup inverse key check
+        // const key = relatedEntity.keys[0];
         const keys = {} as any;
-        keys[key.name] = this.entity[relation.fkColumn.name];
+        // keys[key.name] = this.entity[relation.fkColumn.name];
+        for (const { fkColumn, relatedKeyColumn } of relation.fkMap) {
+            keys[relatedKeyColumn.name] = this.entity[fkColumn.name];
+        }
         this.entity[relation.name] = await context.model.register(relatedEntity.typeClass).loadByKeys(keys);
     }
 
@@ -281,7 +287,7 @@ export default class ChangeEntry<T = any> implements IChanges {
             }
 
             // if related has key defined.. set it...
-            const rKey = iterator.relatedEntity.keys[0];
+            // const rKey = iterator.relatedEntity.keys[0];
 
             // lets set the prototype...
             const prototype = iterator.relatedTypeClass.prototype;
@@ -290,38 +296,75 @@ export default class ChangeEntry<T = any> implements IChanges {
             }
             const relatedChanges = this.changeSet.getEntry(related);
 
-            const keyValue = related[rKey.name];
-            if (keyValue === void 0) {
+            for (const { fkColumn, relatedKeyColumn } of iterator.fkMap) {
+                const keyValue = related[relatedKeyColumn.name];
+                if (keyValue === void 0) {
 
-                if(relatedChanges.dependents.has(this)) {
-                    continue;
-                }
-                relatedChanges.dependents.add(this);
+                    if(relatedChanges.dependents.has(this)) {
+                        continue;
+                    }
+                    relatedChanges.dependents.add(this);
 
-                this.order++;
+                    this.order++;
 
-                for (const d of this.dependents) {
-                    d.order++;
-                }
+                    for (const d of this.dependents) {
+                        d.order++;
+                    }
 
-                const fk = iterator;
-                if (!fk.fkColumn.columnName) {
-                    throw new EntityAccessError(`Configuration error, fk not set for ${fk.name}`);
-                }
-                relatedChanges.pending.push(() => {
-                    this.entity[fk.fkColumn.name] = related[rKey.name];
-                });
-                if (this.status !== "inserted") {
-                    this.modified.set(iterator, { column: iterator.fkColumn, oldValue: void 0, newValue: void 0});
+                    if (!fkColumn.columnName) {
+                        throw new EntityAccessError(`Configuration error, fk not set for ${fkColumn.name}`);
+                    }
+                    relatedChanges.pending.push(() => {
+                        this.entity[fkColumn.name] = related[relatedKeyColumn.name];
+                    });
+                    if (this.status !== "inserted") {
+                        this.modified.set(iterator, { column: fkColumn, oldValue: void 0, newValue: void 0});
+                    }
                 }
                 continue;
             }
 
+            // const keyValue = related[rKey.name];
+            // if (keyValue === void 0) {
+
+            //     if(relatedChanges.dependents.has(this)) {
+            //         continue;
+            //     }
+            //     relatedChanges.dependents.add(this);
+
+            //     this.order++;
+
+            //     for (const d of this.dependents) {
+            //         d.order++;
+            //     }
+
+            //     const fk = iterator;
+            //     if (!fk.fkMap?.length) {
+            //         throw new EntityAccessError(`Configuration error, fk not set for ${fk.name}`);
+            //     }
+            //     relatedChanges.pending.push(() => {
+            //         for (const { fkColumn, relatedKeyColumn } of fk.fkMap) {
+            //             this.entity[fkColumn.name] = related[relatedKeyColumn.name];
+            //         }
+            //         // this.entity[fk.fkColumn.name] = related[rKey.name];
+            //     });
+            //     if (this.status !== "inserted") {
+            //         for (const { fkColumn } of fk.fkMap) {
+            //             this.modified.set(iterator, { column: fkColumn, oldValue: void 0, newValue: void 0});
+            //         }
+            //         // this.modified.set(iterator, { column: iterator.fkColumn, oldValue: void 0, newValue: void 0});
+            //     }
+            //     continue;
+            // }
+
             if(!relatedChanges.dependents.has(this)) {
                 relatedChanges.dependents.add(this);
                 this.order += relatedChanges.order;
             }
-            this.entity[iterator.fkColumn.name] = related[rKey.name];
+            for (const { fkColumn, relatedKeyColumn } of iterator.fkMap) {
+                this.entity[fkColumn.name] = related[relatedKeyColumn.name];
+            }
+            // this.entity[iterator.fkColumn.name] = related[rKey.name];
         }
     }
 

package/src/model/changes/ChangeSet.ts

@@ -3,6 +3,7 @@ import EntityAccessError from "../../common/EntityAccessError.js";
 import EventSet from "../../common/EventSet.js";
 import SchemaRegistry from "../../decorators/SchemaRegistry.js";
 import EntityContext from "../EntityContext.js";
+import IdentityMap from "../identity/IdentityMap.js";
 import IdentityService, { identityMapSymbol } from "../identity/IdentityService.js";
 import ChangeEntry, { privateUpdateEntry, getContext } from "./ChangeEntry.js";
 
@@ -26,7 +27,7 @@ export default class ChangeSet {
     /**
      * This will provide new entity for same key
      */
-    private identityMap: Map<string,any> = new Map();
+    private identityMap = new IdentityMap();
 
     private nextId = 1;
 
@@ -70,7 +71,7 @@ export default class ChangeSet {
                 this.entryMap.delete(entry.entity);
                 return;
             }
-            this.identityMap.set(jsonKey, entry.entity);
+            this.identityMap.set(jsonKey, entry.entity, entry.type);
         }
     }
 
@@ -101,7 +102,7 @@ export default class ChangeSet {
                     return entry.updateValues(original);
                 }
             } else {
-                this.identityMap.set(jsonKey, entity);
+                this.identityMap.set(jsonKey, entity, type);
             }
         }
         entry = new ChangeEntry({

package/src/model/identity/IdentityMap.ts

@@ -0,0 +1,126 @@
+import { entityTypeSymbol } from "../../common/symbols/symbols.js";
+import { IColumn } from "../../decorators/IColumn.js";
+import type EntityType from "../../entity-query/EntityType.js";
+
+/**
+ * Locally cache uniquely identifiable entities
+ */
+export default class IdentityMap {
+
+    public get indexedColumns() {
+        return this.keys.keys();
+    }
+
+    private map = new Map<string, any>();
+
+    private keys = new Map<IColumn, Map<any, any[]>>();
+
+    public delete(jsonKey) {
+        const item = this.map.get(jsonKey);
+        this.map.delete(jsonKey);
+        if (item) {
+            const type = item[entityTypeSymbol] as EntityType;
+            for (const column of type.columns) {
+                const values = this.keys.get(column);
+                if (!values) {
+                    continue;
+                }
+                const value = item[column.name];
+                if (value === void 0 || value === null) {
+                    continue;
+                }
+                const entries = values.get(value);
+                if (!entries) {
+                    continue;
+                }
+                const index = entries.findIndex(item);
+                entries.splice(index, 1);
+            }
+        }
+    }
+
+    public get(jsonKeys) {
+        return this.map.get(jsonKeys);
+    }
+
+    public set(jsonKey, entity, type: EntityType) {
+        entity[entityTypeSymbol] = type;
+        this.map.set(jsonKey, entity);
+        this.updateSearchIndex(type, entity);
+    }
+
+    public clear() {
+        this.map.clear();
+        this.keys.clear();
+    }
+
+    public build(key: IColumn) {
+        return this.getKeyEntry(key, true);
+    }
+
+    searchByKeys(pairs: { key: IColumn, value}[], create = true) {
+        let results: any[];
+        for (const { key, value } of pairs) {
+            const items = this.getAll(key, value, create);
+            if (!items?.length) {
+                return;
+            }
+            if (!results) {
+                results = [].concat(items);
+                continue;
+            }
+            const old = results;
+            results = [];
+            for (const item of items) {
+                if (old.includes(item)) {
+                    results.push(item);
+                }
+            }
+        }
+        return results[0];
+    }
+
+    private getAll(key: IColumn, value: any, create = true) {
+        const keyEntry = this.getKeyEntry(key, create);
+        return keyEntry.get(value);
+    }
+
+    private getKeyEntry(key: IColumn, create = false) {
+        let keyEntry = this.keys.get(key);
+        if (keyEntry) {
+            return keyEntry;
+        }
+        if (!create) {
+            return;
+        }
+        keyEntry = new Map<any, any[]>();
+        this.keys.set(key, keyEntry);
+        for (const entry of this.map.values()) {
+            this.updateSearchIndex(entry[entityTypeSymbol], entry);
+        }
+        return keyEntry;
+    }
+
+    private updateSearchIndex(type: EntityType, entity: any) {
+        for (const key of this.keys.keys()) {
+            if (type.getField(key.name) !== key) {
+                continue;
+            }
+            const keyEntry = this.getKeyEntry(key, true);
+            const value = entity[key.name];
+            if (value === void 0 || value === null) {
+                continue;
+            }
+            let values = keyEntry.get(value);
+            if (!values) {
+                values = [];
+                keyEntry.set(value, values);
+            }
+            if (values.includes(entity)) {
+                continue;
+            }
+            values.push(entity);
+        }
+    }
+
+}

package/src/model/identity/RelationMapper.ts

@@ -1,26 +1,33 @@
+import EventEmitter from "events";
 import type ChangeEntry from "../changes/ChangeEntry.js";
 import type ChangeSet from "../changes/ChangeSet.js";
 import IdentityService, { identityMapSymbol } from "./IdentityService.js";
+import { IColumn } from "../../decorators/IColumn.js";
+
+
+
 
 export default class RelationMapper {
 
-    private map: Map<string, ChangeEntry[]> = new Map();
+    // private map: Map<string, ChangeEntry[]> = new Map();
+
+    private events: EventEmitter = new EventEmitter();
 
     constructor(
         private changeSet: ChangeSet,
-        private identityMap: Map<string, ChangeEntry> = changeSet[identityMapSymbol]
+        private identityMap = changeSet[identityMapSymbol]
     ) {
 
     }
 
-    push(id: string, waiter: ChangeEntry) {
-        let queue = this.map.get(id);
-        if (!queue) {
-            queue = [];
-            this.map.set(id, queue);
-        }
-        queue.push(waiter);
-    }
+    // push(id: string, waiter: ChangeEntry) {
+    //     let queue = this.map.get(id);
+    //     if (!queue) {
+    //         queue = [];
+    //         this.map.set(id, queue);
+    //     }
+    //     queue.push(waiter);
+    // }
 
     fix(entry: ChangeEntry, nest = true) {
 
@@ -30,23 +37,48 @@ export default class RelationMapper {
             if (iterator.isInverseRelation) {
                 continue;
             }
-            const fkColumn = iterator.fkColumn.name;
-            const fkValue = entity[fkColumn];
-            if (fkValue === void 0) {
-                continue;
-            }
+            // const fkColumn = iterator.fkColumn.name;
+            // const fkValue = entity[fkColumn];
+            // if (fkValue === void 0) {
+            //     continue;
+            // }
+
             // get from identity...
-            const id = IdentityService.buildIdentity(iterator.relatedEntity, fkValue);
-            const parent = this.identityMap.get(id);
+            // const id = IdentityService.buildIdentity(iterator.relatedEntity, fkValue);
+            // const parent = this.identityMap.get(id);
+            // if (!parent) {
+            //     let waiters = this.map.get(id);
+            //     if (!waiters) {
+            //         waiters = [];
+            //         this.map.set(id, waiters);
+            //     }
+            //     waiters.push(entry);
+            //     continue;
+            // }
+
+            const pairs = [] as { key: IColumn, value: any}[];
+
+            for (const { fkColumn, relatedKeyColumn } of iterator.fkMap) {
+                this.identityMap.build(relatedKeyColumn);
+                const fkValue = entity[fkColumn.name];
+                if (fkValue === void 0) {
+                    continue;
+                }
+                pairs.push({ key: relatedKeyColumn, value: fkValue});
+            }
+
+            const parent = this.identityMap.searchByKeys(pairs, true);
             if (!parent) {
-                let waiters = this.map.get(id);
-                if (!waiters) {
-                    waiters = [];
-                    this.map.set(id, waiters);
+                if (nest) {
+                    for (const { key, value } of pairs) {
+                        this.events.once(`${key.entityType.name}-${key.name}-${value}`, (k) => {
+                            this.fix(entry, false);
+                        });
+                    }
                 }
-                waiters.push(entry);
                 continue;
             }
+
             entity[iterator.name] = parent;
 
             if (iterator.relatedRelation.isCollection) {
@@ -64,12 +96,24 @@ export default class RelationMapper {
         }
 
         // see if anyone is waiting for us or not...
-        const identity = IdentityService.getIdentity(entry.type, entry.entity);
-        const pending = this.map.get(identity);
-        if (pending && pending.length) {
-            for (const iterator of pending) {
-                this.fix(iterator, false);
+        // const identity = IdentityService.getIdentity(entry.type, entry.entity);
+        // const pending = this.map.get(identity);
+        // if (pending && pending.length) {
+        //     for (const iterator of pending) {
+        //         this.fix(iterator, false);
+        //     }
+        // }
+
+        for (const iterator of this.identityMap.indexedColumns) {
+            if (iterator.entityType !== entry.type) {
+                continue;
+            }
+            const value = entry.entity[iterator.name];
+            if (value === void 0 || value === null) {
+                continue;
             }
+            const key = `${iterator.entityType.name}-${iterator.name}-${value}`;
+            this.events.emit(key, key);
         }
     }
 }

package/src/model/identity/SearchIndex.ts

@@ -0,0 +1,120 @@
+import type { IColumn } from "../../decorators/IColumn.js";
+import type ChangeEntry from "../changes/ChangeEntry.js";
+
+export default class SearchIndex {
+
+    private keys = new Map<string, Map<any, any[]>>();
+
+    constructor(private entries: ChangeEntry[]) {
+
+    }
+
+    getByKeys(pairs: { key, value}[], create = true) {
+        let results: any[];
+        for (const { key, value } of pairs) {
+            const items = this.getAll(key, value, create);
+            if (!items?.length) {
+                return;
+            }
+            if (!results) {
+                results = [].concat(items);
+                continue;
+            }
+            const old = results;
+            results = [];
+            for (const item of items) {
+                if (old.includes(item)) {
+                    results.push(item);
+                }
+            }
+        }
+        return results;
+    }
+
+    getAll(key: string, value: any, create = true) {
+        const keyEntry = this.getKeyEntry(key, create);
+        return keyEntry.get(value);
+    }
+
+    delete(entry) {
+        for (const [key,values] of this.keys) {
+            const value = entry[key];
+            if (value === void 0 || value === null) {
+                continue;
+            }
+            const entries = values.get(value);
+            if (!entries) {
+                continue;
+            }
+            const index = entries.findIndex(entry);
+            entries.splice(index, 1);
+        }
+    }
+
+    get(keys: IColumn[], entry) {
+        let results: any[];
+        for (const { name } of keys) {
+            const items = this.getAll(name, entry[name]);
+            if (!items?.length) {
+                return;
+            }
+            if (!results) {
+                results = [].concat(items);
+                continue;
+            }
+            const old = results;
+            results = [];
+            for (const item of items) {
+                if (old.includes(item)) {
+                    results.push(item);
+                }
+            }
+        }
+        return results[0];
+    }
+
+    update(keys: IColumn[], entry) {
+        for (const key of keys) {
+            const keyEntry = this.getKeyEntry(key.name, true);
+            const value = entry[key.name];
+            if (value === void 0 || value === null) {
+                continue;
+            }
+            let values = keyEntry.get(value);
+            if (!values) {
+                values = [];
+                keyEntry.set(value, values);
+            }
+            if (values.includes(entry)) {
+                continue;
+            }
+            values.push(entry);
+        }
+    }
+
+    private getKeyEntry(key: string, create = false) {
+        let keyEntry = this.keys.get(key);
+        if (keyEntry) {
+            return keyEntry;
+        }
+        if (!create) {
+            return;
+        }
+        keyEntry = new Map<any, any[]>();
+        this.keys.set(key, keyEntry);
+        for (const entry of this.entries) {
+            const value = entry[key];
+            if (value === void 0 || value === null) {
+                continue;
+            }
+            let values = keyEntry.get(value);
+            if (!values) {
+                values = [];
+                keyEntry.set(value, values);
+            }
+            values.push(value);
+        }
+        return keyEntry;
+    }
+
+}

package/src/model/verification/VerificationSession.ts

@@ -63,30 +63,33 @@ export default class VerificationSession {
                 continue;
             }
 
-            const fk = relation.fkColumn;
+            const fk = relation.fkMap;
             if (!fk) {
                 continue;
             }
 
-            const fkValue = entity[fk.name];
-            if (fkValue === void 0) {
-                // not set... ignore..
-                continue;
-            }
-            if (isKeyEmpty(fkValue, relation.fkColumn)) {
-                continue;
-            }
+            for (const { fkColumn , relatedKeyColumn } of fk) {
 
-            // only if it is modified...
-            if (change.status !== "inserted") {
-                if (!change.isModified(fk.name)) {
+                const fkValue = entity[fkColumn.name];
+                if (fkValue === void 0) {
+                    // not set... ignore..
                     continue;
                 }
+                if (isKeyEmpty(fkValue, fkColumn)) {
+                    continue;
+                }
+
+                // only if it is modified...
+                if (change.status !== "inserted") {
+                    if (!change.isModified(fkColumn.name)) {
+                        continue;
+                    }
+                }
+                this.queueEntityForeignKey(change, relation, fkColumn, relatedKeyColumn, fkValue);
             }
-            this.queueEntityForeignKey(change, relation, fkValue);
         }
     }
-    queueEntityForeignKey(change: ChangeEntry, relation: IEntityRelation, value) {
+    queueEntityForeignKey(change: ChangeEntry, relation: IEntityRelation, fkColumn, relatedKeyColumn, value) {
         const relatedModel = relation.relatedEntity;
         const type = relation.relatedEntity.typeClass;
         const events = this.context.eventsFor(change.type.typeClass);
@@ -97,7 +100,7 @@ export default class VerificationSession {
             events: relatedEvents,
             type: relatedModel,
             name: relation.name,
-            fkName: relation.fkColumn.name,
+            fkName: fkColumn.name,
             entity: change.entity
         });
         let query = events.onForeignKeyFilter(fk);
@@ -110,7 +113,7 @@ export default class VerificationSession {
 
         const eq = query as EntityQuery;
         const compare = Expression.equal(
-            Expression.member(eq.selectStatement.sourceParameter, relatedModel.keys[0].columnName),
+            Expression.member(eq.selectStatement.sourceParameter, relatedKeyColumn.columnName),
             Expression.constant(value)
         );
         const typeName  = TypeInfo.nameOfType(type);