@mountainpass/addressr/lib/swagger.js

Australian Address Validation, Search and Autocomplete

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.swaggerDoc = undefined;
exports.swaggerInit = swaggerInit;
exports.startServer = startServer;
exports.stopServer = stopServer;
var _debug = require("debug");
var _debug2 = _interopRequireDefault(_debug);
var _express = require("express");
var _express2 = _interopRequireDefault(_express);
var _fs = require("fs");
var _http = require("http");
var _jsYaml = require("js-yaml");
var _path = require("path");
var _path2 = _interopRequireDefault(_path);
var _swaggerTools = require("swagger-tools");
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
//import connect from 'connect';

var app = (0, _express2.default)();
var serverPort = process.env.PORT || 8080;
var logger = (0, _debug2.default)('api');
var error = (0, _debug2.default)('error');
error.log = console.error.bind(console); // eslint-disable-line no-console

// swaggerRouter configuration
var options = {
  swaggerUi: _path2.default.join(__dirname, '/swagger.json'),
  controllers: _path2.default.join(__dirname, './controllers'),
  useStubs: process.env.NODE_ENV === 'development' // Conditionally turn on stubs (mock mode)
};

// The Swagger document (require it, build it programmatically, fetch it from a URL, ...)
var spec = (0, _fs.readFileSync)(_path2.default.join(__dirname, 'api/swagger.yaml'), 'utf8');
var swaggerDoc = exports.swaggerDoc = (0, _jsYaml.safeLoad)(spec);
global.swaggerDoc = swaggerDoc;
function swaggerInit() {
  // Initialize the Swagger middleware
  return new Promise(resolve => {
    (0, _swaggerTools.initializeMiddleware)(swaggerDoc, function (middleware) {
      // Interpret Swagger resources and attach metadata to request - must be first in swagger-tools middleware chain
      const metaData = middleware.swaggerMetadata();
      app.use(metaData);

      // Validate Swagger requests
      app.use(middleware.swaggerValidator({
        validateResponse: process.env.NODE_ENV === undefined || process.env.NODE_ENV === 'development'
      }));

      // Route validated requests to appropriate controller
      app.use(middleware.swaggerRouter(options));

      // Serve the Swagger documents and Swagger UI
      app.use(middleware.swaggerUi({
        // apiDocs: '/api-docs',
        // swaggerUi: '/docs',
      }));
      app.use(function (error_, request, res, next) {
        if (error_.failedValidation) {
          // handle validation errror
          const rehydratedError = Object.assign({}, error_);
          if (error_.originalResponse) {
            rehydratedError.originalResponse = JSON.parse(error_.originalResponse);
          }
          if (error_.message) {
            rehydratedError.message = error_.message;
          }
          if (error_.results) {
            rehydratedError.errors = error_.results.errors;
            delete rehydratedError.results;
          }
          error('error!!!', error_.message, JSON.stringify(rehydratedError, undefined, 2));
          res.status(error_.code === 'SCHEMA_VALIDATION_FAILED' ? '500' : '400').json(rehydratedError);
        } else {
          next();
        }
      });
      global.swaggerApp = app;
      global.swaggerMiddleware = middleware;
      resolve({
        app,
        middleware
      });
    });
  });
}
let server;
function startServer() {
  app.use((request, response, next) => {
    if (process.env.ADDRESSR_ACCESS_CONTROL_ALLOW_ORIGIN !== undefined) {
      response.append('Access-Control-Allow-Origin', process.env.ADDRESSR_ACCESS_CONTROL_ALLOW_ORIGIN);
    }
    if (process.env.ADDRESSR_ACCESS_CONTROL_EXPOSE_HEADERS !== undefined) {
      response.append('Access-Control-Expose-Headers', process.env.ADDRESSR_ACCESS_CONTROL_EXPOSE_HEADERS);
    }
    if (process.env.ADDRESSR_ACCESS_CONTROL_ALLOW_HEADERS !== undefined) {
      response.append('Access-Control-Allow-Headers', process.env.ADDRESSR_ACCESS_CONTROL_ALLOW_HEADERS);
    }
    next();
  });
  return swaggerInit().then(({
    app /*, middleware*/
  }) => {
    // logger(app);
    // logger(middleware);

    server = (0, _http.createServer)(app);
    server.listen(serverPort, function () {
      logger('📡  Addressr is listening on port %d ( http://localhost:%d ) ', serverPort, serverPort);
      logger('📑  Swagger-ui is available on http://localhost:%d/docs', serverPort);
      if (process.env.NODE_ENV !== 'PRODUCTION') {
        // ngrok.connect(serverPort).then(url => {
        //   logger('📡  Addressr is listening at %s', url);
        //   logger('📑  Swagger-ui is available on %s/docs/', url);
        // });
      }
    });
    return `http://localhost:${serverPort}`;
  });
}
function stopServer() {
  if (server !== undefined) {
    server.close();
  }
}