@entity-access/entity-access 1.0.99 → 1.0.101

package/src/model/EntityQuery.ts

@@ -1,9 +1,10 @@
+import EntityAccessError from "../common/EntityAccessError.js";
 import Logger from "../common/Logger.js";
 import { DisposableScope } from "../common/usingAsync.js";
 import { ServiceProvider } from "../di/di.js";
 import { IDbReader } from "../drivers/base/BaseDriver.js";
 import EntityType from "../entity-query/EntityType.js";
-import { CallExpression, Expression, ExpressionAs, Identifier, OrderByExpression, SelectStatement } from "../query/ast/Expressions.js";
+import { CallExpression, Expression, ExpressionAs, Identifier, NewObjectExpression, OrderByExpression, SelectStatement } from "../query/ast/Expressions.js";
 import { ITextQuery } from "../query/ast/IStringTransformer.js";
 import { QueryExpander } from "../query/expander/QueryExpander.js";
 import EntityContext from "./EntityContext.js";
@@ -29,10 +30,26 @@ export default class EntityQuery<T = any>
         return this.map(p, fx);
     }
 
-    map(p: any, fx: any): any {
-        // const source = this.source.copy();
-        // const { select } = source;
-        // const exp = this.source.context.driver.compiler.compileToExpression(source, p, fx);
+    map(parameters: any, fx: any): any {
+        return this.extend(parameters, fx, (select, body) => {
+            const fields = [] as Expression[];
+            switch(body.type) {
+                case "NewObjectExpression":
+                    const noe = body as NewObjectExpression;
+                    for (const iterator of noe.properties) {
+                        fields.push(ExpressionAs.create({
+                            expression: iterator.expression,
+                            alias: iterator.alias
+                        }));
+                    }
+                    break;
+                default:
+                    fields.push(body);
+                    break;
+
+            }
+            return { ... select, fields };
+        });
     }
 
     withSignal(signal: AbortSignal): any {
@@ -176,6 +193,47 @@ export default class EntityQuery<T = any>
         return new EntityQuery({ ... this, selectStatement: { ... this.selectStatement, offset: n} });
     }
 
+    async sum(parameters?:any, fx?: any): Promise<number> {
+        if (parameters !== void 0) {
+            return this.map(parameters, fx).sum();
+        }
+        const field = this.selectStatement.fields[0];
+        const select = { ... this.selectStatement, fields: [
+            ExpressionAs.create({
+                expression: CallExpression.create({
+                    callee: Identifier.create({ value: "SUM"}),
+                    arguments: [ field]
+                }),
+                alias: Expression.identifier("c1")
+            })
+            ],
+            orderBy: void 0
+        };
+
+        const nq = new EntityQuery({ ... this, selectStatement: select });
+
+        const scope = new DisposableScope();
+        const session = this.context.logger?.newSession() ?? Logger.nullLogger;
+        let query;
+        try {
+            query = this.context.driver.compiler.compileExpression(nq, select);
+            const reader = await this.context.connection.executeReader(query);
+            scope.register(reader);
+            for await (const iterator of reader.next()) {
+                return iterator.c1 as number;
+            }
+            // this is special case when database does not return any count
+            // like sql server
+            return 0;
+        } catch (error) {
+            session.error(`Failed executing ${query?.text}\r\n${error.stack ?? error}`);
+            throw error;
+        } finally {
+            await scope.dispose();
+        }
+
+    }
+
     async count(parameters?:any, fx?: any): Promise<number> {
         if (parameters !== void 0) {
             return this.where(parameters, fx).count();

package/src/model/IFilterWithParameter.ts

@@ -25,6 +25,9 @@ export interface IBaseQuery<T> {
     count(): Promise<number>;
     count<P>(parameters: P, fx: (p: P) => (x: T) => boolean): Promise<number>;
 
+    sum(): Promise<number>;
+    sum<P>(parameters: P, fx: (p: P) => (x: T) => number): Promise<number>;
+
     withSignal<DT>(this:DT, signal: AbortSignal): DT;
 
     include<TR>(fx: (x: T) => TR | TR[]): IBaseQuery<T>;

package/src/query/ast/ExpressionToSql.ts

@@ -1,10 +1,11 @@
+import EntityAccessError from "../../common/EntityAccessError.js";
 import { DisposableScope } from "../../common/usingAsync.js";
 import QueryCompiler from "../../compiler/QueryCompiler.js";
-import EntityType from "../../entity-query/EntityType.js";
+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 { BigIntLiteral, BinaryExpression, BooleanLiteral, CallExpression, CoalesceExpression, ConditionalExpression, Constant, DeleteStatement, ExistsExpression, Expression, ExpressionAs, ExpressionType, Identifier, InsertStatement, JoinExpression, MemberExpression, NewObjectExpression, NotExits, NullExpression, NumberLiteral, OrderByExpression, ParameterExpression, ReturnUpdated, SelectStatement, StringLiteral, TableLiteral, TemplateLiteral, UnionAllStatement, UpdateStatement, ValuesStatement } from "./Expressions.js";
+import { ArrowFunctionExpression, BigIntLiteral, BinaryExpression, BooleanLiteral, CallExpression, CoalesceExpression, ConditionalExpression, Constant, DeleteStatement, ExistsExpression, Expression, ExpressionAs, ExpressionType, Identifier, InsertStatement, JoinExpression, MemberExpression, NewObjectExpression, NotExits, NullExpression, NumberLiteral, OrderByExpression, ParameterExpression, ReturnUpdated, SelectStatement, StringLiteral, TableLiteral, TemplateLiteral, UnionAllStatement, UpdateStatement, ValuesStatement } from "./Expressions.js";
 import { ITextQuery, QueryParameter, prepare, prepareJoin } from "./IStringTransformer.js";
 import ParameterScope from "./ParameterScope.js";
 import Visitor from "./Visitor.js";
@@ -166,74 +167,15 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
 
                         const body = e.arguments[0] as ExpressionType;
                         if (body.type === "ArrowFunctionExpression") {
-
-                            const param1 = body.params[0];
-                            const relatedModel = relation.relation.relatedEntity;
-                            const relatedType = relatedModel.typeClass;
-
-                            let select: SelectStatement;
-
-                            if (this.source?.context) {
-                                const query = FilteredExpression.isFiltered(e)
-                                    ? this.source.context.query(relatedType)
-                                    : this.source.context.filteredQuery(relatedType, "include", false);
-                                select = { ... (query as EntityQuery).selectStatement };
-                                select.fields = [
-                                    NumberLiteral.create({ value: 1})
-                                ];
-                            } else {
-                                select = relatedModel.selectOneNumber();
-                            }
-
-                            param1.model = relatedModel;
-                            this.scope.create({ parameter: param1, model: relatedModel, selectStatement: select });
-                            this.scope.alias(param1, select.sourceParameter, select);
-                            select.sourceParameter = param1;
-                            select[filteredSymbol] = true;
-                            const targetKey = MemberExpression.create({
-                                target: parameter,
-                                property: Identifier.create({
-                                    value: targetType.keys[0].columnName
-                                })
-                            });
-
-                            const relatedKey = MemberExpression.create({
-                                target: param1,
-                                property: Identifier.create({
-                                    value: relation.relation.fkColumn.columnName
-                                })
-                            });
-
-
-                            const join = Expression.logicalAnd(
-                                Expression.equal(targetKey, relatedKey),
-                                body.body
-                            );
-
-                            let where = select.where;
-
-                            if(where) {
-                                where = BinaryExpression.create({
-                                    left: select.where,
-                                    operator: "AND",
-                                    right: join
-                                });
-                            } else {
-                                where = join;
-                            }
-
-                            select.where = where;
-
-                            const exists = ExistsExpression.create({
-                                target: select
-                            });
-
-                            const r = this.visit(exists);
-                            this.scope.delete(param1);
-                            this.scope.delete(select.sourceParameter);
-                            return r;
+                            return this.expandSome(body, relation, e, parameter, targetType);
                         }
+                    }
+                    if (/^(map|select)$/i.test(chain[1])) {
 
+                        const body = e.arguments[0] as ExpressionType;
+                        if (body.type === "ArrowFunctionExpression") {
+                            return this.expandMap(body, relation, e, parameter, targetType);
+                        }
                     }
                 }
             }
@@ -250,6 +192,136 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
         return prepare `${this.visit(e.callee)}(${args})`;
     }
 
