@koalarx/nest 3.1.35 → 3.1.36

package/core/database/entity.base.d.ts

@@ -13,9 +13,15 @@ export type EntityProps<T extends IComparable<T>> = Overwrite<Omit<{
     } ? U : never;
 }>;
 export declare abstract class EntityBase<T extends IComparable<T>> implements IComparable<T> {
+    private _trackHasUpdateOnSet;
+    private _setTrackingProxy?;
     _id: IComparableId;
     _action: EntityActionType;
+    _hasUpdate: boolean;
     constructor(props?: EntityProps<T>);
+    protected startHasUpdateTracking(): void;
+    protected stopHasUpdateTracking(): void;
+    protected createSetTrackingProxy(): this;
     automap(props?: EntityProps<T>, context?: AutomapContext): void;
     equals(obj: EntityBase<T>): boolean;
 }

package/core/database/entity.base.js

@@ -11,13 +11,41 @@ var EntityActionType;
     EntityActionType[EntityActionType["update"] = 2] = "update";
 })(EntityActionType || (exports.EntityActionType = EntityActionType = {}));
 class EntityBase {
+    _trackHasUpdateOnSet = false;
+    _setTrackingProxy;
     _id;
     _action = EntityActionType.create;
+    _hasUpdate = false;
     constructor(props) {
         if (props) {
             this.automap(props);
         }
     }
+    startHasUpdateTracking() {
+        this._trackHasUpdateOnSet = true;
+    }
+    stopHasUpdateTracking() {
+        this._trackHasUpdateOnSet = false;
+    }
+    createSetTrackingProxy() {
+        if (this._setTrackingProxy) {
+            return this._setTrackingProxy;
+        }
+        this._setTrackingProxy = new Proxy(this, {
+            set: (target, property, value, receiver) => {
+                const success = Reflect.set(target, property, value, receiver);
+                if (success &&
+                    target._trackHasUpdateOnSet &&
+                    property !== '_hasUpdate' &&
+                    property !== '_trackHasUpdateOnSet' &&
+                    property !== '_setTrackingProxy') {
+                    target._hasUpdate = true;
+                }
+                return success;
+            },
+        });
+        return this._setTrackingProxy;
+    }
     automap(props, context = (0, automap_cycle_context_1.createAutomapContext)()) {
         if (props) {
             if (typeof props === 'object' && props !== null) {

package/core/database/entity.decorator.d.ts

@@ -8,12 +8,5 @@ export interface IdConfig<T extends EntityProps<any>> {
     composite?: readonly (keyof T)[];
     custom?: (props: T) => string | number | CompositeId;
 }
-export declare function Entity<T extends new (...args: any[]) => EntityBase<any>>(id?: keyof EntityProps<InstanceType<T>> | IdConfig<EntityProps<InstanceType<T>>>): (target: T) => {
-    new (...args: any[]): {
-        _id: import("../utils/interfaces/icomparable").IComparableId;
-        _action: import("./entity.base").EntityActionType;
-        automap(props?: import("./entity.base").EntityProps<any> | undefined, context?: import("../utils/automap-cycle-context").AutomapContext): void;
-        equals(obj: EntityBase<any>): boolean;
-    };
-} & T;
+export declare function Entity<T extends new (...args: any[]) => EntityBase<any>>(id?: keyof EntityProps<InstanceType<T>> | IdConfig<EntityProps<InstanceType<T>>>): (target: T) => T;
 export {};

package/core/database/entity.decorator.js

@@ -14,9 +14,12 @@ function Entity(id) {
         class NewConstructor extends target {
             constructor(...args) {
                 super(...args);
+                this.stopHasUpdateTracking();
                 if (typeof this.automap === 'function') {
                     this.automap(args[0]);
                 }
+                this.startHasUpdateTracking();
+                return this.createSetTrackingProxy();
             }
         }
         Object.setPrototypeOf(NewConstructor.prototype, target.prototype);

package/core/database/repository.base.js

@@ -210,7 +210,8 @@ class RepositoryBase {
             else if (entity[key] instanceof entity_base_1.EntityBase) {
                 const entityInstance = entity[key];
                 const modelName = entity[key].constructor.name;
-                if (entity[key]._action === entity_base_1.EntityActionType.update) {
+                if (entity[key]._action === entity_base_1.EntityActionType.update &&
+                    entity[key]._hasUpdate) {
                     relationUpdates.push({
                         modelName: (0, KlString_1.toCamelCase)(modelName),
                         entityInstance,
@@ -377,7 +378,16 @@ class RepositoryBase {
         }
         if (relationUpdates.length > 0) {
             await Promise.all([
-                ...relationUpdates.map((relation) => transaction[relation.modelName].update(relation.schema)),
+                ...relationUpdates.map((relationUpdate) => transaction[relationUpdate.modelName]
+                    .update(relationUpdate.schema)
+                    .then(() => {
+                    if (relationUpdate.relations.length === 0) {
+                        return Promise.all([]);
+                    }
+                    return Promise.all(relationUpdate.relations.map((relation) => {
+                        return this.persistRelations(transaction, relation);
+                    }));
+                })),
             ]);
         }
         if (relationCreates.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@koalarx/nest",
-  "version": "3.1.35",
+  "version": "3.1.36",
   "description": "",
   "author": "Igor D. Rangel",
   "license": "MIT",