feat(): Error Handeling

Author: scott-wyatt

lib/Core.ts

@@ -399,29 +399,48 @@ export const Core = {
     app: FabrixApp,
     spools: Spool[]
   ) {
+    // TODO, eliminate waiting on lifecycle events that will not exist
+    // https://github.com/fabrix-app/fabrix/issues/14
     const validatedEvents = spools.map(spool => `spool:${spool.name}:validated`)
     const configuredEvents = spools.map(spool => `spool:${spool.name}:configured`)
     const initializedEvents = spools.map(spool => `spool:${spool.name}:initialized`)
     const sanityEvents = spools.map(spool => `spool:${spool.name}:sane`)
 
-    app.after(configuredEvents).then(async () => {
-      await this.createDefaultPaths(app)
-      app.emit('spool:all:configured')
-    })
+    app.after(configuredEvents)
+      .then(async () => {
+        await this.createDefaultPaths(app)
+        app.emit('spool:all:configured')
+      })
+      .catch(err => {
+        app.log.error(err)
+        throw err
+      })
 
     app.after(validatedEvents)
       .then(() => app.emit('spool:all:validated'))
+      .catch(err => {
+        app.log.error(err)
+        throw err
+      })
 
     app.after(initializedEvents)
       .then(() => {
         app.emit('spool:all:initialized')
       })
+      .catch(err => {
+        app.log.error(err)
+        throw err
+      })
 
     app.after(sanityEvents)
       .then(() => {
         app.emit('spool:all:sane')
         app.emit('fabrix:ready')
       })
+      .catch(err => {
+        app.log.error(err)
+        throw err
+      })
   },
 
   /**
@@ -440,39 +459,41 @@ export const Core = {
       .then(() => spool.sanity())
       .then(() => app.emit(`spool:${spool.name}:sane`))
       .then(() => spool.stage = 'sane')
-      .catch(this.handlePromiseRejection)
+      .catch(err => this.handlePromiseRejection(app, err))
 
     app.after((lifecycle.initialize.listen).concat('spool:all:configured'))
       .then(() => app.log.debug('spool: initializing', spool.name))
       .then(() => spool.stage = 'initializing')
       .then(() => spool.initialize())
       .then(() => app.emit(`spool:${spool.name}:initialized`))
       .then(() => spool.stage = 'initialized')
-      .catch(this.handlePromiseRejection)
+      .catch(err => this.handlePromiseRejection(app, err))
 
     app.after((lifecycle.configure.listen).concat('spool:all:validated'))
       .then(() => app.log.debug('spool: configuring', spool.name))
       .then(() => spool.stage = 'configuring')
       .then(() => spool.configure())
       .then(() => app.emit(`spool:${spool.name}:configured`))
       .then(() => spool.stage = 'configured')
-      .catch(this.handlePromiseRejection)
+      .catch(err => this.handlePromiseRejection(app, err))
 
     app.after('fabrix:start')
       .then(() => app.log.debug('spool: validating', spool.name))
       .then(() => spool.stage = 'validating')
       .then(() => spool.validate())
       .then(() => app.emit(`spool:${spool.name}:validated`))
       .then(() => spool.stage = 'validated')
-      .catch(this.handlePromiseRejection)
+      .catch(err => this.handlePromiseRejection(app, err))
   },
 
   /**
    * Handle a promise rejection
    */
-  handlePromiseRejection (err: Error): void {
-    console.error(err)
+  handlePromiseRejection (app: FabrixApp, err: Error): void {
+    app.log.error(err)
     throw err
+
+    return
   }
 
 }

lib/common/Controller.ts

@@ -8,13 +8,13 @@ import { FabrixGeneric } from './Generic'
  * Fabrix Controller Class.
  */
 export class FabrixController extends FabrixGeneric {
-  public app: FabrixApp
 
   constructor (app: FabrixApp) {
+    super(app)
+
     if (!(app instanceof EventEmitter)) {
       throw new Error('The "app" argument must be of type EventEmitter')
     }
-    super(app)
     this.app.emit(`controller:${this.id}:constructed`, this)
   }
 

lib/common/Generic.ts

@@ -1,3 +1,4 @@
+import { EventEmitter } from 'events'
 import { FabrixApp } from '../index'
 
 export interface FabrixGeneric {
@@ -9,9 +10,16 @@ export interface FabrixGeneric {
  * Fabrix Generic Class.
  */
 export class FabrixGeneric {
-  public app: FabrixApp
   public methods: string[] = []
-  constructor (app: FabrixApp) {
+
+  constructor (
+    public app: FabrixApp
+  ) {
+
+    if (!(app instanceof EventEmitter)) {
+      throw new Error('The "app" argument must be of type EventEmitter')
+    }
+
     Object.defineProperties(this, {
       app: {
         value: app,

lib/common/Model.ts

@@ -22,7 +22,6 @@ import { FabrixGeneric } from './Generic'
  * Fabrix Model Class.
  */
 export class FabrixModel extends FabrixGeneric {
-  public app: FabrixApp
   private _datastore: any
   private _instance: any
   private _config: {[key: string]: any}
@@ -72,11 +71,12 @@ export class FabrixModel extends FabrixGeneric {
    * Construct the model and bind the Resolver
    */
   constructor (app: FabrixApp, datastore?) {
+    super(app)
+
     if (!(app instanceof EventEmitter)) {
       throw new Error('The "app" argument must be of type EventEmitter')
     }
 
-    super(app)
 
     this._datastore = datastore
 

lib/common/Policy.ts

@@ -9,8 +9,6 @@ import { FabrixGeneric } from './Generic'
  * Fabrix Policy Class.
  */
 export class FabrixPolicy extends FabrixGeneric {
-  public app: FabrixApp
-
 
   /**
    * Policy configuration

lib/common/Service.ts

@@ -10,12 +10,16 @@ import { FabrixGeneric } from './Generic'
  */
 export class FabrixService extends FabrixGeneric {
 
-  constructor (app: FabrixApp) {
+  constructor (
+    app: FabrixApp
+  ) {
+
     super(app)
 
     if (!(app instanceof EventEmitter)) {
       throw new Error('The "app" argument must be of type EventEmitter')
     }
+
     this.app.emit(`service:${this.id}:constructed`, this)
   }
 

lib/common/Spool.ts

@@ -14,7 +14,6 @@ export interface Spool {
   [key: string]: any
 }
 export class Spool extends FabrixGeneric {
-  public app: FabrixApp
   private _stage = 'pre'
   private _config: ISpoolConfig
   private _pkg: any // IPkg
@@ -92,7 +91,7 @@ export class Spool extends FabrixGeneric {
       pkg = null,
       config = { },
       api = { }
-    }: { pkg?: any, config?: ISpoolConfig, api?: IApi }
+    }: { pkg?: {[key: string]: any}, config?: ISpoolConfig, api?: IApi }
   ) {
     super(app)
     if (!(app instanceof EventEmitter)) {

lib/tsconfig.json

@@ -9,6 +9,8 @@
     "moduleResolution": "node",
     "declaration": true,
     "strict": false,
+    "esModuleInterop": false,
+    "sourceMap": true,
     "noImplicitAny": false,
     "typeRoots": [
       "node_modules/@types"