typeorm 0.3.0-rc.9 → 0.3.1-dev.9f1b8e3

package/subscriber/Broadcaster.js

@@ -1,18 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Broadcaster = void 0;
+const BroadcasterResult_1 = require("./BroadcasterResult");
+const ObjectUtils_1 = require("../util/ObjectUtils");
 /**
  * Broadcaster provides a helper methods to broadcast events to the subscribers.
  */
-var Broadcaster = /** @class */ (function () {
+class Broadcaster {
     // -------------------------------------------------------------------------
     // Constructor
     // -------------------------------------------------------------------------
-    function Broadcaster(queryRunner) {
+    constructor(queryRunner) {
         this.queryRunner = queryRunner;
     }
     // -------------------------------------------------------------------------
     // Public Methods
     // -------------------------------------------------------------------------
+    async broadcast(event, ...args) {
+        const result = new BroadcasterResult_1.BroadcasterResult();
+        const broadcastFunction = this[`broadcast${event}Event`];
+        if (typeof broadcastFunction === "function") {
+            ;
+            broadcastFunction.call(this, result, ...args);
+        }
+        await result.wait();
+    }
     /**
      * Broadcasts "BEFORE_INSERT" event.
      * Before insert event is executed before entity is being inserted to the database for the first time.
@@ -21,12 +33,11 @@ var Broadcaster = /** @class */ (function () {
      *
      * Note: this method has a performance-optimized code organization, do not change code structure.
      */
-    Broadcaster.prototype.broadcastBeforeInsertEvent = function (result, metadata, entity) {
-        var _this = this;
+    broadcastBeforeInsertEvent(result, metadata, entity) {
         if (entity && metadata.beforeInsertListeners.length) {
-            metadata.beforeInsertListeners.forEach(function (listener) {
+            metadata.beforeInsertListeners.forEach((listener) => {
                 if (listener.isAllowed(entity)) {
-                    var executionResult = listener.execute(entity);
+                    const executionResult = listener.execute(entity);
                     if (executionResult instanceof Promise)
                         result.promises.push(executionResult);
                     result.count++;
@@ -34,14 +45,15 @@ var Broadcaster = /** @class */ (function () {
             });
         }
         if (this.queryRunner.connection.subscribers.length) {
-            this.queryRunner.connection.subscribers.forEach(function (subscriber) {
-                if (_this.isAllowedSubscriber(subscriber, metadata.target) && subscriber.beforeInsert) {
-                    var executionResult = subscriber.beforeInsert({
-                        connection: _this.queryRunner.connection,
-                        queryRunner: _this.queryRunner,
-                        manager: _this.queryRunner.manager,
+            this.queryRunner.connection.subscribers.forEach((subscriber) => {
+                if (this.isAllowedSubscriber(subscriber, metadata.target) &&
+                    subscriber.beforeInsert) {
+                    const executionResult = subscriber.beforeInsert({
+                        connection: this.queryRunner.connection,
+                        queryRunner: this.queryRunner,
+                        manager: this.queryRunner.manager,
                         entity: entity,
-                        metadata: metadata
+                        metadata: metadata,
                     });
                     if (executionResult instanceof Promise)
                         result.promises.push(executionResult);
@@ -49,7 +61,7 @@ var Broadcaster = /** @class */ (function () {
                 }
             });
         }
-    };
+    }
     /**
      * Broadcasts "BEFORE_UPDATE" event.
      * Before update event is executed before entity is being updated in the database.
@@ -58,12 +70,12 @@ var Broadcaster = /** @class */ (function () {
      *
      * Note: this method has a performance-optimized code organization, do not change code structure.
      */
-    Broadcaster.prototype.broadcastBeforeUpdateEvent = function (result, metadata, entity, databaseEntity, updatedColumns, updatedRelations) {
-        var _this = this;
+    broadcastBeforeUpdateEvent(result, metadata, entity, databaseEntity, updatedColumns, updatedRelations) {
+        // todo: send relations too?
         if (entity && metadata.beforeUpdateListeners.length) {
-            metadata.beforeUpdateListeners.forEach(function (listener) {
+            metadata.beforeUpdateListeners.forEach((listener) => {
                 if (listener.isAllowed(entity)) {
-                    var executionResult = listener.execute(entity);
+                    const executionResult = listener.execute(entity);
                     if (executionResult instanceof Promise)
                         result.promises.push(executionResult);
                     result.count++;
@@ -71,17 +83,18 @@ var Broadcaster = /** @class */ (function () {
             });
         }
         if (this.queryRunner.connection.subscribers.length) {
-            this.queryRunner.connection.subscribers.forEach(function (subscriber) {
-                if (_this.isAllowedSubscriber(subscriber, metadata.target) && subscriber.beforeUpdate) {
-                    var executionResult = subscriber.beforeUpdate({
-                        connection: _this.queryRunner.connection,
-                        queryRunner: _this.queryRunner,
-                        manager: _this.queryRunner.manager,
-                        metadata: metadata,
+            this.queryRunner.connection.subscribers.forEach((subscriber) => {
+                if (this.isAllowedSubscriber(subscriber, metadata.target) &&
+                    subscriber.beforeUpdate) {
+                    const executionResult = subscriber.beforeUpdate({
+                        connection: this.queryRunner.connection,
+                        queryRunner: this.queryRunner,
+                        manager: this.queryRunner.manager,
                         entity: entity,
+                        metadata: metadata,
                         databaseEntity: databaseEntity,
                         updatedColumns: updatedColumns || [],
-                        updatedRelations: updatedRelations || []
+                        updatedRelations: updatedRelations || [],
                     });
                     if (executionResult instanceof Promise)
                         result.promises.push(executionResult);
@@ -89,7 +102,7 @@ var Broadcaster = /** @class */ (function () {
                 }
             });
         }
-    };
+    }
     /**
      * Broadcasts "BEFORE_REMOVE" event.
      * Before remove event is executed before entity is being removed from the database.
@@ -98,12 +111,11 @@ var Broadcaster = /** @class */ (function () {
      *
      * Note: this method has a performance-optimized code organization, do not change code structure.
      */
-    Broadcaster.prototype.broadcastBeforeRemoveEvent = function (result, metadata, entity, databaseEntity) {
-        var _this = this;
+    broadcastBeforeRemoveEvent(result, metadata, entity, databaseEntity) {
         if (entity && metadata.beforeRemoveListeners.length) {
-            metadata.beforeRemoveListeners.forEach(function (listener) {
+            metadata.beforeRemoveListeners.forEach((listener) => {
                 if (listener.isAllowed(entity)) {
-                    var executionResult = listener.execute(entity);
+                    const executionResult = listener.execute(entity);
                     if (executionResult instanceof Promise)
                         result.promises.push(executionResult);
                     result.count++;
@@ -111,16 +123,56 @@ var Broadcaster = /** @class */ (function () {
             });
         }
         if (this.queryRunner.connection.subscribers.length) {
-            this.queryRunner.connection.subscribers.forEach(function (subscriber) {
-                if (_this.isAllowedSubscriber(subscriber, metadata.target) && subscriber.beforeRemove) {
-                    var executionResult = subscriber.beforeRemove({
-                        connection: _this.queryRunner.connection,
-                        queryRunner: _this.queryRunner,
-                        manager: _this.queryRunner.manager,
+            this.queryRunner.connection.subscribers.forEach((subscriber) => {
+                if (this.isAllowedSubscriber(subscriber, metadata.target) &&
+                    subscriber.beforeRemove) {
+                    const executionResult = subscriber.beforeRemove({
+                        connection: this.queryRunner.connection,
+                        queryRunner: this.queryRunner,
+                        manager: this.queryRunner.manager,
+                        entity: entity,
                         metadata: metadata,
+                        databaseEntity: databaseEntity,
+                        entityId: metadata.getEntityIdMixedMap(databaseEntity),
+                    });
+                    if (executionResult instanceof Promise)
+                        result.promises.push(executionResult);
+                    result.count++;
+                }
+            });
+        }
+    }
+    /**
+     * Broadcasts "BEFORE_SOFT_REMOVE" event.
+     * Before soft remove event is executed before entity is being soft removed from the database.
+     * All subscribers and entity listeners who listened to this event will be executed at this point.
+     * Subscribers and entity listeners can return promises, it will wait until they are resolved.
+     *
+     * Note: this method has a performance-optimized code organization, do not change code structure.
+     */
+    broadcastBeforeSoftRemoveEvent(result, metadata, entity, databaseEntity) {
+        if (entity && metadata.beforeSoftRemoveListeners.length) {
+            metadata.beforeSoftRemoveListeners.forEach((listener) => {
+                if (listener.isAllowed(entity)) {
+                    const executionResult = listener.execute(entity);
+                    if (executionResult instanceof Promise)
+                        result.promises.push(executionResult);
+                    result.count++;
+                }
+            });
+        }
+        if (this.queryRunner.connection.subscribers.length) {
+            this.queryRunner.connection.subscribers.forEach((subscriber) => {
+                if (this.isAllowedSubscriber(subscriber, metadata.target) &&
+                    subscriber.beforeSoftRemove) {
+                    const executionResult = subscriber.beforeSoftRemove({
+                        connection: this.queryRunner.connection,
+                        queryRunner: this.queryRunner,
+                        manager: this.queryRunner.manager,
                         entity: entity,
+                        metadata: metadata,
                         databaseEntity: databaseEntity,
-                        entityId: metadata.getEntityIdMixedMap(databaseEntity)
+                        entityId: metadata.getEntityIdMixedMap(databaseEntity),
                     });
                     if (executionResult instanceof Promise)
                         result.promises.push(executionResult);
@@ -128,7 +180,46 @@ var Broadcaster = /** @class */ (function () {
                 }
             });
         }
-    };
+    }
+    /**
+     * Broadcasts "BEFORE_RECOVER" event.
+     * Before recover event is executed before entity is being recovered in the database.
+     * All subscribers and entity listeners who listened to this event will be executed at this point.
+     * Subscribers and entity listeners can return promises, it will wait until they are resolved.
+     *
+     * Note: this method has a performance-optimized code organization, do not change code structure.
+     */
+    broadcastBeforeRecoverEvent(result, metadata, entity, databaseEntity) {
+        if (entity && metadata.beforeRecoverListeners.length) {
+            metadata.beforeRecoverListeners.forEach((listener) => {
+                if (listener.isAllowed(entity)) {
+                    const executionResult = listener.execute(entity);
+                    if (executionResult instanceof Promise)
+                        result.promises.push(executionResult);
+                    result.count++;
+                }
+            });
+        }
+        if (this.queryRunner.connection.subscribers.length) {
+            this.queryRunner.connection.subscribers.forEach((subscriber) => {
+                if (this.isAllowedSubscriber(subscriber, metadata.target) &&
+                    subscriber.beforeRecover) {
+                    const executionResult = subscriber.beforeRecover({
+                        connection: this.queryRunner.connection,
+                        queryRunner: this.queryRunner,
+                        manager: this.queryRunner.manager,
+                        entity: entity,
+                        metadata: metadata,
+                        databaseEntity: databaseEntity,
+                        entityId: metadata.getEntityIdMixedMap(databaseEntity),
+                    });
+                    if (executionResult instanceof Promise)
+                        result.promises.push(executionResult);
+                    result.count++;
+                }
+            });
+        }
+    }
     /**
      * Broadcasts "AFTER_INSERT" event.
      * After insert event is executed after entity is being persisted to the database for the first time.
@@ -137,12 +228,11 @@ var Broadcaster = /** @class */ (function () {
      *
      * Note: this method has a performance-optimized code organization, do not change code structure.
      */
-    Broadcaster.prototype.broadcastAfterInsertEvent = function (result, metadata, entity) {
-        var _this = this;
+    broadcastAfterInsertEvent(result, metadata, entity) {
         if (entity && metadata.afterInsertListeners.length) {
-            metadata.afterInsertListeners.forEach(function (listener) {
+            metadata.afterInsertListeners.forEach((listener) => {
                 if (listener.isAllowed(entity)) {
-                    var executionResult = listener.execute(entity);
+                    const executionResult = listener.execute(entity);
                     if (executionResult instanceof Promise)
                         result.promises.push(executionResult);
                     result.count++;
@@ -150,14 +240,91 @@ var Broadcaster = /** @class */ (function () {
             });
         }
         if (this.queryRunner.connection.subscribers.length) {
-            this.queryRunner.connection.subscribers.forEach(function (subscriber) {
-                if (_this.isAllowedSubscriber(subscriber, metadata.target) && subscriber.afterInsert) {
-                    var executionResult = subscriber.afterInsert({
-                        connection: _this.queryRunner.connection,
-                        queryRunner: _this.queryRunner,
-                        manager: _this.queryRunner.manager,
+            this.queryRunner.connection.subscribers.forEach((subscriber) => {
+                if (this.isAllowedSubscriber(subscriber, metadata.target) &&
+                    subscriber.afterInsert) {
+                    const executionResult = subscriber.afterInsert({
+                        connection: this.queryRunner.connection,
+                        queryRunner: this.queryRunner,
+                        manager: this.queryRunner.manager,
                         entity: entity,
-                        metadata: metadata
+                        metadata: metadata,
+                    });
+                    if (executionResult instanceof Promise)
+                        result.promises.push(executionResult);
+                    result.count++;
+                }
+            });
+        }
+    }
+    /**
+     * Broadcasts "BEFORE_TRANSACTION_START" event.
+     */
+    broadcastBeforeTransactionStartEvent(result) {
+        if (this.queryRunner.connection.subscribers.length) {
+            this.queryRunner.connection.subscribers.forEach((subscriber) => {
+                if (subscriber.beforeTransactionStart) {
+                    const executionResult = subscriber.beforeTransactionStart({
+                        connection: this.queryRunner.connection,
+                        queryRunner: this.queryRunner,
+                        manager: this.queryRunner.manager,
+                    });
+                    if (executionResult instanceof Promise)
+                        result.promises.push(executionResult);
+                    result.count++;
+                }
+            });
+        }
+    }
+    /**
+     * Broadcasts "AFTER_TRANSACTION_START" event.
+     */
+    broadcastAfterTransactionStartEvent(result) {
+        if (this.queryRunner.connection.subscribers.length) {
+            this.queryRunner.connection.subscribers.forEach((subscriber) => {
+                if (subscriber.afterTransactionStart) {
+                    const executionResult = subscriber.afterTransactionStart({
+                        connection: this.queryRunner.connection,
+                        queryRunner: this.queryRunner,
+                        manager: this.queryRunner.manager,
+                    });
+                    if (executionResult instanceof Promise)
+                        result.promises.push(executionResult);
+                    result.count++;
+                }
+            });
+        }
+    }
+    /**
+     * Broadcasts "BEFORE_TRANSACTION_COMMIT" event.
+     */
+    broadcastBeforeTransactionCommitEvent(result) {
+        if (this.queryRunner.connection.subscribers.length) {
+            this.queryRunner.connection.subscribers.forEach((subscriber) => {
+                if (subscriber.beforeTransactionCommit) {
+                    const executionResult = subscriber.beforeTransactionCommit({
+                        connection: this.queryRunner.connection,
+                        queryRunner: this.queryRunner,
+                        manager: this.queryRunner.manager,
+                    });
+                    if (executionResult instanceof Promise)
+                        result.promises.push(executionResult);
+                    result.count++;
+                }
+            });
+        }
+    }
+    /**
+     * Broadcasts "AFTER_TRANSACTION_COMMIT" event.
+     */
+    broadcastAfterTransactionCommitEvent(result) {
+        if (this.queryRunner.connection.subscribers.length) {
+            this.queryRunner.connection.subscribers.forEach((subscriber) => {
+                if (subscriber.afterTransactionCommit) {
+                    const executionResult = subscriber.afterTransactionCommit({
+                        connection: this.queryRunner.connection,
+                        queryRunner: this.queryRunner,
+                        manager: this.queryRunner.manager,
                     });
                     if (executionResult instanceof Promise)
                         result.promises.push(executionResult);
@@ -165,7 +332,45 @@ var Broadcaster = /** @class */ (function () {
                 }
             });
         }
-    };
+    }
+    /**
+     * Broadcasts "BEFORE_TRANSACTION_ROLLBACK" event.
+     */
+    broadcastBeforeTransactionRollbackEvent(result) {
+        if (this.queryRunner.connection.subscribers.length) {
+            this.queryRunner.connection.subscribers.forEach((subscriber) => {
+                if (subscriber.beforeTransactionRollback) {
+                    const executionResult = subscriber.beforeTransactionRollback({
+                        connection: this.queryRunner.connection,
+                        queryRunner: this.queryRunner,
+                        manager: this.queryRunner.manager,
+                    });
+                    if (executionResult instanceof Promise)
+                        result.promises.push(executionResult);
+                    result.count++;
+                }
+            });
+        }
+    }
+    /**
+     * Broadcasts "AFTER_TRANSACTION_ROLLBACK" event.
+     */
+    broadcastAfterTransactionRollbackEvent(result) {
+        if (this.queryRunner.connection.subscribers.length) {
+            this.queryRunner.connection.subscribers.forEach((subscriber) => {
+                if (subscriber.afterTransactionRollback) {
+                    const executionResult = subscriber.afterTransactionRollback({
+                        connection: this.queryRunner.connection,
+                        queryRunner: this.queryRunner,
+                        manager: this.queryRunner.manager,
+                    });
+                    if (executionResult instanceof Promise)
+                        result.promises.push(executionResult);
+                    result.count++;
+                }
+            });
+        }
+    }
     /**
      * Broadcasts "AFTER_UPDATE" event.
      * After update event is executed after entity is being updated in the database.
@@ -174,12 +379,11 @@ var Broadcaster = /** @class */ (function () {
      *
      * Note: this method has a performance-optimized code organization, do not change code structure.
      */
-    Broadcaster.prototype.broadcastAfterUpdateEvent = function (result, metadata, entity, databaseEntity, updatedColumns, updatedRelations) {
-        var _this = this;
+    broadcastAfterUpdateEvent(result, metadata, entity, databaseEntity, updatedColumns, updatedRelations) {
         if (entity && metadata.afterUpdateListeners.length) {
-            metadata.afterUpdateListeners.forEach(function (listener) {
+            metadata.afterUpdateListeners.forEach((listener) => {
                 if (listener.isAllowed(entity)) {
-                    var executionResult = listener.execute(entity);
+                    const executionResult = listener.execute(entity);
                     if (executionResult instanceof Promise)
                         result.promises.push(executionResult);
                     result.count++;
@@ -187,17 +391,18 @@ var Broadcaster = /** @class */ (function () {
             });
         }
         if (this.queryRunner.connection.subscribers.length) {
-            this.queryRunner.connection.subscribers.forEach(function (subscriber) {
-                if (_this.isAllowedSubscriber(subscriber, metadata.target) && subscriber.afterUpdate) {
-                    var executionResult = subscriber.afterUpdate({
-                        connection: _this.queryRunner.connection,
-                        queryRunner: _this.queryRunner,
-                        manager: _this.queryRunner.manager,
-                        metadata: metadata,
+            this.queryRunner.connection.subscribers.forEach((subscriber) => {
+                if (this.isAllowedSubscriber(subscriber, metadata.target) &&
+                    subscriber.afterUpdate) {
+                    const executionResult = subscriber.afterUpdate({
+                        connection: this.queryRunner.connection,
+                        queryRunner: this.queryRunner,
+                        manager: this.queryRunner.manager,
                         entity: entity,
+                        metadata: metadata,
                         databaseEntity: databaseEntity,
                         updatedColumns: updatedColumns || [],
-                        updatedRelations: updatedRelations || []
+                        updatedRelations: updatedRelations || [],
                     });
                     if (executionResult instanceof Promise)
                         result.promises.push(executionResult);
@@ -205,7 +410,7 @@ var Broadcaster = /** @class */ (function () {
                 }
             });
         }
-    };
+    }
     /**
      * Broadcasts "AFTER_REMOVE" event.
      * After remove event is executed after entity is being removed from the database.
@@ -214,12 +419,11 @@ var Broadcaster = /** @class */ (function () {
      *
      * Note: this method has a performance-optimized code organization, do not change code structure.
      */
-    Broadcaster.prototype.broadcastAfterRemoveEvent = function (result, metadata, entity, databaseEntity) {
-        var _this = this;
+    broadcastAfterRemoveEvent(result, metadata, entity, databaseEntity) {
         if (entity && metadata.afterRemoveListeners.length) {
-            metadata.afterRemoveListeners.forEach(function (listener) {
+            metadata.afterRemoveListeners.forEach((listener) => {
                 if (listener.isAllowed(entity)) {
-                    var executionResult = listener.execute(entity);
+                    const executionResult = listener.execute(entity);
                     if (executionResult instanceof Promise)
                         result.promises.push(executionResult);
                     result.count++;
@@ -227,16 +431,95 @@ var Broadcaster = /** @class */ (function () {
             });
         }
         if (this.queryRunner.connection.subscribers.length) {
-            this.queryRunner.connection.subscribers.forEach(function (subscriber) {
-                if (_this.isAllowedSubscriber(subscriber, metadata.target) && subscriber.afterRemove) {
-                    var executionResult = subscriber.afterRemove({
-                        connection: _this.queryRunner.connection,
-                        queryRunner: _this.queryRunner,
-                        manager: _this.queryRunner.manager,
+            this.queryRunner.connection.subscribers.forEach((subscriber) => {
+                if (this.isAllowedSubscriber(subscriber, metadata.target) &&
+                    subscriber.afterRemove) {
+                    const executionResult = subscriber.afterRemove({
+                        connection: this.queryRunner.connection,
+                        queryRunner: this.queryRunner,
+                        manager: this.queryRunner.manager,
+                        entity: entity,
                         metadata: metadata,
+                        databaseEntity: databaseEntity,
+                        entityId: metadata.getEntityIdMixedMap(databaseEntity),
+                    });
+                    if (executionResult instanceof Promise)
+                        result.promises.push(executionResult);
+                    result.count++;
+                }
+            });
+        }
+    }
+    /**
+     * Broadcasts "AFTER_SOFT_REMOVE" event.
+     * After soft remove event is executed after entity is being soft removed from the database.
+     * All subscribers and entity listeners who listened to this event will be executed at this point.
+     * Subscribers and entity listeners can return promises, it will wait until they are resolved.
+     *
+     * Note: this method has a performance-optimized code organization, do not change code structure.
+     */
+    broadcastAfterSoftRemoveEvent(result, metadata, entity, databaseEntity) {
+        if (entity && metadata.afterSoftRemoveListeners.length) {
+            metadata.afterSoftRemoveListeners.forEach((listener) => {
+                if (listener.isAllowed(entity)) {
+                    const executionResult = listener.execute(entity);
+                    if (executionResult instanceof Promise)
+                        result.promises.push(executionResult);
+                    result.count++;
+                }
+            });
+        }
+        if (this.queryRunner.connection.subscribers.length) {
+            this.queryRunner.connection.subscribers.forEach((subscriber) => {
+                if (this.isAllowedSubscriber(subscriber, metadata.target) &&
+                    subscriber.afterSoftRemove) {
+                    const executionResult = subscriber.afterSoftRemove({
+                        connection: this.queryRunner.connection,
+                        queryRunner: this.queryRunner,
+                        manager: this.queryRunner.manager,
+                        entity: entity,
+                        metadata: metadata,
+                        databaseEntity: databaseEntity,
+                        entityId: metadata.getEntityIdMixedMap(databaseEntity),
+                    });
+                    if (executionResult instanceof Promise)
+                        result.promises.push(executionResult);
+                    result.count++;
+                }
+            });
+        }
+    }
+    /**
+     * Broadcasts "AFTER_RECOVER" event.
+     * After recover event is executed after entity is being recovered in the database.
+     * All subscribers and entity listeners who listened to this event will be executed at this point.
+     * Subscribers and entity listeners can return promises, it will wait until they are resolved.
+     *
+     * Note: this method has a performance-optimized code organization, do not change code structure.
+     */
+    broadcastAfterRecoverEvent(result, metadata, entity, databaseEntity) {
+        if (entity && metadata.afterRecoverListeners.length) {
+            metadata.afterRecoverListeners.forEach((listener) => {
+                if (listener.isAllowed(entity)) {
+                    const executionResult = listener.execute(entity);
+                    if (executionResult instanceof Promise)
+                        result.promises.push(executionResult);
+                    result.count++;
+                }
+            });
+        }
+        if (this.queryRunner.connection.subscribers.length) {
+            this.queryRunner.connection.subscribers.forEach((subscriber) => {
+                if (this.isAllowedSubscriber(subscriber, metadata.target) &&
+                    subscriber.afterRecover) {
+                    const executionResult = subscriber.afterRecover({
+                        connection: this.queryRunner.connection,
+                        queryRunner: this.queryRunner,
+                        manager: this.queryRunner.manager,
                         entity: entity,
+                        metadata: metadata,
                         databaseEntity: databaseEntity,
-                        entityId: metadata.getEntityIdMixedMap(databaseEntity)
+                        entityId: metadata.getEntityIdMixedMap(databaseEntity),
                     });
                     if (executionResult instanceof Promise)
                         result.promises.push(executionResult);
@@ -244,7 +527,13 @@ var Broadcaster = /** @class */ (function () {
                 }
             });
         }
-    };
+    }
+    /**
+     * @deprecated Use `broadcastLoadForAllEvent`
+     */
+    broadcastLoadEventsForAll(result, metadata, entities) {
+        return this.broadcastLoadEvent(result, metadata, entities);
+    }
     /**
      * Broadcasts "AFTER_LOAD" event for all given entities, and their sub-entities.
      * After load event is executed after entity has been loaded from the database.
@@ -253,50 +542,57 @@ var Broadcaster = /** @class */ (function () {
      *
      * Note: this method has a performance-optimized code organization, do not change code structure.
      */
-    Broadcaster.prototype.broadcastLoadEventsForAll = function (result, metadata, entities) {
-        var _this = this;
-        entities.forEach(function (entity) {
-            if (entity instanceof Promise) // todo: check why need this?
-                return;
+    broadcastLoadEvent(result, metadata, entities) {
+        // Calculate which subscribers are fitting for the given entity type
+        const fittingSubscribers = this.queryRunner.connection.subscribers.filter((subscriber) => this.isAllowedSubscriber(subscriber, metadata.target) &&
+            subscriber.afterLoad);
+        if (metadata.relations.length ||
+            metadata.afterLoadListeners.length ||
+            fittingSubscribers.length) {
+            // todo: check why need this?
+            const nonPromiseEntities = entities.filter((entity) => !(entity instanceof Promise));
             // collect load events for all children entities that were loaded with the main entity
             if (metadata.relations.length) {
-                metadata.relations.forEach(function (relation) {
-                    // in lazy relations we cannot simply access to entity property because it will cause a getter and a database query
-                    if (relation.isLazy && !entity.hasOwnProperty(relation.propertyName))
-                        return;
-                    var value = relation.getEntityValue(entity);
-                    if (value instanceof Object)
-                        _this.broadcastLoadEventsForAll(result, relation.inverseEntityMetadata, value instanceof Array ? value : [value]);
+                metadata.relations.forEach((relation) => {
+                    nonPromiseEntities.forEach((entity) => {
+                        // in lazy relations we cannot simply access to entity property because it will cause a getter and a database query
+                        if (relation.isLazy &&
+                            !entity.hasOwnProperty(relation.propertyName))
+                            return;
+                        const value = relation.getEntityValue(entity);
+                        if (ObjectUtils_1.ObjectUtils.isObject(value))
+                            this.broadcastLoadEvent(result, relation.inverseEntityMetadata, Array.isArray(value) ? value : [value]);
+                    });
                 });
             }
             if (metadata.afterLoadListeners.length) {
-                metadata.afterLoadListeners.forEach(function (listener) {
-                    if (listener.isAllowed(entity)) {
-                        var executionResult = listener.execute(entity);
-                        if (executionResult instanceof Promise)
-                            result.promises.push(executionResult);
-                        result.count++;
-                    }
+                metadata.afterLoadListeners.forEach((listener) => {
+                    nonPromiseEntities.forEach((entity) => {
+                        if (listener.isAllowed(entity)) {
+                            const executionResult = listener.execute(entity);
+                            if (executionResult instanceof Promise)
+                                result.promises.push(executionResult);
+                            result.count++;
+                        }
+                    });
                 });
             }
-            if (_this.queryRunner.connection.subscribers.length) {
-                _this.queryRunner.connection.subscribers.forEach(function (subscriber) {
-                    if (_this.isAllowedSubscriber(subscriber, metadata.target) && subscriber.afterLoad) {
-                        var executionResult = subscriber.afterLoad(entity, {
-                            connection: _this.queryRunner.connection,
-                            queryRunner: _this.queryRunner,
-                            manager: _this.queryRunner.manager,
-                            entity: entity,
-                            metadata: metadata
-                        });
-                        if (executionResult instanceof Promise)
-                            result.promises.push(executionResult);
-                        result.count++;
-                    }
+            fittingSubscribers.forEach((subscriber) => {
+                nonPromiseEntities.forEach((entity) => {
+                    const executionResult = subscriber.afterLoad(entity, {
+                        entity,
+                        metadata,
+                        connection: this.queryRunner.connection,
+                        queryRunner: this.queryRunner,
+                        manager: this.queryRunner.manager,
+                    });
+                    if (executionResult instanceof Promise)
+                        result.promises.push(executionResult);
+                    result.count++;
                 });
-            }
-        });
-    };
+            });
+        }
+    }
     // -------------------------------------------------------------------------
     // Protected Methods
     // -------------------------------------------------------------------------
@@ -304,15 +600,14 @@ var Broadcaster = /** @class */ (function () {
      * Checks if subscriber's methods can be executed by checking if its don't listen to the particular entity,
      * or listens our entity.
      */
-    Broadcaster.prototype.isAllowedSubscriber = function (subscriber, target) {
-        return !subscriber.listenTo ||
+    isAllowedSubscriber(subscriber, target) {
+        return (!subscriber.listenTo ||
             !subscriber.listenTo() ||
             subscriber.listenTo() === Object ||
             subscriber.listenTo() === target ||
-            subscriber.listenTo().isPrototypeOf(target);
-    };
-    return Broadcaster;
-}());
+            subscriber.listenTo().isPrototypeOf(target));
+    }
+}
 exports.Broadcaster = Broadcaster;
 
 //# sourceMappingURL=Broadcaster.js.map