@harmonyjs/controller-apollo-gateway/dist-node/index.js

Apollo Gateway controller for Harmony

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var gateway = require('@apollo/gateway');
var apolloFastify = require('@harmonyjs/apollo-fastify');

function _defineProperty(obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }

  return obj;
}

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 _objectSpread2(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) {
        _defineProperty(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;
}

let gatewayReference = null;
let firstComposition = true;

function didUpdateComposition(callback, serviceNumber) {
  return function (services) {
    if (services.serviceDefinitions.length === serviceNumber && !firstComposition) {
      callback();
    }

    firstComposition = false;
  };
}
/*
 * The Apollo Controller exposes a GraphQL endpoint through an Apollo Server
 */


const ControllerApolloGateway = function (config) {
  return {
    name: 'ControllerApolloGateway',

    async initialize({
      server,
      logger
    }) {
      const {
        path,
        enablePlayground,
        services,
        authentication,
        gatewayConfig,
        apolloConfig,
        routeConfig
      } = config;
      logger.info('Registering GraphQL Federation endpoint...');
      const gateway$1 = gatewayReference || new gateway.ApolloGateway(_objectSpread2(_objectSpread2({}, gatewayConfig || {}), {}, {
        serviceList: services,

        buildService({
          url
        }) {
          return new gateway.RemoteGraphQLDataSource({
            url,

            willSendRequest({
              request,
              context
            }) {
              if (context.headers) {
                Object.keys(context.headers).forEach(header => {
                  request.http.headers.set(header, context.headers[header]);
                });
              }
            }

          });
        }

      }));

      if (config.servicePoller) {
        if (!gatewayReference) {
          logger.warn('Service polling enabled');
          logger.warn('This is a development feature only. Do not use in production!');
        }

        firstComposition = true;
        gatewayReference = gateway$1;
        gatewayReference.experimental_pollInterval = 1000;
        gatewayReference.logger.disableAll(true);
        gatewayReference.startPollingServices();
        gatewayReference.experimental_didUpdateComposition = didUpdateComposition(config.servicePoller, config.services.length);
      }

      const apolloServer = new apolloFastify.ApolloServer(_objectSpread2(_objectSpread2({}, apolloConfig || {}), {}, {
        gateway: gateway$1,
        playground: !!enablePlayground,
        introspection: !!enablePlayground,
        context: ({
          request
        }) => ({
          headers: request.headers
        }),
        subscriptions: false
      }));

      const routeOptions = _objectSpread2({}, routeConfig || {});

      if (authentication) {
        // @ts-ignore
        if (!server[authentication.validator]) {
          logger.error('The provided authentication controller was not initialized');
          logger.error(`Make sure the authentication controller ${authentication().name} is present in your controllers array and is before ${this.name}`);
          throw new Error('Missing controller');
        }

        const preValidation = [];

        if (routeOptions.preValidation) {
          if (Array.isArray(routeOptions.preValidation)) {
            preValidation.push(...routeOptions.preValidation);
          } else {
            preValidation.push(routeOptions.preValidation);
          }
        } // @ts-ignore


        preValidation.push(server[authentication.validator].try);
        routeOptions.preValidation = preValidation;
      }

      await server.register(apolloServer.createHandler({
        path,
        cors: true,
        routeOptions
      }));
      logger.info(`GraphQL endpoint at ${path}`);

      if (enablePlayground) {
        logger.info(`GraphQL playground at ${path}`);
      }
    }

  };
};

exports.default = ControllerApolloGateway;
//# sourceMappingURL=index.js.map