remult 0.27.7 → 0.27.8-next.1

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 { getRowAfterUpdate } from '../src/data-providers/sql-database.js';
+import { aggregateImpl, getRowAfterUpdate, } from '../src/data-providers/sql-database.js';
 export class KnexDataProvider {
     knex;
     constructor(knex) {
@@ -70,7 +70,7 @@ export class KnexDataProvider {
                 }
             }
         }
-        return new KnexEntityDataProvider(entity, this.knex, this.wrapIdentifier);
+        return new KnexEntityDataProvider(entity, this.knex, this.wrapIdentifier, this);
     }
     async transaction(action) {
         let t = await this.knex.transaction();
@@ -110,10 +110,15 @@ class KnexEntityDataProvider {
     entity;
     knex;
     rawSqlWrapIdentifier;
-    constructor(entity, knex, rawSqlWrapIdentifier) {
+    dp;
+    constructor(entity, knex, rawSqlWrapIdentifier, dp) {
         this.entity = entity;
         this.knex = knex;
         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 count(where) {
         const e = await this.init();

package/esm/remult-mongo.js

@@ -5,6 +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';
 export class MongoDataProvider {
     db;
     client;
@@ -97,6 +98,98 @@ class MongoEntityDataProvider {
         let w = await x.resolveWhere();
         return await collection.countDocuments(w, { session: this.session });
     }
+    async aggregate(options) {
+        let { collection, e } = await this.collection();
+        let x = new FilterConsumerBridgeToMongo(e);
+        const pipeLine = [];
+        if (options?.where) {
+            options.where.__applyToConsumer(x);
+            let where = await x.resolveWhere();
+            pipeLine.push({ $match: where });
+        }
+        const processResultRow = [];
+        const $group = {
+            __count: { $sum: 1 },
+        };
+        processResultRow.push((mongoRow, resultRow) => {
+            resultRow[AggregateCountMember] = mongoRow.__count;
+        });
+        pipeLine.push({ $group });
+        if (options?.groupBy) {
+            $group._id = {};
+            for (const element of options.groupBy) {
+                const name = e.$dbNameOf(element);
+                $group._id[name] = `$${name}`;
+                processResultRow.push((mongoRow, resultRow) => {
+                    resultRow[element.key] = element.valueConverter.fromDb(mongoRow._id[name]);
+                });
+            }
+        }
+        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]),
+                    };
+                });
+            }
+        }
+        if (options?.orderBy) {
+            let sort = {};
+            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:
+                        sort['_id.' + e.$dbNameOf(x.field)] = direction;
+                }
+            }
+            pipeLine.push({ $sort: sort });
+        }
+        if (options?.limit) {
+            pipeLine.push({ $limit: options.limit });
+            if (options.page) {
+                pipeLine.push({ $skip: (options.page - 1) * options.limit });
+            }
+        }
+        const r = await collection
+            .aggregate(pipeLine, { session: this.session })
+            .toArray();
+        const r2 = r.map((x) => {
+            let resultRow = {};
+            for (const f of processResultRow) {
+                f(x, resultRow);
+            }
+            return resultRow;
+        });
+        return r2;
+    }
     async find(options) {
         let { collection, e } = await this.collection();
         let x = new FilterConsumerBridgeToMongo(e);

package/esm/src/data-api.js

@@ -2,6 +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 { ForbiddenError } from './server-action.js';
 export class DataApi {
     repository;
@@ -18,6 +19,8 @@ export class DataApi {
             case 'get':
             case 'count':
                 return this.count(res, req, undefined);
+            case 'aggregate':
+                return this.aggregate(res, req, undefined);
         }
         return this.getArray(res, req, undefined);
     }
@@ -42,6 +45,8 @@ export class DataApi {
             case 'count':
                 validateWhereInBody();
                 return this.count(res, req, body);
+            case 'aggregate':
+                return this.aggregate(res, req, body);
             case 'deleteMany':
                 validateWhereInBody();
                 return this.deleteMany(res, req, body);
@@ -98,7 +103,56 @@ export class DataApi {
             response.error(err, this.repository.metadata);
         }
     }
+    async aggregate(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,
+                        };
+                        break;
+                    case 'count':
+                        orderBy[AggregateCountMember] = direction;
+                        break;
+                    default:
+                        orderBy[element.field] = direction;
+                        break;
+                }
+            }
+        }
+        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()),
+            sum: body?.sum?.filter((x) => this.repository.fields.find(x).includedInApi()),
+            avg: body?.avg?.filter((x) => this.repository.fields.find(x).includedInApi()),
+            orderBy: orderBy,
+        });
+        if (!Array.isArray(result)) {
+            result = [result];
+        }
+        response.success(result);
+    }
     async getArrayImpl(response, request, body) {
+        let findOptions = await this.findOptionsFromRequest(request, body);
+        const r = await this.repository.find(findOptions).then(async (r) => {
+            return await Promise.all(r.map(async (y) => this.repository.getEntityRef(y).toApiJson()));
+        });
+        return { r, findOptions };
+    }
+    async findOptionsFromRequest(request, body) {
         let findOptions = {
             load: () => [],
             include: this.includeNone(),
@@ -147,14 +201,10 @@ export class DataApi {
                 });
             }
             if (!hasId) {
-                response.forbidden();
                 throw new ForbiddenError();
             }
         }
