@entity-access/entity-access 1.0.300 → 1.0.302

package/src/query/ast/ExpressionToSql.ts

@@ -12,7 +12,13 @@ import Visitor from "./Visitor.js";
 interface IPropertyChain {
     identifier?: Identifier,
     parameter?: ParameterExpression,
-    chain: string[]
+    chain: { member: string, args?: Expression[] }[]
+}
+
+interface IPropertyMethods {
+    identifier?: Identifier;
+    parameter?: ParameterExpression;
+    
 }
 
 export interface IMappingModel {
@@ -161,6 +167,24 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
         // let us check if we are using any of array extension methods...
         // .some alias .any
         // .find alias .firstOrDefault
+        // if (e.callee.type === "MemberExpression") {
+        //     const me = e.callee as MemberExpression;
+        //     if (me.target.type === "CallExpression") {
+        //         // nested...
+        //         const ce = me.target as CallExpression;
+        //         const cme = ce.callee as MemberExpression;
+        //         if(cme.property.type !== "Identifier") {
+        //             throw new EntityAccessError("Invalid expression");
+        //         }
+        //         const property = cme.property as Identifier;
+        //         if(property.value !== "filter") {
+        //             throw new EntityAccessError("Invalid expression");
+        //         }
+
+        //         filter = e;
+        //         e = cme.target as CallExpression;
+        //     }
+        // }
 
         const targetProperty = this.getPropertyChain(e.callee as ExpressionType);
         if (targetProperty) {
@@ -168,29 +192,50 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
             const existingTarget = parameter; // this.scope.get(parameter);
             if (existingTarget) {
 
+                // check if first chain is a filter
+                const [firstMember, ... methods] = chain;
+                const lastMethod = methods.pop();
+
 
                 // calling method on property...
                 // should be navigation...
                 const targetType = existingTarget.model;
-                const relation = targetType?.getProperty(chain[0]);
+                const relation = targetType?.getProperty(firstMember.member);
                 if (relation) {
 
                     const body = e.arguments?.[0] as ExpressionType;
                     if (body?.type === "ArrowFunctionExpression") {
                         const exists = this.expandSome(body, relation, e, parameter, targetType) as ExistsExpression;
-                        if (/^(some|any)$/.test(chain[1])) {
+                        if (/^(some|any)$/.test(lastMethod.member)) {
                             return this.visit(exists);
                         }
-                        if (/^(map|select)$/.test(chain[1])) {
+                        if (/^(map|select)$/.test(lastMethod.member)) {
                             const select = this.expandCollection(relation, e, parameter, targetType);
+                            const p1 = body.params[0];
+                            this.scope.alias(select.sourceParameter, p1, select);
+
+                            let where = select.where;
+
+                                while(methods.length) {
+                                    const last = methods.pop();
+                                    if (last.member !== "filter") {
+                                        throw new EntityAccessError(`Invalid method ${last.member}`);
+                                    }
+                                    const filterArrow = last.args[0] as ArrowFunctionExpression;
+                                    this.scope.alias(select.sourceParameter, filterArrow.params[0], select);
+                                    if (where) {
+                                        where = Expression.logicalAnd(where, filterArrow.body);
+                                    } else {
+                                        where = filterArrow.body;
+                                    }
+                                }
+
                             if (body.body.type === "NewObjectExpression") {
                                 const noe = body.body as NewObjectExpression;
-                                const p1 = body.params[0];
-                                this.scope.alias(select.sourceParameter, p1, select);
                                 const fields = noe.properties as ExpressionAs[];
-                                return this.visit({ ... select, fields } as SelectStatement);
+                                return this.visit({ ... select, where, fields } as SelectStatement);
                             }
-                            return this.visit({ ... select, fields: [body.body] } as SelectStatement);
+                            return this.visit({ ... select, where, fields: [body.body] } as SelectStatement);
                         }
                     }
 
@@ -200,7 +245,7 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
 
             if (identifier?.value === "Sql") {
                 const argList = e.arguments?.map((x) => this.visit(x)) ?? [];
-                const transformedCallee = this.compiler.sqlMethodTransformer(this.compiler, chain, argList.map((al) => al.flat(2)) as any[]);
+                const transformedCallee = this.compiler.sqlMethodTransformer(this.compiler, chain.map((x) => x.member), argList.map((al) => al.flat(2)) as any[]);
                 if (transformedCallee) {
                     return prepare `${transformedCallee}`;
                 }
@@ -233,7 +278,7 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
 
         let where = select.where;
 
-        for (const { fkColumn, relatedKeyColumn } of relation.relation.fkMap) {
+        for (const { fkColumn, relatedKeyColumn } of relation.relation.relatedRelation.fkMap) {
             const targetKey = MemberExpression.create({
                 target: parameter,
                 property: Identifier.create({
@@ -347,15 +392,15 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
             if (parameter) {
                 if (parameter === this.root) {
                     // we have a parameter...
-                    return [(p) => p[chain[0]]];
+                    return [(p) => p[chain[0].member]];
                 }
                 if (parameter.value) {
                     const value = parameter.value;
-                    return [() => value[chain[0]]];
+                    return [() => value[chain[0].member]];
                 }
                 const scope = this.scope.get(parameter);
                 if (scope.isRuntimeParam) {
-                    return [(p) => p[chain[0]]];
+                    return [(p) => p[chain[0].member]];
                 }
 
                 const name = this.scope.nameOf(parameter);
@@ -366,7 +411,7 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
                 //     chain[0] = namingConvention(chain[0]);
                 // }
 
-                return [ QueryParameter.create(() => name) , "." , chain.join(".")];
+                return [ QueryParameter.create(() => name) , "." , chain.map((x) => x.member).join(".")];
             }
         }
 
@@ -809,7 +854,7 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
             x = resolved;
         }
 
-        const chain = [];
+        const chain = [] as { member: string, args?: Expression[]}[];
         while (x) {
             if (x.type === "ParameterExpression") {
                 return { parameter: x as ParameterExpression, chain };
@@ -820,8 +865,20 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
             if (x.type === "MemberExpression") {
                 const me = x as MemberExpression;
                 x = me.target;
-                chain.unshift((me.property as Identifier).value);
+                chain.unshift({ member: (me.property as Identifier).value });
+                continue;
+            }
+            if (x.type === "CallExpression") {
+                const ce = x as CallExpression;
+                const me = ce.callee.type === "MemberExpression" && ce.callee as MemberExpression;
+                if (!me) {
+                    throw new EntityAccessError("Invalid call expression");
+                }
+                x = me.target;
+                chain.splice(0, 0, { member: (me.property as Identifier).value, args: ce.arguments });
+                continue;
             }
+            throw new EntityAccessError(`Invalid expression expression ${x.type}`);
         }
 
         throw new NotSupportedError();

package/src/query/parser/ArrowToExpression.ts

@@ -215,6 +215,8 @@ export default class ArrowToExpression extends BabelVisitor<Expression> {
         // we need to sanitize callee
         this.sanitize(callee);
 
+        // change Sql.coll. with arrow functions to move it inside
+
         return CallExpression.create({
             callee: callee ? this.visit(callee) : void 0,
             arguments: args ? args.map((x) => this.visit(x)) : []
@@ -302,6 +304,11 @@ export default class ArrowToExpression extends BabelVisitor<Expression> {
                     throw new Error(`Unknown identifier ${name}`);
                 }
                 return;
+            case "CallExpression":
+                for (const iterator of node.arguments) {
+                    this.visit(iterator as bpe.Expression);
+                }
+                return;
             case "MemberExpression":
             case "OptionalMemberExpression":
                 return this.sanitize(node.object);

package/src/sql/ISql.ts

@@ -90,6 +90,7 @@ export interface ISql {
         addHours(d: Date|DateTime, n: number): Date;
         addMinutes(d: Date|DateTime, n: number): Date;
         addSeconds(d: Date|DateTime, n: number): Date;
+        epoch(d: DateTime);
     }
 
 }

package/src/tests/db-tests/tests/select-items-sum.ts

@@ -0,0 +1,38 @@
+import assert from "assert";
+import { TestConfig } from "../../TestConfig.js";
+import { createContext, headPhoneCategory } from "../../model/createContext.js";
+import Sql from "../../../sql/Sql.js";
+
+export default async function(this: TestConfig) {
+
+    if (!this.db) {
+        return;
+    }
+
+    const context = await createContext(this.driver);
+
+    let report;
+    // report  = await context.users.all()
+    //     .where({}, (p) => (x) => x.orders.some((oi) => oi.customerID  > 0))
+    //     .map({}, (p) => (x) => ({
+    //             total: Sql.coll.sum(x.orders.map((o) => Sql.coll.sum(o.orderItems.map((oi) => oi.amount))))
+    //         })
+    //     )
+    //     .trace(console.log)
+    //     .first();
+
+    // assert.notEqual(null, report);
+
+    report = await context.users.all()
+        .where({}, (p) => (x) => x.orders.some((oi) => oi.customerID  > 0))
+        .map({}, (p) => (x) => ({
+                total: Sql.coll.sum(x.orders
+                    .filter((o) => o.status === "pending")
+                    .map((o) => Sql.coll.sum(o.orderItems.map((oi) => oi.amount))))
+            })
+        )
+        .trace(console.log)
+        .first();
+
+    assert.notEqual(null, report);
+}

package/src/tests/model/ShoppingContext.ts

@@ -342,6 +342,9 @@ export class Order {
     @Column({ dataType: "Char", length: 200, nullable: true})
     public purchaseOrder: string;
 
+    @Column({ dataType: "Char", length: 20, default: () => "pending"})
+    public status: string;
+
     public orderItems: OrderItem[];
 
     public customer: User;