@entity-access/entity-access 1.0.105 → 1.0.108

package/src/query/ast/DebugStringVisitor.ts

@@ -134,7 +134,7 @@ export default class DebugStringVisitor extends Visitor<string> {
     }
 
     visitJoinExpression(e: JoinExpression): string {
-        return `\n${e.joinType} JOIN ${this.visit(e.source)}\n\t\tON ${this.visit(e.where)}\n`;
+        return `\n${e.joinType} JOIN ${this.visit(e.source)} ${this.visit(e.as)} \n\t\tON ${this.visit(e.where)}\n`;
     }
 
     visitOrderByExpression(e: OrderByExpression): string {

package/src/query/ast/ExpressionToSql.ts

@@ -353,6 +353,7 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
                 if (scope.isRuntimeParam) {
                     return [(p) => p[chain[0]]];
                 }
+
                 const name = this.scope.nameOf(parameter);
 
                 // need to change name as per naming convention here...

package/src/query/ast/ParameterScope.ts

@@ -28,8 +28,8 @@ export default class ParameterScope {
 
     public nameOf(p: ParameterExpression) {
         const model = this.map.get(p);
-        p.name = model.name;
-        return model.name;
+        // p.name = model.name;
+        return model?.name ?? p.name;
     }
 
     public alias(

package/src/query/expander/QueryExpander.ts

@@ -1,6 +1,8 @@
+import { cloner } from "../../common/cloner.js";
 import EntityType from "../../entity-query/EntityType.js";
 import EntityContext from "../../model/EntityContext.js";
 import EntityQuery from "../../model/EntityQuery.js";
+import DebugStringVisitor from "../ast/DebugStringVisitor.js";
 import { ArrowFunctionExpression, ExistsExpression, Expression, ExpressionType, JoinExpression, NumberLiteral, ParameterExpression, SelectStatement, TableSource } from "../ast/Expressions.js";
 import ReplaceParameter from "../ast/ReplaceParameter.js";
 import ArrowToExpression from "../parser/ArrowToExpression.js";
@@ -24,6 +26,8 @@ export class QueryExpander {
 
     expandNode(parent: SelectStatement, model: EntityType, node: ExpressionType): [SelectStatement, EntityType] {
 
+        parent = cloner.clone(parent);
+
         if (node.type === "ArrayExpression") {
             for (const iterator of node.elements) {
                 this.expandNode(parent, model,  iterator as ExpressionType);
@@ -83,7 +87,7 @@ export class QueryExpander {
             //     query = events.includeFilter(query, model, p.value) ?? query;
             // }
         // }
-        const select = { ... (query as EntityQuery).selectStatement };
+        const select = cloner.clone((query as EntityQuery).selectStatement);
 
         let where: Expression;
         let joinWhere: Expression;
@@ -108,17 +112,18 @@ export class QueryExpander {
             //     ? Expression.logicalAnd(joinWhere, parent.where)
             //     : joinWhere;
 
-            let keyColumn = 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 = model.keys[0].columnName;
-                keyColumn = select.model.keys[0].columnName;
+                columnName = select.model.keys[0].columnName;
             }
 
 
             const joins = (select.joins ??= []);
+            // const joinParameter = Expression.parameter(parent.sourceParameter.name);
+            // joinParameter.model = parent.sourceParameter.model;
             joins.push(JoinExpression.create({
                 joinType: "LEFT",
                 source: parent.source as TableSource,
@@ -127,21 +132,33 @@ export class QueryExpander {
                 where: Expression.equal(
                     Expression.member(
                         parent.sourceParameter,
-                        Expression.identifier(columnName)
+                        Expression.identifier(keyColumn)
                     ),
                     Expression.member(
                         select.sourceParameter,
-                        Expression.identifier(keyColumn)
+                        Expression.identifier(columnName)
                     )
                 )
             }));
-            // if (parent.joins?.length) {
-            //     joins.push(... parent.joins);
-            // }
+
+            if (parent.where) {
+                select.where = select.where
+                    ? Expression.logicalAnd(select.where, parent.where)
+                    : parent.where;
+            }
+
+            if (parent.joins?.length) {
+                 joins.push(... parent.joins);
+            }
+            // Object.setPrototypeOf(select, SelectStatement.prototype);
+            // const text = DebugStringVisitor.expressionToString(select);
+            // console.log(text);
             (this.select.include ??= []).push(select);
             return [select, relation.relatedEntity];
         }
 
+        // if we can skip this if join already exists !!
+
         joinWhere = Expression.equal(
             Expression.member(
                 parent.sourceParameter,
@@ -153,7 +170,7 @@ export class QueryExpander {
             )
         );
 
-        parent = { ... parent, fields: [ NumberLiteral.one ] };
+        parent = cloner.clone({ ... parent, fields: [ NumberLiteral.one ]});
 
         parent.where = parent.where
             ? Expression.logicalAnd(parent.where, joinWhere)

package/src/tests/db-tests/tests/select-inverse-one-to-one.ts

@@ -10,11 +10,11 @@ export default async function(this: TestConfig) {
 
     const context = await createContext(this.driver);
 
-    const count = await context.users.all()
-        .where({} , (p) => (x) => x.profile.photos.some((a) => true) || x.profile.photos.some((a) => true))
-        .count();
+    // const count = await context.users.all()
+    //     .where({} , (p) => (x) => x.profile.photos.some((a) => true) || x.profile.photos.some((a) => true))
+    //     .count();
 
-    assert.equal(0, count);
+    // assert.equal(0, count);
 
     // include inverse...
     const all = await context.users.all()

package/src/tests/db-tests/tests/select-nested.ts

@@ -0,0 +1,23 @@
+import assert from "assert";
+import { TestConfig } from "../../TestConfig.js";
+import { createContext, headPhoneCategory } from "../../model/createContext.js";
+
+export default async function(this: TestConfig) {
+
+    if (!this.db) {
+        return;
+    }
+
+    const context = await createContext(this.driver);
+
+    const headphone = await context.products
+        .where({ name: "Jabber Head Phones" }, (p) => (x) => x.name === p.name)
+        .include((x) => x.categories.forEach((c) => c.category.children))
+        .first();
+
+    assert.notEqual(null, headphone);
+
+    const child = headphone.categories[0].category.children[0];
+    assert.notEqual(null, child);
+
+}

package/src/tests/model/ShoppingContext.ts

@@ -66,10 +66,21 @@ export class Category {
     @Column({ length: 200 })
     public name: string;
 
+    @Column({ dataType: "Char", length: 200, nullable: true })
+    @RelateTo(Category, {
+        property: (c) => c.parent,
+        inverseProperty: (c) => c.children
+    })
+    public parentID: string;
+
     public productCategories: ProductCategory[];
 
     public users: UserCategory[];
 
+    public children: Category[];
+
+    public parent: Category;
+
 }
 
 @Table("UserProfile")

package/src/tests/model/createContext.ts

@@ -236,7 +236,13 @@ export const headPhoneCategory = "head-phones";
 function addHeadPhones(context: ShoppingContext, now: Date, owner: User) {
     const category = context.categories.add({
         name: "Headphones",
-        categoryID: headPhoneCategory
+        categoryID: headPhoneCategory,
+        children: [
+            context.categories.add({
+                name: "Bluetooth",
+                categoryID: `${headPhoneCategory}/blue-tooth`
+            })
+        ]
     });
 
     const startDate = new Date();