oors-graphql/build/index.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
var _exportNames = {
  decorators: true,
  Resolvers: true
};
Object.defineProperty(exports, "Resolvers", {
  enumerable: true,
  get: function () {
    return _Resolvers.default;
  }
});
exports.decorators = exports.default = void 0;

var _easevalidation = require("easevalidation");

var _graphql = require("graphql");

var _glob = _interopRequireDefault(require("glob"));

var _path = _interopRequireDefault(require("path"));

var _fsExtra = _interopRequireDefault(require("fs-extra"));

var _get = _interopRequireDefault(require("lodash/get"));

var _set = _interopRequireDefault(require("lodash/set"));

var _has = _interopRequireDefault(require("lodash/has"));

var _pick = _interopRequireDefault(require("lodash/pick"));

var _isPlainObject = _interopRequireDefault(require("lodash/isPlainObject"));

var _invariant = _interopRequireDefault(require("invariant"));

var _identity = _interopRequireDefault(require("lodash/identity"));

var _oors = require("oors");

var _graphqlSubscriptions = require("graphql-subscriptions");

var _merge = _interopRequireDefault(require("lodash/merge"));

var _graphqlTools = require("graphql-tools");

var _middleware = require("graphql-voyager/middleware");

var _graphqlImport = require("graphql-import");

var _graphqlBinding = require("graphql-binding");

var _graphqlConstraintDirective = _interopRequireDefault(require("graphql-constraint-directive"));

var _graphqlDepthLimit = _interopRequireDefault(require("graphql-depth-limit"));

var _validators = require("oors-express/build/validators");

var _resolvers = _interopRequireDefault(require("./graphql/resolvers"));

var _modulesResolvers = _interopRequireDefault(require("./graphql/modulesResolvers"));

var _LoadersMap = _interopRequireDefault(require("./libs/LoadersMap"));

var decorators = _interopRequireWildcard(require("./decorators"));

exports.decorators = decorators;
Object.keys(decorators).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function () {
      return decorators[key];
    }
  });
});

var _Server = _interopRequireDefault(require("./libs/Server"));

var _Resolvers = _interopRequireDefault(require("./libs/Resolvers"));

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: 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 _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

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; }

const asyncGlob = (...args) => new Promise((resolve, reject) => {
  (0, _glob.default)(...args, (err, files) => {
    if (err) {
      reject(err);
    } else {
      resolve(files);
    }
  });
});

