@entity-access/entity-access 1.0.316 → 1.0.318

package/src/model/EntityQuery.ts

@@ -176,7 +176,7 @@ export default class EntityQuery<T = any>
     }
 
     async delete(p, f): Promise<number> {
-        if (p || f) {
+        if (f) {
             return this.where(p, f).delete(void 0, void 0);
         }
 
@@ -218,9 +218,60 @@ export default class EntityQuery<T = any>
         }
     }
 
+    async updateSelect(p?, f?): Promise<T[]> {
+        const updateStatement = this.getUpdateStatement(p, f, true);
+
+        await using scope = new AsyncDisposableScope();
+        const session = this.context.logger?.newSession() ?? Logger.nullLogger;
+        let query: { text: string, values: any[]};
+        try {
+            scope.register(session);
+            const type = this.type;
+            const signal = this.signal;
+
+            const relationMapper = new RelationMapper(this.context.changeSet);
+
+            signal?.throwIfAborted();
+
+            query = this.context.driver.compiler.compileExpression(this, updateStatement);
+            this.traceQuery?.(query.text);
+            const reader = await this.context.connection.executeReader(query, signal);
+            scope.register(reader);
+            const results = [] as T[];
+            for await (const iterator of reader.next(10, signal)) {
+                const item = type.map(iterator) as any;
+                // set identity...
+                const entry = this.context.changeSet.getEntry(item, item);
+                relationMapper.fix(entry);
+                results.push(entry.entity);
+            }
+            return results;
+        } catch(error) {
+            session.error(`Failed executing ${query?.text}\n${error.stack ?? error}`);
+            throw error;
+        }
+    }
+
     async update(p?, f?): Promise<number> {
 
-        if (p || f) {
+        const updateStatement = this.getUpdateStatement(p, f);
+
+        const session = this.context.logger?.newSession() ?? Logger.nullLogger;
+        let query;
+        try {
+            query = this.context.driver.compiler.compileExpression(this, updateStatement);
+            this.traceQuery?.(query.text);
+            const r = await this.context.connection.executeQuery(query);
+            return r.updated;
+        } catch (error) {
+            session.error(`Failed executing ${query?.text}\r\n${error.stack ?? error}`);
+            throw error;
+        }
+    }
+
+    getUpdateStatement(p?, f?, returnEntity = false) {
+
+        if (f) {
             return this.extend(p, f, (select, body) => {
                 const fields = [] as Expression[];
                 switch(body.type) {
@@ -238,7 +289,7 @@ export default class EntityQuery<T = any>
                         break;
                 }
                 return { ... select, fields };
-            }).update();
+            }).getUpdateStatement(void 0, void 0, returnEntity);
         }
 
         const as = Expression.parameter("s1", this.type);
@@ -253,13 +304,13 @@ export default class EntityQuery<T = any>
         const fieldMap = new Set();
 
         for (const iterator of this.selectStatement.fields) {
-            if(iterator.type !== "ExpressionAs") {
+            if (iterator.type !== "ExpressionAs") {
                 throw new Error(`Invalid expression ${iterator.type}`);
             }
             const eAs = iterator as ExpressionAs;
             const { field } = this.type.getProperty(eAs.alias.value);
             fieldMap.add(field.columnName);
-            set.push(Expression.assign( Expression.quotedIdentifier(field.columnName), Expression.member(as, Expression.quotedIdentifier(eAs.alias.value))));
+            set.push(Expression.assign(Expression.quotedIdentifier(field.columnName), Expression.member(as, Expression.quotedIdentifier(eAs.alias.value))));
         }
 
         let where = null as Expression;
@@ -272,7 +323,18 @@ export default class EntityQuery<T = any>
             if (fieldMap.has(iterator.columnName)) {
                 continue;
             }
-            this.selectStatement.fields.push( Expression.member( this.selectStatement.sourceParameter, Expression.quotedIdentifier(iterator.columnName)));
+            this.selectStatement.fields.push(Expression.member(this.selectStatement.sourceParameter, Expression.quotedIdentifier(iterator.columnName)));
+        }
+
+        let returnUpdated = null as ExpressionAs[];
+        if(returnEntity) {
+            returnUpdated = [];
+            for (const iterator of this.type.columns) {
+                returnUpdated.push(Expression.as(
+                    Expression.identifier(iterator.columnName),
+                    Expression.quotedIdentifier(iterator.name)
+                ));
+            }
         }
 
         const updateStatement = UpdateStatement.create({
@@ -281,20 +343,10 @@ export default class EntityQuery<T = any>
             table: this.type.fullyQualifiedName,
             model: this.type,
             where,
-            join
+            join,
+            returnUpdated
         });
