@entity-access/entity-access 1.0.304 → 1.0.306

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, "");
@@ -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 = {
@@ -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

@@ -243,7 +243,7 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
                             if (lastMethod.isCollectionMethod) {
                                 return this.visit({ ... select, where, fields: [
                                         CallExpression.create({
-                                            callee: Expression.member(Expression.member(Expression.identifier("Sql"), "coll"), lastMethod.member),
+                                            callee: Expression.identifier("Sql.coll." + lastMethod.member),
                                             arguments: [body.body]
                                         })
                                     ] } as SelectStatement);
@@ -259,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}`;
                 }
@@ -891,6 +893,9 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
                     throw new EntityAccessError("Invalid call expression");
                 }
                 x = me.target;
+                if (x.type === "MemberExpression") {
+                    x = this.resolveExpression(x) ?? x;
+                }
                 chain.splice(0, 0, { member: (me.property as Identifier).value, args: ce.arguments });
                 continue;
             }

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

@@ -240,34 +240,49 @@ export default class ArrowToExpression extends BabelVisitor<Expression> {
             return ce;
         }
 
-        const firstArg = ce.arguments[0] as CallExpression;
-        if (firstArg?.type !== "CallExpression") {
-            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;
+            }
         }
 
-        const mapCallee = firstArg.callee as MemberExpression;
-        if (mapCallee?.type !== "MemberExpression") {
+        if (name[0] !== "Sql") {
             return ce;
         }
 
-        const me = ce.callee as MemberExpression;
-        const method = (me.property as Identifier).value;
+        const method = name[2];
 
-        if (me.type !== "MemberExpression") {
-            return ce;
-        }
+        const reWrittenCe = CallExpression.create({
+            callee: Expression.identifier(name.join(".")),
+            arguments: ce.arguments
+        });
 
-        if(me.target.type !== "MemberExpression") {
-            return ce;
+
+        if (name[1] !== "coll") {
+            // rewrite...
+            return reWrittenCe;
         }
 
-        const collMember = me.target as MemberExpression;
-        if((collMember.property as Identifier).value !== "coll") {
-            return ce;
+        const firstArg = ce.arguments[0] as CallExpression;
+        if (firstArg?.type !== "CallExpression") {
+            return reWrittenCe;
         }
 
-        if((collMember.target as Identifier)?.value !== "Sql") {
-            return ce;
+        const mapCallee = firstArg.callee as MemberExpression;
+        if (mapCallee?.type !== "MemberExpression") {
+            return reWrittenCe;
         }
 
         const left = CallExpression.create({

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

@@ -31,13 +31,12 @@ 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 ))
-        }));
+    // 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")

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