remult 0.27.8-next.2 → 0.27.8-next.4

package/esm/remult-knex/index.js

@@ -7,7 +7,7 @@ import { Sort } from '../src/sort.js';
 import { ValueConverters } from '../src/valueConverters.js';
 import { getRepositoryInternals } from '../src/remult3/repository-internals.js';
 import { remultStatic } from '../src/remult-static.js';
-import { aggregateImpl, getRowAfterUpdate, } from '../src/data-providers/sql-database.js';
+import { groupByImpl, getRowAfterUpdate, } from '../src/data-providers/sql-database.js';
 export class KnexDataProvider {
     knex;
     constructor(knex) {
@@ -117,8 +117,8 @@ class KnexEntityDataProvider {
         this.rawSqlWrapIdentifier = rawSqlWrapIdentifier;
         this.dp = dp;
     }
-    async aggregate(options) {
-        return aggregateImpl(options, await this.init(), this.dp.createCommand(), false, (limit, offset) => ' limit ' + limit + ' offset ' + offset);
+    async groupBy(options) {
+        return groupByImpl(options, await this.init(), this.dp.createCommand(), false, (limit, offset) => ' limit ' + limit + ' offset ' + offset);
     }
     async count(where) {
         const e = await this.init();

package/esm/remult-mongo.js

@@ -5,7 +5,7 @@ import { remult as remultContext } from './src/remult-proxy.js';
 import { getRepository } from './src/remult3/RepositoryImplementation.js';
 import { getRepositoryInternals } from './src/remult3/repository-internals.js';
 import { getRowAfterUpdate } from './src/data-providers/sql-database.js';
-import { AggregateCountMember } from './src/remult3/remult3.js';
+import { GroupByCountMember, GroupByOperators } from './src/remult3/remult3.js';
 export class MongoDataProvider {
     db;
     client;
@@ -98,7 +98,7 @@ class MongoEntityDataProvider {
         let w = await x.resolveWhere();
         return await collection.countDocuments(w, { session: this.session });
     }
-    async aggregate(options) {
+    async groupBy(options) {
         let { collection, e } = await this.collection();
         let x = new FilterConsumerBridgeToMongo(e);
         const pipeLine = [];
@@ -112,12 +112,14 @@ class MongoEntityDataProvider {
             __count: { $sum: 1 },
         };
         processResultRow.push((mongoRow, resultRow) => {
-            resultRow[AggregateCountMember] = mongoRow.__count;
+            resultRow[GroupByCountMember] = mongoRow.__count;
         });
         pipeLine.push({ $group });
-        if (options?.groupBy) {
+        const $addFields = {};
+        pipeLine.push({ $addFields });
+        if (options?.group) {
             $group._id = {};
-            for (const element of options.groupBy) {
+            for (const element of options.group) {
                 const name = e.$dbNameOf(element);
                 $group._id[name] = `$${name}`;
                 processResultRow.push((mongoRow, resultRow) => {
@@ -128,28 +130,23 @@ class MongoEntityDataProvider {
         else {
             $group._id = null;
         }
-        if (options?.sum) {
-            for (const element of options.sum) {
-                const name = e.$dbNameOf(element) + '_sum';
-                $group[name] = { $sum: `$${e.$dbNameOf(element)}` };
-                processResultRow.push((mongoRow, resultRow) => {
-                    resultRow[element.key] = {
-                        ...resultRow[element.key],
-                        sum: element.valueConverter.fromDb(mongoRow[name]),
-                    };
-                });
-            }
-        }
-        if (options?.avg) {
-            for (const element of options.avg) {
-                const name = e.$dbNameOf(element) + '_avg';
-                $group[name] = { $avg: `$${e.$dbNameOf(element)}` };
-                processResultRow.push((mongoRow, resultRow) => {
-                    resultRow[element.key] = {
-                        ...resultRow[element.key],
-                        avg: element.valueConverter.fromDb(mongoRow[name]),
-                    };
-                });
+        for (const operator of GroupByOperators) {
+            if (options?.[operator]) {
+                for (const element of options[operator]) {
+                    const name = e.$dbNameOf(element) + '_' + operator;
+                    if (operator === 'distinctCount') {
+                        $group[name + '_temp'] = { $addToSet: `$${e.$dbNameOf(element)}` };
+                        $addFields[name] = { $size: `$${name + '_temp'}` };
+                    }
+                    else
+                        $group[name] = { ['$' + operator]: `$${e.$dbNameOf(element)}` };
+                    processResultRow.push((mongoRow, resultRow) => {
+                        resultRow[element.key] = {
+                            ...resultRow[element.key],
+                            [operator]: mongoRow[name],
+                        };
+                    });
+                }
             }
         }
         if (options?.orderBy) {
@@ -157,17 +154,15 @@ class MongoEntityDataProvider {
             for (const x of options.orderBy) {
                 const direction = x.isDescending ? -1 : 1;
                 switch (x.operation) {
-                    case 'sum':
-                        sort[e.$dbNameOf(x.field) + '_sum'] = direction;
-                        break;
-                    case 'avg':
-                        sort[e.$dbNameOf(x.field) + '_avg'] = direction;
-                        break;
                     case 'count':
                         sort['__count'] = direction;
                         break;
-                    default:
+                    case undefined:
                         sort['_id.' + e.$dbNameOf(x.field)] = direction;
+                        break;
+                    default:
+                        sort[e.$dbNameOf(x.field) + '_' + x.operation] = direction;
+                        break;
                 }
             }
             pipeLine.push({ $sort: sort });

package/esm/src/data-api.js

@@ -2,7 +2,7 @@ import { doTransaction } from './context.js';
 import { findOptionsToJson, liveQueryAction, } from './data-providers/rest-data-provider.js';
 import { Filter, buildFilterFromRequestParameters, customUrlToken, } from './filter/filter-interfaces.js';
 import { getRelationFieldInfo } from './remult3/relationInfoMember.js';
-import { AggregateCountMember, } from './remult3/remult3.js';
+import { GroupByCountMember, GroupByForApiKey, } from './remult3/remult3.js';
 import { ForbiddenError } from './server-action.js';
 export class DataApi {
     repository;
@@ -19,8 +19,8 @@ export class DataApi {
             case 'get':
             case 'count':
                 return this.count(res, req, undefined);
-            case 'aggregate':
-                return this.aggregate(res, req, undefined);
+            case 'groupBy':
+                return this.groupBy(res, req, undefined);
         }
         return this.getArray(res, req, undefined);
     }
@@ -45,8 +45,8 @@ export class DataApi {
             case 'count':
                 validateWhereInBody();
                 return this.count(res, req, body);
-            case 'aggregate':
-                return this.aggregate(res, req, body);
+            case 'groupBy':
+                return this.groupBy(res, req, body);
             case 'deleteMany':
                 validateWhereInBody();
                 return this.deleteMany(res, req, body);
@@ -103,46 +103,49 @@ export class DataApi {
             response.error(err, this.repository.metadata);
         }
     }
-    async aggregate(response, request, body) {
+    async groupBy(response, request, body) {
         let findOptions = await this.findOptionsFromRequest(request, body);
         let orderBy = {};
         if (body?.orderBy) {
             for (const element of body?.orderBy) {
                 const direction = element.isDescending ? 'desc' : 'asc';
                 switch (element.operation) {
-                    case 'sum':
-                        orderBy[element.field] = {
-                            ...orderBy[element.field],
-                            sum: direction,
-                        };
-                        break;
-                    case 'avg':
-                        orderBy[element.field] = {
-                            ...orderBy[element.field],
-                            avg: direction,
-                        };
+                    case undefined:
+                        orderBy[element.field] = direction;
                         break;
                     case 'count':
-                        orderBy[AggregateCountMember] = direction;
+                        orderBy[GroupByCountMember] = direction;
                         break;
                     default:
-                        orderBy[element.field] = direction;
+                        orderBy[element.field] = {
+                            ...orderBy[element.field],
+                            [element.operation]: direction,
+                        };
                         break;
                 }
             }
         }
-        let result = await this.repository.aggregate({
+        const group = body?.groupBy?.filter((x) => this.repository.fields.find(x).includedInApi());
+        let result = await this.repository.groupBy({
             where: findOptions.where,
             limit: findOptions.limit,
             page: findOptions.page,
-            groupBy: body?.groupBy?.filter((x) => this.repository.fields.find(x).includedInApi()),
+            //@ts-expect-error internal key
+            [GroupByForApiKey]: true,
+            group,
             sum: body?.sum?.filter((x) => this.repository.fields.find(x).includedInApi()),
             avg: body?.avg?.filter((x) => this.repository.fields.find(x).includedInApi()),
+            min: body?.min?.filter((x) => this.repository.fields.find(x).includedInApi()),
+            max: body?.max?.filter((x) => this.repository.fields.find(x).includedInApi()),
+            distinctCount: body?.distinctCount?.filter((x) => this.repository.fields.find(x).includedInApi()),
             orderBy: orderBy,
         });
-        if (!Array.isArray(result)) {
-            result = [result];
-        }
+        if (group)
+            result.forEach((x) => {
+                for (const f of group) {
+                    x[f] = this.repository.fields.find(f).valueConverter.toJson(x[f]);
+                }
+            });
         response.success(result);
     }
     async getArrayImpl(response, request, body) {

package/esm/src/data-providers/array-entity-data-provider.js

@@ -1,7 +1,7 @@
 import { CompoundIdField } from '../CompoundIdField.js';
 import { dbNamesOf, isDbReadonly, } from '../filter/filter-consumer-bridge-to-sql-request.js';
 import { Filter, customDatabaseFilterToken, } from '../filter/filter-interfaces.js';
-import { AggregateCountMember, } from '../remult3/remult3.js';
+import { GroupByCountMember, GroupByOperators, } from '../remult3/remult3.js';
 import { compareForSort, Sort } from '../sort.js';
 export class ArrayEntityDataProvider {
     entity;
@@ -17,10 +17,10 @@ export class ArrayEntityDataProvider {
         this.entity = entity;
         this.rows = rows;
     }
-    async aggregate(options) {
+    async groupBy(options) {
         const sort = new Sort();
-        if (options?.groupBy)
-            for (const field of options?.groupBy) {
+        if (options?.group)
+            for (const field of options?.group) {
                 sort.Segments.push({ field: field });
             }
         const rows = await this.find({ orderBy: sort, where: options?.where });
@@ -29,69 +29,110 @@ export class ArrayEntityDataProvider {
         let first = true;
         let count = 0;
         let aggregates = [];
-        if (options?.sum) {
-            class Sum {
-                key;
-                constructor(key) {
-                    this.key = key;
-                }
-                sum = 0;
-                process(row) {
-                    const val = row[this.key];
-                    if (val !== undefined && val !== null)
-                        this.sum += row[this.key];
-                }
-                finishGroup(result) {
-                    result[this.key] = { ...result[this.key], sum: this.sum };
-                    this.sum = 0;
-                }
-            }
-            for (const element of options.sum) {
-                aggregates.push(new Sum(element.key));
-            }
-        }
-        if (options?.avg) {
-            class Avg {
-                key;
-                constructor(key) {
-                    this.key = key;
-                }
-                sum = 0;
-                count = 0;
-                process(row) {
-                    const val = row[this.key];
-                    if (val !== undefined && val !== null) {
-                        this.sum += row[this.key];
-                        this.count++;
-                    }
-                }
-                finishGroup(result) {
-                    result[this.key] = {
-                        ...result[this.key],
-                        avg: this.sum / this.count,
-                    };
-                    this.sum = 0;
-                    this.count = 0;
+        const operatorImpl = {
+            sum: (key) => {
+                let sum = 0;
+                return {
+                    process(row) {
+                        const val = row[key];
+                        if (val !== undefined && val !== null)
+                            sum += row[key];
+                    },
+                    finishGroup(result) {
+                        result[key] = { ...result[key], sum };
+                        sum = 0;
+                    },
+                };
+            },
+            avg: (key) => {
+                let sum = 0;
+                let count = 0;
+                return {
+                    process(row) {
+                        const val = row[key];
+                        if (val !== undefined && val !== null) {
+                            sum += row[key];
+                            count++;
+                        }
+                    },
+                    finishGroup(result) {
+                        result[key] = {
+                            ...result[key],
+                            avg: sum / count,
+                        };
+                        sum = 0;
+                        count = 0;
+                    },
+                };
+            },
+            min: (key) => {
+                let min = undefined;
+                return {
+                    process(row) {
+                        const val = row[key];
+                        if (val !== undefined && val !== null) {
+                            if (min === undefined || val < min)
+                                min = val;
+                        }
+                    },
+                    finishGroup(result) {
+                        result[key] = { ...result[key], min };
+                        min = undefined;
+                    },
+                };
+            },
+            max: (key) => {
+                let max = undefined;
+                return {
+                    process(row) {
+                        const val = row[key];
+                        if (val !== undefined && val !== null) {
+                            if (max === undefined || val > max)
+                                max = val;
+                        }
+                    },
+                    finishGroup(result) {
+                        result[key] = { ...result[key], max };
+                        max = undefined;
+                    },
+                };
+            },
+            distinctCount: (key) => {
+                let distinct = new Set();
+                return {
+                    process(row) {
+                        const val = row[key];
+                        if (val !== undefined && val !== null)
+                            distinct.add(val);
+                    },
+                    finishGroup(result) {
+                        result[key] = { ...result[key], distinctCount: distinct.size };
+                        distinct.clear();
+                    },
+                };
+            },
+        };
+        for (let operator of GroupByOperators) {
+            if (options?.[operator]) {
+                for (const element of options[operator]) {
+                    aggregates.push(operatorImpl[operator](element.key));
                 }
             }
-            for (const element of options.avg) {
-                aggregates.push(new Avg(element.key));
-            }
         }
         function finishGroup() {
             const r = { ...group, $count: count };
             for (const a of aggregates) {
                 a.finishGroup(r);
             }
-            r[AggregateCountMember] = count;
+            r[GroupByCountMember] = count;
             result.push(r);
             first = true;
             count = 0;
         }
         for (const row of rows) {
-            if (options?.groupBy) {
+            if (options?.group) {
                 if (!first) {
-                    for (const field of options?.groupBy) {
+                    for (const field of options?.group) {
                         if (group[field.key] != row[field.key]) {
                             finishGroup();
                             break;
@@ -99,7 +140,7 @@ export class ArrayEntityDataProvider {
                     }
                 }
                 if (first) {
-                    for (const field of options?.groupBy) {
+                    for (const field of options?.group) {
                         group[field.key] = row[field.key];
                     }
                 }
@@ -116,17 +157,18 @@ export class ArrayEntityDataProvider {
                 for (const x of options.orderBy) {
                     const getValue = (row) => {
                         if (!x.field && x.operation == 'count') {
-                            return row[AggregateCountMember];
+                            return row[GroupByCountMember];
                         }
                         else {
                             switch (x.operation) {
-                                case 'sum':
-                                    return row[x.field.key].sum;
-                                case 'avg':
-                                    return row[x.field.key].avg;
+                                case 'count':
+                                    return row[GroupByCountMember];
+                                case undefined:
+                                    return row[x.field.key];
+                                default:
+                                    return row[x.field.key][x.operation];
                             }
                         }
-                        return row[x.field.key];
                     };
                     let compare = compareForSort(getValue(a), getValue(b), x.isDescending);
                     if (compare != 0)

package/esm/src/data-providers/json-data-provider.js

@@ -22,8 +22,8 @@ class JsonEntityDataProvider {
         this.helper = helper;
         this.formatted = formatted;
     }
-    aggregate(options) {
-        return (this.p = this.p.then(() => this.loadEntityData((dp, save) => dp.aggregate(options))));
+    groupBy(options) {
+        return (this.p = this.p.then(() => this.loadEntityData((dp, save) => dp.groupBy(options))));
     }
     async loadEntityData(what) {
         let data = [];

package/esm/src/data-providers/rest-data-provider.js

@@ -101,22 +101,25 @@ export class RestEntityDataProvider {
         this.http = http;
         this.entity = entity;
     }
-    async aggregate(options) {
+    async groupBy(options) {
         const { run } = this.buildFindRequest({
             where: options?.where,
             limit: options?.limit,
             page: options?.page,
         });
         const body = {
-            groupBy: options?.groupBy?.map((x) => x.key),
+            groupBy: options?.group?.map((x) => x.key),
             sum: options?.sum?.map((x) => x.key),
             avg: options?.avg?.map((x) => x.key),
+            min: options?.min?.map((x) => x.key),
+            max: options?.max?.map((x) => x.key),
+            distinctCount: options?.distinctCount?.map((x) => x.key),
             orderBy: options?.orderBy?.map((x) => ({ ...x, field: x.field?.key })),
         };
-        const result = await run('aggregate', Object.keys(body).length > 0 ? body : undefined);
-        if (options?.groupBy)
+        const result = await run('groupBy', Object.keys(body).length > 0 ? body : undefined);
+        if (options?.group)
             result.forEach((row) => {
-                for (const g of options.groupBy) {
+                for (const g of options.group) {
                     row[g.key] = g.valueConverter.fromJson(row[g.key]);
                 }
             });

package/esm/src/data-providers/sql-database.js

@@ -1,7 +1,7 @@
 import { FilterConsumerBridgeToSqlRequest, dbNamesOfWithForceSqlExpression, isDbReadonly, } from '../filter/filter-consumer-bridge-to-sql-request.js';
 import { Filter, customDatabaseFilterToken, } from '../filter/filter-interfaces.js';
 import { remult as defaultRemult } from '../remult-proxy.js';
-import { AggregateCountMember, } from '../remult3/remult3.js';
+import { GroupByCountMember, GroupByOperators, } from '../remult3/remult3.js';
 import { getRepository, isAutoIncrement, } from '../remult3/RepositoryImplementation.js';
 import { Sort } from '../sort.js';
 import { ValueConverters } from '../valueConverters.js';
@@ -287,8 +287,8 @@ class ActualSQLEntityDataProvider {
             return Number(r.rows[0].count);
         });
     }
-    async aggregate(options) {
-        return await aggregateImpl(options, await this.init(), this.sql.createCommand(), this.sql._getSourceSql().orderByNullsFirst, this.sql._getSourceSql().getLimitSqlSyntax);
+    async groupBy(options) {
+        return await groupByImpl(options, await this.init(), this.sql.createCommand(), this.sql._getSourceSql().orderByNullsFirst, this.sql._getSourceSql().getLimitSqlSyntax);
     }
     async find(options) {
         let e = await this.init();
@@ -541,15 +541,15 @@ export function getRowAfterUpdate(meta, dataProvider, data, id, operation) {
         return r[0];
     });
 }
-export async function aggregateImpl(options, e, r, orderByNullFirst, limitSyntax) {
+export async function groupByImpl(options, e, r, orderByNullFirst, limitSyntax) {
     let select = 'select count(*) as count';
     let groupBy = '';
     const processResultRow = [];
     processResultRow.push((sqlVal, theResult) => {
-        theResult[AggregateCountMember] = Number(sqlVal);
+        theResult[GroupByCountMember] = Number(sqlVal);
     });
-    if (options?.groupBy)
-        for (const x of options?.groupBy) {
+    if (options?.group)
+        for (const x of options?.group) {
             if (x.isServerExpression) {
             }
             else {
@@ -566,28 +566,21 @@ export async function aggregateImpl(options, e, r, orderByNullFirst, limitSyntax
                 theResult[x.key] = x.valueConverter.fromDb(sqlResult);
             });
         }
-    if (options?.sum)
-        for (const x of options?.sum) {
-            if (x.isServerExpression) {
-            }
-            else {
-                select += ', sum(' + e.$dbNameOf(x) + ') as ' + x.key + '_sum';
-            }
-            processResultRow.push((sqlResult, theResult) => {
-                theResult[x.key] = { ...theResult[x.key], sum: sqlResult };
-            });
-        }
-    if (options?.avg)
-        for (const x of options?.avg) {
-            if (x.isServerExpression) {
-            }
-            else {
-                select += ', avg(' + e.$dbNameOf(x) + ') as ' + x.key + '_avg';
+    for (const operator of GroupByOperators) {
+        const fields = options?.[operator];
+        if (fields)
+            for (const x of fields) {
+                if (x.isServerExpression) {
+                }
+                else {
+                    const dbName = await e.$dbNameOf(x);
+                    select += `, ${aggregateSqlSyntax(operator, dbName)} as ${x.key}_${operator}`;
+                }
+                processResultRow.push((sqlResult, theResult) => {
+                    theResult[x.key] = { ...theResult[x.key], [operator]: sqlResult };
+                });
             }
-            processResultRow.push((sqlResult, theResult) => {
-                theResult[x.key] = { ...theResult[x.key], avg: sqlResult };
-            });
-        }
+    }
     select += '\n from ' + e.$entityName;
     if (options?.where) {
         let where = new FilterConsumerBridgeToSqlRequest(r, e);
@@ -603,21 +596,17 @@ export async function aggregateImpl(options, e, r, orderByNullFirst, limitSyntax
                 orderBy = ' order by ';
             else
                 orderBy += ', ';
-            if (!x.field && x.operation == 'count') {
-                orderBy += x.operation + '(*)';
-            }
-            else {
-                let field = await e.$dbNameOf(x.field);
-                switch (x.operation) {
-                    case 'sum':
-                        field = 'sum(' + field + ')';
-                        break;
-                    case 'avg':
-                        field = 'avg(' + field + ')';
-                        break;
-                }
-                orderBy += field;
+            let field = x.field && (await e.$dbNameOf(x.field));
+            switch (x.operation) {
+                case 'count':
+                    field = x.operation + '(*)';
+                    break;
+                case undefined:
+                    break;
+                default:
+                    field = aggregateSqlSyntax(x.operation, field);
             }
+            orderBy += field;
             if (x.isDescending)
                 orderBy += ' desc';
             if (orderByNullFirst) {
@@ -644,4 +633,9 @@ export async function aggregateImpl(options, e, r, orderByNullFirst, limitSyntax
         processResultRow.forEach((x, i) => x(sql[result.getColumnKeyInResultForIndexInSelect(i)], theResult));
         return theResult;
     });
+    function aggregateSqlSyntax(operator, dbName) {
+        return operator === 'distinctCount'
+            ? `count (distinct ${dbName})`
+            : `${operator}( ${dbName} )`;
+    }
 }

package/esm/src/remult-proxy.js

@@ -112,6 +112,11 @@ export class RemultProxy {
                 .remultFactory()
                 .repo(...args)
                 .find(...args2),
+            groupBy: (...args2) => self
+                .remultFactory()
+                .repo(...args)
+                //@ts-ignore
+                .groupBy(...args2),
             aggregate: (...args2) => self
                 .remultFactory()
                 .repo(...args)