@koalarx/nest 3.1.35 → 3.1.37

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,75 @@ var EntityActionType;
     EntityActionType[EntityActionType["update"] = 2] = "update";
 })(EntityActionType || (exports.EntityActionType = EntityActionType = {}));
 class EntityBase {
+    _trackHasUpdateOnSet = false;
+    _setTrackingProxy;
     _id;
     _action = EntityActionType.create;
+    _hasUpdate = false;
     constructor(props) {
+        Object.defineProperties(this, {
+            _trackHasUpdateOnSet: {
+                enumerable: false,
+                configurable: true,
+                writable: true,
+                value: false,
+            },
+            _setTrackingProxy: {
+                enumerable: false,
+                configurable: true,
+                writable: true,
+                value: undefined,
+            },
+            _id: {
+                enumerable: false,
+                configurable: true,
+                writable: true,
+                value: this._id,
+            },
+            _action: {
+                enumerable: false,
+                configurable: true,
+                writable: true,
+                value: this._action,
+            },
+            _hasUpdate: {
+                enumerable: false,
+                configurable: true,
+                writable: true,
+                value: this._hasUpdate,
+            },
+        });
         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 !== '_action' &&
+                    property !== '_id' &&
+                    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(id?: keyof EntityProps<any> | IdConfig<EntityProps<any>>): <T extends new (...args: any[]) => EntityBase<any>>(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);
@@ -27,6 +30,8 @@ function Entity(id) {
         });
         const idConfig = normalizeIdConfig(id);
         Reflect.defineMetadata('entity:id', idConfig, NewConstructor.prototype);
+        Reflect.defineMetadata('entity:decorated-constructor', NewConstructor, target.prototype);
+        Reflect.defineMetadata('entity:decorated-constructor', NewConstructor, NewConstructor.prototype);
         return NewConstructor;
     };
 }

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,
@@ -284,8 +285,15 @@ class RepositoryBase {
     }
     createEntity(data, entityClass) {
         const entity = new (entityClass || this._modelName)();
+        const trackedEntity = entity;
+        if (typeof trackedEntity.stopHasUpdateTracking === 'function') {
+            trackedEntity.stopHasUpdateTracking();
+        }
         entity._action = entity_base_1.EntityActionType.update;
         entity.automap(data);
+        if (typeof trackedEntity.startHasUpdateTracking === 'function') {
+            trackedEntity.startHasUpdateTracking();
+        }
         return entity;
     }
     orphanRemoval(client, entity) {
@@ -377,7 +385,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/core/utils/automap-cycle-context.js

@@ -15,12 +15,19 @@ function mapEntityReference(value, EntityOnPropKey, context, action) {
     if (cachedEntity) {
         return cachedEntity;
     }
-    const entity = new EntityOnPropKey();
+    const DecoratedEntityConstructor = Reflect.getMetadata('entity:decorated-constructor', EntityOnPropKey.prototype) ?? EntityOnPropKey;
+    const entity = new DecoratedEntityConstructor();
+    const trackedEntity = entity;
     if (entity && typeof entity.automap === 'function') {
-        ;
-        entity._action = action;
+        if (typeof trackedEntity.stopHasUpdateTracking === 'function') {
+            trackedEntity.stopHasUpdateTracking();
+        }
+        trackedEntity._action = action;
         context.references.set(value, entity);
-        entity.automap(value, context);
+        trackedEntity.automap(value, context);
+        if (typeof trackedEntity.startHasUpdateTracking === 'function') {
+            trackedEntity.startHasUpdateTracking();
+        }
     }
     return entity;
 }

package/package.json

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