@powership/server/out/graphql/graphqlHandler.cjs

Powership server

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.createGraphQLHandlers = createGraphQLHandlers;
var _path = _interopRequireDefault(require("path"));
var _schema = require("@powership/schema");
var _utils = require("@powership/utils");
var _graphql = require("graphql");
var _graphqlPlaygroundHtml = require("graphql-playground-html");
var _ServerLogs = require("../ServerLogs.cjs");
var _createRouteHandler = require("../createRouteHandler.cjs");
var _errorHandler = require("./errorHandler.cjs");
var _generateTypes = require("./generateTypes.cjs");
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
function createGraphQLHandlers(definition) {
  const {
    resolvers,
    path = '/graphql',
    playgroundAPIUrl = path
  } = definition;
  const IS_PROD = (0, _utils.isProduction)();
  const resolversList = Object.values(resolvers);
  const schema = (0, _schema.createGraphQLSchema)(resolversList);
  (0, _errorHandler.maskErrors)(schema);
  const data = {
    schema,
    resolvers,
    definition,
    resolversList
  };
  const graphQLHandler = (0, _createRouteHandler.createRouteHandler)(path, async function onRequest({
    request,
    response,
    close
  }) {
    // Determine whether we should render GraphiQL instead of returning an API response
    if (request.method === 'GET') {
      Object.assign(response, genPlaygroudResponse(playgroundAPIUrl));
      close(response);
      return;
    } else if (request.method === 'POST') {
      const {
        operationName,
        query,
        variables
      } = request.body;
      try {
        const {
          data,
          errors
        } = await (0, _graphql.graphql)({
          contextValue: request,
          schema,
          source: query,
          variableValues: variables,
          operationName
        });
        response.statusCode = 200;
        response.body = JSON.stringify({
          data,
          errors
        });
        close(response);
      } catch (e) {
        close(500);
      }
    }
  }, data);
  const typesPath = _path.default.join(path, 'types');
  const mockPath = _path.default.join(path, 'mock');
  const typesHandler = (0, _createRouteHandler.createRouteHandler)(typesPath, async function ({
    response,
    close
  }) {
    response.body = await (0, _generateTypes.generateTypes)(schema);
    response.statusCode = 200;
    response.headers.append('Content-Type', 'text/typescript');
    return close(response);
  });
  const mockHandler = (0, _createRouteHandler.createRouteHandler)(mockPath, async function ({
    response,
    close
  }) {
    if (IS_PROD) {
      response.statusCode = 'METHOD_NOT_ALLOWED';
      response.body = 'NOT_ALLOWED_IN_PRODUCTION';
      return close(response);
    }
    response.body = '';
    response.statusCode = 200;
    response.headers.append('Content-type', 'text/html');
    close(response);
  });

  // const utilsHandler = createRouteHandler(
  //   utilsPath,
  //   async function ({ response, request, close }) {
  //     const body: any = request.body;
  //
  //     const json =
  //       typeof body.json === 'string'
  //         ? JSON.parse(body.json.trim())
  //         : body.json || {};
  //
  //     const page = await powershipUtilsResolver({
  //       ...body,
  //       json,
  //       url: request.urlObject.pathname,
  //     });
  //
  //     response.body = page.body;
  //     response.headers.set('Content-Type', page.headers['Content-Type']);
  //     response.statusCode = page.statusCode;
  //
  //     return close(response);
  //   }
  // );

  return [
  // utilsHandler,
  typesHandler, mockHandler, graphQLHandler //
  ];
}
function genPlaygroudResponse(playgroundAPIUrl) {
  let html = (0, _graphqlPlaygroundHtml.renderPlaygroundPage)({
    title: 'GraphQL',
    endpoint: playgroundAPIUrl,
    // @ts-ignore
    // https://github.com/graphql/graphql-playground/pull/1401/files#
    shareEnabled: true,
    settings: {
      'editor.cursorShape': 'line',
      'editor.fontFamily': "'Source Code Pro', 'Consolas', 'Inconsolata', 'Droid Sans Mono', 'Monaco', monospace",
      'editor.fontSize': 14,
      'editor.reuseHeaders': true,
      'editor.theme': 'dark',
      'general.betaUpdates': false,
      // @ts-ignore
      'prettier.printWidth': 80,
      'prettier.tabWidth': 2,
      'prettier.useTabs': false,
      'request.credentials': 'include',
      'request.globalHeaders': {},
      'schema.disableComments': true,
      'schema.polling.enable': true,
      'schema.polling.endpointFilter': '*localhost*',
      'schema.polling.interval': 10000,
      'tracing.hideTracingResponse': true,
      'tracing.tracingSupported': true
    }
  });
  html = html.replace('</body>', `
    window.addEventListener('load', function (event) {
      document.title = "Playground"
    });
  </body>`);
  try {
    return {
      body: html,
      statusCode: 200,
      headers: {
        'Content-Type': 'text/html'
      }
    };
  } catch (e) {
    console.error(e);
    _ServerLogs.ServerLogs.error(e);
    return {
      body: 'INVALID_REQUEST',
      statusCode: 400
    };
  }
}
//# sourceMappingURL=graphqlHandler.cjs.map