remult 0.27.8-next.0 → 0.27.8-next.2

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,13 +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;
     }
-    aggregate(options) {
-        throw new Error('Method not implemented.');
+    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;
@@ -70,9 +71,6 @@ 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) {
@@ -100,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

@@ -116,14 +116,15 @@ export class DataApi {
                             sum: direction,
                         };
                         break;
-                    case 'average':
+                    case 'avg':
                         orderBy[element.field] = {
                             ...orderBy[element.field],
-                            average: direction,
+                            avg: direction,
                         };
                         break;
                     case 'count':
                         orderBy[AggregateCountMember] = direction;
+                        break;
                     default:
                         orderBy[element.field] = direction;
                         break;
@@ -136,7 +137,7 @@ export class DataApi {
             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()),
+            avg: body?.avg?.filter((x) => this.repository.fields.find(x).includedInApi()),
             orderBy: orderBy,
         });
         if (!Array.isArray(result)) {

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

@@ -50,8 +50,8 @@ export class ArrayEntityDataProvider {
                 aggregates.push(new Sum(element.key));
             }
         }
-        if (options?.average) {
-            class Average {
+        if (options?.avg) {
+            class Avg {
                 key;
                 constructor(key) {
                     this.key = key;
@@ -68,14 +68,14 @@ export class ArrayEntityDataProvider {
                 finishGroup(result) {
                     result[this.key] = {
                         ...result[this.key],
-                        average: this.sum / this.count,
+                        avg: this.sum / this.count,
                     };
                     this.sum = 0;
                     this.count = 0;
                 }
             }
-            for (const element of options.average) {
-                aggregates.push(new Average(element.key));
+            for (const element of options.avg) {
+                aggregates.push(new Avg(element.key));
             }
         }
         function finishGroup() {
@@ -122,8 +122,8 @@ export class ArrayEntityDataProvider {
                             switch (x.operation) {
                                 case 'sum':
                                     return row[x.field.key].sum;
-                                case 'average':
-                                    return row[x.field.key].average;
+                                case 'avg':
+                                    return row[x.field.key].avg;
                             }
                         }
                         return row[x.field.key];

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

@@ -110,7 +110,7 @@ export class RestEntityDataProvider {
         const body = {
             groupBy: options?.groupBy?.map((x) => x.key),
             sum: options?.sum?.map((x) => x.key),
-            average: options?.average?.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);
@@ -196,9 +196,13 @@ export class RestEntityDataProvider {
             if (action)
                 u.add('__action', action);
             if (filterObject) {
-                body = { set: body, where: filterObject };
+                if (method === 'put') {
+                    return this.http().post(u.url, { set: body, where: filterObject });
+                }
+                else
+                    body = { ...body, where: filterObject };
             }
-            if (body)
+            if (body && method != 'put')
                 return this.http().post(u.url, body);
             else
                 return this.http()[method](u.url, body);

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

@@ -288,112 +288,7 @@ class ActualSQLEntityDataProvider {
         });
     }
     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;
-        });
+        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();
@@ -646,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/remult3/RepositoryImplementation.js

@@ -131,13 +131,24 @@ export class RepositoryImplementation {
         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((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)),
+            groupBy: options?.groupBy?.map(getField),
+            sum: options?.sum?.map(getFieldNotInGroupBy),
+            avg: options?.avg?.map(getFieldNotInGroupBy),
         };
         if (options?.orderBy) {
             dpOptions.orderBy = [];
@@ -147,9 +158,7 @@ export class RepositoryImplementation {
                     if (element)
                         if (typeof element === 'string') {
                             dpOptions.orderBy.push({
-                                field: key === '$count'
-                                    ? undefined
-                                    : this.metadata.fields.find(key),
+                                field: key === '$count' ? undefined : getField(key),
                                 isDescending: element === 'desc',
                                 operation: key === '$count' ? 'count' : undefined,
                             });

package/esm/src/remult3/remult3.js

@@ -7,8 +7,6 @@ export const flags = {
 //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

package/package.json

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

package/remult-knex/index.js

@@ -112,7 +112,7 @@ var KnexDataProvider = /** @class */ (function () {
                 finally { if (e_2) throw e_2.error; }
             }
         }
-        return new KnexEntityDataProvider(entity, this.knex, this.wrapIdentifier);
+        return new KnexEntityDataProvider(entity, this.knex, this.wrapIdentifier, this);
     };
     KnexDataProvider.prototype.transaction = function (action) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
@@ -196,13 +196,27 @@ var KnexDataProvider = /** @class */ (function () {
 }());
 exports.KnexDataProvider = KnexDataProvider;
 var KnexEntityDataProvider = /** @class */ (function () {
-    function KnexEntityDataProvider(entity, knex, rawSqlWrapIdentifier) {
+    function KnexEntityDataProvider(entity, knex, rawSqlWrapIdentifier, dp) {
         this.entity = entity;
         this.knex = knex;
         this.rawSqlWrapIdentifier = rawSqlWrapIdentifier;
+        this.dp = dp;
     }
     KnexEntityDataProvider.prototype.aggregate = function (options) {
-        throw new Error('Method not implemented.');
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _a, _b;
+            return tslib_1.__generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        _a = sql_database_js_1.aggregateImpl;
+                        _b = [options];
+                        return [4 /*yield*/, this.init()];
+                    case 1: return [2 /*return*/, _a.apply(void 0, _b.concat([_c.sent(), this.dp.createCommand(),
+                            false,
+                            function (limit, offset) { return ' limit ' + limit + ' offset ' + offset; }]))];
+                }
+            });
+        });
     };
     KnexEntityDataProvider.prototype.count = function (where) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {