node-mu/node-mu-FULL.js

/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/index.js
 */

'use strict';

// yeah, I know... it's a global! ... go on :)!
Promise = require('bluebird');

const inversify = require('inversify');
require('reflect-metadata');
const ioc = require('./node-mu/ioc');
const Application = require('./node-mu/application');

const {LoggerWrapper} = require('./node-mu/logger');
const logger = new LoggerWrapper('build');


/**
 * Register the application Service class into the inversify IoC Container and returns the managed instance.
 *
 * @param applicationClass - the actual service class
 * @returns {*}
 */
const build = (applicationClass) => {
  logger.info('starting service', true);

  const application = ioc.container.get(applicationClass.prototype.ioc.id);
  logger.info(`service Application instance [${application.id}] builded`, true);
  return application;
};

/* main export */
exports = module.exports = (applicationClass) => {
  return build(applicationClass);
};


/**
 * Main lib exports
 * @module node-mu
 * @public
 */
exports.ioc = ioc;
exports.Application = Application;
exports.Providers = require('./node-mu/providers');
exports.Controllers = require('./node-mu/components').Controllers;
exports.Route = require('./node-mu/components').Route;
exports.Component = require('./node-mu/components').Component;
exports.Repository = require('./node-mu/components').Repository;
exports.Service = require('./node-mu/components').Service;
exports.LoggerWrapper = LoggerWrapper;
exports.Utils = require('./node-mu/utils');/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 * 
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 * 
 * See node-mu license text even in LICENSE file.
 * 
 * lib/node-mu/application.js
 */

'use strict';

require('reflect-metadata');

const {container, Injectable, Inject} = require('./ioc');
const config = require('config');
const {Component} = require('./components');
const RoutesRegister = require('./providers/api/routes-register');
const ProvidersRegister = require('./providers/health/providers-register');

/**
 * The main Service class from which derive our service.
 *
 * @public
 */
class Application extends Component {
  constructor() {
    super();
  }

  /**
   * Runs the service.
   * @returns {Promise<void>}
   */
  async run() {
    try {
      await this.$bootstrap();
      await this._start();
    } catch (err) {
      throw err;
    }
  }

  /**
   * To be implemented in the derived service class to initialize anything useful.
   * Normally used to register injectable components.
   * @returns {Promise<void>}
   */
  async $bootstrap() {
    console.log('$bootstrap() not yet implemented');
  }

  /**
   * Try and start the injected provider (if it has been injected ... != null).
   *
   * @param provider
   * @param after
   * @returns {Promise<void>}
   */
  async _startProvider(provider) {
    if (provider) {
      try {
        this._logger.debug(`[*] starting injected ${provider.constructor.name} provider`);
        await provider.$start();
      } catch (err) {
        throw err;
      }
    }
  }

  // TODO: make a better providers loading procedure (configuring, rules, etc...)
  async _startInjectedProviders() {
    return new Promise(async (resolve, reject) => {
      try {

        // TOTALLY ASYNC PROVIDERS INITIALIZATION
        /*
        const startProviderPromises = Object.keys(this)
          .filter(k => {
            let obj = Object(this)[k];
            if (/(provider)/i.test(obj.ctype) || /router/i.test(obj.ctype)) {
              return k;
            }
          })
          .map(async (k) => {
            return new Promise(async (resolve, reject) => {
              try {
                let obj = Object(this)[k];
                await this._startInjectedProvider(obj);

                // setup routes for each Api provider
                if (/router/i.test(obj.ctype)) {
                  await this._setupRoutes(obj);
                }

                resolve()
              } catch (err) {
                reject(err);
              }
            });
          });

        Promise.all(startProviderPromises)
          .then(() => {
            this._logger.info('[*] all Providers started');
            resolve();
          });
         */

        // SEQUENTIAL PROVIDERS INITIALIZATION
        for (let k of Object.keys(this)) {
          let obj = Object(this)[k];
          if (/(provider)/i.test(obj.ctype)) {
            await this._startProvider(obj);
            this._logger.info(`[*] ${obj.constructor.name} provider started`, true);
            ProvidersRegister.register(obj.constructor.name);

            // setup routes for each Api provider
            if (/router/i.test(obj.ctype)) {
              await this._setupRoutes(obj);
            }
          }
        }
        resolve();
      } catch (err) {
        reject(err);
      }
    });
  }

  /**
   * Start the service registering providers
   * @returns {Promise<void>}
   * @private
   */
  async _start() {
    try {
      this._logger.info('starting providers');
      await this._startInjectedProviders();

      try {
        const mgmtConfig = config.get('management');
        if (mgmtConfig.health) {
          this._health = container.get('Health');
          await this._startProvider(this._health);
        } else {
          this._logger.warn('No Health provider configured. Could be difficult to integrate with a Service Registry.', true);
        }
        this._management = container.get('Management');
        await this._startProvider(this._management);
      } catch (err) {
        console.log(err);
        this._logger.warn('No Management provider configuration found. The service will not have a Management endpoint.');
      }

      this._logger.info('registering service shutdown hook');
      const shudownHook = async () => {
        try {
          console.log('\n');
          this._logger.info('\uD83D\uDCA3  [shutdownHook] BORN TO KILL SERVICES!');
          await this.stop();
          process.exit(0);
        } catch (err) {
          this._logger.error(`error killing service process: ${err}`);
          process.exit(1);
        }
      };

      process.on('SIGTERM', shudownHook);
      process.on('SIGINT', shudownHook);

      this._logger.info(`service started [pid: ${process.pid}]`, true);
    } catch (err) {
      throw err;
    }
  }

  /** Stops the service */
  async stop() {
    return new Promise(async (resolve, reject) => {
      try {
        this._logger.info('gracefully shutting down the service');

        for (let k of Object.keys(this)) {
          let obj = Object(this)[k];
          if (/(provider)/i.test(obj.ctype)) {
            obj.$stop && await obj.$stop();
            this._logger.info(`${obj.name} provider stoppped`);
          }
        }

        this._logger.info('service shutted down. Bye!');
        resolve(true);
      } catch (err) {
        reject(err);
      }
    });
  }

  /**
   * Set up the API routes.
   * @private
   */
  async _setupRoutes(api) {
    return new Promise((resolve, reject) => {
      try {
        this._logger.info(`setting up routes for ${this.constructor.name}`);
        RoutesRegister.ids.forEach(iocId => {
          const route = container.get(iocId);
          this.addRoute(api, route);
        });
        //this.$setupRoutes();
        resolve();
      } catch (err) {
        reject(err);
      }
    });

  }

  async _setHealthRoute() {
    return new Promise((resolve, reject) => {
      try {
        const healthRoute = container.get('HealthRoute');
        this.addRoute(healthRoute);
        resolve();
      } catch (err) {
        reject(err);
      }
    });
  }

  /**
   * Set up the API routes. To be implemented in the actual service class.
   * @abstract
   */
  //$setupRoutes() {
  //}


  /**
   * Add a route to the API router.
   * @param {*} route - The route to add.
   */
  addRoute(api, route) {
    route.$setupValidationRules();
    route.$setupRoutes();
    api.addRoute(route.basePath, route.router);
  }

  /**
   * Called from derived service class to set injected instances (usually the injected providers instances)
   * @param n - the instance to set
   */
  set ['name'](n) {
    this['name'] = n;
  }

}

module.exports = Application;/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/components/component.js
 */

'use strict';

const uuidv1 = require('uuid/v1');
const {LoggerWrapper} = require('../logger');

/**
 * A component class which generates and maintain an instance id.
 * Actually used only by the AmqpProducer instance classes.
 */
class Component {

  /**
   * Initialize the component generating an uuid v1 code and grabbing the only the first part,
   * and storing the class instance full name into an internal const.
   */
  constructor(ctype = 'component') {
    this._id = uuidv1().split('-')[0];
    this._name = this.constructor.name + '-' + this._id;
    this._ctype = ctype;
    this._logger = new LoggerWrapper(this.constructor.name, this._id);
  }

  /**
   * Returns the instance id
   * @return {number} _id - The instance id number.
   */
  get id() {
    return this._id;
  }

  /**
   * Returns the full class instance name.
   * @return {string} _name - The instance class name.
   */
  get name() {
    return this._name;
  }

  get ctype() {
    return this._ctype;
  }
}

module.exports = Component;
/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/components/controllers/events-emitter.controller.js
 */

'use strict';

const EventsEmitterController = require('./events-emitter.controller');

/**
 * A base class to derive a controller which can emit events on the default 'api-events' event-channel.
 * The 'api-events' channel is the default node-mu channel to which publish events to be published on AMQP.
 */
class ApiEventsEmitterController extends EventsEmitterController {
  constructor() {
    super('api-events');
  }
}

module.exports = ApiEventsEmitterController;
/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/components/controllers/controller.js
 */

'use strict';

const { injectable } = require('../../ioc');
const Component = require('../component');
const autoBind = require('auto-bind');

class Controller extends Component {
  /** Initialize the controller logger and binds its methods. */
  constructor() {
    super();
    this._logger.info('auto-binding all methods');
    autoBind(this);
  }

  /** used to return a converted view of a model (call it a dto!) */
  _wrapResponse(model, converter, res, next) {
    if (!model || model.length == 0) {
      res.status(404);
      return next();
    } else {
      return res.json(converter != null ? converter(model) : model);
    }
  }

}

module.exports = Controller;
/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/components/controllers/events-emitter.controller.js
 */

'use strict';

const Controller = require('./controller');
const Hertzy = require('hertzy');

/**
 * A base class to derive a controller which can emit events on an Hertzy events-channel.
 * Hertzy channels follows the Mediator desing pattern.
 * Using this base class the actual derived controller can emit events to the channel
 * and publish on an AMQP server staying decoupled from the AMQP Publisher.
 */
class EventsEmitterController extends Controller {

  /**
   * Initialize the controller with the events-channel.
   * @param {string} eventChannelName - The events-channel name.
   */
  constructor(eventChannelName = undefined) {
    super();

    this._eventChannelName = eventChannelName;
    if (this._eventChannelName) this._eventsChannel = Hertzy.tune(eventChannelName);
    this._logger.info('Hertzy API events channel initialized as "api-events"');
  }

  set eventChannelName(name) {
    this._eventChannelName = name;
    this.startEventChannel();
  }

  get eventChannelName() {
    return this._eventChannelName;
  }

  startEventChannel() {
    this._eventsChannel = Hertzy.tune(eventChannelName);
  }

  /**
   * Emit an event on the Event Channel. The event will be triggered by the service Events Emitter
   * which in turn will publish it on the configured AMQP Server (on exchange).
   *
   * @param {*} evt - The event name
   * @param {*} data - The event payload to be published into the AMQP server
   */
  emit(evt, data) {
    this._eventsChannel.emit(evt, data);
  }
}

module.exports = EventsEmitterController;
/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/components/controllers/index.js
 */

'use strict';

/** @module node-mu/controllers */
module.exports = {
  Controller: require('./controller'),
  EventsEmitterController: require('./events-emitter.controller'),
  ApiEventsEmitterController:require('./api-events-emitter.controller')
};
/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/components/index.js
 */

'use strict';

module.exports = {
  Component: require('./component'),
  Controllers: require('./controllers'),
  Route: require('./route'),
  Service: require('./service'),
  Repository: require('./repository')
};/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/components/repository/index.js
 */

'use strict';

/** @module node-mu/repository */
module.exports = require('./repository');
/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/components/repository/repository.js
 */

'use strict';

const {EntityRepository} = require('objection-repositories');
const {container} = require('../../ioc');

class Repository extends EntityRepository {
  constructor(Model) {
    super((container.get('DbConnectionManager')).knex, Model);
  }
}

module.exports = Repository;
/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/components/route/index.js
 */

'use strict';

/** @module node-mu/route */
module.exports = require('./route');
/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/components/route/route.js
 */

'use strict';

const Component = require('../component');
const express = require('express');
const validate = require('express-validation');

class Route extends Component {
  constructor(basePath = '/') {
    super();
    this._basePath = basePath;
    this._router = express.Router();
    if (this._basePath) this._logger.debug('Route base path: ' + this._basePath);
  }

  route(basePath = '/', validationRules = []) {
    this._basePath = basePath;
    this._logger.debug('Route base path: ' + this._basePath);
    this._validationRules = validationRules;
    return this;
  }

  /**
   * Returns this route Express Router.
   * @return {express.Router} _router - This route Express Router.
   */
  get router() {
    return this._router;
  }

  /**
   * Returns thi route base path.
   * @return {string} _basePath - The base path for this route.
   */
  get basePath() {
    return this._basePath;
  }

  /**
   * Adds a route.
   * @param {string} method - HTTP method.
   * @param {string} path - The route path.
   * @param {[function]} handlers - The route handlers (middlewares... handler).
   */
  addRoute(method, path, ...handlers) {
    this._logger.debug(`addRoute() - method: '${method}', path: '${path}'`);
    const _validationRule = this.getValidationRule(path);
    let validationOnRoute = false;
    if (_validationRule && this._checkValidationRuleMethod(_validationRule.method, method)) {
      this._logger.debug(`adding validation rule for method '${method}' on paht '${path}'`);
      handlers.splice(0, 0, validate(_validationRule));
      validationOnRoute = true;
    }

    this._router.route(path)[method](handlers);
    this._logger.info(`[${method.toUpperCase()} ${this._basePath}${path}] route configured ${validationOnRoute ? ' (with validation rule)' : ''}`);
    return this;
  }

  _checkValidationRuleMethod(ruleMethods, method) {
    if(typeof array != "undefined" && array != null && array.length != null && array.length > 0){
      for (let m of ruleMethods) {
        if ((new RegExp(m, 'i')).test(method)) {
          return true;
        }
      }
      return false;
    }
    return true;
  }

  /**
   * Adds a GET route.
   * @param {string} path - The route path.
   * @param {[function]} handlers - The route handlers (middlewares... handler).
   */
  get(path, ...handlers) {
    return this.addRoute('get', path, handlers);
  }

