@entity-access/entity-access 1.0.251 → 1.0.253

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/query/parser/ArrowToExpression.ts

@@ -10,8 +10,19 @@ type IQueryFragment = string | { name?: string, value?: any };
 
 const parsedCache = new TimedCache<string, bpe.Node>();
 
+const parameterCacheSymbol = Symbol("parameterCacheSymbol");
+
+const defaultObject = {};
+
 export default class ArrowToExpression extends BabelVisitor<Expression> {
 
+    /**
+     * Parses lambda expression function or string to set simple SQL ready AST which
+     * transforms basic && to AND etc.
+     * @param fx function code (usually lambda expression)
+     * @param target parameter target
+     * @returns Parsed expression
+     */
     public static transform(fx: (p: any) => (x: any) => any, target?: ParameterExpression) {
         const key = fx.toString();
         const node = parsedCache.getOrCreate(key, fx, (k, f) => {
@@ -21,41 +32,54 @@ export default class ArrowToExpression extends BabelVisitor<Expression> {
         return this.transformUncached(node, target);
     }
 
-    private static transformUncached(node: bpe.Node, target?: ParameterExpression) {
+    /**
+     * Since expression parsed as a different parameter in nested lambda (p) => (x) => x..,
+     * we need to replace x with provided target to bind x with respective ParameterExpression.
+     * As ParameterExpression contains the type and model associated with the table represented by `x`.
+     * @param node parsed node
+     * @param target parameter to replace
+     * @returns transformed node
+     */
+    private static transformUncached(node: bpe.Node, tx?: ParameterExpression) {
 
-        if (node.type !== "ArrowFunctionExpression") {
-            throw new Error("Expecting an arrow function");
-        }
+        const cache = node[parameterCacheSymbol] ??= new TimedCache<ParameterExpression,bpe.Node>();
 
-        const params = [] as ParameterExpression[];
+        return cache.getOrCreate(tx ?? defaultObject, tx, (_, target) => {
 
-        for (const iterator of node.params) {
-            if (iterator.type !== "Identifier") {
-                throw new Error("Expecting an identifier");
+            if (node.type !== "ArrowFunctionExpression") {
+                throw new Error("Expecting an arrow function");
             }
-            params.push(ParameterExpression.create({ name: iterator.name }));
-        }
 
-        let body = node.body;
-        if (body.type !== "ArrowFunctionExpression") {
-            throw new Error("Expecting an arrow function");
-        }
+            const params = [] as ParameterExpression[];
 
-        const firstTarget = body.params[0];
-        if (firstTarget.type !== "Identifier") {
-            throw new Error("Expecting an identifier");
-        }
+            for (const iterator of node.params) {
+                if (iterator.type !== "Identifier") {
+                    throw new Error("Expecting an identifier");
+                }
+                params.push(ParameterExpression.create({ name: iterator.name }));
+            }
 
-        target ??= ParameterExpression.create({ name: firstTarget.name});
+            let body = node.body;
+            if (body.type !== "ArrowFunctionExpression") {
+                throw new Error("Expecting an arrow function");
+            }
 
-        body = body.body;
+            const firstTarget = body.params[0];
+            if (firstTarget.type !== "Identifier") {
+                throw new Error("Expecting an identifier");
+            }
 
-        const visitor = new this(params, target, firstTarget.name);
-        return {
-            params,
-            target,
-            body: visitor.visit(body)
-        };
+            target ??= ParameterExpression.create({ name: firstTarget.name});
+
+            body = body.body;
+
+            const visitor = new this(params, target, firstTarget.name);
+            return {
+                params,
+                target,
+                body: visitor.visit(body)
+            };
+        });
     }
 
     public readonly leftJoins: string[] = [];

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