class Gql extends _oors.Module {
  constructor(..._args) {
    super(..._args);
    this.name = 'oors.graphql';
    this.hooks = {
      'oors.cache.load': ({
        createPolicy
      }) => {
        createPolicy('graphqlResolvers');
      }
    };

    this.teardown = () => this.server.stop();

    this.extendContext = extender => {
      (0, _invariant.default)(typeof extender === 'function' || (0, _isPlainObject.default)(extender), `Invalid context extender! Needs to be either a function or a an object that will get 
      assigned to the context.`);
      this.contextExtenders.push(extender);
      return this.contextExtenders;
    };

    this.bindSchema = (schema, options = {}) => new _graphqlBinding.Binding(_objectSpread({
      schema
    }, options));

    this.addTypeDefs = typeDefs => {
      this.typeDefs.push(typeDefs);
    };

    this.addDirectives = directives => {
      Object.assign(this.directives, directives);
    };

    this.addResolvers = resolvers => {
      if (this.schema) {
        (0, _graphqlTools.addResolveFunctionsToSchema)({
          schema: this.schema,
          resolvers
        });
      } else {
        (0, _merge.default)(this.resolvers, resolvers);
      }
    };

    this.addResolverMiddleware = (matcher, middleware) => {
      this.resolverMiddlewares.push({
        matcher: typeof matcher === 'string' ? new RegExp(`^${matcher}$`) : matcher,
        middleware
      });
      return this;
    };

    this.addLoader = (...args) => {
      this.loaders.add(...args);
    };

    this.addLoaders = (...args) => {
      this.loaders.multiAdd(...args);
    };

    this.addTypeDefsByPath = async filePath => {
      this.addTypeDefs((await _fsExtra.default.readFile(filePath, 'utf8')));
    };

    this.importSchema = schemaPath => {
      this.addTypeDefs((0, _graphqlImport.importSchema)(schemaPath));
    };

    this.loadFromDir = async dirPath => Promise.all([this.loadTypeDefsFromDir(dirPath), this.loadResolversFromDir(dirPath), this.loadDirectivesFromDir(dirPath)]);

    this.loadTypeDefsFromDir = async dirPath => {
      try {
        // try to load /graphql/typeDefs/**/*.graphl
        const typeDefsDirPath = _path.default.join(dirPath, 'typeDefs');

        const stats = await _fsExtra.default.stat(typeDefsDirPath);

        if (stats.isDirectory()) {
          const files = await asyncGlob(_path.default.resolve(typeDefsDirPath, '**/*.graphql'));
          await Promise.all(files.map(file => this.addTypeDefsByPath(file)));
        }
      } catch (_unused) {
        // try to load /graphql/typeDefs.graphl
        try {
          await this.addTypeDefsByPath(_path.default.join(dirPath, 'typeDefs.graphql'));
        } catch (_unused2) {}
      }
    };

    this.loadResolversFromDir = async dirPath => {
      try {
        const resolvers = require(`${dirPath}/resolvers`);

        if (resolvers.default) {
          Object.assign(resolvers, resolvers.default);
          delete resolvers.default;
        }

        this.addResolvers(resolvers);
      } catch (err) {
        const resolversPath = await asyncGlob(_path.default.resolve(`${dirPath}/resolvers`, '**/*.js'));
        const resolvers = resolversPath.reduce((acc, resolverPath) => {
          const resolverName = _path.default.relative(`${dirPath}/resolvers`, resolverPath).slice(0, -3).split(_path.default.sep).join('.');

          (0, _set.default)(acc, resolverName, require(resolverPath).default);
          return acc;
        }, {});
        this.addResolvers(resolvers);
      }
    };

    this.loadDirectivesFromDir = async dirPath => {
      try {
        const directives = require(`${dirPath}/directives`);

        if (directives.default) {
          Object.assign(directives, directives.default);
          delete directives.default;
        }

        this.addDirectives(directives);
      } catch (err) {}
    };

    this.collectFromModule = async module => {
      if (!module.getConfig('oors.graphql.autoload', true)) {
        return;
      }

      if ((0, _has.default)(module, 'graphql')) {
        this.addTypeDefs((0, _get.default)(module, 'graphql.typeDefs', ''));
        this.addResolvers((0, _get.default)(module, 'graphql.resolvers', {}));

        if ((0, _has.default)(module, 'graphql.typeDefsPath')) {
          await this.addTypeDefsByPath((0, _get.default)(module, 'graphql.typeDefsPath'));
        }
      } else {
        await this.loadFromDir(_path.default.resolve(_path.default.dirname(module.filePath), 'graphql'));
      }
    };

    this.buildSchema = async () => {
      const schema = (0, _graphqlTools.makeExecutableSchema)(this.getConfig('configureSchema', _identity.default)({
        typeDefs: this.typeDefs,
        resolvers: this.applyResolversMiddlewares(this.resolvers),
        logger: {
          log: err => {
            this.emit('error', err);
          }
        },
        allowUndefinedInResolve: false,
        inheritResolversFromInterfaces: true,
        schemaDirectives: this.directives
      }));
      const schemas = (await this.runHook('getSchema', () => {}, {
        schema,
        mergeSchemas: _graphqlTools.mergeSchemas,
        makeExecutableSchema: _graphqlTools.makeExecutableSchema,
        makeRemoteExecutableSchema: _graphqlTools.makeRemoteExecutableSchema
      })).filter(s => s);
      return schemas.length ? (0, _graphqlTools.mergeSchemas)({
        schemas: [schema, ...schemas]
      }) : schema;
    };

    this.buildServer = (options = {}) => {
      const config = _objectSpread({
        context: this.buildContext,
        formatError: this.format('error'),
        formatParams: this.format('params'),
        formatResponse: this.format('response'),
        schema: this.schema,
        debug: true,
        tracing: true,
        cacheControl: true,
        subscriptions: true,
        introspection: true,
        mocks: false,
        persistedQueries: true,
        validationRules: [(0, _graphqlDepthLimit.default)(this.getConfig('depthLimit.limit'), this.getConfig('depthLimit.options'), this.getConfig('depthLimit.callback'))],
        costAnalysisConfig: this.getConfig('costAnalysis')
      }, this.getConfig('serverOptions'), {}, options);

      const server = new _Server.default(config);

      if (config.subscriptions) {
        server.installSubscriptionHandlers(this.deps['oors.express'].server);
      }

      return server;
    };

    this.buildContext = ({
      req,
      connection
    } = {}) => {
      const context = _objectSpread({}, this.gqlContext, {
        loaders: this.loaders.build(),
        req,
        connection
      }, req ? {
        user: req.user
      } : {}, {}, connection ? connection.context || {} : {});

      this.contextExtenders.forEach(extender => extender(context));

      context.execute = (source, options = {}) => this.execute(source, _objectSpread({}, options, {
        context: () => _objectSpread({}, context, {}, options.context || {})
      }));

      return context;
    };

    this.execute = (source, options = {}) => {
      const {
        root,
        context,
        variables,
        operation
      } = _objectSpread({
        root: undefined,
        variables: {},
        operation: undefined
      }, options, {
        context: typeof options.context === 'function' ? options.context(this.buildContext) : _objectSpread({}, this.buildContext(), {}, options.context || {})
      });

      return (0, _graphql.graphql)(this.schema, source, root, context, variables, operation);
    };

    this.format = type => {
      (0, _invariant.default)(Array.isArray(this.formatters[type]), `Unknown formatter type - ${type}!`);
      return arg => this.formatters[type].reduce((acc, formatter) => formatter(acc), arg);
    };
  }