  /**
   * Adds a POST route.
   * @param {string} path - The route path.
   * @param {[function]} handlers - The route handlers (middlewares... handler).
   */
  post(path, ...handlers) {
    return this.addRoute('post', path, handlers);
  }

  /**
   * Adds a PUT route.
   * @param {string} path - The route path.
   * @param {[function]} handlers - The route handlers (middlewares... handler).
   */
  put(path, ...handlers) {
    return this.addRoute('put', path, handlers);
  }

  /**
   * Adds a DELETE route.
   * @param {string} path - The route path.
   * @param {[function]} handlers - The route handlers (middlewares... handler).
   */
  delete(path, ...handlers) {
    return this.addRoute('delete', path, handlers);
  }

  /**
   * Adds a PATCH route.
   * @param {string} path - The route path.
   * @param {[function]} handlers - The route handlers (middlewares... handler).
   */
  patch(path, ...handlers) {
    return this.addRoute('patch', path, handlers);
  }

  /**
   * Adds an OPTIONS route.
   * @param {string} path - The route path.
   * @param {[function]} handlers - The route handlers (middlewares... handler).
   */
  options(path, ...handlers) {
    return this.addRoute('options', path, handlers);
  }

  /**
   * Adds a HEAD route.
   * @param {string} path - The route path.
   * @param {[function]} handlers - The route handlers (middlewares... handler).
   */
  head(path, ...handlers) {
    return this.addRoute('head', path, handlers);
  }

  setValidationRules(rules) {
    this._validationRules = rules;
    return this;
  }

  getValidationRule(path) {
    if (this._validationRules) {
      return this._validationRules[path];
    }

    return undefined;
  }

  /**
   * Helper function called by the Service during initialization.
   * Implement it in the derived Route class
   */
  $setupRoutes() {
  }

  /**
   * Helper function called by the Service during initialization.
   * Implement it in the derived Route class
   */
  $setupValidationRules() {
  }


}

module.exports = Route;
/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/components/service/index.js
 */

'use strict';

/** @module node-mu/service */
module.exports = require('./service');
/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/components/service/service.js
 */

'use strict';

const Component = require('../component');

class Service extends Component {
  constructor(knex, entity) {
    super(knex, entity);
  }
}

module.exports = Service;
/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/ioc/index.js
 */

'use strict';

const inversify = require('inversify');
require('reflect-metadata');
const IocContainer = new (require('./ioc-container'))();
const container = IocContainer.container;
const logger = IocContainer.logger;
//const ProvidersRegister = require('../providers/health/providers-register');
const RoutesRegister = require('../providers/api/routes-register');

const injectable = (target, singleton = false) => {
  logger.debug(`registering ${target.name} type as injectable`);
  target.prototype.ioc = {id: target.name};
  inversify.decorate(inversify.injectable(), target);
  logger.debug(`binding '${target.prototype.ioc.id}' to ${target.name} into the IoC Container`);
  const _bindContext = container.bind(target.name).to(target);
  if (singleton) {
    _bindContext.inSingletonScope();
    logger.debug(`${target.name} binded as Singleton`);
  }
  return target;
};

const component = (target) => {
  return injectable(target);
};

const provider = (target, singleton = true) => {
  const injectableProvider = injectable(target, singleton);
  //ProvidersRegister.register(injectableProvider.prototype.ioc.id);
  logger.debug(`provider ${injectableProvider.prototype.ioc.id} registered into the Providers Register`);
  return injectableProvider;
};

const factoryFunction = (target) => {
  logger.debug(`registering factory ${target.name} type as injectable`);
  target.prototype.ioc = {id: target.name};
  logger.debug(`binding '${target.prototype.ioc.id}' to ${target.name} into the IoC Container`);
  container.bind(target.name).toFunction(target);
  return target;
};

const controller = (target) => {
  return injectable(target);
};

const route = (target) => {
  const injectableRoute = injectable(target);
  RoutesRegister.register(injectableRoute.prototype.ioc.id);
  logger.debug(`route ${injectableRoute.prototype.ioc.id} registered into the Routes Register`);
  return injectableRoute;
};

const service = (target) => {
  return injectable(target);
};

const repository = (target) => {
  return injectable(target);
};

const application = (target) => {
  let appTarget = injectable(target, true);
  global.APPLICATION_TYPE = appTarget.prototype.ioc.id;
  return appTarget;
};

const isInjectable = (target) => {
  return target.prototype.ioc && target.prototype.ioc.id;
};

const inject = (injectables, target) => {
  for (let order = 0; order < injectables.length; order++) {
    const injectable = injectables[order];
    logger.debug(`injecting ${injectable.name} into ${target.name}`);
    if (!isInjectable(injectable)) {
      throw Error(`${injectable.name} is not registered as injectable in the IoC Container.`);
    } else if (!container.isBound(injectable.prototype.ioc.id)) {
      throw Error(`${injectable.name} is unbound in the IoC Container.`);
    }

    logger.debug(`making ${injectable.prototype.ioc.id} injectable into ${target.name}`);
    inversify.decorate(inversify.inject(injectable.prototype.ioc.id), target, order);
  }

  return target;
};


module.exports = {
  container,
  injectable,
  component,
  provider,
  factoryFunction,
  route,
  controller,
  service,
  repository,
  application,
  inject
};
/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/ioc/ioc-container.js
 */

'use strict';

const inversify = require('inversify');
require('reflect-metadata');
const {LoggerWrapper} = require('../logger');

let _instance = null;

class IocContainer {
  constructor() {
    if (!_instance) {
      this._container = new inversify.Container({skipBaseClassChecks: true});
      _instance = this;
      this._logger = new LoggerWrapper(this.constructor.name);
    }

    return _instance;
  }

  get container() {
    return this._container;
  }

  get logger() {
    return this._logger;
  }
}

module.exports = IocContainer;
/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 * 
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 * 
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/logger/index.js
 */

'use strict';

/** @module node-mu/logger */
module.exports = {
  Logger: require('./logger'),
  LoggerWrapper: require('./logger-wrapper')
}/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 * 
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 * 
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/logger/logger-wrapper.js
 */

'use strict';

const Logger = require('./logger');

/** Helper wrapper for the logger. */
class LoggerWrapper {
  constructor(cname, id = undefined) {
    this._logger = (new Logger()).logger;
    this._cname = cname;
    this._id = id;
  }

  /** Logs out in INFO level. */
  info(msg, evidence = false) {
    evidence && this._logger.info(` ${this._msg('-'.repeat(msg.length))}`);
    this._logger.info(` ${this._msg(msg)}`);
    evidence && this._logger.info(` ${this._msg('-'.repeat(msg.length))}`);
  }

  /** Logs out in DEBUG level. */
  debug(msg) {
    this._logger.debug(this._msg(msg));
  }

  /** Logs out in ERROR level. */
  error(msg) {
    this._logger.error(this._msg(msg));
  }

