@entity-access/entity-access 1.0.251 → 1.0.253

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);

package/src/query/ast/ExpressionToSql.ts

@@ -1,3 +1,4 @@
+import EntityAccessError from "../../common/EntityAccessError.js";
 import QueryCompiler from "../../compiler/QueryCompiler.js";
 import EntityType, { IEntityProperty } from "../../entity-query/EntityType.js";
 import EntityQuery from "../../model/EntityQuery.js";
@@ -225,33 +226,27 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
 
         this.scope.create({ parameter: select.sourceParameter, model: relatedModel, selectStatement: select });
         select[filteredSymbol] = true;
-        const targetKey = MemberExpression.create({
-            target: parameter,
-            property: Identifier.create({
-                value: targetType.keys[0].columnName
-            })
-        });
-
-        const relatedKey = MemberExpression.create({
-            target: select.sourceParameter,
-            property: Identifier.create({
-                value: relation.relation.fkColumn.columnName
-            })
-        });
-
-
-        const join = Expression.equal(targetKey, relatedKey);
 
         let where = select.where;
 
-        if (where) {
-            where = BinaryExpression.create({
-                left: select.where,
-                operator: "AND",
-                right: join
+        for (const { fkColumn, relatedKeyColumn } of relation.relation.fkMap) {
+            const targetKey = MemberExpression.create({
+                target: parameter,
+                property: Identifier.create({
+                    value: relatedKeyColumn.columnName
+                })
             });
-        } else {
-            where = join;
+
+            const relatedKey = MemberExpression.create({
+                target: select.sourceParameter,
+                property: Identifier.create({
+                    value: fkColumn.columnName
+                })
+            });
+            const join = Expression.equal(targetKey, relatedKey);
+            where = where
+                ? Expression.logicalAnd(where, join)
+                : join;
         }
 
         select.where = where;
@@ -282,36 +277,33 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
         this.scope.alias(param1, select.sourceParameter, select);
         select.sourceParameter = param1;
         select[filteredSymbol] = true;
-        const targetKey = MemberExpression.create({
-            target: parameter,
-            property: Identifier.create({
-                value: targetType.keys[0].columnName
-            })
-        });
-
-        const relatedKey = MemberExpression.create({
-            target: param1,
-            property: Identifier.create({
-                value: relation.relation.fkColumn.columnName
-            })
-        });
 
+        let where = select.where;
+        where = where
+            ? Expression.logicalAnd(where, body.body)
+            : body.body;
 
-        const join = Expression.logicalAnd(
-            Expression.equal(targetKey, relatedKey),
-            body.body
-        );
+        for (const { fkColumn, relatedKeyColumn } of relation.relation.relatedRelation.fkMap) {
 
-        let where = select.where;
+            const targetKey = MemberExpression.create({
+                target: parameter,
+                property: Identifier.create({
+                    value: relatedKeyColumn.columnName
+                })
+            });
 
-        if (where) {
-            where = BinaryExpression.create({
-                left: select.where,
-                operator: "AND",
-                right: join
+            const relatedKey = MemberExpression.create({
+                target: param1,
+                property: Identifier.create({
+                    value: fkColumn.columnName
+                })
             });
-        } else {
-            where = join;
+
+            const join = Expression.equal(targetKey, relatedKey);
+
+            where = where
+                ? Expression.logicalAnd(where, join)
+                : join;
         }
 
         select.where = where;
@@ -723,16 +715,18 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
                 }
                 if (relation) {
 
-                    const { fkColumn } = relation;
-
                     if (!relation.isCollection) {
 
-                        let columnName = fkColumn.columnName;
-                        // for inverse relation, we need to
-                        // use primary key of current model
-                        if (relation.isInverseRelation) {
-                            columnName = peModel.keys[0].columnName;
-                        }
+                        // let columnName = fkColumn.columnName;
+                        // // for inverse relation, we need to
+                        // // use primary key of current model
+                        // if (relation.isInverseRelation) {
+                        //     columnName = peModel.keys[0].columnName;
+                        // }
+
+                        const fkMap = relation.fkMap ?? relation.relatedRelation.fkMap;
+
+                        const isNullable = fkMap.some(({ fkColumn }) => fkColumn.nullable);
 
                         const select = scope?.selectStatement ?? this.source?.selectStatement;
                         if (select) {
@@ -743,20 +737,42 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
                                 this.scope.create({ parameter: join.as as ParameterExpression, model: join.model, selectStatement: select });
                                 return join.as;
                             }
-                            const joinType = select.preferLeftJoins ? "LEFT" : (fkColumn.nullable ? "LEFT" : "INNER");
+                            const joinType = select.preferLeftJoins ? "LEFT" : (isNullable ? "LEFT" : "INNER");
                             const joinParameter = ParameterExpression.create({
                                 name: relation.relatedEntity.name[0],
                                 model: relation.relatedEntity
                             });
+                            let where: Expression;
+                            for (const {fkColumn, relatedKeyColumn} of fkMap) {
+                                let peColumn;
+                                let joinColumn;
+                                if (fkColumn.entityType === pe.model) {
+                                    peColumn = fkColumn;
+                                } else if (relatedKeyColumn.entityType === pe.model) {
+                                    peColumn = relatedKeyColumn;
+                                } else {
+                                    throw new EntityAccessError(`Invalid configuration`);
+                                }
+                                if (fkColumn.entityType === joinParameter.model) {
+                                    joinColumn = fkColumn;
+                                } else if (relatedKeyColumn.entityType === joinParameter.model) {
+                                    joinColumn = relatedKeyColumn;
+                                } else {
+                                    throw new EntityAccessError(`Invalid configuration`);
+                                }
+                                const joinOn = Expression.equal(
+                                    Expression.member(pe, peColumn.columnName),
+                                    Expression.member(joinParameter, joinColumn.columnName));
+                                where = where
+                                    ? Expression.logicalAnd(where, joinOn)
+                                    : joinOn;
+                            }
                             join = JoinExpression.create({
                                 as: joinParameter,
                                 joinType,
                                 model: joinParameter.model,
                                 source: Expression.identifier(relation.relatedEntity.name),
-                                where: Expression.equal(
-                                    Expression.member(pe, columnName),
-                                    Expression.member(joinParameter, relation.relatedEntity.keys[0].columnName)
-                                )
+                                where
                             });
                             select.joins.push(join);
                             this.scope.create({ parameter: joinParameter, model: relation.relatedEntity, selectStatement: select});