  initialize() {
    this.typeDefs = [];
    this.directives = {
      constraint: _graphqlConstraintDirective.default
    };
    this.resolvers = _resolvers.default;
    this.resolverMiddlewares = [];
    this.pubsub = this.getConfig('pubsub', new _graphqlSubscriptions.PubSub());
    this.gqlContext = {
      pubsub: this.pubsub,
      modules: this.manager
    };
    this.loaders = new _LoadersMap.default();
    this.contextExtenders = [];
    this.formatters = {
      params: [],
      error: [],
      response: []
    };
  }

  async setup() {
    await this.loadDependencies(['oors.express']);
    await this.runHook('load', this.collectFromModule, (0, _pick.default)(this, ['pubsub', 'addTypeDefs', 'addDirectives', 'addTypeDefsByPath', 'addResolvers', 'addResolverMiddleware', 'addLoader', 'loadFromDir']));
    Object.assign(this.gqlContext, {
      app: this.deps['oors.express'].app
    });

    if (this.getConfig('exposeModules')) {
      this.addResolvers(_modulesResolvers.default);
      await this.addTypeDefsByPath(_path.default.resolve(__dirname, './graphql/modulesTypeDefs.graphql'));
    }

    await this.runHook('buildContext', () => {}, {
      context: this.gqlContext
    });
    this.schema = await this.buildSchema();
    this.server = this.buildServer();
    this.applyMiddlewares(this.server);
    const binding = this.bindSchema(this.schema);
    this.exportProperties(['extendContext', 'schema', 'server', 'loaders', 'addResolverMiddleware', 'addLoader', 'addLoaders', 'addResolvers', 'importSchema', 'bindSchema', 'binding', 'setupListen', 'pubsub', 'formatters', 'buildContext', 'execute']);
    this.export({
      context: this.gqlContext,
      addSchemaResolvers: rootResolveFunction => (0, _graphqlTools.addSchemaLevelResolveFunction)(this.schema, rootResolveFunction),
      addDirectivesResolvers: directivesResolvers => (0, _graphqlTools.attachDirectiveResolvers)(this.schema, directivesResolvers)
    });
    this.on('after:setup', () => {
      Object.assign(this.gqlContext, {
        binding
      });
    });
  }