  /** Logs out in WARN level */
  warn(msg, evidence = false) {
    evidence && this._logger.warn(` ${this._msg('-'.repeat(msg.length))}`);
    this._logger.warn(` ${this._msg(msg)}`);
    evidence && this._logger.warn(` ${this._msg('-'.repeat(msg.length))}`);
  }

  _msg(msg) {
    return `[${this._cname.padEnd(29)}]${this._id ? ' - [' + this._id + '] - ' : '-'} ${msg}`;
  }

}

module.exports = LoggerWrapper;/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 * 
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 * 
 * See node-mu license text even in LICENSE file.
 * 
 * lib/node-mu/logger/logger.js
 */

'use strict';

const path = require('path');
const config = require('config');
const winston = require('winston');
require('winston-daily-rotate-file');
const fs = require('fs');
const { serviceInfo } = require('../utils');

let _instance = null;

/** Singleton for the main logger class. */
class Logger {
  constructor() {
    if (!_instance) {
      this._configuration = config.get('log');
      this._initialize();
      _instance = this;
    } else {
      return _instance;
    }
  }

  /**
   * Initialize the logger Winston transport.
   * @private
   */
  _initialize() {
    const fullPath = path.join(process.cwd(), this._configuration.path);
    if (!fs.existsSync(fullPath)) {
      fs.mkdirSync(fullPath);
    }

    const fullname = path.join(fullPath, serviceInfo.name);

    const fileTransport = new (winston.transports.DailyRotateFile)({
      filename: fullname + '-%DATE%.log',
      datePattern: 'DD-MM-YYYY',
      zippedArchive: true,
      maxSize: '20m',
      maxFiles: '14d',
      level: this._configuration.level,
      json: false
    });
  
    const transports = [fileTransport];
    if (this._configuration.console) {
      transports.push(new winston.transports.Console({ json: false, colorize: true, level: this._configuration.level }));
    }
  
    this._logger = new (winston.Logger)({
      transports,
    });
    this._logger.exitOnError = false;
  }

  /**
   * Returns this logger object.
   * @return {winston.Logger} _logger - The internal winston logger instance.
   */
  get logger() {
    return this._logger;
  }
}

module.exports = Logger;
/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/providers/amqp/amqp-connection-manager.provider.js
 */

'use strict';

const {provider} = require('../../ioc');
const {LoggerWrapper} = require('../../logger');
const Provider = require('../provider');
const config = require('config');
const amqp = require('amqplib');
const axios = require('axios');

module.exports =
  provider(
    class AmqpConnectionManager extends Provider {
      constructor() {
        super();
      }

      async $start() {
        try {
          this._amqpConfig = config.get('amqp');
          this._logger.debug(JSON.stringify(this._amqpConfig));

          await this.connect();
        } catch (err) {
          throw err;
        }
      }

      async $stop() {
        try {
          await this._channel.close();
          this._logger.debug('AMQP Channel closed');

          await this._connection.close();
          this._logger.debug('AMQP Connection closed');
        } catch (err) {
          throw err;
        }
      }

      /** Connect to the AMQP Server and open a channel on the connetion. */
      async connect() {
        if (!this._connection) {
          try {
            this._connection = await amqp.connect(this._amqpConfig.url);
            this._logger.info(`AMQP connection established`);
          } catch (error) {
            this._logger.error(`error connecting to AMQP: ${error}`);
            throw error;
          }
        }

        // here we open the channel to the queue
        if (!this._channel) {
          try {
            this._channel = await this._connection.createChannel();
            this._logger.info('AMQP channel opened');

            this._channel.on('error', async (err) => {
              this._logger.error(`error on AMQP channel: ${err}`);
            });
          } catch (error) {
            this._logger.error(`error creating channel on AMQP connection: ${error}`);
            throw error;
          }
        }
      }

      /**
       * Returns the AMQP connection channel.
       * @return {object} _channel - The AMQP connection channel.
       */
      get channel() {
        return this._channel;
      }

      async getRabbitHealth() {
        try {
          return await axios.get('http://guest:guest@127.0.0.1:15672/api/aliveness-test/%2F');
          /*, {
            auth: {
              username: 'guest',
              password: 'guest'
            }
          })*/
        } catch (err) {
          throw err;
        }
      }

      $isCheckableForHealth() {
        return true;
      }

      async $health() {
        return new Promise(async (resolve, reject) => {
          try {
            const response = await this.getRabbitHealth();
            resolve({
              status: 'UP',
              message: response.data
            });
          } catch (err) {
            if (err.errno == 'ECONNREFUSED') {
              reject({
                status: 'DOWN',
                message: err.stack
              });
            } else if (err.message.indexOf('401')) {
              reject({
                status: 'UNKNOWN',
                message: 'unauthorized RabbitMQ user'
              });
            }
          }
        });
      }

      get $healthId() {
        return 'amqp';
      }

    }
  );
/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/providers/amqp/amqp-publisher.factory.js
 */

'use strict';

const {container, factoryFunction} = require('../../ioc');

module.exports =
  factoryFunction(
    function AmqpPublisherFactory(destination) {
      return {
        newPublisher: (destination) => {
          const publisher = container.get('AmqpPublisher');
          publisher.init(destination);
          return publisher;
        }
      }
    }
  );
/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/providers/amqp/amqp-publisher.provider.js
 */

'use strict';

const {inject, provider} = require('../../ioc');
const Provider = require('../provider');
const AmqpConnectionManager = require('./amqp-connection-manager.provider');

module.exports =
  inject(
    [AmqpConnectionManager],
    provider(
      class AmqpPublisher extends Provider {
        constructor(amqpConnectionManager) {
          super();
          this._channel = amqpConnectionManager.channel;
        }

        init(destination) {
          this._detination;
          this._logger.debug(`destination ${JSON.stringify(destination)} initialized`);
        }

        publish(evt, dest = undefined) {
          const destination = dest || this._destination;
          this._logger.debug(`publishing to: ${JSON.stringify(destination)}`);

          this._logger.debug('check exchange');
          this._channel.checkExchange(destination.name)
            .then((res, err) => {
              if (err) {
                this._logger.error('** ' + err);
                return;
              }
              this._logger.debug(`check exchange ${destination.name} ok`);
              const result = this._channel.publish(destination.name, destination.route, new Buffer(JSON.stringify(evt)));
              this._logger.debug(`publish result: ${result}`);
            })
            .catch((err) => {
              this._logger.error(`AMQP exchange ${destination.name} does not exists. Error: ${err}`);
            })
        }
      }
    )
  );
/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/providers/amqp/index.js
 */

'use strict';

module.exports = {
  AmqpConnectionManager: require('./amqp-connection-manager.provider'),
  AmqpPublisher: require('./amqp-publisher.provider'),
  AmqpPublisherFactory: require('./amqp-publisher.factory')
};/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/providers/api/api.provider.js
 */

'use strict';

const {container, provider} = require('../../ioc');
const express = require('express');
const Router = require('./router');
const http = require('http');
const bodyParser = require('body-parser');
const compression = require('compression');
const methodOverride = require('method-override');
const helmet = require('helmet');
const cors = require('cors');
const ignoreFavicon = require('./middlewares/ignore-favicon');
const errorMiddleware = require('./middlewares/error');
const enableDestroy = require('server-destroy');
const expressWinston = require('express-winston');
const RequestLoggerTransport = require('./request-logger-transport');
const passport = require('passport');
const passportStrategy = require('./passport-strategy');
const config = require('config');
const routesRegister = require('./routes-register');

