typeorm 0.2.38-dev.324f1d8

package/schema-builder/view/View.d.ts

@@ -0,0 +1,36 @@
+import { Connection, Driver, EntityMetadata, SelectQueryBuilder } from "../..";
+import { ViewOptions } from "../options/ViewOptions";
+/**
+ * View in the database represented in this class.
+ */
+export declare class View {
+    /**
+     * Database name that this view resides in if it applies.
+     */
+    database?: string;
+    /**
+     * Schema name that this view resides in if it applies.
+     */
+    schema?: string;
+    /**
+     * View name
+     */
+    name: string;
+    /**
+     * Indicates if view is materialized.
+     */
+    materialized: boolean;
+    /**
+     * View definition.
+     */
+    expression: string | ((connection: Connection) => SelectQueryBuilder<any>);
+    constructor(options?: ViewOptions);
+    /**
+     * Clones this table to a new table with all properties cloned.
+     */
+    clone(): View;
+    /**
+     * Creates view from a given entity metadata.
+     */
+    static create(entityMetadata: EntityMetadata, driver: Driver): View;
+}

package/schema-builder/view/View.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.View = void 0;
+/**
+ * View in the database represented in this class.
+ */
+var View = /** @class */ (function () {
+    // -------------------------------------------------------------------------
+    // Constructor
+    // -------------------------------------------------------------------------
+    function View(options) {
+        if (options) {
+            this.database = options.database;
+            this.schema = options.schema;
+            this.name = options.name;
+            this.expression = options.expression;
+            this.materialized = !!options.materialized;
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Public Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Clones this table to a new table with all properties cloned.
+     */
+    View.prototype.clone = function () {
+        return new View({
+            database: this.database,
+            schema: this.schema,
+            name: this.name,
+            expression: this.expression,
+            materialized: this.materialized,
+        });
+    };
+    // -------------------------------------------------------------------------
+    // Static Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Creates view from a given entity metadata.
+     */
+    View.create = function (entityMetadata, driver) {
+        var options = {
+            database: entityMetadata.database,
+            schema: entityMetadata.schema,
+            name: driver.buildTableName(entityMetadata.tableName, entityMetadata.schema, entityMetadata.database),
+            expression: entityMetadata.expression,
+            materialized: entityMetadata.tableMetadataArgs.materialized
+        };
+        return new View(options);
+    };
+    return View;
+}());
+exports.View = View;
+
+//# sourceMappingURL=View.js.map

package/schema-builder/view/View.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/schema-builder/view/View.ts"],"names":[],"mappings":";;;AAGA;;GAEG;AACH;IAgCI,4EAA4E;IAC5E,cAAc;IACd,4EAA4E;IAE5E,cAAY,OAAqB;QAC7B,IAAI,OAAO,EAAE;YACT,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;YACjC,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;YAC7B,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;YACzB,IAAI,CAAC,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;YACrC,IAAI,CAAC,YAAY,GAAG,CAAC,CAAC,OAAO,CAAC,YAAY,CAAC;SAC9C;IACL,CAAC;IAED,4EAA4E;IAC5E,iBAAiB;IACjB,4EAA4E;IAE5E;;OAEG;IACH,oBAAK,GAAL;QACI,OAAO,IAAI,IAAI,CAAc;YACzB,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,YAAY,EAAE,IAAI,CAAC,YAAY;SAClC,CAAC,CAAC;IACP,CAAC;IAED,4EAA4E;IAC5E,iBAAiB;IACjB,4EAA4E;IAE5E;;OAEG;IACI,WAAM,GAAb,UAAc,cAA8B,EAAE,MAAc;QACxD,IAAM,OAAO,GAAgB;YACzB,QAAQ,EAAE,cAAc,CAAC,QAAQ;YACjC,MAAM,EAAE,cAAc,CAAC,MAAM;YAC7B,IAAI,EAAE,MAAM,CAAC,cAAc,CAAC,cAAc,CAAC,SAAS,EAAE,cAAc,CAAC,MAAM,EAAE,cAAc,CAAC,QAAQ,CAAC;YACrG,UAAU,EAAE,cAAc,CAAC,UAAW;YACtC,YAAY,EAAE,cAAc,CAAC,iBAAiB,CAAC,YAAY;SAC9D,CAAC;QAEF,OAAO,IAAI,IAAI,CAAC,OAAO,CAAC,CAAC;IAC7B,CAAC;IAEL,WAAC;AAAD,CAlFA,AAkFC,IAAA;AAlFY,oBAAI","file":"View.js","sourcesContent":["import {Connection, Driver, EntityMetadata, SelectQueryBuilder} from \"../..\";\nimport {ViewOptions} from \"../options/ViewOptions\";\n\n/**\n * View in the database represented in this class.\n */\nexport class View {\n\n    // -------------------------------------------------------------------------\n    // Public Properties\n    // -------------------------------------------------------------------------\n\n    /**\n     * Database name that this view resides in if it applies.\n     */\n    database?: string;\n\n    /**\n     * Schema name that this view resides in if it applies.\n     */\n    schema?: string;\n\n    /**\n     * View name\n     */\n    name: string;\n\n\n    /**\n     * Indicates if view is materialized.\n     */\n    materialized: boolean;\n\n    /**\n     * View definition.\n     */\n    expression: string | ((connection: Connection) => SelectQueryBuilder<any>);\n\n    // -------------------------------------------------------------------------\n    // Constructor\n    // -------------------------------------------------------------------------\n\n    constructor(options?: ViewOptions) {\n        if (options) {\n            this.database = options.database;\n            this.schema = options.schema;\n            this.name = options.name;\n            this.expression = options.expression;\n            this.materialized = !!options.materialized;\n        }\n    }\n\n    // -------------------------------------------------------------------------\n    // Public Methods\n    // -------------------------------------------------------------------------\n\n    /**\n     * Clones this table to a new table with all properties cloned.\n     */\n    clone(): View {\n        return new View(<ViewOptions>{\n            database: this.database,\n            schema: this.schema,\n            name: this.name,\n            expression: this.expression,\n            materialized: this.materialized,\n        });\n    }\n\n    // -------------------------------------------------------------------------\n    // Static Methods\n    // -------------------------------------------------------------------------\n\n    /**\n     * Creates view from a given entity metadata.\n     */\n    static create(entityMetadata: EntityMetadata, driver: Driver): View {\n        const options: ViewOptions = {\n            database: entityMetadata.database,\n            schema: entityMetadata.schema,\n            name: driver.buildTableName(entityMetadata.tableName, entityMetadata.schema, entityMetadata.database),\n            expression: entityMetadata.expression!,\n            materialized: entityMetadata.tableMetadataArgs.materialized\n        };\n\n        return new View(options);\n    }\n\n}\n"],"sourceRoot":"../.."}

