terra-toolkit/lib/wdio/services/ServeStaticService.js

Utilities to help when developing terra modules.

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));

var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));

var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));

var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));

var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));

var _serveStatic = _interopRequireDefault(require("../../../scripts/serve/serve-static"));

var _services = _interopRequireDefault(require("../../../config/wdio/services.default-config"));

var _logger = _interopRequireDefault(require("../../../scripts/utils/logger"));

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

var WebpackDevServer = require('webpack-dev-server');

var webpack = require('webpack');

var SERVE_STATIC_DEFAULTS = _services.default.serveStatic;
var context = '[Terra-Toolkit:serve-static-service]';

var displayServer = function displayServer() {
  _logger.default.log('Server started listening', {
    context: context
  });
}; // Create a new proxy watch function


var watch = function watch(compiler) {
  // Store off original watch function.
  var origWatch = compiler.watch; // Return new watch function

  return function (watchOptions, handler) {
    // Call original watch functions with the compiler as 'this'
    var watcher = origWatch.call(compiler, watchOptions, handler); // Remove the 'watch' function from the returned watcher.

    watcher.watch = function () {
      _logger.default.log('Hot reloading has been disabled for tests.', {
        context: context
      });
    };

    return watcher;
  };
}; // Create a webpack dev server instance.


var startWebpackDevServer = function startWebpackDevServer(options) {
  var port = options.port,
      index = options.index,
      locale = options.locale,
      theme = options.theme;
  var host = '0.0.0.0';
  var config = options.config; // if config is a function, execute it with prod mode if applicable.

  if (typeof config === 'function') {
    var env = _objectSpread(_objectSpread({}, locale && {
      defaultLocale: locale
    }), theme && {
      theme: theme
    });

    config = config(env, {
      p: true
    });
  }

  return new Promise(function (resolve, reject) {
    // get a compiler
    var compiler = webpack(config); // Disable hot reloading

    compiler.watch = watch(compiler); // Give webpack plugins a chance to modify dev server config.

    var devServerOptions = _objectSpread(_objectSpread({}, compiler.options.devServer), {}, {
      hot: false,
      inline: false,
      host: host,
      port: port,
      index: index,
      stats: {
        colors: true,
        children: false
      }
    }); // get a server


    var devServer = new WebpackDevServer(compiler, devServerOptions); // add a hook to report when webpacking is done

    compiler.hooks.done.tap('Done', function (stats) {
      if (stats.hasErrors()) {
        reject();
      } else {
        resolve(devServer);
      }
    });
    compiler.hooks.failed.tap('Failed', function () {
      _logger.default.warn('Webpack failed to compile', {
        context: context
      });

      reject();
    }); // start that server.

    devServer.listen(port, host, function (err) {
      if (err) {
        reject(err);
      }

      displayServer();
    });
  });
};

var ServeStaticService = /*#__PURE__*/function () {
  function ServeStaticService() {
    (0, _classCallCheck2.default)(this, ServeStaticService);
  }

  (0, _createClass2.default)(ServeStaticService, [{
    key: "onPrepare",
    value: function () {
      var _onPrepare = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
        var _this = this;

        var config,
            site,
            webpackConfig,
            locale,
            theme,
            port,
            index,
            serveOptions,
            _args = arguments;
        return _regenerator.default.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                config = _args.length > 0 && _args[0] !== undefined ? _args[0] : {};
                site = config.site, webpackConfig = config.webpackConfig;
                locale = process.env.LOCALE || config.locale;
                theme = process.env.THEME || config.theme;

                if (!(!webpackConfig && !site)) {
                  _context.next = 7;
                  break;
                }

                _logger.default.warn('No webpack configuration provided', {
                  context: context
                });

                return _context.abrupt("return");

              case 7:
                port = (config.serveStatic || {}).port || SERVE_STATIC_DEFAULTS.port;
                index = (config.serveStatic || {}).index || SERVE_STATIC_DEFAULTS.index; // Explicitly not providing a fallback locale. Providing a fallback will lock the locale for all test runs when using the tt-wdio-runner.
                // Ensure the server was properly shut down.

                if (!this.server) {
                  _context.next = 12;
                  break;
                }

                _context.next = 12;
                return this.stop();

              case 12:
                serveOptions = _objectSpread(_objectSpread({}, site && {
                  site: site
                }), {}, {
                  config: webpackConfig,
                  port: port,
                  index: index,
                  locale: locale,
                  theme: theme,
                  production: true
                });
                _context.next = 15;
                return ServeStaticService.startService(serveOptions).then(function (server) {
                  _this.server = server;
                });

              case 15:
              case "end":
                return _context.stop();
            }
          }
        }, _callee, this);
      }));

      function onPrepare() {
        return _onPrepare.apply(this, arguments);
      }

      return onPrepare;
    }()
  }, {
    key: "onComplete",
    value: function () {
      var _onComplete = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2() {
        return _regenerator.default.wrap(function _callee2$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                _context2.next = 2;
                return this.stop();

              case 2:
              case "end":
                return _context2.stop();
            }
          }
        }, _callee2, this);
      }));

      function onComplete() {
        return _onComplete.apply(this, arguments);
      }

      return onComplete;
    }() // Options include config, site, port, index, locale

  }, {
    key: "stop",
    value: function stop() {
      var _this2 = this;

      return new Promise(function (resolve) {
        _logger.default.log('Closing Server', {
          context: context
        });

        if (_this2.server) {
          _this2.server.close();

          _this2.server = null;
        }

        resolve();
      });
    }
  }], [{
    key: "startService",
    value: function startService(serveOptions) {
      if (serveOptions.site) {
        return (0, _serveStatic.default)(serveOptions);
      }

      return startWebpackDevServer(serveOptions);
    }
  }]);
  return ServeStaticService;
}();

exports.default = ServeStaticService;