module.exports =
  provider(
    class Api extends Router {
      constructor() {
        super();

        this._endpointConfig = config.get('api.endpoint');
        this._securityConfig = config.get('api.security');
        //this._jwtConfig = config.get('jwt');

        this._app = express();
        this._configureApp();

        this._logger.info('initializing API server');
        this._logger.info(`routing with basePath: ${this._endpointConfig.baseRoutingPath}`);
        this._app.use(this._endpointConfig.baseRoutingPath, this.routes);

        this._logger.info('setting up error handler');
        this._setupErrorHandlers();
      }

      async $start() {
        return new Promise((resolve, reject) => {
          this._logger.debug('starting API server');
          this._server = http.createServer(this._app);
          this._server.listen(this._endpointConfig.port, (err) => {
            if (err) {
              return reject(err);
            }
            this._logger.info(`API server Listening on http://${this._server.address().address}:${this._server.address().port}`);

            return resolve();
          });

          /* Hack to close all pending connections: https://github.com/isaacs/server-destroy */
          enableDestroy(this._server);
        });
      }

      /** Stops the API Http server. */
      async $stop() {
        return new Promise((resolve, reject) => {
          this._logger.debug('gracefully shutting down the Api server');
          if (this._server) {
            this._server.destroy(() => {
              this._logger.debug('API server destroyed');
              return resolve(true);
            });
          } else {
            this._logger.warn('[API] API server destroyed (it was null!)');
            return resolve(true);
          }
        });
      }

      /**
       * Configure the Express app.
       * @private
       */
      _configureApp() {
        this._logger.debug('configuring API express app');

        this._requestLoggerTransport = new RequestLoggerTransport();
        this._app.use(expressWinston.logger(this._requestLoggerTransport.requestsLoggerTransports));

        this._app.use(bodyParser.json());
        this._app.use(bodyParser.urlencoded({extended: true}));
        this._app.use(compression());
        this._app.use(methodOverride());
        this._app.use(helmet());
        this._app.use(cors());
        this._app.use(ignoreFavicon);

        //if (this._endpointConfig.authEnabled) {
        if (this._securityConfig.enabled) {
          this._app.use(passport.initialize());
          passport.use('jwt', passportStrategy(this._securityConfig.jwt.secret));
        }

      }

      /**
       * Configure the Api error handlers.
       * @private
       */
      _setupErrorHandlers() {
        // configure error logger
        this._app.use(expressWinston.errorLogger(this._requestLoggerTransport.errorLoggerTransports));
        this._logger.debug('errorLogger ok');

        // convert APIError error
        this._app.use(errorMiddleware.converter);
        this._logger.debug('errorMiddleware.converter ok');

        // catch 404 and go on to error handler
        this._app.use(errorMiddleware.notFound);
        this._logger.debug('errorMiddleware.notFound ok');

        // error handler: stacktrace is sent only in development
        this._app.use(errorMiddleware.handler);
        this._logger.debug('errorMiddleware.handler ok');
      }

      get $healthId() {
        return 'api';
      }
    }
  );/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/providers/api/index.js
 */

'use strict';

/** @module node-mu/api */
module.exports = {
  Api: require('./api.provider'),
  AuthMiddleware: require('./middlewares/auth').authorize
};/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-muproviders/api/middlewares/auth.js
 */

'use strict';

const jwt = require('jsonwebtoken');
const httpStatus = require('http-status');
const passport = require('passport');
const { APIError } = require('../../../utils');


const handleJWT = (req, res, next, roles) => async (err, user, info) => {
  const error = err || info;
  const apiError = new APIError({
    message: error ? error.message : 'Unauthorized',
    status: httpStatus.UNAUTHORIZED,
    stack: error ? error.stack : undefined,
  });

  // TODO: check if this is better
  // if (error || !user) {
  //   return next(apiError);
  // }
  try {
    if (error || !user) {
      throw error;
    }
  } catch (err) {
    return next(apiError);
  }

  const hasRole = user.auth.some(role => {
    return roles.indexOf(role) > -1;
  });
  if (!hasRole) {
    apiError.stack = 'User role has no permission for path ' + req.path;
    return next(apiError);
  }

  req.user = user;

  return next();
};

// TODO: put roles in configuration file
exports.authorize = (roles = ['ROLE_ADMIN', 'ROLE_USER', 'ROLE_PARENT', 'ROLE_PEDIATRICIAN']) => (req, res, next) =>
  passport.authenticate(
    'jwt', { session: false },
    handleJWT(req, res, next, roles)
  )(req, res, next);/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/providers/api/middlewares/error.js
 */

'use strict';

const httpStatus = require('http-status');
const expressValidation = require('express-validation');
const { APIError } = require('../../../utils');
const { LoggerWrapper } = require('../../../logger');

/**
 * Error handler. Send stacktrace only during development
 * @public
 */
const handler = (err, req, res, next) => {
  const env = process.NODE_ENV || 'development';
  const response = {
    code: err.status,
    message: err.message || httpStatus[err.status],
    errors: err.errors,
    stack: err.stack,
  };

  if (env !== 'development') {
    delete response.stack;
  }

  res.status(err.status);
  res.json(response);
  res.end();
};

/**
 * If error is not an instanceOf APIError, convert it.
 * @public
 */
const converter = (err, req, res, next) => {
  let convertedError = err;

  if (err instanceof expressValidation.ValidationError) {
    convertedError = new APIError({
      message: 'Validation error',
      errors: err.errors,
      status: err.status,
      stack: err.stack,
    });
  } else if (!(err instanceof APIError)) {
    convertedError = new APIError({
      message: err.message,
      status: err.status,
      stack: err.stack,
    });
  }

  return handler(convertedError, req, res);
};

/**
 * Catch 404 and forward to error handler
 * @public
 */
const notFound = (req, res, next) => {
  const err = new APIError({
    message: 'Not found',
    status: httpStatus.NOT_FOUND,
  });
  return handler(err, req, res);
};

module.exports = {
  handler, converter, notFound
}/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/providers/api/middlewares/ignore-favicon.js
 */

'use strict';

/** A moddleware to ignore the browsers' favicon requests. */
module.exports = (req, res, next) => {
  if (req.originalUrl === '/favicon.ico') {
    res.status(204).json({ nope: true });
  } else {
    next();
  }
};/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/providers/api/passport-strategy.js
 */

'use strict';

const JwtStrategy = require('passport-jwt').Strategy;
const BearerStrategy = require('passport-http-bearer');
const {ExtractJwt} = require('passport-jwt');