-        const r = await this.repository.find(findOptions).then(async (r) => {
-            return await Promise.all(r.map(async (y) => this.repository.getEntityRef(y).toApiJson()));
-        });
-        return { r, findOptions };
+        return findOptions;
     }
     includeNone() {
         let include = {};

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

@@ -1,6 +1,8 @@
 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 { compareForSort, Sort } from '../sort.js';
 export class ArrayEntityDataProvider {
     entity;
     rows;
@@ -15,6 +17,126 @@ export class ArrayEntityDataProvider {
         this.entity = entity;
         this.rows = rows;
     }
+    async aggregate(options) {
+        const sort = new Sort();
+        if (options?.groupBy)
+            for (const field of options?.groupBy) {
+                sort.Segments.push({ field: field });
+            }
+        const rows = await this.find({ orderBy: sort, where: options?.where });
+        let result = [];
+        let group = {};
+        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;
+                }
+            }
+            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;
+            result.push(r);
+            first = true;
+            count = 0;
+        }
+        for (const row of rows) {
+            if (options?.groupBy) {
+                if (!first) {
+                    for (const field of options?.groupBy) {
+                        if (group[field.key] != row[field.key]) {
+                            finishGroup();
+                            break;
+                        }
+                    }
+                }
+                if (first) {
+                    for (const field of options?.groupBy) {
+                        group[field.key] = row[field.key];
+                    }
+                }
+            }
+            for (const a of aggregates) {
+                a.process(row);
+            }
+            count++;
+            first = false;
+        }
+        finishGroup();
+        if (options?.orderBy) {
+            result.sort((a, b) => {
+                for (const x of options.orderBy) {
+                    const getValue = (row) => {
+                        if (!x.field && x.operation == 'count') {
+                            return row[AggregateCountMember];
+                        }
+                        else {
+                            switch (x.operation) {
+                                case 'sum':
+                                    return row[x.field.key].sum;
+                                case 'avg':
+                                    return row[x.field.key].avg;
+                            }
+                        }
+                        return row[x.field.key];
+                    };
+                    let compare = compareForSort(getValue(a), getValue(b), x.isDescending);
+                    if (compare != 0)
+                        return compare;
+                }
+                return 0;
+            });
+        }
+        return pageArray(result, { page: options?.page, limit: options?.limit });
+    }
     //@internal
     __names;
     //@internal

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

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

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

@@ -101,6 +101,27 @@ export class RestEntityDataProvider {
         this.http = http;
         this.entity = entity;
     }
+    async aggregate(options) {
+        const { run } = this.buildFindRequest({
+            where: options?.where,
+            limit: options?.limit,
+            page: options?.page,
+        });
+        const body = {
+            groupBy: options?.groupBy?.map((x) => x.key),
+            sum: options?.sum?.map((x) => x.key),
+            avg: options?.avg?.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)
+            result.forEach((row) => {
+                for (const g of options.groupBy) {
+                    row[g.key] = g.valueConverter.fromJson(row[g.key]);
+                }
+            });
+        return result;
+    }
     translateFromJson(row) {
         let result = {};
         for (const col of this.entity.fields) {
@@ -176,8 +197,9 @@ export class RestEntityDataProvider {
                 u.add('__action', action);
             if (filterObject) {
                 body = { set: body, where: filterObject };
-                return this.http().post(u.url, body);
             }
+            if (body)
+                return this.http().post(u.url, body);
             else
                 return this.http()[method](u.url, body);
         };

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

@@ -1,6 +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 { getRepository, isAutoIncrement, } from '../remult3/RepositoryImplementation.js';
 import { Sort } from '../sort.js';
 import { ValueConverters } from '../valueConverters.js';
@@ -286,6 +287,9 @@ 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 find(options) {
         let e = await this.init();
         let { colKeys, select } = this.buildSelect(e);
@@ -537,3 +541,107 @@ export function getRowAfterUpdate(meta, dataProvider, data, id, operation) {
         return r[0];
     });
 }
+export async function aggregateImpl(options, e, r, orderByNullFirst, limitSyntax) {
+    let select = 'select count(*) as count';
+    let groupBy = '';
+    const processResultRow = [];
+    processResultRow.push((sqlVal, theResult) => {
+        theResult[AggregateCountMember] = Number(sqlVal);
+    });
+    if (options?.groupBy)
+        for (const x of options?.groupBy) {
+            if (x.isServerExpression) {
+            }
+            else {
+                select += ', ' + e.$dbNameOf(x);
+                if (x.options.sqlExpression)
+                    select += ' as ' + x.key;
+                if (groupBy == '')
+                    groupBy = ' group by ';
+                else
+                    groupBy += ', ';
+                groupBy += e.$dbNameOf(x);
+            }
+            processResultRow.push((sqlResult, theResult) => {
+                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';
+            }
+            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);
+        options?.where.__applyToConsumer(where);
+        select += await where.resolveWhere();
+    }
+    if (groupBy)
+        select += groupBy;
+    let orderBy = '';
+    if (options?.orderBy) {
+        for (const x of options?.orderBy) {
+            if (orderBy == '')
+                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;
+            }
+            if (x.isDescending)
+                orderBy += ' desc';
+            if (orderByNullFirst) {
+                if (x.isDescending)
+                    select += ' nulls last';
+                else
+                    select += ' nulls first';
+            }
+        }
+        if (orderBy)
+            select += orderBy;
+    }
+    if (options?.limit) {
+        let page = 1;
+        if (options.page)
+            page = options.page;
+        if (page < 1)
+            page = 1;
+        select += ' ' + limitSyntax(options.limit, (page - 1) * options.limit);
+    }
+    const result = await r.execute(select);
+    return result.rows.map((sql) => {
+        let theResult = {};
+        processResultRow.forEach((x, i) => x(sql[result.getColumnKeyInResultForIndexInSelect(i)], theResult));
+        return theResult;
+    });
+}

