typeorm 0.3.29-dev.cc07c90 → 1.0.0-beta.1

package/browser/subscriber/Broadcaster.js

@@ -1,9 +1,12 @@
-import { ObjectUtils } from "../util/ObjectUtils";
-import { BroadcasterResult } from "./BroadcasterResult";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Broadcaster = void 0;
+const ObjectUtils_1 = require("../util/ObjectUtils");
+const BroadcasterResult_1 = require("./BroadcasterResult");
 /**
  * Broadcaster provides a helper methods to broadcast events to the subscribers.
  */
-export class Broadcaster {
+class Broadcaster {
     // -------------------------------------------------------------------------
     // Constructor
     // -------------------------------------------------------------------------
@@ -14,7 +17,7 @@ export class Broadcaster {
     // Public Methods
     // -------------------------------------------------------------------------
     async broadcast(event, ...args) {
-        const result = new BroadcasterResult();
+        const result = new BroadcasterResult_1.BroadcasterResult();
         const broadcastFunction = this[`broadcast${event}Event`];
         if (typeof broadcastFunction === "function") {
             ;
@@ -29,6 +32,9 @@ export class Broadcaster {
      * 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.
+     * @param result
+     * @param metadata
+     * @param entity
      */
     broadcastBeforeInsertEvent(result, metadata, entity) {
         if (entity && metadata.beforeInsertListeners.length) {
@@ -41,12 +47,13 @@ export class Broadcaster {
                 }
             });
         }
-        if (this.queryRunner.connection.subscribers.length) {
-            this.queryRunner.connection.subscribers.forEach((subscriber) => {
+        if (this.queryRunner.dataSource.subscribers.length) {
+            this.queryRunner.dataSource.subscribers.forEach((subscriber) => {
                 if (this.isAllowedSubscriber(subscriber, metadata.target) &&
                     subscriber.beforeInsert) {
                     const executionResult = subscriber.beforeInsert({
-                        connection: this.queryRunner.connection,
+                        dataSource: this.queryRunner.dataSource,
+                        connection: this.queryRunner.dataSource,
                         queryRunner: this.queryRunner,
                         manager: this.queryRunner.manager,
                         entity: entity,
@@ -66,6 +73,12 @@ export class Broadcaster {
      * 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.
+     * @param result
+     * @param metadata
+     * @param entity
+     * @param databaseEntity
+     * @param updatedColumns
+     * @param updatedRelations
      */
     broadcastBeforeUpdateEvent(result, metadata, entity, databaseEntity, updatedColumns, updatedRelations) {
         // todo: send relations too?
@@ -79,12 +92,13 @@ export class Broadcaster {
                 }
             });
         }
-        if (this.queryRunner.connection.subscribers.length) {
-            this.queryRunner.connection.subscribers.forEach((subscriber) => {
+        if (this.queryRunner.dataSource.subscribers.length) {
+            this.queryRunner.dataSource.subscribers.forEach((subscriber) => {
                 if (this.isAllowedSubscriber(subscriber, metadata.target) &&
                     subscriber.beforeUpdate) {
                     const executionResult = subscriber.beforeUpdate({
-                        connection: this.queryRunner.connection,
+                        dataSource: this.queryRunner.dataSource,
+                        connection: this.queryRunner.dataSource,
                         queryRunner: this.queryRunner,
                         manager: this.queryRunner.manager,
                         entity: entity,
@@ -107,6 +121,11 @@ export class Broadcaster {
      * 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.
+     * @param result
+     * @param metadata
+     * @param entity
+     * @param databaseEntity
+     * @param identifier
      */
     broadcastBeforeRemoveEvent(result, metadata, entity, databaseEntity, identifier) {
         if (entity && metadata.beforeRemoveListeners.length) {
@@ -119,12 +138,13 @@ export class Broadcaster {
                 }
             });
         }
-        if (this.queryRunner.connection.subscribers.length) {
-            this.queryRunner.connection.subscribers.forEach((subscriber) => {
+        if (this.queryRunner.dataSource.subscribers.length) {
+            this.queryRunner.dataSource.subscribers.forEach((subscriber) => {
                 if (this.isAllowedSubscriber(subscriber, metadata.target) &&
                     subscriber.beforeRemove) {
                     const executionResult = subscriber.beforeRemove({
-                        connection: this.queryRunner.connection,
+                        dataSource: this.queryRunner.dataSource,
+                        connection: this.queryRunner.dataSource,
                         queryRunner: this.queryRunner,
                         manager: this.queryRunner.manager,
                         entity: entity,
@@ -146,6 +166,11 @@ export class Broadcaster {
      * 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.
+     * @param result
+     * @param metadata
+     * @param entity
+     * @param databaseEntity
+     * @param identifier
      */
     broadcastBeforeSoftRemoveEvent(result, metadata, entity, databaseEntity, identifier) {
         if (entity && metadata.beforeSoftRemoveListeners.length) {
@@ -158,12 +183,13 @@ export class Broadcaster {
                 }
             });
         }
-        if (this.queryRunner.connection.subscribers.length) {
-            this.queryRunner.connection.subscribers.forEach((subscriber) => {
+        if (this.queryRunner.dataSource.subscribers.length) {
+            this.queryRunner.dataSource.subscribers.forEach((subscriber) => {
                 if (this.isAllowedSubscriber(subscriber, metadata.target) &&
                     subscriber.beforeSoftRemove) {
                     const executionResult = subscriber.beforeSoftRemove({
-                        connection: this.queryRunner.connection,
+                        dataSource: this.queryRunner.dataSource,
+                        connection: this.queryRunner.dataSource,
                         queryRunner: this.queryRunner,
                         manager: this.queryRunner.manager,
                         entity: entity,
@@ -185,6 +211,11 @@ export class Broadcaster {
      * 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.
+     * @param result
+     * @param metadata
+     * @param entity
+     * @param databaseEntity
+     * @param identifier
      */
     broadcastBeforeRecoverEvent(result, metadata, entity, databaseEntity, identifier) {
         if (entity && metadata.beforeRecoverListeners.length) {
@@ -197,12 +228,13 @@ export class Broadcaster {
                 }
             });
         }
-        if (this.queryRunner.connection.subscribers.length) {
-            this.queryRunner.connection.subscribers.forEach((subscriber) => {
+        if (this.queryRunner.dataSource.subscribers.length) {
+            this.queryRunner.dataSource.subscribers.forEach((subscriber) => {
                 if (this.isAllowedSubscriber(subscriber, metadata.target) &&
                     subscriber.beforeRecover) {
                     const executionResult = subscriber.beforeRecover({
-                        connection: this.queryRunner.connection,
+                        dataSource: this.queryRunner.dataSource,
+                        connection: this.queryRunner.dataSource,
                         queryRunner: this.queryRunner,
                         manager: this.queryRunner.manager,
                         entity: entity,
@@ -224,6 +256,10 @@ export class Broadcaster {
      * 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.
+     * @param result
+     * @param metadata
+     * @param entity
+     * @param identifier
      */
     broadcastAfterInsertEvent(result, metadata, entity, identifier) {
         if (entity && metadata.afterInsertListeners.length) {
@@ -236,12 +272,13 @@ export class Broadcaster {
                 }
             });
         }
-        if (this.queryRunner.connection.subscribers.length) {
-            this.queryRunner.connection.subscribers.forEach((subscriber) => {
+        if (this.queryRunner.dataSource.subscribers.length) {
+            this.queryRunner.dataSource.subscribers.forEach((subscriber) => {
                 if (this.isAllowedSubscriber(subscriber, metadata.target) &&
                     subscriber.afterInsert) {
                     const executionResult = subscriber.afterInsert({
-                        connection: this.queryRunner.connection,
+                        dataSource: this.queryRunner.dataSource,
+                        connection: this.queryRunner.dataSource,
                         queryRunner: this.queryRunner,
                         manager: this.queryRunner.manager,
                         entity: entity,
@@ -257,13 +294,17 @@ export class Broadcaster {
     }
     /**
      * Broadcasts "BEFORE_QUERY" event.
+     * @param result
+     * @param query
+     * @param parameters
      */
     broadcastBeforeQueryEvent(result, query, parameters) {
-        if (this.queryRunner.connection.subscribers.length) {
-            this.queryRunner.connection.subscribers.forEach((subscriber) => {
+        if (this.queryRunner.dataSource.subscribers.length) {
+            this.queryRunner.dataSource.subscribers.forEach((subscriber) => {
                 if (subscriber.beforeQuery) {
                     const executionResult = subscriber.beforeQuery({
-                        connection: this.queryRunner.connection,
+                        dataSource: this.queryRunner.dataSource,
+                        connection: this.queryRunner.dataSource,
                         queryRunner: this.queryRunner,
                         manager: this.queryRunner.manager,
                         query: query,
@@ -278,13 +319,21 @@ export class Broadcaster {
     }
     /**
      * Broadcasts "AFTER_QUERY" event.
+     * @param result
+     * @param query
+     * @param parameters
+     * @param success
+     * @param executionTime
+     * @param rawResults
+     * @param error
      */
     broadcastAfterQueryEvent(result, query, parameters, success, executionTime, rawResults, error) {
-        if (this.queryRunner.connection.subscribers.length) {
-            this.queryRunner.connection.subscribers.forEach((subscriber) => {
+        if (this.queryRunner.dataSource.subscribers.length) {
+            this.queryRunner.dataSource.subscribers.forEach((subscriber) => {
                 if (subscriber.afterQuery) {
                     const executionResult = subscriber.afterQuery({
-                        connection: this.queryRunner.connection,
+                        dataSource: this.queryRunner.dataSource,
+                        connection: this.queryRunner.dataSource,
                         queryRunner: this.queryRunner,
                         manager: this.queryRunner.manager,
                         query: query,
@@ -303,13 +352,15 @@ export class Broadcaster {
     }
     /**
      * Broadcasts "BEFORE_TRANSACTION_START" event.
+     * @param result
      */
     broadcastBeforeTransactionStartEvent(result) {
-        if (this.queryRunner.connection.subscribers.length) {
-            this.queryRunner.connection.subscribers.forEach((subscriber) => {
+        if (this.queryRunner.dataSource.subscribers.length) {
+            this.queryRunner.dataSource.subscribers.forEach((subscriber) => {
                 if (subscriber.beforeTransactionStart) {
                     const executionResult = subscriber.beforeTransactionStart({
-                        connection: this.queryRunner.connection,
+                        dataSource: this.queryRunner.dataSource,
+                        connection: this.queryRunner.dataSource,
                         queryRunner: this.queryRunner,
                         manager: this.queryRunner.manager,
                     });
@@ -322,13 +373,15 @@ export class Broadcaster {
     }
     /**
      * Broadcasts "AFTER_TRANSACTION_START" event.
+     * @param result
      */
     broadcastAfterTransactionStartEvent(result) {
-        if (this.queryRunner.connection.subscribers.length) {
-            this.queryRunner.connection.subscribers.forEach((subscriber) => {
+        if (this.queryRunner.dataSource.subscribers.length) {
+            this.queryRunner.dataSource.subscribers.forEach((subscriber) => {
                 if (subscriber.afterTransactionStart) {
                     const executionResult = subscriber.afterTransactionStart({
-                        connection: this.queryRunner.connection,
+                        dataSource: this.queryRunner.dataSource,
+                        connection: this.queryRunner.dataSource,
                         queryRunner: this.queryRunner,
                         manager: this.queryRunner.manager,
                     });
@@ -341,13 +394,15 @@ export class Broadcaster {
     }
     /**
      * Broadcasts "BEFORE_TRANSACTION_COMMIT" event.
+     * @param result
      */
     broadcastBeforeTransactionCommitEvent(result) {
-        if (this.queryRunner.connection.subscribers.length) {
-            this.queryRunner.connection.subscribers.forEach((subscriber) => {
+        if (this.queryRunner.dataSource.subscribers.length) {
+            this.queryRunner.dataSource.subscribers.forEach((subscriber) => {
                 if (subscriber.beforeTransactionCommit) {
                     const executionResult = subscriber.beforeTransactionCommit({
-                        connection: this.queryRunner.connection,
+                        dataSource: this.queryRunner.dataSource,
+                        connection: this.queryRunner.dataSource,
                         queryRunner: this.queryRunner,
                         manager: this.queryRunner.manager,
                     });
@@ -360,13 +415,15 @@ export class Broadcaster {
     }
     /**
      * Broadcasts "AFTER_TRANSACTION_COMMIT" event.
+     * @param result
      */
     broadcastAfterTransactionCommitEvent(result) {
-        if (this.queryRunner.connection.subscribers.length) {
-            this.queryRunner.connection.subscribers.forEach((subscriber) => {
+        if (this.queryRunner.dataSource.subscribers.length) {
+            this.queryRunner.dataSource.subscribers.forEach((subscriber) => {
                 if (subscriber.afterTransactionCommit) {
                     const executionResult = subscriber.afterTransactionCommit({
-                        connection: this.queryRunner.connection,
+                        dataSource: this.queryRunner.dataSource,
+                        connection: this.queryRunner.dataSource,
                         queryRunner: this.queryRunner,
                         manager: this.queryRunner.manager,
                     });
@@ -379,13 +436,15 @@ export class Broadcaster {
     }
     /**
      * Broadcasts "BEFORE_TRANSACTION_ROLLBACK" event.
+     * @param result
      */
     broadcastBeforeTransactionRollbackEvent(result) {
-        if (this.queryRunner.connection.subscribers.length) {
-            this.queryRunner.connection.subscribers.forEach((subscriber) => {
+        if (this.queryRunner.dataSource.subscribers.length) {
+            this.queryRunner.dataSource.subscribers.forEach((subscriber) => {
                 if (subscriber.beforeTransactionRollback) {
                     const executionResult = subscriber.beforeTransactionRollback({
-                        connection: this.queryRunner.connection,
+                        dataSource: this.queryRunner.dataSource,
+                        connection: this.queryRunner.dataSource,
                         queryRunner: this.queryRunner,
                         manager: this.queryRunner.manager,
                     });
@@ -398,13 +457,15 @@ export class Broadcaster {
     }
     /**
      * Broadcasts "AFTER_TRANSACTION_ROLLBACK" event.
+     * @param result
      */
     broadcastAfterTransactionRollbackEvent(result) {
-        if (this.queryRunner.connection.subscribers.length) {
-            this.queryRunner.connection.subscribers.forEach((subscriber) => {
+        if (this.queryRunner.dataSource.subscribers.length) {
+            this.queryRunner.dataSource.subscribers.forEach((subscriber) => {
                 if (subscriber.afterTransactionRollback) {
                     const executionResult = subscriber.afterTransactionRollback({
-                        connection: this.queryRunner.connection,
+                        dataSource: this.queryRunner.dataSource,
+                        connection: this.queryRunner.dataSource,
                         queryRunner: this.queryRunner,
                         manager: this.queryRunner.manager,
                     });
@@ -422,6 +483,12 @@ export class Broadcaster {
      * 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.
+     * @param result
+     * @param metadata
+     * @param entity
+     * @param databaseEntity
+     * @param updatedColumns
+     * @param updatedRelations
      */
     broadcastAfterUpdateEvent(result, metadata, entity, databaseEntity, updatedColumns, updatedRelations) {
         if (entity && metadata.afterUpdateListeners.length) {
@@ -434,12 +501,13 @@ export class Broadcaster {
                 }
             });
         }
-        if (this.queryRunner.connection.subscribers.length) {
-            this.queryRunner.connection.subscribers.forEach((subscriber) => {
+        if (this.queryRunner.dataSource.subscribers.length) {
+            this.queryRunner.dataSource.subscribers.forEach((subscriber) => {
                 if (this.isAllowedSubscriber(subscriber, metadata.target) &&
                     subscriber.afterUpdate) {
                     const executionResult = subscriber.afterUpdate({
-                        connection: this.queryRunner.connection,
+                        dataSource: this.queryRunner.dataSource,
+                        connection: this.queryRunner.dataSource,
                         queryRunner: this.queryRunner,
                         manager: this.queryRunner.manager,
                         entity: entity,
@@ -462,6 +530,11 @@ export class Broadcaster {
      * 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.
+     * @param result
+     * @param metadata
+     * @param entity
+     * @param databaseEntity
+     * @param identifier
      */
     broadcastAfterRemoveEvent(result, metadata, entity, databaseEntity, identifier) {
         if (entity && metadata.afterRemoveListeners.length) {
@@ -474,12 +547,13 @@ export class Broadcaster {
                 }
             });
         }
-        if (this.queryRunner.connection.subscribers.length) {
-            this.queryRunner.connection.subscribers.forEach((subscriber) => {
+        if (this.queryRunner.dataSource.subscribers.length) {
+            this.queryRunner.dataSource.subscribers.forEach((subscriber) => {
                 if (this.isAllowedSubscriber(subscriber, metadata.target) &&
                     subscriber.afterRemove) {
                     const executionResult = subscriber.afterRemove({
-                        connection: this.queryRunner.connection,
+                        dataSource: this.queryRunner.dataSource,
+                        connection: this.queryRunner.dataSource,
                         queryRunner: this.queryRunner,
                         manager: this.queryRunner.manager,
                         entity: entity,
@@ -501,6 +575,11 @@ export class Broadcaster {
      * 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.
+     * @param result
+     * @param metadata
+     * @param entity
+     * @param databaseEntity
+     * @param identifier
      */
     broadcastAfterSoftRemoveEvent(result, metadata, entity, databaseEntity, identifier) {
         if (entity && metadata.afterSoftRemoveListeners.length) {
@@ -513,12 +592,13 @@ export class Broadcaster {
                 }
             });
         }
-        if (this.queryRunner.connection.subscribers.length) {
-            this.queryRunner.connection.subscribers.forEach((subscriber) => {
+        if (this.queryRunner.dataSource.subscribers.length) {
+            this.queryRunner.dataSource.subscribers.forEach((subscriber) => {
                 if (this.isAllowedSubscriber(subscriber, metadata.target) &&
                     subscriber.afterSoftRemove) {
                     const executionResult = subscriber.afterSoftRemove({
-                        connection: this.queryRunner.connection,
+                        dataSource: this.queryRunner.dataSource,
+                        connection: this.queryRunner.dataSource,
                         queryRunner: this.queryRunner,
                         manager: this.queryRunner.manager,
                         entity: entity,
@@ -540,6 +620,11 @@ export class Broadcaster {
      * 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.
+     * @param result
+     * @param metadata
+     * @param entity
+     * @param databaseEntity
+     * @param identifier
      */
     broadcastAfterRecoverEvent(result, metadata, entity, databaseEntity, identifier) {
         if (entity && metadata.afterRecoverListeners.length) {
@@ -552,12 +637,13 @@ export class Broadcaster {
                 }
             });
         }
-        if (this.queryRunner.connection.subscribers.length) {
-            this.queryRunner.connection.subscribers.forEach((subscriber) => {
+        if (this.queryRunner.dataSource.subscribers.length) {
+            this.queryRunner.dataSource.subscribers.forEach((subscriber) => {
                 if (this.isAllowedSubscriber(subscriber, metadata.target) &&
                     subscriber.afterRecover) {
                     const executionResult = subscriber.afterRecover({
-                        connection: this.queryRunner.connection,
+                        dataSource: this.queryRunner.dataSource,
+                        connection: this.queryRunner.dataSource,
                         queryRunner: this.queryRunner,
                         manager: this.queryRunner.manager,
                         entity: entity,
@@ -572,12 +658,6 @@ export class Broadcaster {
             });
         }
     }
-    /**
-     * @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.
@@ -585,10 +665,13 @@ export class Broadcaster {
      * 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.
+     * @param result
+     * @param metadata
+     * @param entities
      */
     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) &&
+        const fittingSubscribers = this.queryRunner.dataSource.subscribers.filter((subscriber) => this.isAllowedSubscriber(subscriber, metadata.target) &&
             subscriber.afterLoad);
         if (metadata.relations.length ||
             metadata.afterLoadListeners.length ||
@@ -604,7 +687,7 @@ export class Broadcaster {
                             !entity.hasOwnProperty(relation.propertyName))
                             return;
                         const value = relation.getEntityValue(entity);
-                        if (ObjectUtils.isObject(value))
+                        if (ObjectUtils_1.ObjectUtils.isObject(value))
                             this.broadcastLoadEvent(result, relation.inverseEntityMetadata, Array.isArray(value) ? value : [value]);
                     });
                 });
@@ -624,11 +707,12 @@ export class Broadcaster {
             fittingSubscribers.forEach((subscriber) => {
                 nonPromiseEntities.forEach((entity) => {
                     const executionResult = subscriber.afterLoad(entity, {
-                        entity,
-                        metadata,
-                        connection: this.queryRunner.connection,
+                        dataSource: this.queryRunner.dataSource,
+                        connection: this.queryRunner.dataSource,
                         queryRunner: this.queryRunner,
                         manager: this.queryRunner.manager,
+                        entity,
+                        metadata,
                     });
                     if (executionResult instanceof Promise)
                         result.promises.push(executionResult);
@@ -643,6 +727,8 @@ export class Broadcaster {
     /**
      * Checks if subscriber's methods can be executed by checking if its don't listen to the particular entity,
      * or listens our entity.
+     * @param subscriber
+     * @param target
      */
     isAllowedSubscriber(subscriber, target) {
         return (!subscriber.listenTo ||
@@ -652,5 +738,5 @@ export class Broadcaster {
             subscriber.listenTo().isPrototypeOf(target));
     }
 }
-
-//# sourceMappingURL=Broadcaster.js.map
+exports.Broadcaster = Broadcaster;
+//# sourceMappingURL=Broadcaster.js.map