@entity-access/entity-access 1.0.303 → 1.0.305

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@entity-access/entity-access",
-  "version": "1.0.303",
+  "version": "1.0.305",
   "description": "",
   "main": "index.js",
   "scripts": {

package/src/compiler/ISqlHelpers.ts

@@ -1,4 +1,7 @@
+import EntityAccessError from "../common/EntityAccessError.js";
+import type { ISqlMethodTransformer } from "../query/ast/IStringTransformer.js";
 import { ISql } from "../sql/ISql.js";
+import type QueryCompiler from "./QueryCompiler.js";
 
 type IFunction = ( ... a: any[]) => any;
 
@@ -28,3 +31,33 @@ export const flattenHelpers = (f, name, target = {}) => {
     }
     return target;
 };
+
+export const flattenMethods = (m: any): ISqlMethodTransformer => {
+
+    const map = new Map<string, (...a) => any>();
+
+    const fillMap = (target, root = "Sql") => {
+        for (const key in target) {
+            if (Object.prototype.hasOwnProperty.call(target, key)) {
+                const element = target[key];
+                if (typeof element === "object") {
+                    fillMap(element, root + "." + key);
+                    continue;
+                }
+                if (typeof element === "function") {
+                    map.set(root + "." + key, element);
+                }
+            }
+        }
+    };
+
+    fillMap(m);
+
+    return (compiler: QueryCompiler, method: string, args: string[]) => {
+        const fx = map.get(method);
+        if (!fx) {
+            throw new EntityAccessError(`Invalid method ${method}`);
+        }
+        return fx.apply(compiler, args);
+    };
+};

package/src/compiler/QueryCompiler.ts

@@ -3,7 +3,7 @@ import { ISqlMethodTransformer, IStringTransformer, ITextQuery } from "../query/
 import { Expression, ParameterExpression, SelectStatement } from "../query/ast/Expressions.js";
 import SqlLiteral from "../query/ast/SqlLiteral.js";
 import ArrowToExpression from "../query/parser/ArrowToExpression.js";
-import PostgreSqlMethodTransformer from "./postgres/PostgreSqlMethodTransformer.js";
+import { PostgreSqlMethodTransformer } from "./postgres/PostgreSqlMethodTransformer.js";
 import EntityQuery from "../model/EntityQuery.js";
 import { NamingConventions } from "./NamingConventions.js";
 import RawQuery from "./RawQuery.js";

package/src/compiler/postgres/PostgreSqlMethodTransformer.ts

@@ -1,7 +1,7 @@
 import { joinAny, joinMap, prepareAny } from "../../query/ast/IStringTransformer.js";
 import { NotSupportedError } from "../../query/parser/NotSupportedError.js";
 import Sql from "../../sql/Sql.js";
-import { ISqlHelpers } from "../ISqlHelpers.js";
+import { ISqlHelpers, flattenMethods } from "../ISqlHelpers.js";
 import type QueryCompiler from "../QueryCompiler.js";
 
 const onlyAlphaNumeric = (x: string) => x.replace(/\W/g, "");
@@ -13,13 +13,13 @@ export const PostgreSqlHelper: ISqlHelpers = {
     },
     coll: {
         sum(a) {
-            return prepareAny `COALESCE(SUM((${a})), 0.0)`;
+            return prepareAny `SUM(${a})`;
         },
         count(a) {
             return prepareAny `COUNT(${a})`;
         },
         avg(a) {
-            return prepareAny `COALESCE(AVG(${a}, 0.0)`;
+            return prepareAny `AVG(${a})`;
         },
     },
     math: {
@@ -204,18 +204,20 @@ export const PostgreSqlHelper: ISqlHelpers = {
     }
 };
 
-export default function PostgreSqlMethodTransformer(compiler: QueryCompiler, callee: string[], args: any[]): string {
+export const PostgreSqlMethodTransformer = flattenMethods(PostgreSqlHelper);
 
-    let start = PostgreSqlHelper;
-    for (const iterator of callee) {
-        start = start[iterator];
-        if (!start) {
-            return;
-        }
-    }
-    if (!start) {
-        return;
-    }
-    // eslint-disable-next-line @typescript-eslint/ban-types
-    return (start as unknown as Function).apply(compiler, args);
-}
+// export default function PostgreSqlMethodTransformer(compiler: QueryCompiler, method: string, args: any[]): string {
+
+//     let start = PostgreSqlHelper;
+//     for (const iterator of callee) {
+//         start = start[iterator];
+//         if (!start) {
+//             return;
+//         }
+//     }
+//     if (!start) {
+//         return;
+//     }
+//     // eslint-disable-next-line @typescript-eslint/ban-types
+//     return (start as unknown as Function).apply(compiler, args);
+// }

