remult 0.27.8-next.2 → 0.27.8-next.3

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 { AggregateCountMember, AggregateOperators, } from './src/remult3/remult3.js';
 export class MongoDataProvider {
     db;
     client;
@@ -115,6 +115,8 @@ class MongoEntityDataProvider {
             resultRow[AggregateCountMember] = mongoRow.__count;
         });
         pipeLine.push({ $group });
+        const $addFields = {};
+        pipeLine.push({ $addFields });
         if (options?.groupBy) {
             $group._id = {};
             for (const element of options.groupBy) {
@@ -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 AggregateOperators) {
+            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 { AggregateCountMember, AggregateForApiKey, } from './remult3/remult3.js';
 import { ForbiddenError } from './server-action.js';
 export class DataApi {
     repository;
@@ -110,39 +110,46 @@ export class DataApi {
             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;
                         break;
                     default:
-                        orderBy[element.field] = direction;
+                        orderBy[element.field] = {
+                            ...orderBy[element.field],
+                            [element.operation]: direction,
+                        };
                         break;
                 }
             }
         }
+        const groupBy = body?.groupBy?.filter((x) => this.repository.fields.find(x).includedInApi());
         let result = await this.repository.aggregate({
             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
+            [AggregateForApiKey]: true,
+            groupBy,
             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];
         }
+        else {
+            result.forEach((x) => {
+                for (const f of groupBy) {
+                    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 { AggregateCountMember, AggregateOperators, } from '../remult3/remult3.js';
 import { compareForSort, Sort } from '../sort.js';
 export class ArrayEntityDataProvider {
     entity;
@@ -29,54 +29,95 @@ 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 AggregateOperators) {
+            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 };
@@ -120,13 +161,14 @@ export class ArrayEntityDataProvider {
                         }
                         else {
                             switch (x.operation) {
-                                case 'sum':
-                                    return row[x.field.key].sum;
-                                case 'avg':
-                                    return row[x.field.key].avg;
+                                case 'count':
+                                    return row[AggregateCountMember];
+                                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/rest-data-provider.js

@@ -111,6 +111,9 @@ export class RestEntityDataProvider {
             groupBy: options?.groupBy?.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);

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 { AggregateCountMember, AggregateOperators, } from '../remult3/remult3.js';
 import { getRepository, isAutoIncrement, } from '../remult3/RepositoryImplementation.js';
 import { Sort } from '../sort.js';
 import { ValueConverters } from '../valueConverters.js';
@@ -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 AggregateOperators) {
+        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/remult3/RepositoryImplementation.js

@@ -3,6 +3,7 @@ import { CompoundIdField } from '../CompoundIdField.js';
 import { Remult, isBackend, queryConfig } from '../context.js';
 import { Filter } from '../filter/filter-interfaces.js';
 import { Sort } from '../sort.js';
+import { AggregateForApiKey, } from './remult3.js';
 import { assign } from '../../assign.js';
 import { ValueConverters } from '../valueConverters.js';
 import { findOptionsToJson } from '../data-providers/rest-data-provider.js';
@@ -149,6 +150,9 @@ export class RepositoryImplementation {
             groupBy: options?.groupBy?.map(getField),
             sum: options?.sum?.map(getFieldNotInGroupBy),
             avg: options?.avg?.map(getFieldNotInGroupBy),
+            min: options?.min?.map(getFieldNotInGroupBy),
+            max: options?.max?.map(getFieldNotInGroupBy),
+            distinctCount: options?.distinctCount?.map(getFieldNotInGroupBy),
         };
         if (options?.orderBy) {
             dpOptions.orderBy = [];
@@ -181,6 +185,18 @@ export class RepositoryImplementation {
         const result = await this._edp.aggregate(dpOptions);
         if (!options?.groupBy)
             return result[0];
+        //@ts-expect-error an internal option
+        if (!options?.[AggregateForApiKey]) {
+            const loaderOptions = {
+                include: {},
+            };
+            for (const key of options.groupBy) {
+                loaderOptions.include[key] = true;
+            }
+            const loader = new RelationLoader();
+            await this.populateRelationsForFields(dpOptions.groupBy, loaderOptions, result, loader);
+            await loader.resolveAll();
+        }
         return result;
     }
     _idCache = new Map();
@@ -535,7 +551,12 @@ export class RepositoryImplementation {
             }
         }
         let result = await promiseAll(rawRows, async (r) => await this._mapRawDataToResult(r, loadFields));
-        for (const col of this.metadata.fields) {
+        const fields = this.metadata.fields.toArray();
+        this.populateRelationsForFields(fields, loadOptions, result, loader);
+        return result;
+    }
+    populateRelationsForFields(fields, loadOptions, result, loader) {
+        for (const col of fields) {
             let rel = getRelationFieldInfo(col);
             let incl = col.options
                 .defaultIncluded;
@@ -573,7 +594,6 @@ export class RepositoryImplementation {
                 }
             }
         }
-        return result;
     }
     /*@internal */
     _findOptionsBasedOnRelation(rel, field, moreFindOptions, row, otherRepo) {
@@ -605,8 +625,9 @@ export class RepositoryImplementation {
         }
         const relFields = rel.getFields();
         const getFieldValue = (key) => {
-            let val = rel.type === 'reference'
-                ? getEntityRef(row).fields.find(field.key).getId()
+            const ref = getEntityRef(row, false);
+            let val = rel.type === 'reference' && ref
+                ? ref.fields.find(field.key).getId()
                 : row[key];
             if (rel.type === 'toOne' || rel.type === 'reference') {
                 if (val === null)

package/esm/src/remult3/remult3.js

@@ -1,4 +1,12 @@
 export const AggregateCountMember = '$count';
+export const AggregateForApiKey = Symbol.for('AggregateForApiKey');
+export const AggregateOperators = [
+    'sum',
+    'avg',
+    'min',
+    'max',
+    'distinctCount',
+];
 export const flags = {
     error500RetryCount: 4,
 };

package/index.d.ts

@@ -2,7 +2,7 @@ import type { ClassType } from './classType.js';
 import type { DataProvider } from './src/data-interfaces.js';
 export { ArrayEntityDataProvider } from './src/data-providers/array-entity-data-provider.js';
 export type { ClassType } from './classType.js';
-export { ValidateFieldEvent, MembersOnly, FieldsMetadata, FieldRef, IdFieldRef, FieldsRef, EntityMetadata, EntityOrderBy, EntityFilter, FindOptions, FindOptionsBase, QueryResult, QueryOptions, Repository, FindFirstOptions, ComparisonValueFilter, ValueFilter, IdFilter, ContainsStringValueFilter, EntityRef, SortSegments, Paginator, LiveQuery, LiveQueryChangeInfo, Subscribable, RefSubscriber, RefSubscriberBase, RelationOptions, ObjectMembersOnly, MembersToInclude, RepositoryRelations, EntityIdFields, ClassFieldDecorator, ClassFieldDecoratorContextStub, //n1 consider removing in ts5
+export { ValidateFieldEvent, MembersOnly, FieldsMetadata, FieldRef, IdFieldRef, FieldsRef, EntityMetadata, EntityOrderBy, EntityFilter, FindOptions, FindOptionsBase, QueryResult, QueryOptions, Repository, AggregateOptions, FindFirstOptions, ComparisonValueFilter, ValueFilter, IdFilter, ContainsStringValueFilter, EntityRef, SortSegments, Paginator, LiveQuery, LiveQueryChangeInfo, Subscribable, RefSubscriber, RefSubscriberBase, RelationOptions, ObjectMembersOnly, MembersToInclude, RepositoryRelations, EntityIdFields, ClassFieldDecorator, ClassFieldDecoratorContextStub, //n1 consider removing in ts5
 LifecycleEvent, FieldsRefBase, FieldsRefForEntityBase, RepositoryRelationsForEntityBase, ControllerRefForControllerBase, ControllerRefBase, ControllerRef, EntityRefForEntityBase, IdMetadata, FindFirstOptionsBase, } from './src/remult3/remult3.js';
 export { EntityBase, ControllerBase, FieldType, getFields, ValueListFieldType, getValueList, ValueListFieldOptions, ValueListInfo, CaptionTransformer, } from './src/remult3/RepositoryImplementation.js';
 export { Entity } from './src/remult3/entity.js';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "0.27.8-next.2",
+    "version": "0.27.8-next.3",
     "description": "A CRUD framework for full-stack TypeScript",
     "homepage": "https://remult.dev",
     "repository": {