@entity-access/entity-access 1.0.251 → 1.0.253

package/src/entity-query/EntityType.ts

@@ -82,8 +82,27 @@ export default class EntityType {
 
         const existing = this.fieldMap.get(c.name);
         if (existing) {
-            c.fkRelation = existing.fkRelation;
-            c.fkRelation.fkColumn = c;
+            const fkRelation = c.fkRelation = existing.fkRelation;
+            if(fkRelation) {
+                fkRelation.fkMap = [{ fkColumn: c, relatedKeyColumn: null }];
+                // if(!fkRelation.fkMap?.length) {
+                //     fkRelation.fkMap = [{ fkColumn: c, relatedKeyColumn: null}];
+                // } else {
+                //     if(fkRelation.fkMap.length === 1) {
+                //         fkRelation.fkMap[0].fkColumn = c;
+                //     }
+                // }
+            }
+            // if (fkRelation?.fkMap) {
+            //     if (!c.fkRelation.fkMap.length) {
+            //         c.fkRelation.fkMap = [{ fkColumn: c, relatedKeyColumn: null }];
+            //     } else {
+            //         c.fkRelation.fkMap[0].fkColumn = c;
+            //     }
+            // } else {
+            //     c
+            // }
+            // c.fkRelation.fkColumn = c;
         }
 
         this.fieldMap.set(c.name, c);
@@ -109,26 +128,29 @@ export default class EntityType {
     }
 
 
-    addRelation(relation: IEntityRelation, getInverseModel?: (t) => EntityType) {
+    addRelation(relation: IEntityRelation & { fkName?: string }, getInverseModel?: (t) => EntityType) {
         // we will also set fk to the corresponding column
         this.relations.push(relation);
         this.relationMap.set(relation.name, relation);
 
-        // find fk...
-        let fkColumn = this.fieldMap.get(relation.foreignKey);
-        if(!fkColumn) {
-            fkColumn = {
-                name: relation.foreignKey,
-                // columnName: relation.foreignKey,
-                fkRelation: relation,
-                dataType: "BigInt"
-            };
-            this.fieldMap.set(relation.foreignKey, fkColumn);
-        }
-        fkColumn.fkRelation = relation;
-        relation.fkColumn = fkColumn;
-        if (fkColumn.dataType === "Double") {
-            fkColumn.dataType = "BigInt";
+        if (!relation.fkMap) {
+            // find fk...
+            let fkColumn = this.fieldMap.get(relation.fkName);
+            if(!fkColumn) {
+                fkColumn = {
+                    name: relation.fkName,
+                    // columnName: relation.foreignKey,
+                    fkRelation: relation,
+                    dataType: "BigInt"
+                };
+                this.fieldMap.set(relation.fkName, fkColumn);
+                relation.fkMap = [ { fkColumn, relatedKeyColumn: null} ];
+            }
+            fkColumn.fkRelation = relation;
+            // relation.fkColumn = fkColumn;
+            if (fkColumn.dataType === "Double") {
+                fkColumn.dataType = "BigInt";
+            }
         }
 
         if (!getInverseModel) {
@@ -137,14 +159,23 @@ export default class EntityType {
 
         // let us set inverse relations...
         const relatedType = getInverseModel(relation.relatedTypeClass);
+
+        relation.fkMap[0].relatedKeyColumn ??= relatedType.keys[0];
+        relation.fkMap = [ ... relation.fkMap.map((x) => ({ ... x}))];
+        for (const iterator of relation.fkMap) {
+            iterator.fkColumn = this.getField(iterator.fkColumn.name);
+            // iterator.fkColumn.fkRelation = relation;
+            iterator.relatedKeyColumn = relatedType.getField(iterator.relatedKeyColumn.name);
+            iterator.relatedKeyColumn.entityType = relatedType;
+        }
+
         relation.relatedEntity = relatedType;
         const inverseRelation: IEntityRelation = {
             name: relation.relatedName,
-            foreignKey: "",
             relatedName: relation.name,
             relatedTypeClass: this.typeClass,
-            dotNotCreateIndex: true,
-            fkColumn,
+            doNotCreateIndex: true,
+            fkMap: null,
             isInverseRelation: true,
             isCollection: relation.singleInverseRelation ? false : true,
             relatedRelation: relation,
@@ -158,11 +189,14 @@ export default class EntityType {
 
         let { foreignKeyConstraint } = relation;
         if(foreignKeyConstraint) {
-            foreignKeyConstraint = { ... foreignKeyConstraint};
-            relation.foreignKeyConstraint = foreignKeyConstraint;
-            foreignKeyConstraint.name ||= `FK_${this.name}_${fkColumn.name}_${this.typeClass.name}_${relatedType.keys[0].name}`;
-            foreignKeyConstraint.column = fkColumn;
-            foreignKeyConstraint.refColumns = relatedType.keys;
+            if (relation.fkMap.length === 1) {
+                const { fkColumn } = relation.fkMap[0];
+                foreignKeyConstraint = { ... foreignKeyConstraint};
+                relation.foreignKeyConstraint = foreignKeyConstraint;
+                foreignKeyConstraint.name ||= `FK_${this.name}_${fkColumn.name}_${this.typeClass.name}_${relatedType.keys[0].name}`;
+                foreignKeyConstraint.column = fkColumn;
+                foreignKeyConstraint.refColumns = relatedType.keys;
+            }
         }
         return relation;
     }

package/src/migrations/postgres/PostgresAutomaticMigrations.ts

@@ -26,7 +26,7 @@ export default class PostgresAutomaticMigrations extends PostgresMigrations {
         await this.createIndexes(context, type, nonKeyColumns.filter((x) =>
             x.fkRelation
             && (!x.key || type.keys.indexOf(x) !== 0)
-            && !x.fkRelation?.dotNotCreateIndex));
+            && !x.fkRelation?.doNotCreateIndex));
 
     }
 

package/src/migrations/sql-server/SqlServerAutomaticMigrations.ts

@@ -26,7 +26,7 @@ export default class SqlServerAutomaticMigrations extends SqlServerMigrations {
         await this.createIndexes(context, type, nonKeyColumns.filter((x) =>
             x.fkRelation
             && (!x.key || type.keys.indexOf(x) !== 0)
-            && !x.fkRelation?.dotNotCreateIndex));
+            && !x.fkRelation?.doNotCreateIndex));
 
     }
 

package/src/model/EntityModel.ts

@@ -23,8 +23,8 @@ const getOrCreateModel = (map: Map<any, EntityType>, type: IClassOf<any>, naming
             ? column.columnName
             : (namingConvention
                     ? namingConvention(column.columnName) : column.columnName);
-        t.addColumn(column);
         column.entityType = t;
+        t.addColumn(column);
     }
     t.indexes.push(... original.indexes.map((i) => ({ ... i, columns: [ ... i.columns.map((c) => ( { ... c}))] })));
     // sort keys...
@@ -38,7 +38,7 @@ const getOrCreateModel = (map: Map<any, EntityType>, type: IClassOf<any>, naming
         if (iterator.isInverseRelation) {
             continue;
         }
-        const relation: IEntityRelation = { ... iterator, fkColumn: void 0, relatedEntity: void 0,type: t };
+        const relation: IEntityRelation = { ... iterator, relatedEntity: void 0,type: t };
         t.addRelation(relation, (tc) => getOrCreateModel(map, tc, namingConvention));
     }
     return t;

package/src/model/EntitySource.ts

@@ -28,8 +28,13 @@ export type ISaveDirect<T> = {
     keys: Partial<T>,
     changes: Partial<T>,
     // select?: Partial<T>,
-    mode: "selectOrInsert" | "insert",
+    mode: "selectOrInsert",
     updateAfterSelect?: never
+} | {
+    keys?: never,
+    mode: "insert",
+    changes: Partial<T>,
+    updateAfterSelect?: never,
 } | {
     keys?: Partial<T>,
     changes: Partial<T>,

package/src/model/SourceExpression.ts

@@ -1,132 +1,132 @@
-import { modelSymbol } from "../common/symbols/symbols.js";
-import EntityType from "../entity-query/EntityType.js";
-import { Expression, JoinExpression, ParameterExpression, SelectStatement } from "../query/ast/Expressions.js";
-import { ITextQueryFragment, QueryParameter } from "../query/ast/IStringTransformer.js";
-import EntityContext from "./EntityContext.js";
-
-const sourceSymbol = Symbol("source");
-
-export class SourceExpression {
-
-    public static create(p: Partial<SourceExpression>) {
-        return new SourceExpression(p);
-    }
-
-    alias: ParameterExpression;
-    parameter?: ParameterExpression;
-    context: EntityContext;
-    model?: EntityType;
-    include?: EntityType[];
-    select: SelectStatement;
-    parent?: SourceExpression;
-
-    private map: Map<string,SourceExpression>;
-    private paramMap: Map<string, SourceExpression>;
-
-    private constructor(p: Partial<SourceExpression>) {
-        Object.setPrototypeOf(p, SourceExpression.prototype);
-        const r = p as SourceExpression;
-        if (r.parent) {
-            r.map = r.parent.map;
-            r.paramMap = r.parent.paramMap;
-        } else {
-            r.paramMap = new Map();
-            r.map = new Map();
-        }
-        return r;
-    }
-
-    copy() {
-        const r = { ... this } as SourceExpression;
-        Object.setPrototypeOf(r, Object.getPrototypeOf(this));
-        r.map = new Map(this.map.entries());
-        r.paramMap = new Map(this.paramMap.entries());
-        r.select = Expression.clone(this.select);
-        return r;
-    }
-
-    addJoin(property: string) {
-        const { select } = this;
-        select.joins ??= [];
-
-        const relation = this.model.getProperty(property);
-        const model = this.context.model.register(relation.relation.relatedTypeClass)[modelSymbol];
-
-        for (const iterator of select.joins) {
-            if (model === iterator.model) {
-                return iterator[sourceSymbol] as SourceExpression;
-            }
-        }
-        const column = relation.relation.fkColumn;
-        const parameter = ParameterExpression.create({ name: this.parameter + "." + property, model });
-        const source = this.addSource(model, parameter);
-        const join = JoinExpression.create({
-            as: source.alias,
-            joinType: column.nullable ? "LEFT" : "INNER",
-            model,
-            source: Expression.identifier(model.name),
-            where: Expression.logicalAnd(
-                Expression.member(
-                    this.alias,
-                    column.columnName),
-                Expression.member(
-                    source.alias,
-                    model.keys[0].columnName)
-            )
-        });
-        select.joins.push(join);
-        join[sourceSymbol] = source;
-        return source;
-    }
-
-    addSource(model: EntityType, parameter: ParameterExpression) {
-
-        const { context } = this;
-        const source = SourceExpression.create({
-            model,
-            parameter,
-            context,
-            parent: this
-        });
-
-        source.map = this.map;
-        source.paramMap = this.paramMap;
-
-        let id = 0;
-        let alias: string;
-        do {
-            alias = model.name[0] + id++;
-            const exists = this.map.get(alias);
-            if (exists === null || exists === void 0) {
-                break;
-            }
-        }while (true);
-        source.alias = ParameterExpression.create({ name: alias, model });
-        this.map.set(alias, source);
-        this.paramMap.set(parameter.name, source);
-        return source;
-    }
-
-    flatten(chain: string[]): ITextQueryFragment {
-        const [start, ... others ] = chain;
-        if (start === this.parameter.name) {
-            return this.prepareNames(others);
-        }
-        const mapped = this.paramMap.get(start);
-        if (mapped) {
-            return mapped.prepareNames(others);
-        }
-        throw new Error("Not found");
-    }
-
-    prepareNames([property , ... others]: string[]): ITextQueryFragment {
-        const p = this.model.getProperty(property);
-        if (others.length === 0) {
-            return `${ QueryParameter.create(() => this.alias.name)}.${p.field.columnName}`;
-        }
-
-        // this must be a navigation...
-        const source = this.addJoin(property);
-        return source.prepareNames(others);
-    }
-}
+// import { modelSymbol } from "../common/symbols/symbols.js";
+// import EntityType from "../entity-query/EntityType.js";
+// import { Expression, JoinExpression, ParameterExpression, SelectStatement } from "../query/ast/Expressions.js";
+// import { ITextQueryFragment, QueryParameter } from "../query/ast/IStringTransformer.js";
+// import EntityContext from "./EntityContext.js";
+
+// const sourceSymbol = Symbol("source");
+
+// export class SourceExpression {
+
+//     public static create(p: Partial<SourceExpression>) {
+//         return new SourceExpression(p);
+//     }
+
+//     alias: ParameterExpression;
+//     parameter?: ParameterExpression;
+//     context: EntityContext;
+//     model?: EntityType;
+//     include?: EntityType[];
+//     select: SelectStatement;
+//     parent?: SourceExpression;
+
+//     private map: Map<string,SourceExpression>;
+//     private paramMap: Map<string, SourceExpression>;
+
+//     private constructor(p: Partial<SourceExpression>) {
+//         Object.setPrototypeOf(p, SourceExpression.prototype);
+//         const r = p as SourceExpression;
+//         if (r.parent) {
+//             r.map = r.parent.map;
+//             r.paramMap = r.parent.paramMap;
+//         } else {
+//             r.paramMap = new Map();
+//             r.map = new Map();
+//         }
+//         return r;
+//     }
+
+//     copy() {
+//         const r = { ... this } as SourceExpression;
+//         Object.setPrototypeOf(r, Object.getPrototypeOf(this));
+//         r.map = new Map(this.map.entries());
+//         r.paramMap = new Map(this.paramMap.entries());
+//         r.select = Expression.clone(this.select);
+//         return r;
+//     }
+
+//     addJoin(property: string) {
+//         const { select } = this;
+//         select.joins ??= [];
+
+//         const relation = this.model.getProperty(property);
+//         const model = this.context.model.register(relation.relation.relatedTypeClass)[modelSymbol];
+
+//         for (const iterator of select.joins) {
+//             if (model === iterator.model) {
+//                 return iterator[sourceSymbol] as SourceExpression;
+//             }
+//         }
+//         const column = relation.relation.fkColumn;
+//         const parameter = ParameterExpression.create({ name: this.parameter + "." + property, model });
+//         const source = this.addSource(model, parameter);
+//         const join = JoinExpression.create({
+//             as: source.alias,
+//             joinType: column.nullable ? "LEFT" : "INNER",
+//             model,
+//             source: Expression.identifier(model.name),
+//             where: Expression.logicalAnd(
+//                 Expression.member(
+//                     this.alias,
+//                     column.columnName),
+//                 Expression.member(
+//                     source.alias,
+//                     model.keys[0].columnName)
+//             )
+//         });
+//         select.joins.push(join);
+//         join[sourceSymbol] = source;
+//         return source;
+//     }
+
+//     addSource(model: EntityType, parameter: ParameterExpression) {
+
+//         const { context } = this;
+//         const source = SourceExpression.create({
+//             model,
+//             parameter,
+//             context,
+//             parent: this
+//         });
+
+//         source.map = this.map;
+//         source.paramMap = this.paramMap;
+
+//         let id = 0;
+//         let alias: string;
+//         do {
+//             alias = model.name[0] + id++;
+//             const exists = this.map.get(alias);
+//             if (exists === null || exists === void 0) {
+//                 break;
+//             }
+//         }while (true);
+//         source.alias = ParameterExpression.create({ name: alias, model });
+//         this.map.set(alias, source);
+//         this.paramMap.set(parameter.name, source);
+//         return source;
+//     }
+
+//     flatten(chain: string[]): ITextQueryFragment {
+//         const [start, ... others ] = chain;
+//         if (start === this.parameter.name) {
+//             return this.prepareNames(others);
+//         }
+//         const mapped = this.paramMap.get(start);
+//         if (mapped) {
+//             return mapped.prepareNames(others);
+//         }
+//         throw new Error("Not found");
+//     }
+
+//     prepareNames([property , ... others]: string[]): ITextQueryFragment {
+//         const p = this.model.getProperty(property);
+//         if (others.length === 0) {
+//             return `${ QueryParameter.create(() => this.alias.name)}.${p.field.columnName}`;
+//         }
+
+//         // this must be a navigation...
+//         const source = this.addJoin(property);
+//         return source.prepareNames(others);
+//     }
+// }

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({