package/src/compiler/sql-server/SqlServerSqlMethodTransformer.ts

@@ -1,7 +1,7 @@
 
 import { joinAny, joinMap, prepareAny } from "../../query/ast/IStringTransformer.js";
 import Sql from "../../sql/Sql.js";
-import { ISqlHelpers } from "../ISqlHelpers.js";
+import { ISqlHelpers, flattenMethods } from "../ISqlHelpers.js";
 import type QueryCompiler from "../QueryCompiler.js";
 
 export const SqlServerSqlHelper: ISqlHelpers = {
@@ -11,13 +11,13 @@ export const SqlServerSqlHelper: ISqlHelpers = {
     },
     coll: {
         sum(a) {
-            return prepareAny `COALESCE(SUM((${a})), 0.0)`;
+            return prepareAny `SUM(${a})`;
         },
         count(a) {
             return prepareAny `COUNT(${a})`;
         },
         avg(a) {
-            return prepareAny `COALESCE(AVG((${a}), 0.0)`;
+            return prepareAny `AVG(${a})`;
         },
     },
     cast: {
@@ -207,18 +207,20 @@ export const SqlServerSqlHelper: ISqlHelpers = {
     }
 };
 
-export default function SqlServerSqlMethodTransformer(compiler: QueryCompiler, callee: string[], args: any[]): string {
+export const SqlServerSqlMethodTransformer = flattenMethods(SqlServerSqlHelper);
 
-    let start = SqlServerSqlHelper;
-    for (const iterator of callee) {
-        start = start[iterator];
-        if (!start) {
-            return;
-        }
-    }
-    if (!start) {
-        return;
-    }
-    // eslint-disable-next-line @typescript-eslint/ban-types
-    return (start as unknown as Function).apply(compiler, args);
-}
+// export default function SqlServerSqlMethodTransformer(compiler: QueryCompiler, method: string, args: any[]): string {
+
+//     let start = SqlServerSqlHelper;
+//     for (const iterator of callee) {
+//         start = start[iterator];
+//         if (!start) {
+//             return;
+//         }
+//     }
+//     if (!start) {
+//         return;
+//     }
+//     // eslint-disable-next-line @typescript-eslint/ban-types
+//     return (start as unknown as Function).apply(compiler, args);
+// }

package/src/drivers/sql-server/SqlServerQueryCompiler.ts

@@ -1,6 +1,6 @@
 import { NamingConventions } from "../../compiler/NamingConventions.js";
 import QueryCompiler from "../../compiler/QueryCompiler.js";
-import SqlServerSqlMethodTransformer from "../../compiler/sql-server/SqlServerSqlMethodTransformer.js";
+import { SqlServerSqlMethodTransformer } from "../../compiler/sql-server/SqlServerSqlMethodTransformer.js";
 import ArrowToExpression from "../../query/parser/ArrowToExpression.js";
 import ExpressionToSqlServer from "./ExpressionToSqlServer.js";
 import { SqlServerLiteral } from "./SqlServerLiteral.js";

package/src/query/ast/DebugStringVisitor.ts

@@ -1,4 +1,4 @@
-import { ArrayExpression, ArrowFunctionExpression, BigIntLiteral, BinaryExpression, BooleanLiteral, CallExpression, CoalesceExpression, ConditionalExpression, Constant, DeleteStatement, ExistsExpression, Expression, ExpressionAs, Identifier, InsertStatement, JoinExpression, MemberExpression, NewObjectExpression, NotExits, NullExpression, NumberLiteral, OrderByExpression, ParameterExpression, ReturnUpdated, SelectStatement, StringLiteral, TableLiteral, TemplateElement, TemplateLiteral, UnionAllStatement, UpdateStatement, ValuesStatement } from "./Expressions.js";
+import { ArrayExpression, ArrowFunctionExpression, BigIntLiteral, BinaryExpression, BooleanLiteral, BracketExpression, CallExpression, CoalesceExpression, ConditionalExpression, Constant, DeleteStatement, ExistsExpression, Expression, ExpressionAs, Identifier, InsertStatement, JoinExpression, MemberExpression, NewObjectExpression, NotExits, NullExpression, NumberLiteral, OrderByExpression, ParameterExpression, ReturnUpdated, SelectStatement, StringLiteral, TableLiteral, TemplateElement, TemplateLiteral, UnionAllStatement, UpdateStatement, ValuesStatement } from "./Expressions.js";
 import Visitor from "./Visitor.js";
 
 const isBinary = (type) => /^(BinaryExpression|CoalesceExpression)$/.test(type);
@@ -58,6 +58,10 @@ export default class DebugStringVisitor extends Visitor<string> {
         return `"Constant:${e.value}"`;
     }
 
+    visitBracketExpression(e: BracketExpression): string {
+        return `(${this.visit(e.target)})`;
+    }
+
     visitExpressionAs(e: ExpressionAs): string {
         return `${this.visit(e.expression)} as ${this.visit(e.alias)}`;
     }

package/src/query/ast/ExpressionToSql.ts

@@ -4,7 +4,7 @@ import EntityType, { IEntityProperty } from "../../entity-query/EntityType.js";
 import EntityQuery from "../../model/EntityQuery.js";
 import { FilteredExpression, filteredSymbol } from "../../model/events/FilteredExpression.js";
 import { NotSupportedError } from "../parser/NotSupportedError.js";
-import { ArrowFunctionExpression, BigIntLiteral, BinaryExpression, BooleanLiteral, CallExpression, CoalesceExpression, ConditionalExpression, Constant, DeleteStatement, ExistsExpression, Expression, ExpressionAs, ExpressionType, Identifier, InsertStatement, JoinExpression, MemberExpression, UpsertStatement, NewObjectExpression, NotExits, NullExpression, NumberLiteral, OrderByExpression, ParameterExpression, ReturnUpdated, SelectStatement, StringLiteral, TableLiteral, TemplateLiteral, UnionAllStatement, UpdateStatement, ValuesStatement, NotExpression, ArrayExpression } from "./Expressions.js";
+import { ArrowFunctionExpression, BigIntLiteral, BinaryExpression, BooleanLiteral, CallExpression, CoalesceExpression, ConditionalExpression, Constant, DeleteStatement, ExistsExpression, Expression, ExpressionAs, ExpressionType, Identifier, InsertStatement, JoinExpression, MemberExpression, UpsertStatement, NewObjectExpression, NotExits, NullExpression, NumberLiteral, OrderByExpression, ParameterExpression, ReturnUpdated, SelectStatement, StringLiteral, TableLiteral, TemplateLiteral, UnionAllStatement, UpdateStatement, ValuesStatement, NotExpression, ArrayExpression, BracketExpression } from "./Expressions.js";
 import { ITextQuery, QueryParameter, joinMap, prepare, prepareJoin } from "./IStringTransformer.js";
 import ParameterScope from "./ParameterScope.js";
 import Visitor from "./Visitor.js";
@@ -12,7 +12,7 @@ import Visitor from "./Visitor.js";
 interface IPropertyChain {
     identifier?: Identifier,
     parameter?: ParameterExpression,
-    chain: { member: string, args?: Expression[] }[]
+    chain: { member: string, args?: Expression[], isCollectionMethod?: boolean }[]
 }
 
 interface IPropertyMethods {
@@ -163,6 +163,10 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
         return prepare `CONCAT(${args})`;
     }
 
+    visitBracketExpression(e: BracketExpression): ITextQuery {
+        return prepare `(${this.visit(e.target)})`;
+    }
+
     visitCallExpression(e: CallExpression): ITextQuery {
         // let us check if we are using any of array extension methods...
         // .some alias .any
@@ -209,33 +213,45 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
                         if (/^(some|any)$/.test(lastMethod.member)) {
                             return this.visit(exists);
                         }
-                        if (/^(map|select)$/.test(lastMethod.member)) {
+                        if (/^(map|select)$/.test(lastMethod.member) || lastMethod.isCollectionMethod ) {
                             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;
-                                    }
+                            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 fields = noe.properties as ExpressionAs[];
                                 return this.visit({ ... select, where, fields } as SelectStatement);
                             }
-                            return this.visit({ ... select, where, fields: [body.body] } as SelectStatement);
+
+                            if (lastMethod.isCollectionMethod) {
+                                return this.visit({ ... select, where, fields: [
+                                        CallExpression.create({
+                                            callee: Expression.identifier("Sql.coll." + lastMethod.member),
+                                            arguments: [body.body]
+                                        })
+                                    ] } as SelectStatement);
+                                }
+
+                            return this.visit({ ... select, where, fields: [
+                                body.body
+                            ] } as SelectStatement);
                         }
                     }
 