+    expandMap(body: ArrowFunctionExpression, relation: IEntityProperty, e: CallExpression, parameter: ParameterExpression, targetType: EntityType): ITextQuery {
+        const param1 = body.params[0];
+        const relatedModel = relation.relation.relatedEntity;
+        const relatedType = relatedModel.typeClass;
+
+        let select: SelectStatement;
+
+        if (this.source?.context) {
+            const query = FilteredExpression.isFiltered(e)
+                ? this.source.context.query(relatedType)
+                : this.source.context.filteredQuery(relatedType, "include", false);
+            select = { ...(query as EntityQuery).selectStatement };
+        } else {
+            select = relatedModel.selectOneNumber();
+        }
+
+        param1.model = relatedModel;
+        this.scope.create({ parameter: param1, model: relatedModel, selectStatement: select });
+        this.scope.alias(param1, select.sourceParameter, select);
+        select.sourceParameter = param1;
+        select[filteredSymbol] = true;
+        const targetKey = MemberExpression.create({
+            target: parameter,
+            property: Identifier.create({
+                value: targetType.keys[0].columnName
+            })
+        });
+
+        const relatedKey = MemberExpression.create({
+            target: param1,
+            property: Identifier.create({
+                value: relation.relation.fkColumn.columnName
+            })
+        });
+
+
+        const join = Expression.equal(targetKey, relatedKey);
+
+        let where = select.where;
+
+        if (where) {
+            where = BinaryExpression.create({
+                left: select.where,
+                operator: "AND",
+                right: join
+            });
+        } else {
+            where = join;
+        }
+
+        select.where = where;
+
+        const exists = ExistsExpression.create({
+            target: select
+        });
+
+        const r = this.visit(exists);
+        this.scope.delete(param1);
+        this.scope.delete(select.sourceParameter);
+        return r;
+    }
+
+    expandSome(body: ArrowFunctionExpression, relation: IEntityProperty, e: CallExpression, parameter: ParameterExpression, targetType: EntityType) {
+        const param1 = body.params[0];
+        const relatedModel = relation.relation.relatedEntity;
+        const relatedType = relatedModel.typeClass;
+
+        let select: SelectStatement;
+
+        if (this.source?.context) {
+            const query = FilteredExpression.isFiltered(e)
+                ? this.source.context.query(relatedType)
+                : this.source.context.filteredQuery(relatedType, "include", false);
+            select = { ...(query as EntityQuery).selectStatement };
+            select.fields = [
+                NumberLiteral.create({ value: 1 })
+            ];
+        } else {
+            select = relatedModel.selectOneNumber();
+        }
+
+        param1.model = relatedModel;
+        this.scope.create({ parameter: param1, model: relatedModel, selectStatement: select });
+        this.scope.alias(param1, select.sourceParameter, select);
+        select.sourceParameter = param1;
+        select[filteredSymbol] = true;
+        const targetKey = MemberExpression.create({
+            target: parameter,
+            property: Identifier.create({
+                value: targetType.keys[0].columnName
+            })
+        });
+
+        const relatedKey = MemberExpression.create({
+            target: param1,
+            property: Identifier.create({
+                value: relation.relation.fkColumn.columnName
+            })
+        });
+
+
+        const join = Expression.logicalAnd(
+            Expression.equal(targetKey, relatedKey),
+            body.body
+        );
+
+        let where = select.where;
+
+        if (where) {
+            where = BinaryExpression.create({
+                left: select.where,
+                operator: "AND",
+                right: join
+            });
+        } else {
+            where = join;
+        }
+
+        select.where = where;
+
+        const exists = ExistsExpression.create({
+            target: select
+        });
+
+        const r = this.visit(exists);
+        this.scope.delete(param1);
+        this.scope.delete(select.sourceParameter);
+        return r;
+    }
+
     visitIdentifier(e: Identifier): ITextQuery {
         // need to visit parameters
         return [e.value];

package/src/sql/ISql.ts

@@ -3,6 +3,11 @@ import DateTime from "../types/DateTime.js";
 export interface ISql {
 
     in<T>(a: T, array: T[]): boolean;
+    coll: {
+        sum<T>(a: number[]): number;
+        count<T>(a: number[]): number;
+        avg<T>(a: number[]): number
+    }
 
     cast: {
         asNumber(a: any): number;

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

@@ -0,0 +1,20 @@
+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 sum = await context.orderItems.all()
+        .where({}, (p) => (x) => x.order.orderID > 0)
+        .map({}, (p) => ({ amount }) => amount)
+        .sum();
+
+    assert.notEqual(0, sum);
+
+}