remult 0.27.7 → 0.27.8-next.0

package/esm/remult-knex/index.js

@@ -115,6 +115,9 @@ class KnexEntityDataProvider {
         this.knex = knex;
         this.rawSqlWrapIdentifier = rawSqlWrapIdentifier;
     }
+    aggregate(options) {
+        throw new Error('Method not implemented.');
+    }
     async count(where) {
         const e = await this.init();
         const br = new FilterConsumerBridgeToKnexRequest(e, this.rawSqlWrapIdentifier);

package/esm/remult-mongo.js

@@ -70,6 +70,9 @@ class MongoEntityDataProvider {
         this.entity = entity;
         this.session = session;
     }
+    aggregate(options) {
+        throw new Error('Method not implemented.');
+    }
     translateFromDb(row, nameProvider) {
         let result = {};
         for (const col of this.entity.fields) {

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,55 @@ 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 'average':
+                        orderBy[element.field] = {
+                            ...orderBy[element.field],
+                            average: direction,
+                        };
+                        break;
+                    case 'count':
+                        orderBy[AggregateCountMember] = direction;
+                    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()),
+            average: body?.average?.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 +200,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?.average) {
+            class Average {
+                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],
+                        average: this.sum / this.count,
+                    };
+                    this.sum = 0;
+                    this.count = 0;
+                }
+            }
+            for (const element of options.average) {
+                aggregates.push(new Average(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 'average':
+                                    return row[x.field.key].average;
+                            }
+                        }
+                        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),
+            average: options?.average?.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,114 @@ class ActualSQLEntityDataProvider {
             return Number(r.rows[0].count);
         });
     }
+    async aggregate(options) {
+        let e = await this.init();
+        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?.average)
+            for (const x of options?.average) {
+                if (x.isServerExpression) {
+                }
+                else {
+                    select += ', avg(' + e.$dbNameOf(x) + ') as ' + x.key + '_average';
+                }
+                processResultRow.push((sqlResult, theResult) => {
+                    theResult[x.key] = { ...theResult[x.key], average: sqlResult };
+                });
+            }
+        select += '\n from ' + e.$entityName;
+        let r = this.sql.createCommand();
+        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 'average':
+                            field = 'avg(' + field + ')';
+                            break;
+                    }
+                    orderBy += field;
+                }
+                if (x.isDescending)
+                    orderBy += ' desc';
+                if (this.sql._getSourceSql().orderByNullsFirst) {
+                    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 +=
+                ' ' +
+                    this.strategy.getLimitSqlSyntax(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;
+        });
+    }
     async find(options) {
         let e = await this.init();
         let { colKeys, select } = this.buildSelect(e);

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,53 @@ export class RepositoryImplementation {
         this._info = _info;
         this._defaultFindOptions = _defaultFindOptions;
     }
+    async aggregate(options) {
+        let findOptions = await this._buildEntityDataProviderFindOptions({
+            ...options,
+        });
+        var dpOptions = {
+            where: findOptions.where,
+            limit: findOptions.limit,
+            page: findOptions.page,
+            groupBy: options?.groupBy?.map((f) => this.metadata.fields.find(f)),
+            sum: options?.sum?.map((f) => this.metadata.fields.find(f)),
+            average: options?.average?.map((f) => this.metadata.fields.find(f)),
+        };
+        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
+                                    : this.metadata.fields.find(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,15 @@
+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 - 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

package/esm/src/sort.js

@@ -57,22 +57,17 @@ export class Sort {
     compare(a, b, getFieldKey) {
         if (!getFieldKey)
             getFieldKey = (x) => x.key;
-        let r = 0;
         for (let i = 0; i < this.Segments.length; i++) {
             let seg = this.Segments[i];
-            let left = fixValueForSort(a[getFieldKey(seg.field)]);
-            let right = fixValueForSort(b[getFieldKey(seg.field)]);
-            if (left > right)
-                r = 1;
-            else if (left < right)
-                r = -1;
+            let left = a[getFieldKey(seg.field)];
+            let right = b[getFieldKey(seg.field)];
+            let descending = seg.isDescending;
+            let r = compareForSort(left, right, descending);
             if (r != 0) {
-                if (seg.isDescending)
-                    r *= -1;
                 return r;
             }
         }
-        return r;
+        return 0;
     }
     /**
      * Translates an `EntityOrderBy` to a `Sort` instance.
@@ -169,7 +164,19 @@ export class Sort {
         return orderBy;
     }
 }
-function fixValueForSort(a) {
+export function compareForSort(left, right, descending) {
+    left = fixValueForSort(left);
+    right = fixValueForSort(right);
+    let r = 0;
+    if (left > right)
+        r = 1;
+    else if (left < right)
+        r = -1;
+    if (descending)
+        r *= -1;
+    return r;
+}
+export function fixValueForSort(a) {
     if (a == undefined || a == null)
         return a;
     if (a.id !== undefined)

package/package.json

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

package/remult-knex/index.js

@@ -201,6 +201,9 @@ var KnexEntityDataProvider = /** @class */ (function () {
         this.knex = knex;
         this.rawSqlWrapIdentifier = rawSqlWrapIdentifier;
     }
+    KnexEntityDataProvider.prototype.aggregate = function (options) {
+        throw new Error('Method not implemented.');
+    };
     KnexEntityDataProvider.prototype.count = function (where) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             var e, br, r, result, row, key, element;

package/remult-mongo.js

@@ -107,6 +107,9 @@ var MongoEntityDataProvider = /** @class */ (function () {
         this.entity = entity;
         this.session = session;
     }
+    MongoEntityDataProvider.prototype.aggregate = function (options) {
+        throw new Error('Method not implemented.');
+    };
     MongoEntityDataProvider.prototype.translateFromDb = function (row, nameProvider) {
         var e_1, _a;
         var result = {};

package/src/data-api.d.ts

@@ -1,6 +1,6 @@
 import type { Remult } from './context.js';
 import type { ErrorInfo } from './data-interfaces.js';
-import type { EntityMetadata, FindOptions, Repository } from './remult3/remult3.js';
+import { type EntityMetadata, type FindOptions, type Repository } from './remult3/remult3.js';
 import type { rowHelperImplementation } from './remult3/RepositoryImplementation.js';
 export declare class DataApi<T = unknown> {
     private repository;
@@ -12,10 +12,12 @@ export declare class DataApi<T = unknown> {
     get(response: DataApiResponse, id: any): Promise<void>;
     count(response: DataApiResponse, request: DataApiRequest, body?: any): Promise<void>;
     deleteMany(response: DataApiResponse, request: DataApiRequest, body?: any): Promise<void>;
+    aggregate(response: DataApiResponse, request: DataApiRequest, body: any): Promise<void>;
     getArrayImpl(response: DataApiResponse, request: DataApiRequest, body: any): Promise<{
         r: any[];
         findOptions: FindOptions<T>;
     }>;
+    private findOptionsFromRequest;
     private includeNone;
     getArray(response: DataApiResponse, request: DataApiRequest, body?: any): Promise<void>;
     liveQuery(response: DataApiResponse, request: DataApiRequest, body: any, serializeContext: () => Promise<any>, queryChannel: string): Promise<void>;