refactored orm-prefixed classes

docs/decorators-reference.md

@@ -16,7 +16,7 @@
     * [@ManyToMany](#many-to-many)
     * [@ManyToManyInverse](#many-to-many-inverse)
 * Subscriber and Listener Decorators
-    * [@OrmEventSubscriber](#orm-event-subscriber)
+    * [@EventSubscriber](#event-subscriber)
     * [@AfterLoad](#after-load)
     * [@BeforeInsert](#before-insert)
     * [@AfterInsert](#after-insert)
@@ -132,12 +132,12 @@ entity1 and entity2 ids. This is inverse side of the relationship.
 
 ### Subscriber and Listener Decorators
 
-#### @OrmEventSubscriber
+#### @EventSubscriber
 
-`@OrmEventSubscriber()`
+`@EventSubscriber()`
 
 Classes decorated with this decorator will listen to ORM events and their methods will be triggered when event
-occurs. Those classes must implement OrmSubscriber interface.
+occurs. Those classes must implement EventSubscriberInterface.
 
 #### @AfterLoad
 

docs/subscribers-and-entity-listeners.md

@@ -7,17 +7,14 @@ You can listen to events in the ORM. There two concepts you can use:
 
 ### Subscribers
 
-First you need to create a new subscriber class and implement `OrmSubscriber` interface:
+First you need to create a new subscriber class and implement `EventSubscriberInterface` interface:
 
 ```typescript
-import {OrmEventSubscriber} from "typeorm/decorator/listeners"
-import {OrmSubscriber} from "typeorm/subscriber/OrmSubscriber";
-import {UpdateEvent} from "typeorm/subscriber/event/UpdateEvent";
-import {RemoveEvent} from "typeorm/subscriber/event/RemoveEvent";
-import {InsertEvent} from "typeorm/subscriber/event/InsertEvent";
+import {EventSubscriber, UpdateEvent, RemoveEvent, InsertEvent} from "typeorm/decorator/listeners"
+import {EventSubscriberInterface} from "typeorm/subscriber/EventSubscriberInterface";
 
-@OrmEventSubscriber()
-export class MySubscriber implements OrmSubscriber<any> {
+@EventSubscriber()
+export class MySubscriber implements EventSubscriberInterface<any> {
 
     /**
      * Called after entity insertion.

sample/sample5-subscribers/subscriber/EverythingSubscriber.ts

@@ -1,11 +1,11 @@
-import {OrmEventSubscriber} from "../../../src/decorator/listeners/OrmEventSubscriber";
-import {OrmSubscriber} from "../../../src/subscriber/OrmSubscriber";
+import {EventSubscriber} from "../../../src/decorator/listeners/EventSubscriber";
+import {EventSubscriberInterface} from "../../../src/subscriber/EventSubscriberInterface";
 import {InsertEvent} from "../../../src/subscriber/event/InsertEvent";
 import {RemoveEvent} from "../../../src/subscriber/event/RemoveEvent";
 import {UpdateEvent} from "../../../src/subscriber/event/UpdateEvent";
 
-@OrmEventSubscriber()
-export class EverythingSubscriber implements OrmSubscriber<any> {
+@EventSubscriber()
+export class EverythingSubscriber implements EventSubscriberInterface<any> {
     
     /**
      * Called after entity insertion.

src/connection/Connection.ts

@@ -1,7 +1,7 @@
 import {Driver} from "../driver/Driver";
 import {ConnectionOptions} from "./ConnectionOptions";
 import {Repository} from "../repository/Repository";
-import {OrmSubscriber} from "../subscriber/OrmSubscriber";
+import {EventSubscriberInterface} from "../subscriber/EventSubscriberInterface";
 import {RepositoryNotFoundError} from "./error/RepositoryNotFoundError";
 import {EntityMetadata} from "../metadata-builder/metadata/EntityMetadata";
 import {SchemaCreator} from "../schema-creator/SchemaCreator";
@@ -25,7 +25,7 @@ export class Connection {
     private _driver: Driver;
     private _entityMetadatas: EntityMetadata[] = [];
     private _entityListenerMetadatas: EntityListenerMetadata[] = [];
-    private _subscribers: OrmSubscriber<any>[] = [];
+    private _subscribers: EventSubscriberInterface<any>[] = [];
     private repositoryAndMetadatas: RepositoryAndMetadata[] = [];
     private _options: ConnectionOptions;
     private entityManager: EntityManager;
@@ -63,7 +63,7 @@ export class Connection {
     /**
      * All subscribers that are registered for this connection.
      */
-    get subscribers(): OrmSubscriber<any>[] {
+    get subscribers(): EventSubscriberInterface<any>[] {
         return this._subscribers;
     }
 
@@ -167,7 +167,7 @@ export class Connection {
     /**
      * Registers subscribers for the current connection.
      */
-    addSubscribers(subscribers: OrmSubscriber<any>[]): Connection {
+    addSubscribers(subscribers: EventSubscriberInterface<any>[]): Connection {
         this._subscribers = this._subscribers.concat(subscribers);
         return this;
     }

src/connection/ConnectionManager.ts

@@ -149,7 +149,7 @@ export class ConnectionManager {
         }
 
         const subscribers = defaultMetadataStorage
-            .findOrmEventSubscribersForClasses(subscriberClasses)
+            .findEventSubscribersForClasses(subscriberClasses)
             .map(metadata => this.createContainerInstance(metadata.target));
 
         this.getConnection(connectionName).addSubscribers(subscribers);

src/decorator/Listeners.ts

@@ -1,4 +1,4 @@
-export * from "./listeners/OrmEventSubscriber";
+export * from "./listeners/EventSubscriber";
 export * from "./listeners/AfterInsert";
 export * from "./listeners/BeforeInsert";
 export * from "./listeners/AfterUpdate";

src/decorator/listeners/EventSubscriber.ts

@@ -0,0 +1,12 @@
+import {defaultMetadataStorage} from "../../metadata-builder/MetadataStorage";
+import {EventSubscriberMetadata} from "../../metadata-builder/metadata/EventSubscriberMetadata";
+
+/**
+ * Classes decorated with this decorator will listen to ORM events and their methods will be triggered when event
+ * occurs. Those classes must implement EventSubscriberInterface interface.
+ */
+export function EventSubscriber() {
+    return function (target: Function) {
+        defaultMetadataStorage.addEventSubscriberMetadata(new EventSubscriberMetadata(target));
+    };
+}

src/decorator/listeners/OrmEventSubscriber.ts

@@ -1,12 +0,0 @@
-import {defaultMetadataStorage} from "../../metadata-builder/MetadataStorage";
-import {OrmEventSubscriberMetadata} from "../../metadata-builder/metadata/OrmEventSubscriberMetadata";
-
-/**
- * Classes decorated with this decorator will listen to ORM events and their methods will be triggered when event
- * occurs. Those classes must implement OrmSubscriber interface.
- */
-export function OrmEventSubscriber() {
-    return function (target: Function) {
-        defaultMetadataStorage.addOrmEventSubscriberMetadata(new OrmEventSubscriberMetadata(target));
-    };
-}

src/metadata-builder/MetadataStorage.ts

@@ -5,7 +5,7 @@ import {RelationMetadata} from "./metadata/RelationMetadata";
 import {IndexMetadata} from "./metadata/IndexMetadata";
 import {CompoundIndexMetadata} from "./metadata/CompoundIndexMetadata";
 import {ColumnMetadata} from "./metadata/ColumnMetadata";
-import {OrmEventSubscriberMetadata} from "./metadata/OrmEventSubscriberMetadata";
+import {EventSubscriberMetadata} from "./metadata/EventSubscriberMetadata";
 import {EntityListenerMetadata} from "./metadata/EntityListenerMetadata";
 
 /**
@@ -19,7 +19,7 @@ export class MetadataStorage {
     // -------------------------------------------------------------------------
 
     private _tableMetadatas: TableMetadata[] = [];
-    private _ormEventSubscriberMetadatas: OrmEventSubscriberMetadata[] = [];
+    private _eventSubscriberMetadatas: EventSubscriberMetadata[] = [];
     private _columnMetadatas: ColumnMetadata[] = [];
     private _indexMetadatas: IndexMetadata[] = [];
     private _entityListenerMetadatas: EntityListenerMetadata[] = [];
@@ -34,8 +34,8 @@ export class MetadataStorage {
         return this._tableMetadatas;
     }
 
-    get ormEventSubscriberMetadatas(): OrmEventSubscriberMetadata[] {
-        return this._ormEventSubscriberMetadatas;
+    get eventSubscriberMetadatas(): EventSubscriberMetadata[] {
+        return this._eventSubscriberMetadatas;
     }
 
     get columnMetadatas(): ColumnMetadata[] {
@@ -92,11 +92,11 @@ export class MetadataStorage {
         this.columnMetadatas.push(metadata);
     }
 
-    addOrmEventSubscriberMetadata(metadata: OrmEventSubscriberMetadata) {
-        if (this.hasOrmEventSubscriberWithObjectConstructor(metadata.target))
-            throw new MetadataAlreadyExistsError("OrmEventSubscriber", metadata.target);
+    addEventSubscriberMetadata(metadata: EventSubscriberMetadata) {
+        if (this.hasEventSubscriberWithObjectConstructor(metadata.target))
+            throw new MetadataAlreadyExistsError("EventSubscriber", metadata.target);
 
-        this.ormEventSubscriberMetadatas.push(metadata);
+        this.eventSubscriberMetadatas.push(metadata);
     }
 
     addIndexMetadata(metadata: IndexMetadata) {
@@ -127,8 +127,8 @@ export class MetadataStorage {
     // Public Methods
     // -------------------------------------------------------------------------
 
-    findOrmEventSubscribersForClasses(classes: Function[]): OrmEventSubscriberMetadata[] { 
-        return this.ormEventSubscriberMetadatas.filter(metadata => classes.indexOf(metadata.target) !== -1);
+    findEventSubscribersForClasses(classes: Function[]): EventSubscriberMetadata[] { 
+        return this.eventSubscriberMetadatas.filter(metadata => classes.indexOf(metadata.target) !== -1);
     }
 
     findEntityListenersForClasses(classes: Function[]): EntityListenerMetadata[] { 
@@ -171,8 +171,8 @@ export class MetadataStorage {
         return !!this.compoundIndexMetadatas.find(metadata => metadata.target === constructor);
     }
 
-    private hasOrmEventSubscriberWithObjectConstructor(constructor: Function): boolean {
-        return !!this.ormEventSubscriberMetadatas.find(metadata => metadata.target === constructor);
+    private hasEventSubscriberWithObjectConstructor(constructor: Function): boolean {
+        return !!this.eventSubscriberMetadatas.find(metadata => metadata.target === constructor);
     }
 
     private hasFieldMetadataOnProperty(constructor: Function, propertyName: string): boolean {

src/metadata-builder/metadata/EventSubscriberMetadata.ts

@@ -1,7 +1,7 @@
 /**
  * Contains metadata information about ORM event subscribers.
  */
-export class OrmEventSubscriberMetadata {
+export class EventSubscriberMetadata {
 
     // ---------------------------------------------------------------------
     // Private Properties

src/persistment/PersistOperationExecutor.ts

@@ -6,7 +6,7 @@ import {JunctionInsertOperation} from "./operation/JunctionInsertOperation";
 import {InsertOperation} from "./operation/InsertOperation";
 import {JunctionRemoveOperation} from "./operation/JunctionRemoveOperation";
 import {UpdateByRelationOperation} from "./operation/UpdateByRelationOperation";
-import {OrmBroadcaster} from "../subscriber/OrmBroadcaster";
+import {Broadcaster} from "../subscriber/Broadcaster";
 
 /**
  * Executes PersistOperation in the given connection.
@@ -28,7 +28,7 @@ export class PersistOperationExecutor {
      * Executes given persist operation.
      */
     executePersistOperation(persistOperation: PersistOperation) {
-        const broadcaster = new OrmBroadcaster(this.connection);
+        const broadcaster = new Broadcaster(this.connection);
         
         return Promise.resolve()
             .then(() => this.broadcastBeforeEvents(broadcaster, persistOperation))
@@ -53,7 +53,7 @@ export class PersistOperationExecutor {
     /**
      * Broadcast all before persistment events - beforeInsert, beforeUpdate and beforeRemove events.
      */
-    private broadcastBeforeEvents(broadcaster: OrmBroadcaster, persistOperation: PersistOperation) {
+    private broadcastBeforeEvents(broadcaster: Broadcaster, persistOperation: PersistOperation) {
         
         const insertEvents = persistOperation.inserts.map(insertOperation => {
             const persistedEntityWithId = persistOperation.allPersistedEntities.find(e => e.entity === insertOperation.entity);
@@ -77,7 +77,7 @@ export class PersistOperationExecutor {
     /**
      * Broadcast all after persistment events - afterInsert, afterUpdate and afterRemove events.
      */
-    private broadcastAfterEvents(broadcaster: OrmBroadcaster, persistOperation: PersistOperation) {
+    private broadcastAfterEvents(broadcaster: Broadcaster, persistOperation: PersistOperation) {
         
         const insertEvents = persistOperation.inserts.map(insertOperation => {
             const persistedEntity = persistOperation.allPersistedEntities.find(e => e.entity === insertOperation.entity);

src/query-builder/QueryBuilder.ts

@@ -2,7 +2,7 @@ import {Alias} from "./alias/Alias";
 import {AliasMap} from "./alias/AliasMap";
 import {Connection} from "../connection/Connection";
 import {RawSqlResultsToEntityTransformer} from "./transformer/RawSqlResultsToEntityTransformer";
-import {OrmBroadcaster} from "../subscriber/OrmBroadcaster";
+import {Broadcaster} from "../subscriber/Broadcaster";
 
 export interface Join {
     alias: Alias;
@@ -17,7 +17,7 @@ export class QueryBuilder<Entity> {
     // Private properties
     // -------------------------------------------------------------------------
 
-    private broadcaster: OrmBroadcaster;
+    private broadcaster: Broadcaster;
     private _aliasMap: AliasMap;
     private type: "select"|"update"|"delete";
     private selects: string[] = [];
@@ -42,7 +42,7 @@ export class QueryBuilder<Entity> {
 
     constructor(private connection: Connection) {
         this._aliasMap = new AliasMap(connection.entityMetadatas);
-        this.broadcaster = new OrmBroadcaster(connection);
+        this.broadcaster = new Broadcaster(connection);
     }
 
     // -------------------------------------------------------------------------

src/subscriber/Broadcaster.ts

@@ -1,4 +1,4 @@
-import {OrmSubscriber} from "./OrmSubscriber";
+import {EventSubscriberInterface} from "./EventSubscriberInterface";
 import {Connection} from "../connection/Connection";
 import {ColumnMetadata} from "../metadata-builder/metadata/ColumnMetadata";
 import {EventListenerTypes} from "../metadata-builder/types/EventListenerTypes";
@@ -6,7 +6,7 @@ import {EventListenerTypes} from "../metadata-builder/types/EventListenerTypes";
 /**
  * Broadcaster provides a helper methods to broadcast events to the subscribers.
  */
-export class OrmBroadcaster {
+export class Broadcaster {
 
     // -------------------------------------------------------------------------
     // Constructor
@@ -154,7 +154,7 @@ export class OrmBroadcaster {
     // Private Methods
     // -------------------------------------------------------------------------
 
-    private isAllowedSubscribers(subscriber: OrmSubscriber<any>, cls: Function) {
+    private isAllowedSubscribers(subscriber: EventSubscriberInterface<any>, cls: Function) {
         return  !subscriber.listenTo ||
                 !subscriber.listenTo() ||
                 subscriber.listenTo() === Object ||

src/subscriber/EventSubscriberInterface.ts

@@ -5,7 +5,7 @@ import {InsertEvent} from "./event/InsertEvent";
 /**
  * Classes that implement this interface are subscribers that subscribe for the specific events of the ORM.
  */
-export interface OrmSubscriber<Entity> {
+export interface EventSubscriberInterface<Entity> {
 
     /**
      * Returns the class of the entity to which events will listen.