package/subscriber/Broadcaster.d.ts

@@ -0,0 +1,106 @@
+import { EntitySubscriberInterface } from "./EntitySubscriberInterface";
+import { ObjectLiteral } from "../common/ObjectLiteral";
+import { QueryRunner } from "../query-runner/QueryRunner";
+import { EntityMetadata } from "../metadata/EntityMetadata";
+import { BroadcasterResult } from "./BroadcasterResult";
+import { ColumnMetadata } from "../metadata/ColumnMetadata";
+import { RelationMetadata } from "../metadata/RelationMetadata";
+/**
+ * Broadcaster provides a helper methods to broadcast events to the subscribers.
+ */
+export declare class Broadcaster {
+    private queryRunner;
+    constructor(queryRunner: QueryRunner);
+    /**
+     * Broadcasts "BEFORE_INSERT" event.
+     * Before insert event is executed before entity is being inserted to the database for the first time.
+     * 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.
+     */
+    broadcastBeforeInsertEvent(result: BroadcasterResult, metadata: EntityMetadata, entity?: ObjectLiteral): void;
+    /**
+     * Broadcasts "BEFORE_UPDATE" event.
+     * Before update event is executed before entity is being updated 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.
+     */
+    broadcastBeforeUpdateEvent(result: BroadcasterResult, metadata: EntityMetadata, entity?: ObjectLiteral, databaseEntity?: ObjectLiteral, updatedColumns?: ColumnMetadata[], updatedRelations?: RelationMetadata[]): void;
+    /**
+     * Broadcasts "BEFORE_REMOVE" event.
+     * Before remove event is executed before entity is being 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.
+     */
+    broadcastBeforeRemoveEvent(result: BroadcasterResult, metadata: EntityMetadata, entity?: ObjectLiteral, databaseEntity?: ObjectLiteral): void;
+    /**
+     * Broadcasts "AFTER_INSERT" event.
+     * After insert event is executed after entity is being persisted to the database for the first time.
+     * 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.
+     */
+    broadcastAfterInsertEvent(result: BroadcasterResult, metadata: EntityMetadata, entity?: ObjectLiteral): void;
+    /**
+     * Broadcasts "BEFORE_TRANSACTION_START" event.
+     */
+    broadcastBeforeTransactionStartEvent(result: BroadcasterResult): void;
+    /**
+     * Broadcasts "AFTER_TRANSACTION_START" event.
+     */
+    broadcastAfterTransactionStartEvent(result: BroadcasterResult): void;
+    /**
+     * Broadcasts "BEFORE_TRANSACTION_COMMIT" event.
+     */
+    broadcastBeforeTransactionCommitEvent(result: BroadcasterResult): void;
+    /**
+     * Broadcasts "AFTER_TRANSACTION_COMMIT" event.
+     */
+    broadcastAfterTransactionCommitEvent(result: BroadcasterResult): void;
+    /**
+     * Broadcasts "BEFORE_TRANSACTION_ROLLBACK" event.
+     */
+    broadcastBeforeTransactionRollbackEvent(result: BroadcasterResult): void;
+    /**
+     * Broadcasts "AFTER_TRANSACTION_ROLLBACK" event.
+     */
+    broadcastAfterTransactionRollbackEvent(result: BroadcasterResult): void;
+    /**
+     * Broadcasts "AFTER_UPDATE" event.
+     * After update event is executed after entity is being updated 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.
+     */
+    broadcastAfterUpdateEvent(result: BroadcasterResult, metadata: EntityMetadata, entity?: ObjectLiteral, databaseEntity?: ObjectLiteral, updatedColumns?: ColumnMetadata[], updatedRelations?: RelationMetadata[]): void;
+    /**
+     * Broadcasts "AFTER_REMOVE" event.
+     * After remove event is executed after entity is being 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.
+     */
+    broadcastAfterRemoveEvent(result: BroadcasterResult, metadata: EntityMetadata, entity?: ObjectLiteral, databaseEntity?: ObjectLiteral): void;
+    /**
+     * 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.
+     * 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.
+     */
+    broadcastLoadEventsForAll(result: BroadcasterResult, metadata: EntityMetadata, entities: ObjectLiteral[]): void;
+    /**
+     * Checks if subscriber's methods can be executed by checking if its don't listen to the particular entity,
+     * or listens our entity.
+     */
+    protected isAllowedSubscriber(subscriber: EntitySubscriberInterface<any>, target: Function | string): boolean;
+}