-
-        const session = this.context.logger?.newSession() ?? Logger.nullLogger;
-        let query;
-        try {
-            query = this.context.driver.compiler.compileExpression(this, updateStatement);
-            this.traceQuery?.(query.text);
-            const r = await this.context.connection.executeQuery(query);
-            return r.updated;
-        } catch (error) {
-            session.error(`Failed executing ${query?.text}\r\n${error.stack ?? error}`);
-            throw error;
-        }
+        return updateStatement;
     }
 
     async toArray(): Promise<T[]> {
@@ -453,20 +505,35 @@ 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) {
+    async sum(parameters?:any, fx?: any): Promise<any> {
+        if (fx !== void 0) {
             return this.map(parameters, fx).sum();
         }
-        const field = this.selectStatement.fields[0];
-        const select = { ... this.selectStatement, fields: [
-            ExpressionAs.create({
+
+        const fields = [];
+
+        let fieldName;
+
+        for (const field of this.selectStatement.fields) {
+            let expression = field;
+            if (field.type === "ExpressionAs") {
+                const fe = field as ExpressionAs;
+                expression = fe.expression;
+                fieldName = fe.alias.value;
+            } else {
+                fieldName = "c1";
+            }
+
+            fields.push(ExpressionAs.create({
                 expression: Expression.callExpression(
                     "COALESCE",
-                    Expression.callExpression("SUM", field),
+                    Expression.callExpression("SUM", expression),
                     NumberLiteral.zero),
-                alias: Expression.identifier("c1")
-            })
-            ],
+                alias: Expression.quotedIdentifier(fieldName)
+            }));
+        }
+
+        const select = { ... this.selectStatement, fields,
             orderBy: void 0
         };
 
@@ -477,9 +544,13 @@ export default class EntityQuery<T = any>
         let query;
         try {
             query = this.context.driver.compiler.compileExpression(nq, select);
+            this.traceQuery?.(query.text);
             const reader = await this.context.connection.executeReader(query);
             scope.register(reader);
             for await (const iterator of reader.next()) {
+                if (fields.length > 1) {
+                    return iterator as any;
+                }
                 return iterator.c1 as number;
             }
             // this is special case when database does not return any count

package/src/model/IFilterWithParameter.ts

@@ -7,6 +7,8 @@ export type ILambdaExpression<P = any, T = any, TR = any> = [input: P, x: (p: P)
 
 export type IFilterExpression<P = any, T = any> = [input: P, x: (p: P) => (s: T) => boolean];
 
+export type IFieldsAsNumbers<T> = { [P in keyof T]: number };
+
 export interface IBaseQuery<T> {
     enumerate(): AsyncGenerator<T>;
 
@@ -32,6 +34,7 @@ export interface IBaseQuery<T> {
 
     sum(): Promise<number>;
     sum<P>(parameters: P, fx: (p: P) => (x: T) => number): Promise<number>;
+    sum<P, TR>(parameters: P, fx: (p: P) => (x: T) => TR): Promise<IFieldsAsNumbers<TR>>;
 
 
     withSignal<DT>(this:DT, signal: AbortSignal): DT;
@@ -39,6 +42,7 @@ export interface IBaseQuery<T> {
     include<TR>(fx: (x: T) => TR | TR[]): IBaseQuery<T>;
 
     update<P>(parameters: P, fx: (p: P) => (x:T) => Partial<T>): Promise<number>;
+    updateSelect<P>(parameters: P, fx: (p: P) => (x:T) => Partial<T>): Promise<T[]>;
 
     /**
      * Warning !! Be careful, this will delete rows from the database and neither soft delete nor any other events will be invoked.

package/src/query/ast/ExpressionToSql.ts

@@ -587,7 +587,11 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
             const joinName = this.scope.nameOf(as);
             const asName = this.scope.nameOf(e.sourceParameter);
             const set = this.visitArray(e.set, ",");
-            return prepare `WITH ${joinName} as (${join}) UPDATE ${table} ${asName} SET ${set} FROM ${joinName} WHERE ${where}`;
+            const returning = e.returnUpdated ? [ ` RETURNING `, ... e.returnUpdated.map((r, i) => i
+                ? [ `, ${asName}.`, this.visit(r.expression), ` as ${this.visit(r.alias)}`]
+                : [ `${asName}.`, this.visit(r.expression), ` as ${this.visit(r.alias)}`]
+            ) ] : [];
+            return prepare `WITH ${joinName} as (${join}) UPDATE ${table} ${asName} SET ${set} FROM ${joinName} WHERE ${where} ${returning}`;
 
         }
 

package/src/query/ast/Expressions.ts

@@ -423,6 +423,8 @@ export class UpdateStatement extends Expression {
 
     join: JoinExpression;
 
+    returnUpdated: ExpressionAs[];
+
 }
 
 export class UpsertStatement extends Expression {

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

@@ -20,16 +20,16 @@ export default async function(this: TestConfig) {
 
     // assert.notEqual(null, user);
 
-    report  = await context.users.all()
-        // .where({}, (p) => (x) => x.orders.some((oi) => oi.customerID  > 0))
-        .map({}, (p) => (x) => ({
-                total: 5 * Sql.coll.sum(x.orders.map((o) => Sql.coll.sum(o.orderItems.map((oi) => oi.amount))))
-            })
-        )
-        .trace(console.log)
-        .first();
+    // report  = await context.users.all()
+    //     // .where({}, (p) => (x) => x.orders.some((oi) => oi.customerID  > 0))
+    //     .map({}, (p) => (x) => ({
+    //             total: 5 * Sql.coll.sum(x.orders.map((o) => Sql.coll.sum(o.orderItems.map((oi) => oi.amount))))
+    //         })
+    //     )
+    //     .trace(console.log)
+    //     .first();
 
-    assert.notEqual(null, report);
+    // assert.notEqual(null, report);
 
     // await context.orders.asQuery()
     //     .update(void 0, (p) => (x) => ({
@@ -47,4 +47,14 @@ export default async function(this: TestConfig) {
         .first();
 
     assert.notEqual(null, report);
+
+    // const r = await context.users.all()
+    //     .trace(console.log)
+    //     .sum(void 0, (p) => (x) => ({
+    //         paid: x.orders.some((o) => o.status === "pending") ? 1 : 0,
+    //         total: 1
+    //     }));
+
+    // assert.notEqual(r.paid, undefined);
+    // assert.notEqual(r.total, undefined);
 }

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

@@ -0,0 +1,28 @@
+import assert from "assert";
+import { Sql } from "../../../index.js";
+import { TestConfig } from "../../TestConfig.js";
+import { createContext } from "../../model/createContext.js";
+
+export default async function(this: TestConfig) {
+
+    if (!this.db) {
+        return;
+    }
+
+    const context = await createContext(this.driver);
+
+    const first = await context.products.all().first();
+
+    first.name = "First product";
+
+    await context.saveChanges();
+
+
+    const results = await context.products
+        .where(void 0, (p) => (x) => x.productID > 1)
+        .trace(console.log)
+        .updateSelect(void 0, (p) => (x) => ({
+            productDescription: "updated"
+        }));
+    assert.equal(results[0].productDescription, "updated");
+}