@superhero/core 4.0.0-beta.6 → 4.0.0-beta.8

package/README.md

@@ -44,10 +44,9 @@ await core.bootstrap()
 
 // Locate a service
 const myService = core.locate('myService')
-console.log(myService)
 
 // Graceful shutdown
-await core.destruct()
+await core.destroy()
 ```
 
 ### Clustering Example
@@ -66,8 +65,8 @@ await core.add('./path/to/config.js')
 // Bootstrap core
 await core.bootstrap()
 
-// Destruct core when done
-await core.destruct()
+// Destroy core when done
+await core.destroy()
 ```
 
 ---
@@ -157,7 +156,7 @@ new Core(branch: string = undefined)
 - **`cluster(forks: number, branch?: number, version?: number): Promise<number>`**  
   Start clustering with the specified number of workers.
 
-- **`destruct(): Promise<void>`**  
+- **`destroy(): Promise<void>`**  
   Gracefully shutdown the core, its workers, and services.
 
 #### Properties

package/index.js

@@ -5,6 +5,7 @@ import path         from 'node:path'
 import bootstrap    from '@superhero/bootstrap'
 import Config       from '@superhero/config'
 import Locate       from '@superhero/locator'
+import Log          from '@superhero/log'
 
 export default class Core
 {
@@ -19,7 +20,7 @@ export default class Core
     this.branch   = branch
     this.basePath = this.locate.pathResolver.basePath // synchronize the base path.
     this.locate.set('@superhero/config', this.config)
-    Core.#setupDestructor(this)
+    Core.#setupDestroyer(this)
   }
 
   #branch