package/subscriber/Broadcaster.js

@@ -0,0 +1,439 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Broadcaster = void 0;
+/**
+ * Broadcaster provides a helper methods to broadcast events to the subscribers.
+ */
+var Broadcaster = /** @class */ (function () {
+    // -------------------------------------------------------------------------
+    // Constructor
+    // -------------------------------------------------------------------------
+    function Broadcaster(queryRunner) {
+        this.queryRunner = queryRunner;
+    }
+    // -------------------------------------------------------------------------
+    // Public Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Broadcasts "BEFORE_INSERT" event.
+     * Before insert event is executed before entity is being inserted to the database for the first time.
+     * 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.
+     */
+    Broadcaster.prototype.broadcastBeforeInsertEvent = function (result, metadata, entity) {
+        var _this = this;
+        if (entity && metadata.beforeInsertListeners.length) {
+            metadata.beforeInsertListeners.forEach(function (listener) {
+                if (listener.isAllowed(entity)) {
+                    var 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.beforeInsert) {
+                    var executionResult = subscriber.beforeInsert({
+                        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++;
+                }
+            });
+        }
+    };
+    /**
+     * Broadcasts "BEFORE_UPDATE" event.
+     * Before update event is executed before entity is being updated 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.
+     */
+    Broadcaster.prototype.broadcastBeforeUpdateEvent = function (result, metadata, entity, databaseEntity, updatedColumns, updatedRelations) {
+        var _this = this;
+        if (entity && metadata.beforeUpdateListeners.length) {
+            metadata.beforeUpdateListeners.forEach(function (listener) {
+                if (listener.isAllowed(entity)) {
+                    var 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.beforeUpdate) {
+                    var executionResult = subscriber.beforeUpdate({
+                        connection: _this.queryRunner.connection,
+                        queryRunner: _this.queryRunner,
+                        manager: _this.queryRunner.manager,
+                        entity: entity,
+                        metadata: metadata,
+                        databaseEntity: databaseEntity,
+                        updatedColumns: updatedColumns || [],
+                        updatedRelations: updatedRelations || []
+                    });
+                    if (executionResult instanceof Promise)
+                        result.promises.push(executionResult);
+                    result.count++;
+                }
+            });
+        }
+    };
+    /**
+     * Broadcasts "BEFORE_REMOVE" event.
+     * Before remove event is executed before entity is being 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.
+     */
+    Broadcaster.prototype.broadcastBeforeRemoveEvent = function (result, metadata, entity, databaseEntity) {
+        var _this = this;
+        if (entity && metadata.beforeRemoveListeners.length) {
+            metadata.beforeRemoveListeners.forEach(function (listener) {
+                if (listener.isAllowed(entity)) {
+                    var 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.beforeRemove) {
+                    var 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 "AFTER_INSERT" event.
+     * After insert event is executed after entity is being persisted to the database for the first time.
+     * 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.
+     */
+    Broadcaster.prototype.broadcastAfterInsertEvent = function (result, metadata, entity) {
+        var _this = this;
+        if (entity && metadata.afterInsertListeners.length) {
+            metadata.afterInsertListeners.forEach(function (listener) {
+                if (listener.isAllowed(entity)) {
+                    var 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.afterInsert) {
+                    var executionResult = subscriber.afterInsert({
+                        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++;
+                }
+            });
+        }
+    };
+    /**
+     * Broadcasts "BEFORE_TRANSACTION_START" event.
+     */
+    Broadcaster.prototype.broadcastBeforeTransactionStartEvent = function (result) {
+        var _this = this;
+        if (this.queryRunner.connection.subscribers.length) {
+            this.queryRunner.connection.subscribers.forEach(function (subscriber) {
+                if (subscriber.beforeTransactionStart) {
+                    var 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.
+     */
+    Broadcaster.prototype.broadcastAfterTransactionStartEvent = function (result) {
+        var _this = this;
+        if (this.queryRunner.connection.subscribers.length) {
+            this.queryRunner.connection.subscribers.forEach(function (subscriber) {
+                if (subscriber.afterTransactionStart) {
+                    var 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.
+     */
+    Broadcaster.prototype.broadcastBeforeTransactionCommitEvent = function (result) {
+        var _this = this;
+        if (this.queryRunner.connection.subscribers.length) {
+            this.queryRunner.connection.subscribers.forEach(function (subscriber) {
+                if (subscriber.beforeTransactionCommit) {
+                    var 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.
+     */
+    Broadcaster.prototype.broadcastAfterTransactionCommitEvent = function (result) {
+        var _this = this;
+        if (this.queryRunner.connection.subscribers.length) {
+            this.queryRunner.connection.subscribers.forEach(function (subscriber) {
+                if (subscriber.afterTransactionCommit) {
+                    var executionResult = subscriber.afterTransactionCommit({
+                        connection: _this.queryRunner.connection,
+                        queryRunner: _this.queryRunner,
+                        manager: _this.queryRunner.manager,
+                    });
+                    if (executionResult instanceof Promise)
+                        result.promises.push(executionResult);
+                    result.count++;
+                }
+            });
+        }
+    };
+    /**
+     * Broadcasts "BEFORE_TRANSACTION_ROLLBACK" event.
+     */
+    Broadcaster.prototype.broadcastBeforeTransactionRollbackEvent = function (result) {
+        var _this = this;
+        if (this.queryRunner.connection.subscribers.length) {
+            this.queryRunner.connection.subscribers.forEach(function (subscriber) {
+                if (subscriber.beforeTransactionRollback) {
+                    var 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.
+     */
+    Broadcaster.prototype.broadcastAfterTransactionRollbackEvent = function (result) {
+        var _this = this;
+        if (this.queryRunner.connection.subscribers.length) {
+            this.queryRunner.connection.subscribers.forEach(function (subscriber) {
+                if (subscriber.afterTransactionRollback) {
+                    var 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.
+     * 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.
+     */
+    Broadcaster.prototype.broadcastAfterUpdateEvent = function (result, metadata, entity, databaseEntity, updatedColumns, updatedRelations) {
+        var _this = this;
+        if (entity && metadata.afterUpdateListeners.length) {
+            metadata.afterUpdateListeners.forEach(function (listener) {
+                if (listener.isAllowed(entity)) {
+                    var 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.afterUpdate) {
+                    var executionResult = subscriber.afterUpdate({
+                        connection: _this.queryRunner.connection,
+                        queryRunner: _this.queryRunner,
+                        manager: _this.queryRunner.manager,
+                        entity: entity,
+                        metadata: metadata,
+                        databaseEntity: databaseEntity,
+                        updatedColumns: updatedColumns || [],
+                        updatedRelations: updatedRelations || []
+                    });
+                    if (executionResult instanceof Promise)
+                        result.promises.push(executionResult);
+                    result.count++;
+                }
+            });
+        }
+    };
+    /**
+     * Broadcasts "AFTER_REMOVE" event.
+     * After remove event is executed after entity is being 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.
+     */
+    Broadcaster.prototype.broadcastAfterRemoveEvent = function (result, metadata, entity, databaseEntity) {
+        var _this = this;
+        if (entity && metadata.afterRemoveListeners.length) {
+            metadata.afterRemoveListeners.forEach(function (listener) {
+                if (listener.isAllowed(entity)) {
+                    var 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.afterRemove) {
+                    var 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_LOAD" event for all given entities, and their sub-entities.
+     * After load event is executed after entity has been loaded 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.
+     */
+    Broadcaster.prototype.broadcastLoadEventsForAll = function (result, metadata, entities) {
+        var _this = this;
+        entities.forEach(function (entity) {
+            if (entity instanceof Promise) // todo: check why need this?
+                return;
+            // 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, 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++;
+                    }
+                });
+            }
+            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++;
+                    }
+                });
+            }
+        });
+    };
+    // -------------------------------------------------------------------------
+    // Protected Methods
+    // -------------------------------------------------------------------------
+    /**
+     * 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 ||
+            !subscriber.listenTo() ||
+            subscriber.listenTo() === Object ||
+            subscriber.listenTo() === target ||
+            subscriber.listenTo().isPrototypeOf(target);
+    };
+    return Broadcaster;
+}());
+exports.Broadcaster = Broadcaster;
+
+//# sourceMappingURL=Broadcaster.js.map