remult 3.3.0 → 3.3.1

package/esm/remult-knex/index.js

@@ -256,7 +256,8 @@ class KnexEntityDataProvider {
             }
         }
         let insert = this.getEntityFrom(e).insert(insertObject);
-        if (isAutoIncrement(this.entity.idMetadata.field)) {
+        if (isAutoIncrement(this.entity.idMetadata.field) &&
+            !(options?.select === 'none')) {
             let newId;
             if (this.knex.client.config.client === 'mysql2' ||
                 this.knex.client.config.client === 'mysql') {

package/esm/src/data-api.js

@@ -446,13 +446,15 @@ export class DataApi {
             response.error(err, this.repository.metadata);
         }
     }
-    async actualUpdate(row, body, req) {
+    async actualUpdate(row, body, req, doNotSelect) {
         let ref = this.repository.getEntityRef(row);
         await ref._updateEntityBasedOnApi(body);
         if (!ref.apiUpdateAllowed) {
             throw new ForbiddenError();
         }
-        let options = req.get('_select') === 'none' ? { select: 'none' } : undefined;
+        let options = req.get('_select') === 'none' || doNotSelect
+            ? { select: 'none' }
+            : undefined;
         await ref.save(options);
         if (options?.select === 'none')
             return undefined;

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/remult3/RepositoryImplementation.js

@@ -412,9 +412,11 @@ export class RepositoryImplementation {
         }
         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;
@@ -532,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);
             }
         }
     }
@@ -873,6 +875,8 @@ export class RepositoryImplementation {
         }
         else {
             let deleted = 0;
+            if (where === 'all')
+                where = undefined;
             for await (const item of this.query({ where, aggregate: undefined })) {
                 await getEntityRef(item).delete();
                 deleted++;
@@ -2524,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);

package/package.json

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

package/remult-knex/index.js

@@ -482,7 +482,8 @@ var KnexEntityDataProvider = /** @class */ (function () {
                         return [7 /*endfinally*/];
                     case 10:
                         insert = this.getEntityFrom(e).insert(insertObject);
-                        if (!(0, RepositoryImplementation_js_1.isAutoIncrement)(this.entity.idMetadata.field)) return [3 /*break*/, 15];
+                        if (!((0, RepositoryImplementation_js_1.isAutoIncrement)(this.entity.idMetadata.field) &&
+                            !((options === null || options === void 0 ? void 0 : options.select) === 'none'))) return [3 /*break*/, 15];
                         if (!(this.knex.client.config.client === 'mysql2' ||
                             this.knex.client.config.client === 'mysql')) return [3 /*break*/, 12];
                         return [4 /*yield*/, insert];

package/src/data-api.d.ts

@@ -33,7 +33,7 @@ export declare class DataApi<T = unknown> {
         where?: any;
         set?: any;
     }): Promise<void>;
-    actualUpdate(row: any, body: any, req: DataApiRequest): Promise<any>;
+    actualUpdate(row: any, body: any, req: DataApiRequest, doNotSelect?: boolean): Promise<any>;
     put(response: DataApiResponse, req: DataApiRequest, id: any, body: any): Promise<void>;
     actualDelete(row: any): Promise<void>;
     delete(response: DataApiResponse, id: any): Promise<void>;

package/src/data-api.js

@@ -862,7 +862,7 @@ var DataApi = /** @class */ (function () {
             });
         });
     };