module.exports = (secret) => {
  const jwtOptions = {
    secretOrKey: new Buffer(secret, 'base64'),
    jwtFromRequest: ExtractJwt.fromAuthHeaderWithScheme('Bearer'),
    algorithms: ['HS512'],
    jsonWebTokenOptions: {algorithm: 'HS512'}
  };

  const jwt = async (payload, done) => {
    try {
      if (payload) {
        return done(null, payload);
      }
      return done(null, false);
    } catch (error) {
      return done(error, false);
    }
  };

  return new JwtStrategy(jwtOptions, jwt);
}/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 * 
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 * 
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/providers/api/request-logger-transport.js
 */

'use strict';

const path = require('path');
const winston = require('winston');
require('winston-daily-rotate-file');
const fs = require('fs');
const config = require('config');
const {serviceInfo} = require('../../utils');
const {LoggerWrapper} = require('../../logger');

const REQUESTS_LOGGER_TRANSPORTS = 'requests';
const ERRORS_LOGGER_TRANSPORTS = 'errors';

/** Initialize express-winston to log Api http requests. */
class RequestLoggerTransport {
  constructor() {
    this._configuration = config.get('log');
    this._logger = new LoggerWrapper(this.constructor.name);

    this._requestsLoggerTransports = this._configure(REQUESTS_LOGGER_TRANSPORTS);
    this._logger.debug('requests transports initialized');

    this._errorsLoggerTransports = this._configure(ERRORS_LOGGER_TRANSPORTS);
    this._logger.debug('errors transports initialized');
  }

  /**
   * Returns the winston logger transport for requests.
   * @return {object}
   */
  get requestsLoggerTransports() {
    return this._requestsLoggerTransports;
  }

  /**
   * Returns the winston logger transport for errors.
   * @return {object}
   */
  get errorLoggerTransports() {
    return this._errorsLoggerTransports;
  }

  /**
   * Switch to configure a winston transport.
   * @param {string} type - The logging reason ('requests' or 'errors').
   */
  _configure(type) {
    const fullPath = path.join(process.cwd(), this._configuration.path);
    if (!fs.existsSync(fullPath)) {
      fs.mkdirSync(fullPath);
    }

    switch (type) {
      case REQUESTS_LOGGER_TRANSPORTS:
        const requestsLogFile = `${serviceInfo.name}-requests`;
        return this._configureTransports(fullPath, requestsLogFile, this._configuration.requests.console);
        break;
      case ERRORS_LOGGER_TRANSPORTS:
        const errorsLogFile = `${serviceInfo.name}-errors`;
        return this._configureTransports(fullPath, errorsLogFile, this._configuration.errors.console);
        break;
      default:
        logger.error('Unexpected express winston transport configuration type');
    }
  }

  /**
   * Configure a winston transport.
   * @param {string} logFullPath - The log file full path.
   * @param {string} logFile - The log file name.
   * @param {boolean} logToConsole - wheter or not to log on console.
   */
  _configureTransports(logFullPath, logFile, logToConsole) {
    const fullname = path.join(logFullPath, logFile);
    const fileTransport = new (winston.transports.DailyRotateFile)({
      filename: fullname + '-%DATE%.log',
      datePattern: 'DD-MM-YYYY',
      zippedArchive: true,
      maxSize: '20m',
      maxFiles: '14d',
      level: this._configuration.level,
      json: false
    });

    const transports = [fileTransport];
    if (logToConsole) {
      transports.push(new winston.transports.Console({json: false, colorize: true, level: this._configuration.level}));
    }

    return {transports: transports, expressFormat: true};
  }
}

module.exports = RequestLoggerTransport;
/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/providers/api/router.js
 */

'use strict';

const express = require('express');
const Provider = require('../provider');

class Router extends Provider {
  constructor() {
    super('component:provider:router');
    this._router = express.Router();
  }

  /**
   * Returns this Router routes.
   * @return {express.Router} _router - This router.
   */
  get routes() {
    return this._router;
  }

  /**
   * Adds a route to the Router.
   * @param {string} path - The route path.
   * @param {Route} route - The route object
   */
  addRoute(path, route) {
    this._router.use(path, route);
  }
}

/** The Router base class for the API. */
module.exports = Router;/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/providers/api/routes-register.js
 */

'use strict';

let RoutesIds = module.exports = {
  ids: [],
  register: (id) => {
    RoutesIds.ids.push(id);
  },
  remove: (id) => {
    const idx = RoutesIds.ids.indexOf(id);
    if (idx) RoutesIds.ids.splice(idx, 1);
  }
};/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/providers/db/db-connection-manager.provider.js
 */

'use strict';

const {provider} = require('../../ioc');
const Provider = require('../provider');
const config = require('config');
const Knex = require('knex');
const {Model} = require('objection');

module.exports =
  provider(
    class DbConnectionManager extends Provider {
      constructor() {
        super();
      }

      init(model) {
        this._model = model;
      }

      async $start() {
        try {
          this._knexConfig = config.get('db');
          this._logger.debug(`configuration: ${JSON.stringify(this._knexConfig)}`);

          this.init(Model);

          const knexConnection = await this.connect();
          this._model.knex(knexConnection);
        } catch (err) {
          throw err;
        }
      }

      async $stop() {
      }

      async connect() {
        this._logger.debug('configuring database connection');
        return new Promise((resolve, reject) => {
          this._knex = Knex(this._knexConfig);
          this._knex.raw('select 1 from dual').then(() => {
            this._logger.info('database connection established');
            resolve(this._knex);
          }).catch((err) => {
            this._logger.error('error connecting to database');
            reject(err);
          });
        });
      }

      get knex() {
        this._logger.debug('returning Knex instance');
        return this._knex;
      }

      get $healthId() {
        return 'db';
      }

      $isCheckableForHealth() {
        return true;
      }

      async $health() {
        return new Promise((resolve, reject) => {
          this._logger.debug('***** db health');
          this._knex.raw('select 1 from dual').then(() => {
            this._logger.debug('****database connection established');
            resolve({status: 'UP'});
          }).catch((err) => {
            this._logger.error('****error connecting to database');
            reject({status: 'DOWN', message: err.stack});
          });
        });
      }

      get model() {
        return this._model;
      }
    }
  );
/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/providers/db/index.js
 */

'use strict';

module.exports = require('./db-connection-manager.provider');/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/providers/emitter/events-emitter.provider.js
 */

'use strict';

const {inject, provider} = require('../../ioc');
const Provider = require('../provider');
const Hertzy = require('hertzy');
const config = require('config');
const {AmqpPublisherFactory} = require('../amqp');

const apiEvents = Hertzy.tune('api-events');

