remult 3.2.3 → 3.3.0

package/esm/graphql.js

@@ -360,7 +360,7 @@ export function remultGraphql(options) {
                                     [toCamelCase(getMetaType(meta))]: y,
                                 });
                             },
-                        }, arg1.id, arg1.patch);
+                        }, { get: () => undefined }, arg1.id, arg1.patch);
                     })(args, req);
                 }
                 // update many

package/esm/remult-knex/index.js

@@ -208,7 +208,7 @@ class KnexEntityDataProvider {
             wrapIdentifier: r.wrapIdentifier,
         };
     }
-    async update(id, data) {
+    async update(id, data, options) {
         const e = await this.init();
         let f = new FilterConsumerBridgeToKnexRequest(e, this.rawSqlWrapIdentifier);
         Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
@@ -228,6 +228,8 @@ class KnexEntityDataProvider {
         await this.getEntityFrom(e)
             .update(updateObject)
             .where((b) => where.forEach((w) => w(b)));
+        if (options?.select === 'none')
+            return undefined;
         return getRowAfterUpdate(this.entity, this, data, id, 'update');
     }
     async delete(id) {
@@ -239,7 +241,7 @@ class KnexEntityDataProvider {
             .delete()
             .where((b) => where.forEach((w) => w(b)));
     }
-    async insert(data) {
+    async insert(data, options) {
         const e = await this.init();
         let insertObject = {};
         for (const x of this.entity.fields) {
@@ -265,12 +267,16 @@ class KnexEntityDataProvider {
                 let result = await insert.returning(this.entity.idMetadata.field.dbName);
                 newId = result[0][this.entity.idMetadata.field.dbName];
             }
+            if (options?.select === 'none')
+                return undefined;
             return this.find({
                 where: new Filter((x) => x.isEqualTo(this.entity.idMetadata.field, newId)),
             }).then((y) => y[0]);
         }
         else
             await insert;
+        if (options?.select === 'none')
+            return undefined;
         return getRowAfterUpdate(this.entity, this, data, undefined, 'insert');
     }
 }

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 { GroupByCountMember, GroupByOperators } from './src/remult3/remult3.js';
+import { GroupByCountMember, GroupByOperators, } from './src/remult3/remult3.js';
 export class MongoDataProvider {
     db;
     client;
@@ -246,7 +246,7 @@ class MongoEntityDataProvider {
             .map((x) => this.translateFromDb(x, e, options.select))
             .toArray());
     }
-    async update(id, data) {
+    async update(id, data, options) {
         let { collection, e } = await this.collection();
         let f = new FilterConsumerBridgeToMongo(e);
         Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
@@ -262,6 +262,8 @@ class MongoEntityDataProvider {
         let r = await collection.updateOne(await f.resolveWhere(), {
             $set: newR,
         }, { session: this.session });
+        if (options?.select === 'none')
+            return undefined;
         return getRowAfterUpdate(this.entity, this, data, id, 'update');
     }
     async delete(id) {
@@ -272,11 +274,13 @@ class MongoEntityDataProvider {
             session: this.session,
         });
     }
-    async insert(data) {
+    async insert(data, options) {
         let { collection, e } = await this.collection();
         let r = await collection.insertOne(await this.translateToDb(data, e), {
             session: this.session,
         });
+        if (options?.select === 'none')
+            return undefined;
         return await this.translateFromDb(await collection.findOne({ _id: r.insertedId }, { session: this.session }), e);
     }
     async collection() {

package/esm/server/remult-api-server.js

@@ -316,7 +316,7 @@ export class RemultServerImplementation {
             //@ts-ignore
             .get(this.process(async (c, req, res, orig) => dataApiFactory(c).get(res, orig.params.id)))
             //@ts-ignore
-            .put(this.process(async (c, req, res, reqInfo, _, orig) => dataApiFactory(c).put(res, reqInfo.params.id, await this.coreOptions.getRequestBody(orig))))
+            .put(this.process(async (c, req, res, reqInfo, _, orig) => dataApiFactory(c).put(res, req, reqInfo.params.id, await this.coreOptions.getRequestBody(orig))))
             //@ts-ignore
             .delete(this.process(async (c, req, res, orig) => dataApiFactory(c).delete(res, orig.params.id)));
     }

package/esm/src/data-api.js

@@ -72,7 +72,7 @@ export class DataApi {
                 case 'query':
                     return res.success(await this.query(res, req, body));
                 default:
-                    return res.created(await this.post(body));
+                    return res.created(await this.post(body, req));
             }
         }
         catch (err) {
@@ -93,11 +93,11 @@ export class DataApi {
                     include: this.includeNone(),
                 });
                 if (r.length == 0) {
-                    result.push(await this.post({ ...item.where, ...item.set }));
+                    result.push(await this.post({ ...item.where, ...item.set }, request));
                 }
                 else {
                     if (item.set !== undefined) {
-                        result.push((await this.actualUpdate(r[0], item.set)).toApiJson());
+                        result.push(await this.actualUpdate(r[0], item.set, request));
                     }
                     else
                         result.push(this.repository.getEntityRef(r[0]).toApiJson());
@@ -154,8 +154,7 @@ export class DataApi {
     async deleteMany(response, request, body) {
         try {
             let deleted = 0;
-            let where = await this.buildWhere(request, body);
-            Filter.throwErrorIfFilterIsEmpty(where, 'deleteMany');
+            let where = await this.prepareWhereForManyOperation(body, request);
             return await doTransaction(this.remult, async () => {
                 for await (const x of this.repository.query({
                     where,
@@ -172,6 +171,14 @@ export class DataApi {
             response.error(err, this.repository.metadata);
         }
     }
+    async prepareWhereForManyOperation(body, request) {
+        let where = undefined;
+        if (body?.where !== 'all') {
+            where = await this.buildWhere(request, body);
+            Filter.throwErrorIfFilterIsEmpty(where, 'deleteMany');
+        }
+        return where;
+    }
     async groupBy(request, body) {
         if (!this.repository.metadata.apiReadAllowed) {
             throw new ForbiddenError();
@@ -233,6 +240,8 @@ export class DataApi {
             include: this.includeNone(),
         };
         findOptions.where = await this.buildWhere(request, body);
+        if (body?.args)
+            findOptions.args = body.args;
         if (request) {
             let sort = request.get('_sort');
             if (sort != undefined) {
@@ -410,7 +419,7 @@ export class DataApi {
     async updateManyThroughPutRequest(response, request, body) {
         const action = request?.get('__action');
         if (action == 'emptyId') {
-            return this.put(response, '', body);
+            return this.put(response, request, '', body);
         }
         return this.updateManyImplementation(response, request, {
             where: undefined,
@@ -419,8 +428,7 @@ export class DataApi {
     }
     async updateManyImplementation(response, request, body) {
         try {
-            let where = await this.buildWhere(request, body);
-            Filter.throwErrorIfFilterIsEmpty(where, 'updateMany');
+            let where = await this.prepareWhereForManyOperation(body, request);
             return await doTransaction(this.remult, async () => {
                 let updated = 0;
                 for await (const x of this.repository.query({
@@ -428,7 +436,7 @@ export class DataApi {
                     include: this.includeNone(),
                     aggregate: undefined,
                 })) {
-                    await this.actualUpdate(x, body.set);
+                    await this.actualUpdate(x, body.set, request);
                     updated++;
                 }
                 response.success({ updated });
@@ -438,20 +446,20 @@ export class DataApi {
             response.error(err, this.repository.metadata);
         }
     }
-    async actualUpdate(row, body) {
+    async actualUpdate(row, body, req) {
         let ref = this.repository.getEntityRef(row);
         await ref._updateEntityBasedOnApi(body);
         if (!ref.apiUpdateAllowed) {
             throw new ForbiddenError();
         }
-        await ref.save();
-        return ref;
+        let options = req.get('_select') === 'none' ? { select: 'none' } : undefined;
+        await ref.save(options);
+        if (options?.select === 'none')
+            return undefined;
+        return ref.toApiJson();
     }
-    async put(response, id, body) {
-        await this.doOnId(response, id, async (row) => {
-            const ref = await this.actualUpdate(row, body);
-            response.success(ref.toApiJson());
-        });
+    async put(response, req, id, body) {
+        await this.doOnId(response, id, async (row) => response.success(await this.actualUpdate(row, body, req)));
     }
     async actualDelete(row) {
         if (!this.repository.getEntityRef(row).apiDeleteAllowed) {
@@ -465,14 +473,17 @@ export class DataApi {
             response.deleted();
         });
     }
-    async post(body) {
+    async post(body, req) {
+        let options = req.get('_select') === 'none' ? { select: 'none' } : undefined;
         const insert = async (what) => {
             let newr = this.repository.create();
             await this.repository.getEntityRef(newr)._updateEntityBasedOnApi(what);
             if (!this.repository.getEntityRef(newr).apiInsertAllowed) {
                 throw new ForbiddenError();
             }
-            await this.repository.getEntityRef(newr).save();
+            await this.repository.getEntityRef(newr).save(options);
+            if (options?.select === 'none')
+                return undefined;
             return this.repository.getEntityRef(newr).toApiJson();
         };
         if (Array.isArray(body)) {

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

@@ -71,6 +71,7 @@ export function findOptionsFromJson(json, meta) {
         'orderBy',
         'include',
         'select',
+        'args',
     ]) {
         if (json[key] !== undefined) {
             if (key === 'where') {
@@ -198,36 +199,42 @@ export class RestEntityDataProvider {
         let url = new UrlBuilder(this.url());
         let filterObject;
         if (options) {
-            if (options.where) {
-                filterObject = options.where.toJson(); //        options.where.__applyToConsumer(new FilterConsumnerBridgeToUrlBuilder(url));
-                if (addFilterToUrlAndReturnTrueIfSuccessful(filterObject, url))
-                    filterObject = undefined;
+            if (options.where === 'all') {
+                filterObject = 'all';
             }
-            if (options.orderBy && options.orderBy.Segments) {
-                let sort = '';
-                let order = '';
-                let hasDescending = false;
-                options.orderBy.Segments.forEach((c) => {
-                    if (sort.length > 0) {
-                        sort += ',';
-                        order += ',';
-                    }
-                    sort += c.field.key;
-                    order += c.isDescending ? 'desc' : 'asc';
-                    if (c.isDescending)
-                        hasDescending = true;
-                });
-                if (sort)
-                    url.add('_sort', sort);
-                if (hasDescending)
-                    url.add('_order', order);
-            }
-            if (options.limit)
-                url.add('_limit', options.limit);
-            if (options.page)
-                url.add('_page', options.page);
-            if (options.select) {
-                url.add('_select', options.select.join(','));
+            else {
+                if (options.where) {
+                    filterObject = options.where.toJson();
+                    if (options.args === undefined)
+                        if (addFilterToUrlAndReturnTrueIfSuccessful(filterObject, url))
+                            filterObject = undefined;
+                }
+                if (options.orderBy && options.orderBy.Segments) {
+                    let sort = '';
+                    let order = '';
+                    let hasDescending = false;
+                    options.orderBy.Segments.forEach((c) => {
+                        if (sort.length > 0) {
+                            sort += ',';
+                            order += ',';
+                        }
+                        sort += c.field.key;
+                        order += c.isDescending ? 'desc' : 'asc';
+                        if (c.isDescending)
+                            hasDescending = true;
+                    });
+                    if (sort)
+                        url.add('_sort', sort);
+                    if (hasDescending)
+                        url.add('_order', order);
+                }
+                if (options.limit)
+                    url.add('_limit', options.limit);
+                if (options.page)
+                    url.add('_page', options.page);
+                if (options.select) {
+                    url.add('_select', options.select.join(','));
+                }
             }
         }
         const run = (action, body) => {
@@ -244,6 +251,8 @@ export class RestEntityDataProvider {
                 else
                     body = { ...body, where: filterObject };
             }
+            if (options && 'args' in options)
+                body.args = options.args;
             if (body && method != 'put')
                 return this.http().post(u.url, body);
             else
@@ -265,10 +274,16 @@ export class RestEntityDataProvider {
             },
         };
     }
-    update(id, data) {
+    update(id, data, options) {
+        const urlArgs = [];
+        if (id == '')
+            urlArgs.push('__action=emptyId');
+        if (options?.select === 'none')
+            urlArgs.push('_select=$none');
         return this.http()
             .put(this.url() +
-            (id != '' ? '/' + encodeURIComponent(id) : '?__action=emptyId'), this.toJsonOfIncludedKeys(data))
+            (id != '' ? '/' + encodeURIComponent(id) : '') +
+            (urlArgs.length > 0 ? '?' + urlArgs.join('&') : ''), this.toJsonOfIncludedKeys(data))
             .then((y) => this.translateFromJson(y));
     }
     toJsonOfIncludedKeys(data) {
@@ -286,14 +301,14 @@ export class RestEntityDataProvider {
         else
             return this.http().delete(this.url() + '/' + encodeURIComponent(id));
     }
-    insert(data) {
+    insert(data, options) {
         return this.http()
-            .post(this.url(), this.translateToJson(data))
+            .post(this.url() + (options?.select === 'none' ? '?_select=$none' : ''), this.translateToJson(data))
             .then((y) => this.translateFromJson(y));
     }
-    insertMany(data) {
+    insertMany(data, options) {
         return this.http()
-            .post(this.url(), data.map((data) => this.translateToJson(data)))
+            .post(this.url() + (options?.select === 'none' ? '?_select=$none' : ''), data.map((data) => this.translateToJson(data)))
             .then((y) => y.map((y) => this.translateFromJson(y)));
     }
 }

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

@@ -1,4 +1,4 @@
-import { FilterConsumerBridgeToSqlRequest, dbNamesOfWithForceSqlExpression, isDbReadonly, } from '../filter/filter-consumer-bridge-to-sql-request.js';
+import { FilterConsumerBridgeToSqlRequest, dbNamesOfWithForceSqlExpression, isDbReadonly, toDbSql, } 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 { GroupByCountMember, GroupByOperators, } from '../remult3/remult3.js';
@@ -7,6 +7,7 @@ import { Sort } from '../sort.js';
 import { ValueConverters } from '../valueConverters.js';
 import { getRepositoryInternals } from '../remult3/repository-internals.js';
 import { isOfType } from '../isOfType.js';
+import { originalSqlExpressionKey } from '../filter/fieldDbName.js';
 /**
  * A DataProvider for Sql Databases
  * @example
@@ -292,10 +293,10 @@ class ActualSQLEntityDataProvider {
     }
     async find(options) {
         let e = await this.init();
-        let { colKeys, select } = this.buildSelect(e, options?.select);
+        let r = this.sql.createCommand();
+        let { colKeys, select } = await this.buildSelect(e, r, options?.select, options?.args);
         select = 'select ' + select;
         select += '\n from ' + e.$entityName;
-        let r = this.sql.createCommand();
         if (options) {
             if (options.where) {
                 let where = new FilterConsumerBridgeToSqlRequest(r, e);
@@ -321,7 +322,9 @@ class ActualSQLEntityDataProvider {
                     }
                     else
                         select += ', ';
-                    select += e.$dbNameOf(c.field);
+                    select += c.field.options.sqlExpression
+                        ? c.field.options.key
+                        : await e.$dbNameOf(c.field);
                     if (c.isDescending)
                         select += ' desc';
                     if (this.sql._getSourceSql().orderByNullsFirst) {
@@ -362,7 +365,7 @@ class ActualSQLEntityDataProvider {
         }
         return result;
     }
-    buildSelect(e, selectedFields) {
+    async buildSelect(e, r, selectedFields, args) {
         let select = '';
         let colKeys = [];
         for (const x of this.entity.fields) {
@@ -373,7 +376,15 @@ class ActualSQLEntityDataProvider {
             else {
                 if (colKeys.length > 0)
                     select += ', ';
-                select += e.$dbNameOf(x);
+                if (typeof x.options.sqlExpression === 'function') {
+                    let sql = await x[originalSqlExpressionKey](this.entity, args, r);
+                    if (sql.includes(' '))
+                        select += '(' + sql + ')';
+                    else
+                        select += sql;
+                }
+                else
+                    select += e.$dbNameOf(x);
                 if (x.options.sqlExpression)
                     select += ' as ' + x.key;
                 colKeys.push(x);
@@ -381,7 +392,7 @@ class ActualSQLEntityDataProvider {
         }
         return { colKeys, select };
     }
-    async update(id, data) {
+    async update(id, data, options) {
         let e = await this.init();
         let r = this.sql.createCommand();
         let statement = 'update ' + e.$entityName + ' set ';
@@ -396,7 +407,7 @@ class ActualSQLEntityDataProvider {
                         added = true;
                     else
                         statement += ', ';
-                    statement += e.$dbNameOf(x) + ' = ' + r.param(v);
+                    statement += e.$dbNameOf(x) + ' = ' + toDbSql(r, x, v);
                 }
             }
         }
@@ -404,10 +415,12 @@ class ActualSQLEntityDataProvider {
         let f = new FilterConsumerBridgeToSqlRequest(r, e);
         Filter.fromEntityFilter(this.entity, idFilter).__applyToConsumer(f);
         statement += await f.resolveWhere();
-        let { colKeys, select } = this.buildSelect(e);
+        let { colKeys, select } = await this.buildSelect(e, r, undefined, undefined);
         let returning = true;
         if (this.sql._getSourceSql().doesNotSupportReturningSyntax)
             returning = false;
+        if (options?.select === 'none')
+            returning = false;
         if (returning &&
             this.sql._getSourceSql().doesNotSupportReturningSyntaxOnlyForUpdate)
             returning = false;
@@ -416,6 +429,8 @@ class ActualSQLEntityDataProvider {
         return r.execute(statement).then((sqlResult) => {
             this.sql._getSourceSql().afterMutation?.();
             if (!returning) {
+                if (options?.select === 'none')
+                    return undefined;
                 return getRowAfterUpdate(this.entity, this, data, id, 'update');
             }
             if (sqlResult.rows.length != 1)
@@ -437,7 +452,7 @@ class ActualSQLEntityDataProvider {
             this.sql._getSourceSql().afterMutation?.();
         });
     }
-    async insert(data) {
+    async insert(data, options) {
         let e = await this.init();
         let r = this.sql.createCommand();
         let cols = '';
@@ -456,13 +471,14 @@ class ActualSQLEntityDataProvider {
                         vals += ', ';
                     }
                     cols += e.$dbNameOf(x);
-                    vals += r.param(v);
+                    vals += toDbSql(r, x, v);
                 }
             }
         }
         let statement = `insert into ${e.$entityName} (${cols}) values (${vals})`;
-        let { colKeys, select } = this.buildSelect(e);
-        if (!this.sql._getSourceSql().doesNotSupportReturningSyntax)
+        let { colKeys, select } = await this.buildSelect(e, r, undefined, undefined);
+        if (!this.sql._getSourceSql().doesNotSupportReturningSyntax &&
+            !(options?.select === 'none'))
             statement += ' returning ' + select;
         return await r.execute(statement).then((sql) => {
             this.sql._getSourceSql().afterMutation?.();
@@ -472,14 +488,20 @@ class ActualSQLEntityDataProvider {
                     if (typeof id !== 'number')
                         throw new Error('Auto increment, for a database that is does not support returning syntax, should return an array with the single last added id. Instead it returned: ' +
                             JSON.stringify(id));
+                    if (options?.select === 'none')
+                        return undefined;
                     return this.find({
                         where: new Filter((x) => x.isEqualTo(this.entity.idMetadata.field, id)),
                     }).then((r) => r[0]);
                 }
                 else {
+                    if (options?.select === 'none')
+                        return undefined;
                     return getRowAfterUpdate(this.entity, this, data, undefined, 'insert');
                 }
             }
+            if (options?.select === 'none')
+                return undefined;
             return this.buildResultRow(colKeys, sql.rows[0], sql);
         });
     }

package/esm/src/filter/fieldDbName.js

@@ -1,5 +1,6 @@
 import { getRelationFieldInfo } from '../remult3/relationInfoMember.js';
 const sqlExpressionInProgressKey = Symbol.for(`sqlExpressionInProgressKey`);
+export const originalSqlExpressionKey = Symbol.for(`originalSqlExpressionKey`);
 export async function fieldDbName(f, meta, wrapIdentifier = (x) => x, forceSqlExpression = false) {
     try {
         if (f.options.sqlExpression) {
@@ -11,7 +12,9 @@ export async function fieldDbName(f, meta, wrapIdentifier = (x) => x, forceSqlEx
                 try {
                     ;
                     f[sqlExpressionInProgressKey] = true;
-                    result = await f.options.sqlExpression(meta);
+                    if (!f[originalSqlExpressionKey])
+                        f[originalSqlExpressionKey] = f.options.sqlExpression;
+                    result = await f.options.sqlExpression(meta, undefined, undefined);
                     if (!result.includes('\0'))
                         f.options.sqlExpression = () => result;
                 }

package/esm/src/filter/filter-consumer-bridge-to-sql-request.js

@@ -73,7 +73,7 @@ export class FilterConsumerBridgeToSqlRequest {
                 this.addToWhere(this.nameProvider.$dbNameOf(col) +
                     ' in (' +
                     val
-                        .map((x) => this.r.param(col.valueConverter.toDb(x)))
+                        .map((x) => toDbSql(this.r, col, col.valueConverter.toDb(x)))
                         .join(',') +
                     ')');
             else
@@ -140,7 +140,7 @@ export class FilterConsumerBridgeToSqlRequest {
                 ' ' +
                 operator +
                 ' ' +
-                this.r.param(col.valueConverter.toDb(val));
+                toDbSql(this.r, col, col.valueConverter.toDb(val));
             this.addToWhere(x);
         })());
     }
@@ -261,3 +261,6 @@ async function internalDbNamesOf(repo, wrapIdentifierOrOptions, forceSqlExpressi
     }
     return result;
 }
+export function toDbSql(r, field, val) {
+    return (field.valueConverter.toDbSql ?? ((x) => x))(r.param(val));
+}

package/esm/src/remult-proxy.js

@@ -156,10 +156,10 @@ export class RemultProxy {
                 .remultFactory()
                 .repo(...args)
                 .getEntityRef(...args2),
-            insert: (args2) => self
+            insert: (args2, args3) => self
                 .remultFactory()
                 .repo(...args)
-                .insert(args2),
+                .insert(args2, args3),
             liveQuery: (...args2) => self
                 .remultFactory()
                 .repo(...args)
@@ -179,10 +179,10 @@ export class RemultProxy {
                 .remultFactory()
                 .repo(...args)
                 .upsert(args2),
-            update: (a, b) => self
+            update: (a, b, c) => self
                 .remultFactory()
                 .repo(...args)
-                .update(a, b),
+                .update(a, b, c),
         };
         entityCache.set(args[1], result);
         return result;