@x-ray/core/node/server/run.js

X-Ray Core

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

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

var _http = _interopRequireDefault(require("http"));

var _url = _interopRequireDefault(require("url"));

var _tsfn = require("tsfn");

var _unchunk = require("unchunk");

var _constants = require("../constants");

var _getList = require("./get-list");

var _getMeta = require("./get-meta");

var _getResult = require("./get-result");

var _save = require("./save");

const runServer = options => new Promise((serverResolve, serverReject) => {
  const pathsMap = new Map();

  for (const [key, value] of options.results) {
    pathsMap.set(key, value.name);
    pathsMap.set(value.name, key);
  }

  const savePromise = new Promise((saveResolve, saveReject) => {
    const server = _http.default.createServer(async (req, res) => {
      try {
        res.setHeader('Access-Control-Allow-Origin', `http://${_constants.UI_HOST}:${_constants.UI_PORT}`);

        if ((0, _tsfn.isDefined)(req.url)) {
          const urlData = _url.default.parse(req.url, true);

          if (req.method === 'GET' && urlData.pathname === '/list') {
            const list = (0, _getList.getList)({
              results: options.results,
              encoding: options.encoding
            });
            res.end(JSON.stringify(list));
            return;
          }

          if (req.method === 'GET' && urlData.pathname === '/get-result') {
            const result = (0, _getResult.getResult)({
              results: options.results,
              pathsMap,
              query: urlData.query
            });

            if (result === null) {
              throw new Error(`Invalid get request: ${req.url}`);
            }

            if (options.encoding === 'image') {
              res.setHeader('Content-Type', 'image/png');
              res.end(Buffer.from(result), 'binary');
            } else {
              res.end(result);
            }

            return;
          }

          if (req.method === 'GET' && urlData.pathname === '/get-meta') {
            const result = (0, _getMeta.getMeta)({
              results: options.results,
              pathsMap,
              query: urlData.query
            });

            if (result === null) {
              throw new Error(`Invalid get request: ${req.url}`);
            }

            res.setHeader('Content-Type', 'application/json');
            res.end(JSON.stringify(result));
            return;
          }

          if (req.method === 'POST' && req.url === '/save') {
            const keys = await (0, _unchunk.unchunkJson)(req);
            await (0, _save.save)({
              results: options.results,
              pathsMap,
              keys,
              pluginName: options.pluginName,
              encoding: options.encoding
            });
            res.end();
            server.close(error => {
              if ((0, _tsfn.isError)(error)) {
                saveReject(error);
              } else {
                saveResolve();
              }
            });
            return;
          }
        }

        res.end();
      } catch (error) {
        res.end();
        server.close();
        saveReject(error);
      }
    }).once('error', serverReject).listen(_constants.SERVER_PORT, _constants.SERVER_HOST, () => {
      serverResolve(() => savePromise);
    });
  });
});

exports.runServer = runServer;