@entity-access/entity-access 1.0.252 → 1.0.254

package/src/decorators/IColumn.ts

@@ -3,6 +3,7 @@ import { IClassOf } from "./IClassOf.js";
 import { IForeignKeyConstraint } from "./IForeignKeyConstraint.js";
 import { ISqlType } from "./ISqlType.js";
 
+export type FKType = { fkColumn: IColumn, relatedKeyColumn: IColumn };
 
 export interface IColumn {
     name?: string;
@@ -87,13 +88,13 @@ export interface IEntityRelation {
     singleInverseRelation?
 
 
-    foreignKey: string;
+    // foreignKey: string;
 
     relatedTypeClass: IClassOf<any>;
 
     relatedTypeClassFactory?: () => IClassOf<any>;
 
-    fkColumn?: IColumn;
+    fkMap: FKType[];
 
 
     relatedName: string;
@@ -105,7 +106,7 @@ export interface IEntityRelation {
 
     relatedRelation?: IEntityRelation;
 
-    dotNotCreateIndex?: boolean;
+    doNotCreateIndex?: boolean;
 
     foreignKeyConstraint?: IForeignKeyConstraint;
 

package/src/decorators/Relate.ts

@@ -51,7 +51,7 @@ export function RelateTo(c, p?): any {
 
     const { property, inverseKey: invKey, inverseProperty, dotNotCreateIndex, foreignKeyConstraint } = p;
 
-    return (target: any, foreignKey: string): any => {
+    return (target: any, fkName: string): any => {
 
         const cn = target.constructor ?? target;
         const entityType = SchemaRegistry.model(cn);
@@ -61,13 +61,14 @@ export function RelateTo(c, p?): any {
         entityType.addRelation({
             type: entityType,
             name,
-            foreignKey,
+            fkName,
+            fkMap: null,
             relatedTypeClass: c,
             relatedTypeClassFactory: p.type,
             relatedName: NameParser.parseMember(inverseProperty),
             relatedKey: invKey ? NameParser.parseMember(invKey) : void 0,
             foreignKeyConstraint,
-            dotNotCreateIndex
+            doNotCreateIndex: dotNotCreateIndex
         });
 
     };
@@ -87,7 +88,7 @@ export function RelateToOne(c, p?): any {
 
     const { property, inverseKey: invKey, inverseProperty, dotNotCreateIndex } = p;
 
-    return (target: any, foreignKey: string): any => {
+    return (target: any, fkName: string): any => {
 
         const cn = target.constructor ?? target;
         const entityType = SchemaRegistry.model(cn);
@@ -97,12 +98,13 @@ export function RelateToOne(c, p?): any {
         entityType.addRelation({
             type: entityType,
             name,
-            foreignKey,
+            fkName,
+            fkMap:null,
             relatedTypeClass: c,
             relatedTypeClassFactory: p.type,
             relatedName: NameParser.parseMember(inverseProperty),
             relatedKey: invKey ? NameParser.parseMember(invKey) : void 0,
-            dotNotCreateIndex,
+            doNotCreateIndex: dotNotCreateIndex,
             singleInverseRelation: true
         });
 

package/src/entity-query/EntityType.ts

@@ -7,6 +7,7 @@ import { Expression, ExpressionAs, NumberLiteral, ParameterExpression, SelectSta
 import InstanceCache from "../common/cache/InstanceCache.js";
 import { IIndex } from "../decorators/IIndex.js";
 import { IStringTransformer } from "../query/ast/IStringTransformer.js";
+import { EntityAccessError } from "../index.js";
 
 export const addOrCreateColumnSymbol = Symbol("addOrCreateColumn");
 export const addColumnSymbol = Symbol("addOrCreateColumn");
@@ -82,8 +83,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 +129,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 +160,26 @@ 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;
+            if (!iterator.relatedKeyColumn) {
+                throw new EntityAccessError(`Not key set for ${iterator.fkColumn.name} with keys in ${relatedType.name} `);
+            }
+            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 +193,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);
+//     }
+// }