@entity-access/entity-access 1.0.252 → 1.0.254

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

package/src/query/expander/QueryExpander.ts

@@ -98,7 +98,7 @@ export class QueryExpander {
         // let where: Expression;
         // let joinWhere: Expression;
 
-        const fk = relation.fkColumn ?? relation.relatedRelation.fkColumn;
+        const fk = relation.fkMap ?? relation.relatedRelation.fkMap;
 
         key += "." + relation.name;
 
@@ -107,15 +107,17 @@ export class QueryExpander {
             return relationSet;
         }
 
+        let where: Expression;
+
         if(relation.isInverseRelation) {
 
-            const keyColumn = model.keys[0].columnName;
-            let columnName = fk.columnName;
-            // for inverse relation, we need to
-            // use primary key of current model
-            if (!relation.isCollection) {
-                columnName = select.model.keys[0].columnName;
-            }
+            // const keyColumn = model.keys[0].columnName;
+            // let columnName = fk.columnName;
+            // // for inverse relation, we need to
+            // // use primary key of current model
+            // if (!relation.isCollection) {
+            //     columnName = select.model.keys[0].columnName;
+            // }
 
 
             const joins = (select.joins ??= []);
@@ -124,21 +126,32 @@ export class QueryExpander {
             // This join has to be INNER JOIN as we are only interested
             // in the results that matches parent query exactly
 
+            for (const { fkColumn, relatedKeyColumn } of relation.relatedRelation.fkMap) {
+                const joinColumn = fkColumn.entityType === joinParameter.model ? fkColumn : relatedKeyColumn;
+                const relatedColumn = relatedKeyColumn.entityType === select.sourceParameter.model ? relatedKeyColumn : fkColumn;
+                const joinOn = Expression.equal(
+                    Expression.member(joinParameter, Expression.identifier(joinColumn.columnName)),
+                    Expression.member(select.sourceParameter, Expression.identifier(relatedColumn.columnName))
+                );
+                where = where ? Expression.logicalAnd(where, joinOn) : joinOn;
+            }
+
             joins.push(JoinExpression.create({
                 joinType: "INNER",
                 source: { ... parent },
                 as: joinParameter,
                 model: parent.model,
-                where: Expression.equal(
-                    Expression.member(
-                        joinParameter,
-                        Expression.identifier(keyColumn)
-                    ),
-                    Expression.member(
-                        select.sourceParameter,
-                        Expression.identifier(columnName)
-                    )
-                )
+                where
+                // where: Expression.equal(
+                //     Expression.member(
+                //         joinParameter,
+                //         Expression.identifier(keyColumn)
+                //     ),
+                //     Expression.member(
+                //         select.sourceParameter,
+                //         Expression.identifier(columnName)
+                //     )
+                // )
             }));
 
             // if (parent.where) {
@@ -192,22 +205,33 @@ export class QueryExpander {
         // This join has to be INNER JOIN as we are only interested
         // in the results that matches parent query exactly
 
+        for (const { fkColumn, relatedKeyColumn } of relation.fkMap) {
+            const joinOn = Expression.equal(
+                Expression.member(selectJoinParameter,
+                    Expression.identifier(fkColumn.columnName)),
+                Expression.member(select.sourceParameter,
+                    Expression.identifier(relatedKeyColumn.columnName))
+            );
+            where = where ? Expression.logicalAnd(where, joinOn) : joinOn;
+        }
+
         selectJoins.push(JoinExpression.create({
             joinType: "INNER",
             source: { ... parent },
             as: selectJoinParameter,
             model: parent.model,
+            where
             // model,
-            where: Expression.equal(
-                Expression.member(
-                    selectJoinParameter,
-                    Expression.identifier(fk.columnName)
-                ),
-                Expression.member(
-                    select.sourceParameter,
-                    Expression.identifier(relation.relatedEntity.keys[0].columnName)
-                )
-            )
+            // where: Expression.equal(
+            //     Expression.member(
+            //         selectJoinParameter,
+            //         Expression.identifier(fk.columnName)
+            //     ),
+            //     Expression.member(
+            //         select.sourceParameter,
+            //         Expression.identifier(relation.relatedEntity.keys[0].columnName)
+            //     )
+            // )
         }));
 
         this.include.push(select);

package/src/tests/db-tests/tests/multi-fk-tests.ts

@@ -0,0 +1,46 @@
+import assert from "assert";
+import { TestConfig } from "../../TestConfig.js";
+import { createContext } from "../../model/createContext.js";
+
+export default async function(this: TestConfig) {
+
+    if (!this.db) {
+        return;
+    }
+
+    const context = await createContext(this.driver);
+
+    const { userID } = await context.users.asQuery().first();
+    const { categoryID } = await context.categories.asQuery().first();
+
+    await context.userCategories.saveDirect({
+        mode: "insert",
+        changes: {
+            userID,
+            categoryID
+        }
+    });
+
+    await context.userCategoryTags.saveDirect({
+        mode: "insert",
+        changes: {
+            categoryID,
+            userID,
+            tag: "A"
+        }
+    });
+    await context.userCategoryTags.saveDirect({
+        mode: "insert",
+        changes: {
+            categoryID,
+            userID,
+            tag: "B"
+        }
+    });
+
+    const first = await context.userCategories.asQuery()
+        .include((x) => x.tags)
+        .first();
+
+    assert.notEqual(void 0, first.tags);
+}

package/src/tests/expressions/left-joins/child-joins.ts

@@ -14,7 +14,7 @@ FROM products AS p1
 WHERE EXISTS (SELECT
 1
 FROM order_items AS o
-WHERE (p1.product_id = o.product_id) AND (o.product_id = $1))`;
+WHERE (o.product_id = $1) AND (p1.product_id = o.product_id))`;
 
 const sql2 = `SELECT
 p1.product_id,
@@ -26,10 +26,10 @@ FROM products AS p1
 WHERE EXISTS (SELECT
 1
 FROM order_items AS o
-WHERE (p1.product_id = o.product_id) AND (o.product_id = $1)) AND EXISTS (SELECT
+WHERE (o.product_id = $1) AND (p1.product_id = o.product_id)) AND EXISTS (SELECT
 1
 FROM order_items AS o1
-WHERE (p1.product_id = o1.product_id) AND (o1.amount > $2))`;
+WHERE (o1.amount > $2) AND (p1.product_id = o1.product_id))`;
 
 const sql3 = `SELECT
 p1.product_id,
@@ -41,11 +41,11 @@ FROM products AS p1
 WHERE EXISTS (SELECT
 1
 FROM order_items AS o
-WHERE (p1.product_id = o.product_id) AND (o.product_id = $1)) AND EXISTS (SELECT
+WHERE (o.product_id = $1) AND (p1.product_id = o.product_id)) AND EXISTS (SELECT
 1
 FROM order_items AS o1
  INNER JOIN orders AS o2 ON o1.order_id = o2.order_id
-WHERE (p1.product_id = o1.product_id) AND (o2.order_date > $2))`;
+WHERE (o2.order_date > $2) AND (p1.product_id = o1.product_id))`;
 
 const productJoin = `SELECT
 p1.product_id,
@@ -77,10 +77,10 @@ p1.product_description
 FROM products AS p1
 WHERE EXISTS
     (SELECT 1 FROM order_items AS o
-        WHERE (p1.product_id = o.product_id) AND (o.product_id = $1)) AND
+        WHERE (o.product_id = $1) AND (p1.product_id = o.product_id)) AND
         NOT (EXISTS (SELECT 1 FROM order_items AS o1
                 INNER JOIN orders AS o2 ON o1.order_id = o2.order_id
-                    WHERE (p1.product_id = o1.product_id) AND (o2.order_date > $2)))
+                    WHERE (o2.order_date > $2) AND (p1.product_id = o1.product_id)))
 `;
 
 export default function() {

package/src/tests/model/ShoppingContext.ts

@@ -6,6 +6,7 @@ import Index from "../../decorators/Index.js";
 import DateTime from "../../types/DateTime.js";
 import { UserFile } from "./UseFile.js";
 import Sql from "../../sql/Sql.js";
+import MultiForeignKeys from "../../decorators/ForeignKey.js";
 
 export const statusPublished = "published";
 
@@ -34,6 +35,8 @@ export class ShoppingContext extends EntityContext {
     public userFiles = this.model.register(UserFile);
 
     public emailAddresses = this.model.register(EmailAddress);
+
+    public userCategoryTags = this.model.register(UserCategoryTag);
 }
 
 @Table("Users")
@@ -191,6 +194,35 @@ export class UserCategory {
     public user: User;
 
     public category: Category;
+
+    public tags: UserCategoryTag[];
+}
+
+@Table("UserCategoryTags")
+export class UserCategoryTag {
+
+    @Column({ key: true, dataType: "BigInt", generated: "identity"})
+    tagID: number;
+
+    @Column({ dataType: "Char", length: 200 })
+    tag: string;
+
+    @Column({ dataType: "BigInt"})
+    public userID: number;
+
+    @Column({ dataType: "Char", length: 200 })
+    public categoryID: string;
+
+    @MultiForeignKeys(UserCategory, {
+            inverseProperty: (x) => x.tags,
+            foreignKeys: [
+                { foreignKey: (x) => x.userID, key: (x) => x.userID },
+                { foreignKey: (x) => x.categoryID, key: (x) => x.categoryID}
+            ]
+        }
+    )
+    public userCategory: UserCategory;
+
 }
 
 @Table("Products")

package/src/tests/security/tests/include-items.ts

@@ -15,5 +15,6 @@ export default async function (this: TestConfig) {
         .first();
 
     assert.notEqual(null, order);
+    assert.notEqual(undefined, order.orderItems);
 
 }