increase ioc

Author: hirsch88

src/api/listeners/UserCreatedListener.ts

@@ -0,0 +1,15 @@
+import { events } from '../../core/api/events';
+import { Log } from '../../core/log/';
+
+const log = new Log('api:listeners:UserCreated');
+
+
+export class UserCreatedListener {
+
+    static Event = Symbol('UserCreated');
+
+    public async run(user: any): Promise<void> {
+        log.info('Receive event UserCreated', user);
+    }
+
+}

src/api/models/User.ts

@@ -1,3 +1,4 @@
+import { injectable } from 'inversify';
 import { Bookshelf } from '../../config/Database';
 import { Tables } from '../../constants/Tables';
 
@@ -8,6 +9,7 @@ import { Tables } from '../../constants/Tables';
  * @class User
  * @extends {Bookshelf.Model<User>}
  */
+@injectable()
 export class User extends Bookshelf.Model<User> {
 
     public static async fetchById(id: number): Promise<User> {

src/api/repositories/UserRepository.ts

@@ -1,4 +1,7 @@
 import * as Bookshelf from 'bookshelf';
+import { injectable, inject, named } from 'inversify';
+import { Types } from '../../constants/Types';
+import { Model } from '../../constants/Targets';
 import { User } from '../models/User';
 import { DatabaseException } from '../exceptions/DatabaseException';
 import { NotFoundException } from '../exceptions/NotFoundException';
@@ -9,8 +12,13 @@ import { NotFoundException } from '../exceptions/NotFoundException';
  * @export
  * @class UserRepository
  */
+@injectable()
 export class UserRepository {
 
+    constructor(
+        @inject(Types.Model) @named(Model.User) public UserModel: typeof User
+    ) { }
+
     /**
      * Retrieves all user data out of the database
      *
@@ -19,8 +27,8 @@ export class UserRepository {
      *
      * @memberof UserRepository
      */
-    public static async findAll(): Promise<Bookshelf.Collection<User>> {
-        const users = await User.fetchAll();
+    public async findAll(): Promise<Bookshelf.Collection<User>> {
+        const users = await this.UserModel.fetchAll();
         return <Bookshelf.Collection<User>>users;
     }
 
@@ -31,8 +39,8 @@ export class UserRepository {
      * @param {number} id of the user
      * @returns {Promise<User>}
      */
-    public static async findOne(id: number): Promise<User> {
-        return User.fetchById(id);
+    public async findOne(id: number): Promise<User> {
+        return this.UserModel.fetchById(id);
     }
 
     /**
@@ -42,8 +50,8 @@ export class UserRepository {
      * @param {number} id of the user
      * @returns {Promise<User>}
      */
-    public static async findByUserId(userId: string): Promise<User> {
-        return User.fetchByUserId(userId);
+    public async findByUserId(userId: string): Promise<User> {
+        return this.UserModel.fetchByUserId(userId);
     }
 
     /**
@@ -54,11 +62,11 @@ export class UserRepository {
      * @param {*} data is the new user
      * @returns {Promise<User>}
      */
-    public static async create(data: any): Promise<User> {
-        const user = User.forge<User>(data);
+    public async create(data: any): Promise<User> {
+        const user = this.UserModel.forge<User>(data);
         try {
             const createdUser = await user.save();
-            return await User.fetchById(createdUser.id);
+            return await this.UserModel.fetchById(createdUser.id);
         } catch (error) {
             throw new DatabaseException('Could not create the user!', error);
         }
@@ -72,11 +80,11 @@ export class UserRepository {
      * @param {*} data
      * @returns {Promise<User>}
      */
-    public static async update(id: number, data: any): Promise<User> {
-        const user = User.forge<User>({ id: id });
+    public async update(id: number, data: any): Promise<User> {
+        const user = this.UserModel.forge<User>({ id: id });
         try {
             const updatedUser = await user.save(data, { patch: true });
-            return await User.fetchById(updatedUser.id);
+            return await this.UserModel.fetchById(updatedUser.id);
 
         } catch (error) {
             throw new DatabaseException('Could not update the user!', error);
@@ -91,8 +99,8 @@ export class UserRepository {
      * @param {number} id
      * @returns {Promise<void>}
      */
-    public static async destroy(id: number): Promise<void> {
-        let user = User.forge<User>({ id: id });
+    public async destroy(id: number): Promise<void> {
+        let user = this.UserModel.forge<User>({ id: id });
         try {
             user = await user.fetch({ require: true });
         } catch (error) {

src/api/services/UsersService.ts

@@ -1,16 +1,17 @@
 import * as Bookshelf from 'bookshelf';
 import { injectable, inject, named } from 'inversify';
-import { Repository } from '../../constants/Targets';
+import { Core, Repository } from '../../constants/Targets';
 import { Types } from '../../constants/Types';
 import { Log } from '../../core/log';
+import { EventEmitter } from '../../core/api/events';
 import { Validate, Request } from '../../core/api/Validate';
 import { NotFoundException } from '../exceptions/NotFoundException';
 import { UserCreateRequest } from '../requests/UserCreateRequest';
 import { UserUpdateRequest } from '../requests/UserUpdateRequest';
 import { UserRepository } from '../repositories/UserRepository';
 import { User } from '../models/User';
+import { UserCreatedListener } from '../listeners/UserCreatedListener';
 
-const log = new Log('api:services:UserService');
 
 /**
  * UserService
@@ -19,15 +20,21 @@ const log = new Log('api:services:UserService');
  * database actions. Furthermore you should throw events here if
  * necessary.
  *
- * @export0'
+ * @export
  * @class UserService
  */
 @injectable()
 export class UserService {
 
+    public log: Log;
+
     constructor(
-        @inject(Types.Repository) @named(Repository.UserRepository) public userRepo: typeof UserRepository
-    ) { }
+        @inject(Types.Repository) @named(Repository.UserRepository) public userRepo: UserRepository,
+        @inject(Types.Core) @named(Core.Log) public Logger: typeof Log,
+        @inject(Types.Core) @named(Core.Events) public events: EventEmitter
+    ) {
+        this.log = new Logger('api:services:UserService');
+    }
 
     /**
      * This returns all user database objects
@@ -45,7 +52,7 @@ export class UserService {
     public async findOne(id: number): Promise<User> {
         const user = await this.userRepo.findOne(id);
         if (user === null) {
-            log.warn(`User with the id=${id} was not found!`);
+            this.log.warn(`User with the id=${id} was not found!`);
             throw new NotFoundException(id);
         }
         return user;
@@ -60,7 +67,7 @@ export class UserService {
     public async findByUserId(userId: string): Promise<User> {
         const user = await this.userRepo.findByUserId(userId);
         if (user === null) {
-            log.warn(`User with the userId=${userId} was not found!`);
+            this.log.warn(`User with the userId=${userId} was not found!`);
             throw new NotFoundException(userId);
         }
         return user;
@@ -77,6 +84,7 @@ export class UserService {
     public async create( @Request(UserCreateRequest) data: any): Promise<User> {
         // If the request body was valid we will create the user
         const user = await this.userRepo.create(data);
+        this.events.emit(UserCreatedListener.Event, user.toJSON());
         return user;
     }
 

src/constants/Targets.ts

@@ -6,6 +6,15 @@
  * our controllers, services and repositories
  */
 
+export const Lib = {
+    Request: 'Request'
+};
+
+export const Core = {
+    Events: 'Events',
+    Log: 'Log'
+};
+
 export const Controller = {
     UserController: 'UserController'
 };
@@ -14,6 +23,14 @@ export const Service = {
     UserService: 'UserService'
 };
 
+export const Model = {
+    User: 'User'
+};
+
 export const Repository = {
     UserRepository: 'UserRepository'
 };
+
+export const Middleware = {
+    AuthenticateMiddleware: 'AuthenticateMiddleware'
+};

src/constants/Types.ts

@@ -10,10 +10,12 @@ import { TYPE } from 'inversify-express-utils';
 
 
 const myType = {
-    // UserService: Symbol('UserService'),
-    // UserRepository: Symbol('UserRepository'),
+    Lib: Symbol('Lib'),
+    Core: Symbol('Core'),
+    Model: Symbol('Model'),
     Service: Symbol('Service'),
-    Repository: Symbol('Repository')
+    Repository: Symbol('Repository'),
+    Middleware: Symbol('Middleware')
 };
 
 export const Types = Object.assign(TYPE, myType);

src/container.ts

@@ -9,17 +9,33 @@
 import { interfaces } from 'inversify-express-utils';
 import { Container } from 'inversify';
 import { Types } from './constants/Types';
-import { Controller, Service, Repository } from './constants/Targets';
+import { Core, Model, Controller, Service, Repository } from './constants/Targets';
+
+/**
+ * Core Features
+ */
+import { events, EventEmitter } from './core/api/events';
+import { Log } from './core/log';
 
 /**
  * User Resource
  */
 import { UserController } from './api/controllers/UserController';
 import { UserService } from './api/services/UsersService';
 import { UserRepository } from './api/repositories/UserRepository';
+import { User } from './api/models/User';
+
 
 const container = new Container();
 
+container.bind<EventEmitter>(Types.Core).toConstantValue(events).whenTargetNamed(Core.Events);
+container.bind<typeof Log>(Types.Core).toConstantValue(Log).whenTargetNamed(Core.Log);
+
+/**
+ * Model
+ */
+container.bind<any>(Types.Model).toConstantValue(User).whenTargetNamed(Model.User);
+
 /**
  * Controllers
  */
@@ -33,7 +49,7 @@ container.bind<UserService>(Types.Service).to(UserService).whenTargetNamed(Servi
 /**
  * Repositories
  */
-container.bind<UserRepository>(Types.Repository).toConstantValue(UserRepository).whenTargetNamed(Repository.UserRepository);
+container.bind<UserRepository>(Types.Repository).to(UserRepository).whenTargetNamed(Repository.UserRepository);
 
 
 export default container;

src/core/Bootstrap.ts

@@ -9,13 +9,15 @@
  * small monitor app.
  */
 
+import * as fs from 'fs';
 import * as express from 'express';
 import * as monitor from 'express-status-monitor';
 import { Container } from 'inversify';
 import { InversifyExpressServer } from 'inversify-express-utils';
 import { Environment } from './Environment';
 import { my } from 'my-express';
 import { exceptionHandler, extendExpressResponse } from './api';
+import { events } from './api/events';
 import { Log } from './log';
 
 const log = new Log('core:Bootstrap');
@@ -155,6 +157,27 @@ export class Bootstrap {
         return app;
     }
 
+    /**
+     * Sets up the event listeners and registers them.
+     *
+     * @static
+     *
+     * @memberof Bootstrap
+     */
+    static setupEventListeners(): void {
+        const baseFolder = __dirname.indexOf('/src/') >= 0 ? '/src/' : '/dist/';
+        const basePath = __dirname.substring(0, __dirname.indexOf(baseFolder));
+        const path = `${basePath}${baseFolder}api/listeners`;
+        fs.readdir(path, (err: any, items: string[]): void => {
+            for (let i = 0; i < items.length; i++) {
+                const name = items[i].substring(0, items[i].length - 3);
+                const Listener = require(`${path}/${items[i]}`)[name];
+                const listener = new Listener();
+                events.on(Listener.Event, (...args) => listener.run(...args));
+            }
+        });
+    }
+
     /**
      * Well this method just normalizes the given port :-)
      *

src/core/Server.ts

@@ -43,7 +43,7 @@ export class Server {
      */
     static onStartUp(app: express.Application): void {
         log.info(``);
-        log.info(`Aloha, your app is ready on ${app.get('host')}:${app.get('port')}`);
+        log.info(`Aloha, your app is ready on ${app.get('host')}:${app.get('port')}${process.env.APP_URL_PREFIX}`);
         log.info(`To shut it down, press <CTRL> + C at any time.`);
         log.info(``);
         log.debug('-------------------------------------------------------');

src/core/api/events.ts

@@ -0,0 +1,11 @@
+/**
+ * core.api.events
+ * -----------------------------------
+ *
+ * TODO
+ */
+
+import { EventEmitter } from 'events';
+export { EventEmitter } from 'events';
+
+export const events = new EventEmitter();