@@ -243,9 +259,11 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
                 }
             }
 
-            if (identifier?.value === "Sql") {
+            const identifierValue = identifier?.value;
+
+            if (identifierValue?.startsWith("Sql")) {
                 const argList = e.arguments?.map((x) => this.visit(x)) ?? [];
-                const transformedCallee = this.compiler.sqlMethodTransformer(this.compiler, chain.map((x) => x.member), argList.map((al) => al.flat(2)) as any[]);
+                const transformedCallee = this.compiler.sqlMethodTransformer(this.compiler, identifierValue, argList.map((al) => al.flat(2)) as any[]);
                 if (transformedCallee) {
                     return prepare `${transformedCallee}`;
                 }
@@ -854,7 +872,7 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
             x = resolved;
         }
 
-        const chain = [] as { member: string, args?: Expression[]}[];
+        const chain = [] as { member: string, args?: Expression[], isCollectionMethod?: boolean}[];
         while (x) {
             if (x.type === "ParameterExpression") {
                 return { parameter: x as ParameterExpression, chain };
@@ -865,7 +883,7 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
             if (x.type === "MemberExpression") {
                 const me = x as MemberExpression;
                 x = me.target;
-                chain.unshift({ member: (me.property as Identifier).value });
+                chain.unshift({ member: (me.property as Identifier).value , isCollectionMethod: me.isCollectionMethod });
                 continue;
             }
             if (x.type === "CallExpression") {

package/src/query/ast/Expressions.ts

@@ -214,6 +214,11 @@ export class CallExpression extends Expression {
     arguments: Expression[];
 }
 
+export class BracketExpression extends Expression {
+    readonly type = "BracketExpression";
+    target: Expression;
+}
+
 export class ParameterExpression extends Expression {
     readonly type = "ParameterExpression";
     name: string;
@@ -239,6 +244,7 @@ export class MemberExpression extends Expression {
     target: Expression;
     property: Expression;
     computed: boolean;
+    isCollectionMethod: boolean;
 }
 
 export class ArrowFunctionExpression extends Expression {
@@ -477,5 +483,6 @@ export type ExpressionType =
     NotExits |
     UnionAllStatement |
     NotExpression |
+    BracketExpression |
     TemplateElement
 ;

package/src/query/ast/IStringTransformer.ts

@@ -5,7 +5,7 @@ export type ITextQuery = ITextQueryFragment[];
 
 export type IStringTransformer = (s: string) => string;
 
-export type ISqlMethodTransformer = (compiler: QueryCompiler, callee: string[], args: string[]) => string;
+export type ISqlMethodTransformer = (compiler: QueryCompiler, method: string, args: string[]) => string;
 
 export class QueryParameter {
 

package/src/query/ast/Visitor.ts

@@ -1,5 +1,5 @@
 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, UpsertStatement, NewObjectExpression, NotExits, NullExpression, NumberLiteral, OrderByExpression, ParameterExpression, ReturnUpdated, SelectStatement, StringLiteral, TableLiteral, TemplateElement, TemplateLiteral, UnionAllStatement, UpdateStatement, ValuesStatement, NotExpression } from "./Expressions.js";
+import { ArrayExpression, ArrowFunctionExpression, BigIntLiteral, BinaryExpression, BooleanLiteral, CallExpression, CoalesceExpression, ConditionalExpression, Constant, DeleteStatement, ExistsExpression, Expression, ExpressionAs, ExpressionType, Identifier, InsertStatement, JoinExpression, MemberExpression, UpsertStatement, NewObjectExpression, NotExits, NullExpression, NumberLiteral, OrderByExpression, ParameterExpression, ReturnUpdated, SelectStatement, StringLiteral, TableLiteral, TemplateElement, TemplateLiteral, UnionAllStatement, UpdateStatement, ValuesStatement, NotExpression, BracketExpression } from "./Expressions.js";
 
 
 export default abstract class Visitor<T = any> {
@@ -75,10 +75,15 @@ export default abstract class Visitor<T = any> {
                 return this.visitUpsertStatement(e);
             case "NotExpression":
                 return this.visitNotExpression(e);
+            case "BracketExpression":
+                return this.visitBracketExpression(e);
         }
         const c: never = e;
         throw new Error(`${e1.type} Not implemented`);
     }
+    visitBracketExpression(e: BracketExpression): T {
+        throw new Error("Method not implemented.");
+    }
     visitNotExpression(e: NotExpression): T {
         throw new Error("Method not implemented.");
     }

package/src/query/parser/ArrowToExpression.ts

@@ -1,5 +1,5 @@
 import { parseExpression } from "@babel/parser";
-import { ArrowFunctionExpression, BinaryExpression, BooleanLiteral, CallExpression, CoalesceExpression, ConditionalExpression, Constant, Expression, ExpressionAs, Identifier, MemberExpression, NewObjectExpression, NotExpression, NullExpression, NumberLiteral, ParameterExpression, StringLiteral, TemplateLiteral } from "../ast/Expressions.js";
+import { ArrowFunctionExpression, BinaryExpression, BooleanLiteral, BracketExpression, CallExpression, CoalesceExpression, ConditionalExpression, Constant, Expression, ExpressionAs, Identifier, MemberExpression, NewObjectExpression, NotExpression, NullExpression, NumberLiteral, ParameterExpression, StringLiteral, TemplateLiteral } from "../ast/Expressions.js";
 import { BabelVisitor } from "./BabelVisitor.js";
 import * as bpe from "@babel/types";
 import Restructure from "./Restructure.js";
@@ -217,10 +217,89 @@ export default class ArrowToExpression extends BabelVisitor<Expression> {
 
         // change Sql.coll. with arrow functions to move it inside
 
-        return CallExpression.create({
+        const ce = CallExpression.create({
             callee: callee ? this.visit(callee) : void 0,
             arguments: args ? args.map((x) => this.visit(x)) : []
         });
+
+        // for Sql.Coll. , change it to coalesce
+        // and move Sql.Coll. inside the first map..
+        return this.reAssignCollectionMethods(ce);
+    }
+
+    /**
+     * We need to change Sql.coll.sum(p.orders.map((o) => o.total)
+     * to
+     * p.orders.sum((o) => o.total) ?? 0
+     * @param ce
+     * @returns
+     */
+    reAssignCollectionMethods(ce: CallExpression) {
+
+        if (ce.callee.type !== "MemberExpression") {
+            return ce;
+        }
+
+        let callee = ce.callee as MemberExpression;
+        const name = [];
+        while(callee) {
+            name.splice(0, 0, (callee.property as Identifier)?.value);
+            const target = callee.target;
+            switch(target.type) {
+                case "MemberExpression":
+                    callee = target as MemberExpression;
+                    continue;
+                case "Identifier":
+                    name.splice(0, 0, (target as Identifier).value);
+                    callee = null;
+                    break;
+                default:
+                    return ce;
+            }
+        }
+
+        if (name[0] !== "Sql") {
+            return ce;
+        }
+
+        const method = name[2];
+
+        const reWrittenCe = CallExpression.create({
+            callee: Expression.identifier(name.join(".")),
+            arguments: ce.arguments
+        });
+
+
+        if (name[1] !== "coll") {
+            // rewrite...
+            return reWrittenCe;
+        }
+
+        const firstArg = ce.arguments[0] as CallExpression;
+        if (firstArg?.type !== "CallExpression") {
+            return reWrittenCe;
+        }
+
+        const mapCallee = firstArg.callee as MemberExpression;
+        if (mapCallee?.type !== "MemberExpression") {
+            return reWrittenCe;
+        }
+
+        const left = CallExpression.create({
+            callee: MemberExpression.create({
+                target: mapCallee.target,
+                property: Expression.identifier(method),
+                isCollectionMethod: true
+            }),
+            arguments: firstArg.arguments
+        });
+
+        // move it inside...
+        const rewritten = CoalesceExpression.create({
+            left: BracketExpression.create({ target: left }) ,
+            right: NumberLiteral.zero
+        });
+        return rewritten;
     }
 
     visitIdentifier({ name: value }: bpe.Identifier): Expression {

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

@@ -19,14 +19,14 @@ export default async function(this: TestConfig) {
 
     // include inverse...
     let all = await context.users.all()
-        .where({} , (p) => (x) => x.profile.photos.some((a) => true) || x.profile.photos.some((a) => true))
+        .where({} , (p) => (x) => x.profile.photos.some((a) => a.photoID > 0) || x.profile.photos.some((a) => a.photoID > 0))
         .include((x) => x.profile.photos)
         .first();
 
     assert.equal(null, all);
 
     all = await context.users.all()
-        .where({} , (p) => (x) => x.files.some((a) => true))
+        .where({} , (p) => (x) => x.files.some((a) => a.fileID > 0))
         .include((x) => x.files)
         .first();
 

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

@@ -31,12 +31,17 @@ export default async function(this: TestConfig) {
 
     // assert.notEqual(null, report);
 
+    await context.orders.asQuery()
+        .update(void 0, (p) => (x) => ({
+            total: Sql.coll.sum(x.orderItems.map((o) => o.amount ))
+        }));
+
     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))))
+                    .map((o) => o.total))
             })
         )
         .trace(console.log)

package/src/tests/model/ShoppingContext.ts

@@ -345,6 +345,9 @@ export class Order {
     @Column({ dataType: "Char", length: 20, default: () => "pending"})
     public status: string;
 
+    @Column({ dataType: "Decimal", default: () => 0})
+    public total: number;
+
     public orderItems: OrderItem[];
 
     public customer: User;

package/src/tests/security/events/UserFileEvents.ts

@@ -5,7 +5,7 @@ import { UserFile } from "../../model/UseFile.js";
 export class UserFileEvents extends EntityEvents<UserFile> {
 
     filter(query: IEntityQuery<UserFile>): IEntityQuery<UserFile> {
-        return query.where({}, (p) => (x) => x.photoUsers.some((p1) => p1.orders.some((o1) => true)));
+        return query.where({}, (p) => (x) => x.photoUsers.some((p1) => p1.orders.some((o1) => true === true)));
     }
 
 }

package/src/tests/security/tests/test-events.ts

@@ -48,7 +48,7 @@ export default async function (this: TestConfig) {
     await context.saveChanges();
     assert.equal(true, p.afterInsertInvoked);
 
-    await context.userFiles.filtered("read").where({}, (_) => (x) => x.photoUsers.some((p1) => true))
+    await context.userFiles.filtered("read").where({}, (_) => (x) => x.photoUsers.some((p1) => true === true))
         .include((x) => x.user.profile).toArray();
 
 

package/src/workflows/WorkflowStorage.ts

@@ -274,9 +274,9 @@ export default class WorkflowStorage {
                     Expression.assign(
                         Expression.identifier(lockTTLField),
                         CallExpression.create({
-                            callee: Expression.member(Expression.member(Expression.identifier("Sql"), "date"), "addMinutes"),
+                            callee: Expression.identifier("Sql.date.addMinutes"),
                             arguments: [CallExpression.create({
-                                callee: Expression.member(Expression.member(Expression.identifier("Sql"), "date"), "now")
+                                callee: Expression.identifier("Sql.date.now")
                             }),
                             NumberLiteral.create({ value: 15 })
                         ]
@@ -294,7 +294,7 @@ export default class WorkflowStorage {
                     Expression.lessOrEqual(
                         Expression.identifier(lockTTLField),
                         CallExpression.create({
-                            callee: Expression.member(Expression.member(Expression.identifier("Sql"), "date"), "now")
+                            callee: Expression.identifier("Sql.date.now")
                         })
                     )
                 ))