remult 3.3.0-next.1 → 3.3.1

package/esm/server/remult-admin.js

@@ -51,6 +51,7 @@ export function buildEntityInfo(options) {
                         if (relRepo.metadata.apiReadAllowed) {
                             relation = {
                                 ...relInfo,
+                                allowNull: x.allowNull,
                                 where,
                                 entityKey: relRepo.metadata.key,
                                 idField,
@@ -81,6 +82,7 @@ export function buildEntityInfo(options) {
                     caption: x.label,
                     relationToOne: relation,
                     inputType: x.inputType,
+                    allowNull: x.allowNull,
                     type: x.inputType === InputTypes.json
                         ? 'json'
                         : x.valueType === Number

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();
@@ -412,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,
@@ -421,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({
@@ -430,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 });
@@ -440,20 +446,22 @@ export class DataApi {
             response.error(err, this.repository.metadata);
         }
     }
-    async actualUpdate(row, body) {
+    async actualUpdate(row, body, req, doNotSelect) {
         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' || doNotSelect
+            ? { 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) {
@@ -467,14 +475,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

@@ -199,37 +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 (options.args === undefined)
-                    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) => {
@@ -246,7 +251,7 @@ export class RestEntityDataProvider {
                 else
                     body = { ...body, where: filterObject };
             }
-            if (options?.args)
+            if (options && 'args' in options)
                 body.args = options.args;
             if (body && method != 'put')
                 return this.http().post(u.url, body);
@@ -269,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) {
@@ -290,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

@@ -392,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 ';
@@ -419,6 +419,8 @@ class ActualSQLEntityDataProvider {
         let returning = true;
         if (this.sql._getSourceSql().doesNotSupportReturningSyntax)
             returning = false;
+        if (options?.select === 'none')
+            returning = false;
         if (returning &&
             this.sql._getSourceSql().doesNotSupportReturningSyntaxOnlyForUpdate)
             returning = false;
@@ -427,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)
@@ -448,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 = '';
@@ -473,7 +477,8 @@ class ActualSQLEntityDataProvider {
         }
         let statement = `insert into ${e.$entityName} (${cols}) values (${vals})`;
         let { colKeys, select } = await this.buildSelect(e, r, undefined, undefined);
-        if (!this.sql._getSourceSql().doesNotSupportReturningSyntax)
+        if (!this.sql._getSourceSql().doesNotSupportReturningSyntax &&
+            !(options?.select === 'none'))
             statement += ' returning ' + select;
         return await r.execute(statement).then((sql) => {
             this.sql._getSourceSql().afterMutation?.();
@@ -483,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/live-query/SubscriptionChannel.js

@@ -106,18 +106,66 @@ export const liveQueryKeepAliveRoute = '_liveQueryKeepAlive';
  *
  * @template messageType The type of the message that the channel will handle.
  * @example
+ * ```ts
  * // Defined in code that is shared between the frontend and the backend
- * const statusChange = new SubscriptionChannel<{ oldStatus: number, newStatus: number }>("statusChange");
+ * export const notif = new SubscriptionChannel<{ coolInfo: string }>("notif");
  *
  * // Backend: Publishing a message
- * statusChange.publish({ oldStatus: 1, newStatus: 2 });
+ * notif.publish({ coolInfo: "Message coming from the backend" });
  *
  * // Frontend: Subscribing to messages
- * statusChange.subscribe((message) => {
- *     console.log(`Status changed from ${message.oldStatus} to ${message.newStatus}`);
+ * notif.subscribe((message) => {
+ *     console.log(`Something exciting happened: ${message.coolInfo}`);
  * });
  *
  * // Note: If you want to publish from the frontend, use a BackendMethod for that.
+ * ```
+ *  ---
+ *
+ *  ### Use cases:
+ *
+ *  #### A user _(Paul)_ wants to notify everyone _(Eric & Simona)_
+ *  ```ts
+ *  // shared code between the frontend and the backend
+ *  export const notif = new SubscriptionChannel<{ from: UserInfo, msg: string }>("notif");
+ *
+ *  // Frontend, Paul can call a BackendMethod to send his message
+ *  NotificationContoller.send("Hello everyone!")
+ *
+ *  // Backend
+ *  export class NotificationContoller {
+ *    @BackendMethod({ allowed: true })
+ *    static async send(message: string) {
+ *      notif.publish({ from: remult.user, msg: message });
+ *    }
+ *  }
+ *
+ *  // Frontend: Eric & Simona can subscribe to messages
+ *  notif.subscribe((message) => {
+ *    if (message.from === remult.user) return;
+ *    console.log(`Message from ${message.from.name}: ${message.msg}`);
+ *  });
+ *  ```
+ *
+ *  #### A complexe chart that needs to be updated on multiple changes
+ *  ```ts
+ *  // shared code between the frontend and the backend
+ *  export const chart = new SubscriptionChannel<{ kind: "pie" | "bar" | "line", data: number[] }>("chart");
+ *
+ *  // Entity
+ *  @Entity<Task>("tasks", {
+ *    saved: async (e) => {
+ *      if (e.completed) chart.publish({ kind: "pie", data: [1, 2, 3] });
+ *    }
+ *  })
+ *  export class Task { ... }
+ *
+ *  // Frontend: in the chart component, we can subscribe to messages
+ *  chart.subscribe((message) => {
+ *    chartData = message.data;
+ *  });
+ *  ```
+ *
  */
 export class SubscriptionChannel {
     channelKey;

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;

package/esm/src/remult3/RepositoryImplementation.js

@@ -317,7 +317,7 @@ export class RepositoryImplementation {
         for (const field of this.fields) {
         }
     }
-    async insert(entity) {
+    async insert(entity, options) {
         if (Array.isArray(entity)) {
             if (this._dataProvider.isProxy) {
                 let refs = [];
@@ -335,27 +335,36 @@ export class RepositoryImplementation {
                     refs.push(ref);
                     raw.push(await ref.buildDtoForInsert());
                 }
-                return promiseAll(await this._edp.insertMany(raw), (item, i) => refs[i].processInsertResponseDto(item));
+                const inserted = await this._edp.insertMany(raw, options);
+                if (options?.select === 'none')
+                    return undefined;
+                return promiseAll(inserted, (item, i) => refs[i].processInsertResponseDto(item));
             }
             else {
                 let r = [];
                 for (const item of entity) {
-                    r.push(await this.insert(item));
+                    r.push(await this.insert(item, options));
                 }
+                if (options?.select === 'none')
+                    return undefined;
                 return r;
             }
         }
         else {
             let ref = getEntityRef(entity, false);
+            let result = undefined;
             if (ref) {
                 if (!ref.isNew())
                     throw 'Item is not new';
-                return await ref.save();
+                result = await ref.save(options);
             }
             else {
                 this.__cleanupPartialObject(entity);
-                return await this.getEntityRef(this.create(entity)).save();
+                result = await this.getEntityRef(this.create(entity)).save(options);
             }
+            if (options?.select === 'none')
+                return undefined;
+            return result;
         }
     }
     get fields() {
@@ -399,29 +408,36 @@ export class RepositoryImplementation {
         this.__cleanupPartialObject(set);
         Filter.throwErrorIfFilterIsEmpty(where, 'updateMany');
         if (this._dataProvider.isProxy) {
-            return this._edp.updateMany(await this._translateWhereToFilter(where), this.__createDto({ ...set }));
+            return this._edp.updateMany(where === 'all' ? 'all' : await this._translateWhereToFilter(where), this.__createDto({ ...set }));
         }
         else {
             let updated = 0;
+            if (where === 'all')
+                where = undefined;
             for await (const item of this.query({ where, aggregate: undefined })) {
                 assign(item, set);
-                await getEntityRef(item).save();
+                await getEntityRef(item).save({ select: 'none' });
                 updated++;
             }
             return updated;
         }
     }
-    async update(id, entity) {
+    async update(id, entity, options) {
+        function returnResult(result) {
+            if (options?.select === 'none')
+                return undefined;
+            return result;
+        }
         {
             let ref = getEntityRef(entity, false);
             if (ref)
-                return (await ref.save());
+                return returnResult((await ref.save(options)));
         }
         {
             let ref = getEntityRef(id, false);
             if (ref) {
                 assign(id, entity);
-                return ref.save();
+                return returnResult(await ref.save(options));
             }
         }
         this.__cleanupPartialObject(entity);
@@ -433,7 +449,7 @@ export class RepositoryImplementation {
         else
             ref = this._getRefForExistingRow(entity, id);
         if (this._dataProvider.isProxy) {
-            return await ref.save(Object.keys(entity));
+            return returnResult(await ref.save(options, Object.keys(entity)));
         }
         else {
             const r = await ref.reload();
@@ -450,7 +466,7 @@ export class RepositoryImplementation {
                 }
             }
             await this._fixTypes(r);
-            return await ref.save();
+            return returnResult(await ref.save(options));
         }
     }
     async upsert(options) {
@@ -518,22 +534,22 @@ export class RepositoryImplementation {
         }
         return ref;
     }
-    async save(entity) {
+    async save(entity, options) {
         if (Array.isArray(entity)) {
             return promiseAll(entity, (x) => this.save(x));
         }
         else {
             let ref = getEntityRef(entity, false);
             if (ref)
-                return await ref.save();
+                return await ref.save(options);
             else if (entity instanceof EntityBase) {
-                return await this.getEntityRef(entity).save();
+                return await this.getEntityRef(entity).save(options);
             }
             else {
                 let id = this.metadata.idMetadata.getId(entity);
                 if (id === undefined)
-                    return this.insert(entity);
-                return this.update(id, entity);
+                    return this.insert(entity, options);
+                return this.update(id, entity, options);
             }
         }
     }
@@ -855,10 +871,12 @@ export class RepositoryImplementation {
     async deleteMany({ where, }) {
         Filter.throwErrorIfFilterIsEmpty(where, 'deleteMany');
         if (this._dataProvider.isProxy) {
-            return this._edp.deleteMany(await this._translateWhereToFilter(where));
+            return this._edp.deleteMany(where === 'all' ? 'all' : await this._translateWhereToFilter(where));
         }
         else {
             let deleted = 0;
+            if (where === 'all')
+                where = undefined;
             for await (const item of this.query({ where, aggregate: undefined })) {
                 await getEntityRef(item).delete();
                 deleted++;
@@ -1374,6 +1392,15 @@ export class rowHelperImplementation extends rowHelperBase {
     repo;
     edp;
     _isNew;
+    async _updateResultsFromServerAction(rowInfo) {
+        await this._updateEntityBasedOnApi(rowInfo.data, true);
+        if (this._isNew != rowInfo.isNewRow) {
+            this._isNew = rowInfo.isNewRow;
+            this.originalId = rowInfo.id;
+        }
+        if (!rowInfo.wasChanged)
+            this.originalValues = this.copyDataToObject();
+    }
     constructor(info, instance, repo, edp, remult, _isNew, excludeRelationMembers) {
         super(info.fieldsMetadata, instance, remult, _isNew, excludeRelationMembers);
         this.info = info;
@@ -1474,7 +1501,7 @@ export class rowHelperImplementation extends rowHelperBase {
         return this._columns;
     }
     _saving = false;
-    async save(onlyTheseFieldsSentOnlyInTheCaseOfProxySaveWithPartialObject) {
+    async save(options, onlyTheseFieldsSentOnlyInTheCaseOfProxySaveWithPartialObject) {
         try {
             if (this._saving)
                 throw new Error('cannot save while entity is already saving');
@@ -1517,13 +1544,13 @@ export class rowHelperImplementation extends rowHelperBase {
             try {
                 this._subscribers?.reportChanged();
                 if (this.isNew()) {
-                    if (doNotSave) {
+                    if (doNotSave && options?.select !== 'none') {
                         updatedRow = (updatedRow = await this.edp.find({
                             where: await this.getIdFilter(),
                         }))[0];
                     }
                     else
-                        updatedRow = await this.edp.insert(d);
+                        updatedRow = await this.edp.insert(d, options);
                 }
                 else {
                     let changesOnly = {};
@@ -1542,12 +1569,13 @@ export class rowHelperImplementation extends rowHelperBase {
                     if (!wasChanged)
                         return this.instance;
                     if (doNotSave) {
-                        updatedRow = (await this.edp.find({ where: await this.getIdFilter() }))[0];
+                        if (options?.select !== 'none')
+                            updatedRow = (await this.edp.find({ where: await this.getIdFilter() }))[0];
                     }
                     else {
                         if (this.id === undefined)
                             throw new Error('Invalid operation, id is undefined');
-                        updatedRow = await this.edp.update(this.id, changesOnly);
+                        updatedRow = await this.edp.update(this.id, changesOnly, options);
                     }
                 }
                 if (updatedRow)
@@ -2500,8 +2528,8 @@ export class EntityBase {
     get _() {
         return getEntityRef(this);
     }
-    save() {
-        return getEntityRef(this).save();
+    save(options) {
+        return getEntityRef(this).save(options);
     }
     assign(values) {
         assign(this, values);