@@ -31,7 +32,7 @@ export default class Core
   {
     get: (target, prop, receiver) =>
     {
-      // when pushing events to the eventlog, also send the events to all workers
+      // when pushing events to the eventlog, also sync the event to all workers
       if('push' === prop) return (...events) => 
       {
         setImmediate(() => 
@@ -48,79 +49,84 @@ export default class Core
     }
   })
 
+  // An exposed log instance taht the core instance uses that is open for modification.
+  static log = new Log({ label: process.env.CORE_CLUSTER_WORKER ? `[CORE:${process.env.CORE_CLUSTER_WORKER}]` : '[CORE]' })
+
   // Used for graceful termination, if multiple cores are instanciated.
   static #cores = new Map
 
   // Used to prevent multiple observers on the process events.
-  static #destructorIsSetup = false
+  static #destroyerIsSetup = false
 
-  // Used to prevent multiple destruct calls.
-  static #destructorIsTriggered = false
+  // Used to prevent multiple destroy calls.
+  static #destroyerIsTriggered = false
 
-  static #setupDestructor(core)
+  static #setupDestroyer(core)
   {
     Core.#cores.set(core, core)
 
-    if(false === Core.#destructorIsSetup)
+    if(false === Core.#destroyerIsSetup)
     {
-      Core.#destructorIsSetup = true
+      Core.#destroyerIsSetup = true
 
-      process.on('SIGINT',  (signal) => Core.#destructor(signal))
-      process.on('SIGTERM', (signal) => Core.#destructor(signal))
+      process.on('SIGINT',  (signal) => Core.#destroy(signal))
+      process.on('SIGTERM', (signal) => Core.#destroy(signal))
 
-      process.on('unhandledRejection', (reason) => Core.#destructor(false, reason))
-      process.on('uncaughtException',  (error)  => Core.#destructor(false, error))
+      process.on('unhandledRejection', (reason) => Core.#destroy(false, reason))
+      process.on('uncaughtException',  (error)  => Core.#destroy(false, error))
     }
   }
 
   /**
-   * Attempts to destruct all core instances gracefully.
+   * Attempts to destroy all core instances gracefully.
    */
-  static async #destructor(signal, reason)
+  static async #destroy(signal, reason)
   {
-    if(Core.#destructorIsTriggered)
+    if(Core.#destroyerIsTriggered)
     {
       Core.log.info`redundant shutdown signal ${signal} waiting for previous shutdown process to finalize…`
-      reason && Core.log.error(reason)
+      reason && Core.log.fail`${reason}`
       return
     }
 
-    Core.#destructorIsTriggered = true
+    Core.#destroyerIsTriggered = true
 
-    signal && Core.log.info`${signal} ⇢ graceful shutdown initiated…`
+    signal
+    ? Core.log.info`graceful shutdown initiated ${signal}`
+    : Core.log.info`graceful shutdown initiated`
 
     const
-      destructCores   = [],
-      destructRejects = []
+      destroyedCores = [],
+      destroyRejects = []
 
     for(const core of Core.#cores.values())
     {
-      destructCores.push((async () => 
+      destroyedCores.push((async () => 
       {
         try
         {
-          await core.destruct()
+          await core.destroy()
         }
         catch(error)
         {
-          destructRejects.push(error)
+          destroyRejects.push(error)
         }
       })())
     }
 
-    await Promise.all(destructCores)
+    await Promise.all(destroyedCores)
 
-    if(destructRejects.length)
+    if(destroyRejects.length)
     {
       const error = new Error('Failed to shutdown gracefully')
-      error.code  = 'E_CORE_DESTRUCT_GRACEFUL'
-      error.cause = destructRejects
-      Core.log.error(error)
+      error.code  = 'E_CORE_DESTROY_GRACEFUL'
+      error.cause = destroyRejects
+      Core.log.fail`${error}`
       setImmediate(() => process.exit(1))
     }
     else if(reason)
     {
-      Core.log.error(reason)
+      Core.log.fail`${reason}`
       setImmediate(() => process.exit(1))
     }
     else
@@ -129,25 +135,25 @@ export default class Core
     }
   }
 
-  async destruct()
+  async destroy()
   {
     // First remove the core instance from the static core registry 
-    // to prevent multiple destruct calls.
+    // to prevent multiple destroy calls.
     Core.#cores.delete(this)
 
-    // Then destruct the core workers, if clustered, using a timeout.
+    // Then destroy the core workers, if clustered, using a timeout.
     const
-      timeout         = this.config.find('core/destruct/timeout', 15e3),
-      timeoutError    = new Error(`Failed to destruct core within ${(timeout/1e3).toFixed(1)}s`),
-      destructTimeout = (ctx) => new Promise((_, reject) => ctx.id = setTimeout(() => reject(timeoutError), timeout)),
-      destructWorkers = [],
-      destructRejects = []
+      timeout          = this.config.find('core/destroy/timeout', 15e3),
+      timeoutError     = new Error(`Failed to destroy core within ${(timeout/1e3).toFixed(1)}s`),
+      destroyTimeout   = (ctx) => new Promise((_, reject) => ctx.id = setTimeout(() => reject(timeoutError), timeout)),
+      destroyedWorkers = [],
+      destroyRejects   = []
 
-    timeoutError.code = 'E_CORE_DESTRUCT_TIMEOUT'
+    timeoutError.code = 'E_CORE_DESTROY_TIMEOUT'
 
     for(const id in this.#workers)
     {
-      destructWorkers.push((async () => 
+      destroyedWorkers.push((async () => 
       {
         // Attempt to kill the worker.
         this.#workers[id].kill()
@@ -158,42 +164,42 @@ export default class Core
 
     try
     {
-      if(destructWorkers.length)
+      if(destroyedWorkers.length)
       {
         const timeout = {}
-        await Promise.race([ destructTimeout(timeout), Promise.all(destructWorkers) ])
+        await Promise.race([ destroyTimeout(timeout), Promise.all(destroyedWorkers) ])
         clearTimeout(timeout.id)
       }
     }
     catch(reason)
     {
-      const error = new Error(`Failed to destruct workers`)
-      error.code  = 'E_CORE_DESTRUCT_WORKERS'
+      const error = new Error(`Failed to destroy workers`)
+      error.code  = 'E_CORE_DESTROY_WORKERS'
       error.cause = reason
-      destructRejects.push(error)
+      destroyRejects.push(error)
     }
 
-    // Then destruct the core locator and all loaded services, restricted by a 
+    // Then destroy the core locator and all loaded services, restricted by a 
     // timeout if it takes to long.
     try
     {
       const timeout = {}
-      await Promise.race([ destructTimeout(timeout), this.locate.destruct() ])
+      await Promise.race([ destroyTimeout(timeout), this.locate.destroy() ])
       clearTimeout(timeout.id)
     }
     catch(reason)
     {
-      const error = new Error(`Failed to destruct locator`)
-      error.code  = 'E_CORE_DESTRUCT_LOCATOR'
+      const error = new Error(`Failed to destroy locator`)
+      error.code  = 'E_CORE_DESTROY_LOCATOR'
       error.cause = reason
-      destructRejects.push(error)
+      destroyRejects.push(error)
     }
 
-    if(destructRejects.length)
+    if(destroyRejects.length)
     {
-      const error = new Error(`Failed to destruct core gracefully`)
-      error.code  = 'E_CORE_DESTRUCT'
-      error.cause = destructRejects
+      const error = new Error(`Failed to destroy core gracefully`)
+      error.code  = 'E_CORE_DESTROY'
+      error.cause = destroyRejects
       throw error
     }
   }
@@ -329,7 +335,7 @@ export default class Core
       this.#workers[forkId].once('exit', this.#reloadWorker.bind(this, forkId, forkBranch, forkVersion))
       this.#workers[forkId].sync = this.#createSynchoronizer(forkId)
 
-      Core.log.info`clustered ${'CORE:' + forkId}`
+      Core.log.info`${'CORE:' + forkId} ⇡ clustered`
 
       try
       {
@@ -342,6 +348,8 @@ export default class Core
         error.cause = reason
         throw error
       }
+
+      Core.log.info`synchronized ${'CORE:' + forkId}`
     }
 
     return branch + forks
@@ -377,7 +385,7 @@ export default class Core
             
             if('string' === typeof absolutePath)
             {
-              serviceMap[entry] = path.normalize(absolutePath + '/' + servicePath)
+              serviceMap[entry] = path.normalize(path.join(absolutePath, servicePath))
             }
           }
         }
@@ -634,7 +642,7 @@ export default class Core
 
         if('string' === typeof absolutePath)
         {
-          dependencies[i] = path.normalize(absolutePath + '/' + dependency)
+          dependencies[i] = path.normalize(path.join(absolutePath, dependency))
         }
       }
     }
@@ -734,22 +742,4 @@ export default class Core
       throw error
     }
   }
-
-  // Will make the log methods availible to overwrite 
-  // if a custom logging is desired.
-  static log =
-  {
-    label   : process.env.CORE_CLUSTER_WORKER
-            ? `[CORE:${process.env.CORE_CLUSTER_WORKER}]`
-            : '[CORE]',
-    icon    : ' ⇢ ',
-    basic   : (template, ...args) => template.reduce((result, part, i) => result + args[i - 1] + part),
-    simple  : (template, ...args) => this.log.label + this.log.icon + this.log.basic(template, ...args),
-    colors  : (template, ...args) => '\x1b[90m' + this.log.supress`${this.log.label + this.log.icon}` + template.reduce((result, part, i) => result + '\x1b[96m\x1b[2m' + args[i - 1] + '\x1b[90m' + part) + '\x1b[0m',
-    supress : (template, ...args) => '\x1b[1m\x1b[2m' + this.log.basic(template, ...args) + '\x1b[22m',
-    format  : (...args) => this.log.colors(...args),
-    info    : (...args) => console.info  (this.log.format(...args)),
-    warning : (...args) => console.warn  (this.log.format(...args)),
-    error   : (...args) => console.error (this.log.format`failure`, ...args)
-  }
 }

package/index.test.js

@@ -92,6 +92,6 @@ suite('@superhero/core', () =>
       core.bootstrap(),
       'Should bootstrap without errors')
 
-    await core.destruct()
+    await core.destroy()
   })
 })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@superhero/core",
-  "version": "4.0.0-beta.6",
+  "version": "4.0.0-beta.8",
   "description": "Core functionalities for the superhero framework.",
   "main": "index.js",
   "license": "MIT",
@@ -11,7 +11,8 @@
   "dependencies": {
     "@superhero/bootstrap": "^4.1.0",
     "@superhero/config": "^4.1.2",
-    "@superhero/locator": "^4.1.2"
+    "@superhero/locator": "^4.2.0",
+    "@superhero/log": "^4.0.0"
   },
   "scripts": {
     "test": "node --trace-warnings --test --experimental-test-coverage"