/** The application Events Emitter. For each of the registered events can publish messeages on AMQP exchanges. */
module.exports =
  inject(
    [AmqpPublisherFactory],
    provider(
      class EventsEmitterProvider extends Provider {
        constructor(amqpPublisherFactory) {
          super();
          this._amqpPublisherFactory = amqpPublisherFactory;
          this._eventsMap = new Map();
        }

        async $start() {
          try {
            const eventsMapFile = `${process.cwd()}/${config.get('events.mapFile')}`;
            this._eventsConfigMap = require(eventsMapFile).events;

            this.registerEvents();
          } catch (err) {
            throw err;
          }
        }


        async $stop() {
          // nothing to stop here. AMQP stopping stuffs are in charge of the AmqpConnectionManager Provider
        }

        /** Register events with their relative AMQP Publisher into the <evt;publisher> Map. */
        registerEvents() {
          for (const evt of this._eventsConfigMap) {
            // initialize Publisher and add to the <evt;publisher> map
            const amqpPublisher = this._amqpPublisherFactory().newPublisher(evt.amqpConfig.exchange);
            //const amqpPublisher = new AmqpPublisher(evt.amqpConfig.exchange);
            this._eventsMap.set(evt.name, amqpPublisher);

            this._logger.debug(`registering event ${evt.name} on events-channel "api-events"`);
            // evt callback to publish evt on AMQP queue
            apiEvents.on(evt.name, (data) => {
              this._logger.debug(`got event ${evt.name} with data ${JSON.stringify(data)}`);

              try {
                const amqpPublisher = this._eventsMap.get(evt.name);
                amqpPublisher.publish(data);
                this._logger.info(`${evt.name} event published on AMQP exchange`);
              } catch (err) {
                this._logger.error(`error sending event ${evt.name} - ${JSON.stringify(data)} - error: ${err}`);
              }

            });

            this._logger.info(`event: ${JSON.stringify(evt)} registered`);
          }
        }

        /**
         * Returns the <event;publisher> Map.
         * @return {Map} _eventsMap - The <event;publisher> Map.
         */
        get eventsMap() {
          return this._eventsMap;
        }

        /**
         * Returns the events configuration.
         * @return {object} _eventsConfigMap - The events configuration data structure.
         */
        get eventsConfigMap() {
          return this._eventsConfigMap;
        }

        get $healthId() {
          return 'events-emitter';
        }
      }
    )
  );
/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/providers/emitter/index.js
 */

'use strict';

module.exports = require('./events-emitter.provider');/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/providers/health/index.js
 */

'use strict';

const {provider, container} = require('../../ioc');
const Provider = require('../provider');
const ProvidersRegister = require('./providers-register');
const autoBind = require('auto-bind');
const dayJs = require('dayjs');

module.exports =
  provider(
    class Health extends Provider {
      constructor() {
        super();
        autoBind(this);
      }

      async $start(providersIds) {
        if (providersIds) {
          ProvidersRegister.registerAll(providersIds);
        }

        this._logger.info('providers list set');
      }

      async $stop() {
        this._logger.debug('IMPLEMENT Health Provider stop functionality');
      }

      async health() {
        return new Promise(async (resolve) => {
          this._logger.info('composing health info');
          const timestamp = new dayJs();
          const uptime = process.uptime();
          let healthResponse = {
            status: 'UP',
            starttime: timestamp.subtract(uptime, 'second'),
            uptime: uptime,
            timestamp: timestamp
          };

          for (let providerIocId of ProvidersRegister.ids) {
            try {
              const provider = container.get(providerIocId);
              if (provider.$isCheckableForHealth()) {
                this._logger.debug(`getting health info for ${providerIocId} Provider`);
                let healthMsg = {};
                try {
                  healthMsg = await provider.$health();
                } catch (err) {
                  healthMsg = err;
                }

                healthResponse[provider.$healthId] = healthMsg;
                this._logger.debug(`${providerIocId} Provider health response: ${JSON.stringify(healthMsg)}`);
              } else {
                this._logger.debug(`${providerIocId} Provider has not been set has health checkable`);
              }
            } catch (err) {
              this._logger.warn(`unable to get health info for ${providerIocId} Provider`);
            }
          }

          this._logger.info(`health info: ${JSON.stringify(healthResponse)}`);
          resolve(healthResponse);
        });

      }
    }
  );


/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/providers/health/index.js
 */

'use strict';

module.exports = require('./health.provider');/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/providers/health/providers-register.js
 */

'use strict';

let ProvidersIds = module.exports = {
  ids: [],
  register: (id) => {
    ProvidersIds.ids.push(id);
  },
  registerAll: (providerIds) => {
    ProvidersIds.concat(ProvidersIds);
  },
  remove: (id) => {
    const idx = ProvidersIds.ids.indexOf(id);
    if (idx) ProvidersIds.ids.splice(idx, 1);
  }
};/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/providers/index.js
 */

'use strict';

module.exports = {
  Provider: require('./provider'),
  DbConnectionManager: require('./db'),
  Api: require('./api').Api,
  Router: require('./api').Router,
  AuthMiddleware: require('./api').AuthMiddleware,
  AmqpConnectionManager: require('./amqp').AmqpConnectionManager,
  AmqpPublisher: require('./amqp').AmqpPublisher,
  AmqpPublisherFactory: require('./amqp').AmqpPublisherFactory,
  EventsEmitter: require('./emitter'),
  Health: require('./health'),
  Management: require('./management')
};/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/providers/management/index.js
 */

'use strict';

/** @module node-mu/management */
module.exports = require('./management.provider');/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/providers/management/management.provider.js
 */

'use strict';

const {provider} = require('../../ioc');
const express = require('express');
const Router = require('../api/router');
const http = require('http');
const bodyParser = require('body-parser');
const compression = require('compression');
const methodOverride = require('method-override');
const helmet = require('helmet');
const cors = require('cors');
const ignoreFavicon = require('../api/middlewares/ignore-favicon');
const errorMiddleware = require('../api/middlewares/error');
const enableDestroy = require('server-destroy');
const expressWinston = require('express-winston');
const RequestLoggerTransport = require('../api/request-logger-transport');
const config = require('config');
const {fullInfo} = require('../../utils').serviceInfo;
const ioc = require('../../ioc').container;
const os = require('os');

module.exports =
  provider(
    class Management extends Router {
      constructor() {
        super();
        this._mgmtConfig = config.get('management');
        this._mgmtApp = express();

        this._mgmtPath = this._mgmtConfig.endpoint.baseRoutingPath || '/management';
        this._configureApp();

        this._logger.info('initializing Management server');
        this._logger.info(`routing with basePath ${this._mgmtPath}`);
        this._mgmtApp.use(this._mgmtPath, this.routes);
      }

      async $start() {
        return new Promise((resolve, reject) => {
          this._logger.debug('starting Management server');
          this._server = http.createServer(this._mgmtApp);
          this._server.listen(this._mgmtConfig.endpoint.port, (err) => {
            if (err) {
              return reject(err);
            }
            this._logger.info(`Management server listening on http://${this._server.address().address}:${this._server.address().port}`);
            return resolve();
          });

          /* Hack to close all pending connections: https://github.com/isaacs/server-destroy */
          enableDestroy(this._server);
        });
      }

      /** Stops the Management Http server. */
      async $stop() {
        return new Promise((resolve, reject) => {
          this._logger.info('gracefully shutting down the Management server');
          if (this._server) {
            this._server.destroy(() => {
              this._logger.info('Management server destroyed');
              return resolve(true);
            });
          } else {
            this._logger.warn('[Management] Management server destroyed (it was null!)');
            return resolve(true);
          }
        });
      }

      /**
       * Configure the Express app.
       * @private
       */
      _configureApp() {
        this._logger.debug('configuring Management express app');

        this._requestLoggerTransport = new RequestLoggerTransport();
        this._mgmtApp.use(expressWinston.logger(this._requestLoggerTransport.requestsLoggerTransports));

        this._mgmtApp.use(bodyParser.json());
        this._mgmtApp.use(bodyParser.urlencoded({extended: true}));
        this._mgmtApp.use(compression());
        this._mgmtApp.use(methodOverride());
        this._mgmtApp.use(helmet());
        this._mgmtApp.use(cors());
        this._mgmtApp.use(ignoreFavicon);

        // TODO: add the ability to configure other Management endpoints

        // service info endpoint
        this.addRoute('/info', (req, res) => {
          res.json(fullInfo());
        });

        // service health endpoint
        this.addRoute('/health', async (req, res) => {
          try {
            const healthService = ioc.get('Health');
            const health = await healthService.health();
            return res.json(health);
          } catch (err) {
            throw err;
          }
        });
      }

      get $healthId() {
        return 'management';
      }
    }
  );