package/esm/src/remult-proxy.js

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

package/esm/src/remult3/RepositoryImplementation.js

@@ -1,6 +1,6 @@
 import { LookupColumn, makeTitle } from '../column.js';
 import { CompoundIdField } from '../CompoundIdField.js';
-import { Remult, isBackend, queryConfig, } from '../context.js';
+import { Remult, isBackend, queryConfig } from '../context.js';
 import { Filter } from '../filter/filter-interfaces.js';
 import { Sort } from '../sort.js';
 import { assign } from '../../assign.js';
@@ -127,6 +127,62 @@ export class RepositoryImplementation {
         this._info = _info;
         this._defaultFindOptions = _defaultFindOptions;
     }
+    async aggregate(options) {
+        let findOptions = await this._buildEntityDataProviderFindOptions({
+            ...options,
+        });
+        const getField = (key) => {
+            const r = this.metadata.fields.find(key);
+            if (r === undefined)
+                throw Error(`key "${key}" not found in entity`);
+            return r;
+        };
+        const getFieldNotInGroupBy = (key) => {
+            if (options?.groupBy?.includes(key))
+                throw Error(`field "${key}" cannot be used both in an aggregate and in group by`);
+            return getField(key);
+        };
+        var dpOptions = {
+            where: findOptions.where,
+            limit: findOptions.limit,
+            page: findOptions.page,
+            groupBy: options?.groupBy?.map(getField),
+            sum: options?.sum?.map(getFieldNotInGroupBy),
+            avg: options?.avg?.map(getFieldNotInGroupBy),
+        };
+        if (options?.orderBy) {
+            dpOptions.orderBy = [];
+            for (const key in options.orderBy) {
+                if (Object.prototype.hasOwnProperty.call(options?.orderBy, key)) {
+                    const element = options.orderBy[key];
+                    if (element)
+                        if (typeof element === 'string') {
+                            dpOptions.orderBy.push({
+                                field: key === '$count' ? undefined : getField(key),
+                                isDescending: element === 'desc',
+                                operation: key === '$count' ? 'count' : undefined,
+                            });
+                        }
+                        else {
+                            for (const operation in element) {
+                                if (Object.prototype.hasOwnProperty.call(element, operation)) {
+                                    const direction = element[operation];
+                                    dpOptions.orderBy.push({
+                                        field: this.metadata.fields.find(key),
+                                        isDescending: direction === 'desc',
+                                        operation: operation,
+                                    });
+                                }
+                            }
+                        }
+                }
+            }
+        }
+        const result = await this._edp.aggregate(dpOptions);
+        if (!options?.groupBy)
+            return result[0];
+        return result;
+    }
     _idCache = new Map();
     _getCachedById(id, doNotLoadIfNotFound) {
         id = id + '';

package/esm/src/remult3/remult3.js

@@ -1,10 +1,16 @@
+export const AggregateCountMember = '$count';
 export const flags = {
     error500RetryCount: 4,
 };
-//p1 - add transactional option to backend method
 //p1 - add parameter all to deleteMany, and updateMany
 //p1  filter.apply ApiPreFilter
-//p1 - min, max, avg, sum, countDistinct - noam come up with an api
+//p1 - add not as an overload to not equal
+/*p1 - min, max, avg, sum, countDistinct - noam come up with an api
+  p1 - order by $count
+  p1 - handle relations
+  p1 - mongodb
+  p1 - knex
+*/
 /*p1 - add id and use uuid by default, but allow changes with Fields.id.defaultIdProvider NO but defaultProvider yes???
   //p1 - replace uuid with crypto.randomUUID and allow custom fallback NO
   //p1 - Add example for luid