  applyResolversMiddlewares(resolvers) {
    if (!this.resolverMiddlewares.length) {
      return resolvers;
    }

    return Object.keys(resolvers).reduce((resolversAcc, type) => _objectSpread({}, resolversAcc, {
      [type]: Object.keys(resolvers[type]).reduce((typeAcc, field) => {
        let resolver = resolvers[type][field];
        const branch = `${type}.${field}`;
        const middlewares = this.resolverMiddlewares.filter(({
          matcher
        }) => matcher.test(branch));

        if (middlewares.length) {
          resolver = [...middlewares].reverse().reduce((acc, {
            middleware
          }) => (...args) => middleware(...args, acc), resolver);
        }

        return _objectSpread({}, typeAcc, {
          [field]: resolver
        });
      }, {})
    }), {});
  }

  applyMiddlewares(server) {
    this.deps['oors.express'].middlewares.insertBefore(this.getConfig('middlewarePivot'), this.getApolloServerMiddlewares(server), this.getVoyagerMiddleware());
  } // eslint-disable-next-line class-methods-use-this


  getApolloServerMiddlewares(server) {
    return {
      id: 'apolloServer',
      apply: ({
        app
      }) => {
        server.applyMiddleware({
          app,
          cors: false,
          bodyParserConfig: false,
          onHealthCheck: req => this.asyncEmit('healthCheck', req)
        });
      }
    };
  }

  getVoyagerMiddleware() {
    return {
      id: 'voyager',
      path: '/voyager',
      factory: ({
        endpointURL
      }) => (0, _middleware.express)({
        endpointUrl: endpointURL
      }),
      params: this.getConfig('voyager.params'),
      enabled: this.getConfig('voyager.enabled')
    };
  }

}

exports.default = Gql;
Gql.validateConfig = (0, _easevalidation.validate)(_easevalidation.validators.isSchema({
  voyager: [_easevalidation.validators.isDefault({}), _easevalidation.validators.isSchema({
    enabled: [_easevalidation.validators.isDefault(true), _easevalidation.validators.isBoolean()],
    params: [_easevalidation.validators.isDefault({}), _easevalidation.validators.isSchema({
      endpointURL: [_easevalidation.validators.isDefault('/graphql'), _easevalidation.validators.isString()]
    })]
  })],
  middlewarePivot: [_easevalidation.validators.isDefault('isMethod'), (0, _validators.isMiddlewarePivot)()],
  configureSchema: _easevalidation.validators.isAny(_easevalidation.validators.isFunction(), _easevalidation.validators.isUndefined()),
  exposeModules: [_easevalidation.validators.isDefault(true), _easevalidation.validators.isBoolean()],
  serverOptions: [_easevalidation.validators.isDefault({}), _easevalidation.validators.isObject()],
  pubsub: _easevalidation.validators.isAny(_easevalidation.validators.isObject(), _easevalidation.validators.isUndefined()),
  depthLimit: [_easevalidation.validators.isDefault({}), _easevalidation.validators.isSchema({
    limit: [_easevalidation.validators.isDefault(10), _easevalidation.validators.isInteger()],
    options: _easevalidation.validators.isAny(_easevalidation.validators.isSchema({
      ignore: [_easevalidation.validators.isDefault([]), _easevalidation.validators.isArray()]
    }), _easevalidation.validators.isUndefined()),
    callback: _easevalidation.validators.isAny(_easevalidation.validators.isFunction(), _easevalidation.validators.isUndefined())
  })],
  costAnalysis: [_easevalidation.validators.isDefault({}), _easevalidation.validators.isSchema({
    maximumCost: [_easevalidation.validators.isDefault(1000), _easevalidation.validators.isInteger(), _easevalidation.validators.isPositive()]
  })]
}));