-    DataApi.prototype.actualUpdate = function (row, body, req) {
+    DataApi.prototype.actualUpdate = function (row, body, req, doNotSelect) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             var ref, options;
             return tslib_1.__generator(this, function (_a) {
@@ -875,7 +875,9 @@ var DataApi = /** @class */ (function () {
                         if (!ref.apiUpdateAllowed) {
                             throw new server_action_js_1.ForbiddenError();
                         }
-                        options = req.get('_select') === 'none' ? { select: 'none' } : undefined;
+                        options = req.get('_select') === 'none' || doNotSelect
+                            ? { select: 'none' }
+                            : undefined;
                         return [4 /*yield*/, ref.save(options)];
                     case 2:
                         _a.sent();

package/src/live-query/SubscriptionChannel.d.ts

@@ -38,18 +38,66 @@ export declare type LiveQueryChange = {
  *
  * @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 declare class SubscriptionChannel<messageType> {
     channelKey: string;

package/src/live-query/SubscriptionChannel.js

@@ -167,18 +167,66 @@ exports.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;
+ *  });
+ *  ```
+ *
  */
 var SubscriptionChannel = /** @class */ (function () {
     /**

package/src/remult3/RepositoryImplementation.d.ts

@@ -64,8 +64,8 @@ export declare class RepositoryImplementation<entityType> implements Repository<
     upsert(options: UpsertOptions<entityType>[]): Promise<entityType[]>;
     upsert(options: UpsertOptions<entityType>): Promise<entityType>;
     private _getRefForExistingRow;
-    save(item: Partial<MembersOnly<entityType>>[]): Promise<entityType[]>;
-    save(item: Partial<MembersOnly<entityType>>): Promise<entityType>;
+    save(item: Partial<MembersOnly<entityType>>[], options?: InsertOrUpdateOptions): Promise<entityType[]>;
+    save(item: Partial<MembersOnly<entityType>>, options?: InsertOrUpdateOptions): Promise<entityType>;
     liveQuery(options?: FindOptions<entityType>): LiveQuery<entityType>;
     _rawFind(options: FindOptions<entityType> | undefined, skipOrderByAndLimit: boolean | undefined, loader: RelationLoader, actualFind: (ops: EntityDataProviderFindOptions) => Promise<any[]>): Promise<entityType[]>;
     find(options?: FindOptions<entityType>): Promise<entityType[]>;
@@ -328,7 +328,7 @@ export declare function buildOptions<entityType = unknown, valueType = unknown>(
 export declare function decorateColumnSettings<valueType>(settings: FieldOptions<unknown, valueType>, remult: Remult): FieldOptions<unknown, valueType>;
 export declare class EntityBase {
     get _(): EntityRefForEntityBase<this>;
-    save(): Promise<this>;
+    save(options?: InsertOrUpdateOptions): Promise<this>;
     assign(values: Partial<Omit<this, keyof EntityBase>>): this;
     delete(): Promise<void>;
     isNew(): boolean;

package/src/remult3/RepositoryImplementation.js

@@ -676,6 +676,8 @@ var RepositoryImplementation = /** @class */ (function () {
                     case 3: return [2 /*return*/, _d.apply(_c, [_e, this.__createDto(tslib_1.__assign({}, set))])];
                     case 4:
                         updated = 0;
+                        if (where === 'all')
+                            where = undefined;
                         _m.label = 5;
                     case 5:
                         _m.trys.push([5, 11, 12, 17]);
@@ -688,7 +690,7 @@ var RepositoryImplementation = /** @class */ (function () {
                         _f = false;
                         item = _l;
                         (0, assign_js_1.assign)(item, set);
-                        return [4 /*yield*/, (0, getEntityRef_js_1.getEntityRef)(item).save()];
+                        return [4 /*yield*/, (0, getEntityRef_js_1.getEntityRef)(item).save({ select: 'none' })];
                     case 8:
                         _m.sent();
                         updated++;
@@ -872,7 +874,7 @@ var RepositoryImplementation = /** @class */ (function () {
         }
         return ref;
     };
-    RepositoryImplementation.prototype.save = function (entity) {
+    RepositoryImplementation.prototype.save = function (entity, options) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             var ref, id;
             var _this = this;
@@ -884,17 +886,17 @@ var RepositoryImplementation = /** @class */ (function () {
                     case 1:
                         ref = (0, getEntityRef_js_1.getEntityRef)(entity, false);
                         if (!ref) return [3 /*break*/, 3];
-                        return [4 /*yield*/, ref.save()];
+                        return [4 /*yield*/, ref.save(options)];
                     case 2: return [2 /*return*/, _a.sent()];
                     case 3:
                         if (!(entity instanceof EntityBase)) return [3 /*break*/, 5];
-                        return [4 /*yield*/, this.getEntityRef(entity).save()];
+                        return [4 /*yield*/, this.getEntityRef(entity).save(options)];
                     case 4: return [2 /*return*/, _a.sent()];
                     case 5:
                         id = this.metadata.idMetadata.getId(entity);
                         if (id === undefined)
-                            return [2 /*return*/, this.insert(entity)];
-                        return [2 /*return*/, this.update(id, entity)];
+                            return [2 /*return*/, this.insert(entity, options)];
+                        return [2 /*return*/, this.update(id, entity, options)];
                 }
             });
         });
@@ -1468,6 +1470,8 @@ var RepositoryImplementation = /** @class */ (function () {
                     case 3: return [2 /*return*/, _d.apply(_c, [_e])];
                     case 4:
                         deleted = 0;
+                        if (where === 'all')
+                            where = undefined;
                         _m.label = 5;
                     case 5:
                         _m.trys.push([5, 11, 12, 17]);
@@ -4025,8 +4029,8 @@ var EntityBase = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    EntityBase.prototype.save = function () {
-        return (0, getEntityRef_js_1.getEntityRef)(this).save();
+    EntityBase.prototype.save = function (options) {
+        return (0, getEntityRef_js_1.getEntityRef)(this).save(options);
     };
     EntityBase.prototype.assign = function (values) {
         (0, assign_js_1.assign)(this, values);

package/src/remult3/remult3.d.ts

@@ -395,9 +395,14 @@ export type GroupByResult<entityType, groupByFields extends (keyof entityType)[]
 };
 /** used to perform CRUD operations on an `entityType` */
 export interface Repository<entityType> {
-    /** returns a result array based on the provided options */
+    /** returns an array based on the provided options */
     find(options?: FindOptions<entityType>): Promise<entityType[]>;
-    /** returns a result array based on the provided options */
+    /** Using the same options as the {@link find} method, but subscribing to entity changes.
+     *
+     * _Note that today it subscribes to entity changes, but not included entities [Feature Request](https://github.com/remult/remult/issues/712)!_
+     *
+     * @see {@link LiveQuery}
+     */
     liveQuery(options?: FindOptions<entityType>): LiveQuery<entityType>;
     /** returns the first item that matchers the `where` condition
      * @example
@@ -547,8 +552,8 @@ export interface Repository<entityType> {
      * @example
      * await taskRepo.save({...task, completed:true })
      */
-    save(item: Partial<MembersOnly<entityType>>[]): Promise<entityType[]>;
-    save(item: Partial<MembersOnly<entityType>>): Promise<entityType>;
+    save(item: Partial<MembersOnly<entityType>>[], options?: InsertOrUpdateOptions): Promise<entityType[]>;
+    save(item: Partial<MembersOnly<entityType>>, options?: InsertOrUpdateOptions): Promise<entityType>;
     /**Insert an item or item[] to the data source
      * @example
      * await taskRepo.insert({title:"task a"})
@@ -674,7 +679,7 @@ export interface LiveQuery<entityType> {
      *
      * @example
      * // Subscribing to changes in a live query
-     * const unsubscribe = taskRepo
+     * const unsubscribe = repo(Task)
      *   .liveQuery({
      *     limit: 20,
      *     orderBy: { createdAt: 'asc' }
@@ -734,20 +739,14 @@ export interface LiveQueryChangeInfo<entityType> {
     applyChanges(prevState: entityType[] | undefined): entityType[];
 }
 export interface FindOptions<entityType> extends FindOptionsBase<entityType> {
-    /** Determines the number of rows returned by the request, on the browser the default is 100 rows
+    /** Number of rows returned. _(Defaults to 100 in the browser)_
      * @example
-     * await repo(Products).find({
-     *   limit: 10,
-     *   page: 2
-     * })
+     * await repo(Products).find({ limit: 10 })
      */
     limit?: number;
-    /** Determines the page number that will be used to extract the data
+    /** Determines the page number to retrieve. Works in tandem with the `limit` option.
      * @example
-     * await repo(Products).find({
-     *   limit: 10,
-     *  page: 2
-     * })
+     * await repo(Products).find({ page: 2 })
      */
     page?: number;
 }
@@ -1058,7 +1057,7 @@ export interface FindOptionsBase<entityType> extends LoadOptions<entityType> {
     select?: EntitySelectFields<entityType>;
     /** filters the data
      * @example
-     * await taskRepo.find({where: { completed:false }})
+     * await taskRepo.find({ where: { completed:false } })
      * @see For more usage examples see [EntityFilter](https://remult.dev/docs/entityFilter.html)
      */
     where?: EntityFilter<entityType>;