@entity-access/entity-access 1.0.5 → 1.0.6

package/src/query/ast/ExpressionToSql.ts

@@ -3,6 +3,7 @@ import EntityType from "../../entity-query/EntityType.js";
 import EntityQuery from "../../model/EntityQuery.js";
 import { BigIntLiteral, BinaryExpression, BooleanLiteral, CallExpression, CoalesceExpression, ConditionalExpression, Constant, DeleteStatement, ExistsExpression, Expression, ExpressionAs, ExpressionType, Identifier, InsertStatement, JoinExpression, MemberExpression, NewObjectExpression, NullExpression, NumberLiteral, OrderByExpression, ParameterExpression, QuotedLiteral, ReturnUpdated, SelectStatement, StringLiteral, TableLiteral, TemplateLiteral, UpdateStatement, ValuesStatement } from "./Expressions.js";
 import { ITextQuery, QueryParameter, prepare, prepareJoin } from "./IStringTransformer.js";
+import ParameterScope from "./ParameterScope.js";
 import Visitor from "./Visitor.js";
 
 interface IPropertyChain {
@@ -15,12 +16,12 @@ export interface IMappingModel {
     parameter: ParameterExpression;
     model?: EntityType;
     selectStatement?: SelectStatement;
-    replace?: Expression;
+    name: string;
 }
 
 export default class ExpressionToSql extends Visitor<ITextQuery> {
 
-    protected targets: Map<ParameterExpression, IMappingModel> = new Map();
+    protected readonly scope: ParameterScope = new ParameterScope();
 
     constructor(
         private source: EntityQuery,
@@ -29,8 +30,14 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
         private compiler: QueryCompiler
     ) {
         super();
-        this.targets.set(root, { parameter: root, replace: root });
-        this.targets.set(target, { parameter: target, model: this.source?.type, replace: target ?? source?.selectStatement.as});
+        // this.targets.set(root, { parameter: root });
+        // this.targets.set(target, { parameter: target, model: this.source?.type });
+        if (this.root) {
+            this.scope.create({ parameter: root, name: root.name ?? "x", isRuntimeParam: true });
+        }
+        if (this.target) {
+            this.scope.create({ parameter: target });
+        }
     }
 
     visitArray(e: Expression[], sep = ","): ITextQuery {
@@ -57,37 +64,40 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
 
     visitSelectStatement(e: SelectStatement): ITextQuery {
 
-        // inject parameter and types if we don't have it..
-        if (e.as && e.model) {
-            const scope = this.targets.get(e.as);
-            if (!scope) {
-                this.targets.set(e.as, {
-                    parameter: e.as,
-                    model:
-                    e.model,
-                    replace: e.as,
-                    selectStatement: e
-                });
-            } else {
-                scope.selectStatement = e;
-                scope.model = e.model;
-            }
-        }
+        this.prepareStatement(e);
 
         const where = e.where ? prepare `\n\tWHERE ${this.visit(e.where)}` : "";
-        const joins = e.joins?.length > 0 ? prepare `\n\t\t${this.visitArray(e.joins)}` : [];
         const orderBy = e.orderBy?.length > 0 ? prepare `\n\t\tORDER BY ${this.visitArray(e.orderBy)}` : "";
+        const joins = e.joins?.length > 0 ? prepare `\n\t\t${this.visitArray(e.joins, "\n")}` : [];
         const limit = e.limit > 0 ? prepare ` LIMIT ${Number(e.limit).toString()}` : "";
         const offset = e.offset > 0 ? prepare ` OFFSET ${Number(e.offset).toString()}` : "";
         const source = e.source.type === "ValuesStatement"
             ? prepare `(${this.visit(e.source)})`
             : this.visit(e.source);
-        const as = e.as ? prepare ` AS ${this.compiler.quotedLiteral(e.as.name)}` : "";
+        const as = e.as ? prepare ` AS ${this.compiler.quotedLiteral( this.scope.nameOf(e.as))}` : "";
         const fields = this.visitArray(e.fields, ",\n\t\t");
         return prepare `SELECT
         ${fields}
         FROM ${source}${as}${joins}${where}${orderBy}${limit}${offset}`;
     }
+    prepareStatement(e: SelectStatement) {
+        // inject parameter and types if we don't have it..
+        if (e.as && e.model) {
+            this.scope.create({ parameter: e.as, selectStatement: e });
+        }
+
+        const joins = e.joins;
+        if (joins?.length) {
+            for (const iterator of joins) {
+                if (iterator.as) {
+                    this.scope.create({ parameter: iterator.as as ParameterExpression, model: iterator.model});
+                }
+            }
+            for (const iterator of joins) {
+                this.visit(iterator.where);
+            }
+        }
+    }
 
     visitQuotedLiteral(e: QuotedLiteral): ITextQuery {
         return [this.compiler.quotedLiteral(e.literal)];
@@ -131,7 +141,7 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
         const targetProperty = this.getPropertyChain(e.callee as ExpressionType);
         if (targetProperty) {
             const { parameter , identifier, chain } = targetProperty;
-            const existingTarget = this.targets.get(parameter);
+            const existingTarget = this.scope.get(parameter);
             if (existingTarget) {
 
 
@@ -148,35 +158,42 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
                             const param1 = body.params[0];
                             const relatedModel = relation.relation.relatedEntity;
                             const relatedType = relatedModel.typeClass;
-                            let query = this.source.context.query(relatedType);
-                            const select = { ... (query as EntityQuery).selectStatement };
 
-                            const replaceParam = this.createParameter(this.source.selectStatement, relatedModel.name[0]);
-                            select.as = replaceParam;
+                            let select: SelectStatement;
+
+                            if (this.source?.context) {
+                                let query = this.source.context.query(relatedType);
+                                // check if we have filter...
+                                const entityEvents = this.source.context.eventsFor(relatedType, false);
+                                if (entityEvents) {
+                                    query = entityEvents.includeFilter(query);
+                                }
+                                select = { ... (query as EntityQuery).selectStatement };
+                                select.fields = [
+                                    Identifier.create({ value: "1"})
+                                ];
+                            } else {
+                                select = relatedModel.selectOneNumber();
+                            }
 
-                            this.targets.set(param1, { parameter: param1, model: relatedModel, replace: replaceParam });
-                            this.targets.set(select.as, { parameter: param1, model: relatedModel, replace: replaceParam });
-                            this.targets.set(replaceParam, { parameter: param1, model: relatedModel, replace: replaceParam });
+                            param1.model = relatedModel;
+                            this.scope.create({ parameter: param1, model: relatedModel, selectStatement: select });
+                            this.scope.alias(param1, select.as, select);
+                            select.as = param1;
                             const targetKey = MemberExpression.create({
-                                target: this.target,
+                                target: parameter,
                                 property: Identifier.create({
                                     value: targetType.keys[0].columnName
                                 })
                             });
 
                             const relatedKey = MemberExpression.create({
-                                target: replaceParam,
+                                target: param1,
                                 property: Identifier.create({
                                     value: relation.relation.fkColumn.columnName
                                 })
                             });
 
-                            // check if we have filter...
-                            const entityEvents = this.source.context.eventsFor(relatedType, false);
-                            if (entityEvents) {
-                                query = entityEvents.includeFilter(query);
-                            }
-
 
                             const join = Expression.logicalAnd(
                                 Expression.equal(targetKey, relatedKey),
@@ -197,16 +214,12 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
 
                             select.where = where;
 
-                            select.fields = [
-                                Identifier.create({ value: "1"})
-                            ];
-
                             const exists = ExistsExpression.create({
                                 target: select
                             });
 
                             const r = this.visit(exists);
-                            this.targets.delete(param1);
+                            this.scope.delete(param1);
                             return r;
                         }
 
@@ -233,11 +246,9 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
     }
 
     visitParameterExpression(pe: ParameterExpression): ITextQuery {
-        const replace = this.targets.get(pe);
-        if (replace && replace.replace !== pe) {
-            return this.visit(replace.replace);
-        }
-        const { name, value } = pe;
+        const scope = this.scope.get(pe);
+        const { value } = scope.parameter;
+        const name = this.scope.nameOf(pe);
         if (value !== void 0) {
             return [() => value];
         }
@@ -256,7 +267,12 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
                 const value = parameter.value;
                 return [() => value[chain[0]]];
             }
-            return [ QueryParameter.create(() => parameter.name, this.compiler.quotedLiteral) , "." , chain.map((x) => this.compiler.quotedLiteral(x)).join(".")];
+            const scope = this.scope.get(parameter);
+            if (scope.isRuntimeParam) {
+                return [(p) => p[chain[0]]];
+            }
+            const name = this.scope.nameOf(parameter);
+            return [ QueryParameter.create(() => name, this.compiler.quotedLiteral) , "." , chain.map((x) => this.compiler.quotedLiteral(x)).join(".")];
         }
 
         const { target, computed, property } = me;
@@ -358,7 +374,7 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
         const where = this.visit(e.where);
         const as = e.as ? prepare ` AS ${ e.as.type === "QuotedLiteral"
             ? this.compiler.quotedLiteral(e.as.literal)
-            : this.compiler.quotedLiteral((e.as as any).name)}` : "";
+            : this.compiler.quotedLiteral( this.scope.nameOf(e.as) )}` : "";
         return prepare ` ${e.joinType || "LEFT"} JOIN ${table}${as} ON ${where}`;
     }
 
@@ -384,9 +400,9 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
     private getPropertyChain(x: Expression): IPropertyChain {
 
         // first replace root parameters
-        if (x.type === "MemberExpression") {
-            x = this.replaceParameters(x as MemberExpression);
-        }
+        // if (x.type === "MemberExpression") {
+        //     x = this.replaceParameters(x as MemberExpression);
+        // }
 
         const chain = [];
         let me = (x as ExpressionType).type === "MemberExpression"
@@ -416,20 +432,6 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
         };
     }
 
-    private createParameter (s: SelectStatement, prefix: string) {
-        const names = JSON.parse(s.names ?? "[]") as string[];
-        let i = 0;
-        while(true) {
-            const name = `${prefix}${i++}`;
-            if (names.includes(name)) {
-                continue;
-            }
-            names.push(name);
-            s.names = JSON.stringify(names);
-            return ParameterExpression.create({ name });
-        }
-    };
-
     private flatten(pc: IPropertyChain) : IPropertyChain {
 
         if (!pc) {
@@ -447,7 +449,7 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
 
         const chain = [ ... pc.chain];
 
-        const scope = this.targets.get(parameter);
+        const scope = this.scope.get(parameter);
         const select = scope?.selectStatement ?? this.source?.selectStatement;
         if (!select) {
             return pc;
@@ -459,7 +461,7 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
         while(chain.length > 1) {
             const property = chain.shift();
             const propertyInfo = type.getProperty(property);
-            if (!propertyInfo.relation || propertyInfo.relation.isCollection) {
+            if (!propertyInfo.relation || propertyInfo.relation.isInverseRelation) {
                 return pc;
             }
 
@@ -474,11 +476,12 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
             const join = select.joins.find((x) => x.model === relation.relatedEntity);
             if (!join) {
                 const joinType = fkColumn.nullable ? "LEFT" : "INNER";
-                const joinParameter = this.createParameter(select, relation.relatedEntity.name[0]);
+                const joinParameter = ParameterExpression.create({ name: relation.relatedEntity.name[0]});
+                joinParameter.model = relation.relatedEntity;
                 select.joins.push(JoinExpression.create({
                     as: joinParameter,
                     joinType,
-                    model: relation.relatedEntity,
+                    model: joinParameter.model,
                     source: Expression.quotedLiteral(relation.relatedEntity.name),
                     where: Expression.equal(
                         Expression.member(parameter, fkColumn.columnName),
@@ -487,7 +490,7 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
                 }));
                 parameter = joinParameter;
                 type = relation.relatedEntity;
-                this.targets.set(parameter, { parameter, model: type, replace: parameter});
+                this.scope.create({ parameter, model: type});
                 pc.parameter = parameter;
                 pc.chain = [ ... chain ];
             } else {
@@ -500,19 +503,4 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
         return { parameter, chain };
     }
 
-    private replaceParameters(x: MemberExpression): Expression {
-        const { target, property } = x;
-        if (target.type === "ParameterExpression") {
-            const replace = this.targets.get(target as ParameterExpression);
-            if (replace && replace.replace !== target) {
-                return Expression.member(replace.replace, property);
-            }
-            return x;
-        }
-        if (target.type === "MemberExpression") {
-            return Expression.member(this.replaceParameters(target as MemberExpression), property);
-        }
-        return x;
-    }
-
 }

package/src/query/ast/Expressions.ts

@@ -2,6 +2,7 @@ import { IClassOf } from "../../decorators/IClassOf.js";
 import { ITextQuery } from "./IStringTransformer.js";
 import type EntityType from "../../entity-query/EntityType.js";
 import DebugStringVisitor from "./DebugStringVisitor.js";
+import { IEntityRelation } from "../../decorators/IColumn.js";
 
 const flattenedSelf = Symbol("flattenedSelf");
 
@@ -24,6 +25,10 @@ const flattenedSelf = Symbol("flattenedSelf");
 
 export abstract class Expression {
 
+    static array(elements: Expression[]) {
+        return ArrayExpression.create({ elements });
+    }
+
     static as(expression: Expression, alias: QuotedLiteral | string) {
         if (typeof alias === "string") {
             alias = Expression.quotedLiteral(alias);
@@ -123,6 +128,11 @@ export abstract class Expression {
 
 }
 
+export class ArrayExpression extends Expression {
+    readonly type = "ArrayExpression";
+    elements: Expression[];
+}
+
 export class PartialExpression extends Expression {
     readonly type = "PartialExpression";
     query: ITextQuery;
@@ -175,6 +185,11 @@ export class ParameterExpression extends Expression {
      */
     value: any;
 
+    /**
+     * Entity Model representing the variable
+     */
+    model: EntityType;
+
     quotedLiteral: (x: string) => string;
 
     toString() {
@@ -197,6 +212,8 @@ export class ArrowFunctionExpression extends Expression {
 
 export type TableSource = SelectStatement | QuotedLiteral | ExpressionAs | TableLiteral;
 
+export type Expand = { [key: string]: string | Expand };
+
 export class SelectStatement extends Expression {
 
     readonly type = "SelectStatement";
@@ -217,11 +234,11 @@ export class SelectStatement extends Expression {
 
     offset: number;
 
-    // name holds string
-    names: string;
-
     model: EntityType;
 
+    // include  relations...
+    include: SelectStatement[];
+
 }
 
 export class NewObjectExpression extends Expression {
@@ -239,7 +256,7 @@ export class ConditionalExpression extends Expression {
 export class JoinExpression extends Expression {
     readonly type = "JoinExpression";
     joinType: "LEFT" | "INNER";
-    source: SelectStatement | QuotedLiteral | ExpressionAs;
+    source: SelectStatement | QuotedLiteral | ExpressionAs | TableLiteral;
     as: QuotedLiteral | ParameterExpression;
     where: Expression;
     model: EntityType;
@@ -389,5 +406,6 @@ export type ExpressionType =
     ConditionalExpression |
     NewObjectExpression |
     ParameterExpression |
+    ArrayExpression |
     TemplateElement
 ;

package/src/query/ast/IStringTransformer.ts

@@ -77,7 +77,9 @@ export const prepareJoin = (a: (ITextQueryFragment | ITextQuery)[], sep: string
     let first = true;
     for (const iterator of a) {
         if (!first) {
-            r.push(",");
+            if (sep) {
+                r.push(sep);
+            }
         }
         first = false;
         addNonEmptyFlat(r, iterator);

package/src/query/ast/ParameterScope.ts

@@ -0,0 +1,97 @@
+import type EntityType from "../../entity-query/EntityType.js";
+import type { ParameterExpression, SelectStatement } from "./Expressions.js";
+
+
+export interface IMappingModel {
+    parameter: ParameterExpression;
+    selectStatement?: SelectStatement;
+    name?: string;
+    model?: EntityType;
+    replace?: ParameterExpression;
+    isRuntimeParam?: boolean;
+}
+
+/**
+ * This class will provide scope for ever parameter along with type mapping, unique name and
+ * and replace parameter
+ */
+export default class ParameterScope {
+
+    private map:Map<ParameterExpression, IMappingModel> = new Map();
+
+    private names: Set<string> = new Set();
+
+    public get(p: ParameterExpression) {
+        const model = this.map.get(p);
+        return model;
+    }
+
+    public nameOf(p: ParameterExpression) {
+        const model = this.map.get(p);
+        return model.name;
+    }
+
+    public alias(
+        originalParameter: ParameterExpression,
+        alias: ParameterExpression,
+        selectStatement: SelectStatement
+    ) {
+        const model = this.map.get(originalParameter);
+        if (!model.selectStatement) {
+            model.selectStatement = selectStatement;
+        } else {
+            selectStatement = model.selectStatement;
+        }
+        return this.create({ parameter: alias, selectStatement, name: model.name, replace: originalParameter });
+    }
+
+    create(model: IMappingModel) {
+
+        const existing = this.map.get(model.parameter);
+        if (existing) {
+            existing.replace = model.replace;
+            existing.selectStatement = model.selectStatement;
+            existing.model ??= existing.selectStatement.model;
+            return;
+        }
+
+        if (!model.replace) {
+            // create name...
+            model.name = this.createName(model.parameter.model?.name?.[0] ?? model.parameter.name, model.parameter.name );
+        }
+
+        if (!model.model) {
+            if (model.parameter.model) {
+                model.model = model.parameter.model;
+            } else if (model.selectStatement){
+                model.model = model.selectStatement.model;
+            }
+        }
+
+        this.map.set(model.parameter, model);
+    }
+    createName(prefix: string, name?: string): string {
+        if (name) {
+            name = name.toLocaleLowerCase();
+            if (!this.names.has(name)) {
+                this.names.add(name);
+                return name;
+            }
+        }
+        let index = 1;
+        prefix = prefix.toLocaleLowerCase();
+        while(true) {
+            name = `${prefix}${index++}`;
+            if (this.names.has(name)) {
+                continue;
+            }
+            this.names.add(name);
+            return name;
+        }
+    }
+
+    delete(param1: ParameterExpression) {
+        // this.map.delete(param1);
+    }
+
+}

package/src/query/ast/Visitor.ts

@@ -1,4 +1,5 @@
-import { ArrowFunctionExpression, BigIntLiteral, BinaryExpression, BooleanLiteral, CallExpression, CoalesceExpression, ConditionalExpression, Constant, DeleteStatement, ExistsExpression, Expression, ExpressionAs, ExpressionType, Identifier, InsertStatement, JoinExpression, MemberExpression, NewObjectExpression, NullExpression, NumberLiteral, OrderByExpression, ParameterExpression, QuotedLiteral, ReturnUpdated, SelectStatement, StringLiteral, TableLiteral, TemplateElement, TemplateLiteral, UpdateStatement, ValuesStatement } from "./Expressions.js";
+import { NotSupportedError } from "../parser/NotSupportedError.js";
+import { ArrayExpression, ArrowFunctionExpression, BigIntLiteral, BinaryExpression, BooleanLiteral, CallExpression, CoalesceExpression, ConditionalExpression, Constant, DeleteStatement, ExistsExpression, Expression, ExpressionAs, ExpressionType, Identifier, InsertStatement, JoinExpression, MemberExpression, NewObjectExpression, NullExpression, NumberLiteral, OrderByExpression, ParameterExpression, QuotedLiteral, ReturnUpdated, SelectStatement, StringLiteral, TableLiteral, TemplateElement, TemplateLiteral, UpdateStatement, ValuesStatement } from "./Expressions.js";
 
 
 export default abstract class Visitor<T = any> {
@@ -66,10 +67,15 @@ export default abstract class Visitor<T = any> {
                 return this.visitTemplateElement(e);
             case "ParameterExpression":
                 return this.visitParameterExpression(e);
+            case "ArrayExpression":
+                return this.visitArrayExpression(e);
         }
         const c: never = e;
         throw new Error(`${e1.type} Not implemented`);
     }
+    visitArrayExpression(e: ArrayExpression): T {
+        throw new NotSupportedError("Array Expression");
+    }
     visitParameterExpression(e: ParameterExpression): T {
         return;
     }

package/src/query/expander/QueryExpander.ts

@@ -0,0 +1,147 @@
+import EntityType from "../../entity-query/EntityType.js";
+import EntityContext from "../../model/EntityContext.js";
+import EntityQuery from "../../model/EntityQuery.js";
+import { ArrowFunctionExpression, ExistsExpression, Expression, ExpressionType, JoinExpression, ParameterExpression, SelectStatement, TableSource } from "../ast/Expressions.js";
+import ArrowToExpression from "../parser/ArrowToExpression.js";
+import { NotSupportedError } from "../parser/NotSupportedError.js";
+
+export class QueryExpander {
+    static expand(context: EntityContext, select: SelectStatement, p) {
+        const qe = new QueryExpander(context, select);
+        const expression = ArrowToExpression.transform(`(_____________________x) => ${p}` as any);
+        qe.expandNode(select, select.model, expression.body as ExpressionType);
+        return select;
+    }
+
+    constructor(
+        private context: EntityContext,
+        private select: SelectStatement
+    ) {
+
+    }
+
+    expandNode(parent: SelectStatement, model: EntityType, node: ExpressionType): [SelectStatement, EntityType] {
+
+        if (node.type === "ArrayExpression") {
+            for (const iterator of node.elements) {
+                this.expandNode(parent, model,  iterator as ExpressionType);
+            }
+            return;
+        }
+
+        if(node.type === "CallExpression") {
+            const callee = node.callee as ExpressionType;
+            if (callee.type !== "MemberExpression") {
+                throw new NotSupportedError(callee.type);
+            }
+            const property = callee.property as ExpressionType;
+            if (property.type !== "Identifier") {
+                throw new NotSupportedError(property.type);
+            }
+            if (property.value !== "forEach") {
+                throw new NotSupportedError(property.value);
+            }
+            const [expandedSelect, expandedType] = this.expandNode(parent, model, callee.target as ExpressionType);
+
+            const arrow = node.arguments[0];
+            if (!arrow || arrow.type !== "ArrowFunctionExpression") {
+                throw new NotSupportedError(arrow?.type ?? "Empty Expression");
+            }
+            this.expandNode(expandedSelect, expandedType, (arrow as ArrowFunctionExpression).body as ExpressionType);
+            return [expandedSelect, expandedType];
+        }
+
+        if (node.type !== "MemberExpression") {
+            throw new NotSupportedError(node.type);
+        }
+
+        const p = node.property as ExpressionType;
+        if (p.type !== "Identifier") {
+            throw new NotSupportedError(p.type);
+        }
+
+        const target = node.target as ExpressionType;
+        if (target.type === "MemberExpression") {
+            const [mepSelect, mepType] = this.expandNode(parent, model, target);
+            parent = mepSelect;
+            model = mepType;
+        }
+
+        const mp = model.getProperty(p.value);
+        if (!mp.relation) {
+            throw new NotSupportedError(`No relation found ${p.value} in ${model.name}`);
+        }
+        const { relation } = mp;
+        const { relatedTypeClass: propertyType } = relation;
+
+        let query = this.context.query(propertyType);
+        const events = this.context.eventsFor(propertyType, false);
+        if (events) {
+            query = events.includeFilter(query, model, p.value) ?? query;
+        }
+        const select = { ... (query as EntityQuery).selectStatement };
+
+        let where: Expression;
+        let joinWhere: Expression;
+
+        const fk = relation.fkColumn ?? relation.relatedRelation.fkColumn;
+
+
+        if(relation.isInverseRelation) {
+
+            joinWhere = Expression.equal(
+                Expression.member(
+                    parent.as,
+                    Expression.quotedLiteral(fk.columnName)
+                ),
+                Expression.member(
+                    select.as,
+                    Expression.quotedLiteral(model.keys[0].columnName)
+                )
+            );
+            // load parent..
+            where = parent.where
+                ? Expression.logicalAnd(joinWhere, parent.where)
+                : joinWhere;
+
+            const joins = (select.joins ??= []);
+            joins.push(JoinExpression.create({
+                source: parent.source as TableSource,
+                as: parent.as,
+                model,
+                where
+            }));
+            (this.select.include ??= []).push(select);
+            return [select, relation.relatedEntity];
+        }
+
+        joinWhere = Expression.equal(
+            Expression.member(
+                parent.as,
+                Expression.quotedLiteral(fk.columnName)
+            ),
+            Expression.member(
+                select.as,
+                Expression.quotedLiteral(relation.relatedEntity.keys[0].columnName)
+            )
+        );
+
+        parent = { ... parent };
+
+        parent.where = parent.where
+            ? Expression.logicalAnd(parent.where, joinWhere)
+            : joinWhere;
+
+        const existsWhere = ExistsExpression.create({
+            target: parent
+        });
+
+        select.where = select.where
+            ? Expression.logicalAnd(select.where, existsWhere)
+            : existsWhere;
+
+        (this.select.include ??= []).push(select);
+
+        return [select, relation.relatedEntity];
+    }
+}