/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/providers/provider.js
 */

'use strict';

const {Component} = require('../components');

class Provider extends Component {
  constructor(ctype = 'component:provider') {
    super(ctype);
  }

  async $start(options) {
    throw Error(`${this.constructor.name}.$start() not implemented. Unable to mount the ${this.constructor.name} provider`);
  }

  async $stop() {
    this._logger.warn(`${this.constructor.name} provider stoppped`);
  }

  /**
   * Default health id which will compare in the json health response.
   *
   * NOTE: Override this in your provider if you want to use a different id for your provider.
   * @returns {*}
   */
  get $healthId() {
    return this.constructor.name;
  }

  $isCheckableForHealth() {
    return false;
  }

  /**
   * Default health method for a Provider.
   *
   * NOTE: Ovverride this in your provider in order to do real health checks.
   *
   * @returns {Promise<{status: string}>}
   */
  async $health() {
    return {
      status: "UP"
    }
  }
}

module.exports = Provider;/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/utils/api-error.js
 */

'use strict';

const httpStatus = require('http-status');

/** An extendable base class for custom errors. It extends default Error. */
class ExtendableError extends Error {
  constructor({
                message, errors, status, isPublic, stack,
              }) {
    super(message);
    this.name = this.constructor.name;
    this.message = message;
    this.errors = errors;
    this.status = status;
    this.isPublic = isPublic;
    this.isOperational = true; // This is required since bluebird 4 doesn't append it anymore.
    this.stack = stack;
    // Error.captureStackTrace(this, this.constructor.name);
  }
}

/** Custom error returned by API to the client. */
class APIError extends ExtendableError {
  constructor({
                message,
                errors,
                stack,
                status = httpStatus.INTERNAL_SERVER_ERROR,
                isPublic = false,
              }) {
    super({
      message, errors, status, isPublic, stack,
    });
  }
}

/** @module node-mu/utils/api-error */
module.exports = APIError;/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 * 
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 * 
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/utils/index.js
 */

'use strict';

/** @module node-mu/utils */
module.exports = {
  serviceInfo: require('./service-info'),
  APIError: require('./api-error'),
  generateKey: require('./key-generator'),
  responseUtils : require('./response-utils')
};
/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/utils/key-generator.js
 */

'use strict';

/**
 * Generates a random key of the specified length (default = 20).
 * @param n - the length of the key to generate
 * @returns {string} - the generated key
 */
const keyGenerator = (n = 20) => {
  const add = 1;
  let max = 12 - add;

  if (n > max) {
    return keyGenerator(max) + keyGenerator(n - max);
  }

  max = Math.pow(10, n + add);
  const min = max / 10;
  const number = Math.floor(Math.random() * (max - min + 1)) + min;

  return ("" + number).substring(add);
};

module.exports = keyGenerator;/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/utils/response-utils.js
 */

'use strict';

const httpStatus = require('http-status');

// Response error Utils

const badRequestError = (message) => {
  return errorDescription(httpStatus.BAD_REQUEST, true, message);
};

const unauthorizedError = (message = 'Unauthorized: incorrect username or password.') => {
  return errorDescription(httpStatus.UNAUTHORIZED, true, message);
};

const errorDescription = (status, isPublic, message) => {
  return {
    status: status,
    isPublic: isPublic,
    message: message
  }
};

// Headers Utils

const getPagingParams = (req) => {
  const page = req.query.page || 0;
  const size = req.query.size || 0;
  const sort = req.query.sort;
  let sortField = 'id';
  let sortDirection = 'asc';
  if (sort && sort.indexOf(',') > -1) {
    const splitted = sort.split(',');
    sortField = splitted[0].trim();
    sortDirection = splitted[1].trim();
  }

  return {
    page,
    size,
    sortField,
    sortDirection
  }
};

const setPagingHeaders = (res, data, page, size, baseUrl) => {
  const totalCount = Number.parseInt(data.total || data.length, 10);
  res.set('X-Total-Count', data.total || data.length);

  const _page = Number.parseInt(page, 10);
  const _size = Number.parseInt(size, 10);

  let totalPages = Math.ceil(totalCount / size);

  let link = '';
  if ((page + 1) < totalPages) {
    link = `<${baseUrl}?page=${_page + 1}&size=${_size}>; rel="next",`;
  }

  if (page > 0) {
    link += `<${baseUrl}?page=${_page - 1}&size=${_size}>; rel="prev",`;
  }

  let lastPage = 0;
  if (totalPages > 0) {
    lastPage = totalPages - 1;
  }

  link += `<${baseUrl}?page=${lastPage}&size=${_size}>; rel="last",`;
  link += `<${baseUrl}?page=0&size=${_size}>; rel="first"`;
  res.set('link', link);
};

module.exports = {badRequestError, unauthorizedError, errorDescription, getPagingParams, setPagingHeaders};/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * lib/node-mu/utils/service-info.js
 */

'use strict';

const config = require('config');
const os = require('os');

const env = process.env.NODE_ENV || 'development';

const version = `${config.get('service.version.major')}.${config.get('service.version.minor')}.${config.get('service.version.status')}`;
const name = `${config.get('service.group')}-${config.get('service.name')}-${env.substring(0, 3)}_${version}`;
const serviceName = config.get('service.name');
const serviceGroup = config.get('service.group');

const fullInfo = () => {
  const iocContainer = require('../ioc').container;
  const instanceId = iocContainer.get(APPLICATION_TYPE).id;
  const instanceName = `${instanceId}/${name}@${os.hostname()}`;
  return {serviceName, serviceGroup, name, instanceId, instanceName, version, env};
};
module.exports = {serviceName, serviceGroup, name, version, env, fullInfo};/*!
 * node-mu
 * node.js minimalistic microservices framework on top of Express.js
 *
 * Copyright(c) 2018 IT Resources s.r.l.
 * Copyright(c) 2018 Luca Stasio <joshuagame@gmail.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * See node-mu license text even in LICENSE file.
 *
 * index.js
 */

/*jslint node: true */
'use strict';

const NodeMuLib = require('./lib');
module.exports = NodeMuLib;