clasync

    0.11.8 • Public • Published

    clasync

    [Node.js] CLASses ASYNChronous Your powerful asynchronous imperative code OOP framework. Latest version: 0.11.6

    Known Vulnerabilities

    npm i -S clasync

    Lazy bone

    Below is a bunch of intuitive stuff and main explanations on lifecycle of this framework.

    dep.js

    const {$} = require('clasync');
    
    class Dep extends $ {  // this class extends framework directly
    
      // framework handlers
    
      async init() {  // initialization
        const msec = this.$.msecForInit;  // get our static value
        await this.$.delay(msec);  // call framework method: wait before continue
        this.$.log(`Dep is ready in ${msec} msec`);
      }
    
      async final() {  // finalization
        await this.$.doCommonFinal(this.$.msecForCommonFinal);  // call static method
        const msec = this.msecForFinal;  // get our configured value
        await this.doFinal(msec);  // call non-static method
        this.$.log('Dep finished');
      }
    
      // custom methods
    
      static async doCommonFinal(msec) {  // static method
        await this.delay(msec);  // can omit `$` here as we're already in static scope
        this.$.log(`Dep common final in ${msec} msec`); // or can use '$' for portability
      }
    
      async doFinal(msec) {  // non-static method
        await this.$.delay(msec);  // `$` to use method from static scope
        this.$.log(`Dep final in ${msec} msec`);
      }
    }
    
    Dep.msecForInit = 1000;  // static values
    Dep.msecForCommonFinal = 1000;
    
    module.exports = Dep;

    index.js

    const {App} = require('clasync');
    const Dep = require('./dep');
    
    class Main extends App {
    
      // framework handlers
    
      static async configure() {  // get default configuration for main module
        return {  // will be merged to main class instance
          dep: {msecForFinal: 1500}  // configuration for `Dep` instance
        };
      }  // presence of this static method makes this module launchable
    
      async init(deps) {  // initialization with dependencies
        await deps({
          $dep: Dep.new(this.dep)  // declare dependency: `Dep` with configuration
        });
    
        this.$.log('App and all its dependencies are ready');
      }
    
      async final(reason) {
        this.$.log(`App finished. Reason: ${reason}`);
      }
    
      async main() {
        this.$.log('Main started');
        await this.$.delay(5000);
        this.$.log('Main finished');
        return 0;  // exit code (reason)
      }
    }
    
    Main.gracefulShutdownMsec = 6000;
    
    module.exports = Main;

    node .

    Dep is ready in 1000 msec
    App and all its dependencies are ready
    Main started
    Main finished
    Dep common final in 1000 msec
    Dep final in 1500 msec
    Dep finished
    App finished. Reason: 0
    

    Launch again and after you see Main started press Ctrl+C:

    Dep is ready in 1000 msec
    App and all its dependencies are ready
    Main started
    ^CDep common final in 1000 msec
    Dep final in 1500 msec
    Dep finished
    App finished. Reason: SIGINT
    Main finished
    

    Note the Reason: SIGINT and still clean app shutdown. Change Main.gracefulShutdownMsec = 1500; and launch again. Note app CRITICAL termination before finalizers complete:

    Dep is ready in 1000 msec
    App and all its dependencies are ready
    Main started
    Main finished
    Dep common final in 1000 msec
    
    
    --- CRITICAL --- 2018-09-07T08:51:06.097Z
    Timed out waiting for finalizers
    

    Completion of Dep final is beyond the graceful shutdown time period. Launch again and after Main started press Ctrl+C twice. Application will terminate immediately.

    Async Events

    events.js

    const {Emitter} = require('../clasync');
    
    class Main extends Emitter {  // this class extends framework indirectly
    
      // framework handlers
    
      static async configure() {
        return {
          // no configuration
        };
      }
    
      async init() {
        this.on('start', async ({msec}) => {
          this.$.log('Main started');
          await this.$.delay(msec);
        }, 0);  // stage 0. no results from this stage
    
        this.on('start', async ({}) => {
          // results from same stage will be merged into one object
          return {stage1_handler1: 2};  // here is a stage 1 result
        }, 1);  // stage 1
    
        this.on('start', () => ({stage1_handler2: 2}), 1);  // also stage 1: sync handler
        this.on('start', async ({}) => undefined, 1);  // no result from this stage 1 async handler
    
        // event handler below won't be processed as non-empty result object
        //   is returned from previous stage
        this.on('start', () => ({stage2_handler1: 3}), 2);
    
        this.$.log('App and all its dependencies are ready');
      }
    
      async final(reason) {
        this.$.log(`App finished. Reason: ${reason}`);
      }
    
      async main() {
        const eventResults = await this.emit('start', {msec: 5000});
        this.$.log('Event result:', eventResults);
        this.$.log('Main finished');
        return 0;
      }
    }
    
    module.exports = Main;

    node events

    App and all its dependencies are ready
    Main started
    Event result: { stage1_handler1: 2, stage1_handler2: 2 }
    Main finished
    App finished. Reason: 0
    

    MOAR?

    Documentation in progress... Hubs, promises, funtionals and much more...

    Thanks

    Staff.com

    Install

    npm i clasync

    DownloadsWeekly Downloads

    361

    Version

    0.11.8

    License

    MIT

    Unpacked Size

    196 kB

    Total Files

    33

    Last publish

    Collaborators

    • tarquas