@backland/schema/lib/Resolver.js

TypeScript schema declaration and validation library with static type inference

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.createResolver = void 0;
exports.createResolverFactory = createResolverFactory;
exports.getResolver = getResolver;
exports.isPossibleArgsDef = isPossibleArgsDef;
var _graphql = require("graphql");
var _CircularDeps = require("./CircularDeps");
var _GraphType = require("./GraphType/GraphType");
var _getQueryTemplates = require("./GraphType/getQueryTemplates");
function _createResolver(options) {
  var _CircularDeps$typesWr;
  const {
    args,
    name,
    kind = 'query',
    resolve,
    type,
    ...rest
  } = options;
  if (_GraphType.GraphType.resolvers.has(name)) {
    // @ts-ignore
    return _GraphType.GraphType.resolvers.get(name);
  }
  const payloadType = _GraphType.GraphType.is(type) ? type : (0, _GraphType.createType)(`${name}Payload`, type);
  const gqlType = payloadType.graphQLType();
  const argsType = (0, _GraphType.createType)(`${name}Input`, isPossibleArgsDef(args) ? {
    object: args
  } : 'record');
  const argsGQLType = argsType.graphQLInputType({
    name: `${name}Input`
  });
  const innerArgsGQLType = (0, _getQueryTemplates.getInnerType)(argsGQLType);
  const resolveFunction = async function typeCheckResolveWrapper(source, args, context, info) {
    args = argsType ? argsType.parse(args, {
      customMessage: (_, error) => {
        return `Invalid input provided to resolver "${name}":\n ${error.message}`;
      }
    }) : args;

    // @ts-ignore
    const result = await resolve(source, args, context, info);
    return payloadType.parse(result, {
      customMessage: (_, error) => {
        return `Invalid output from resolver "${name}": ${error.message}`;
      },
      excludeInvalidListItems: true
    });
  };
  const result = {
    ...rest,
    __graphTypeId: payloadType.id,
    __isRelation: false,
    __isResolver: true,
    __relatedToGraphTypeId: '',
    args: 'getFields' in innerArgsGQLType.innerType ? innerArgsGQLType.innerType.getFields() : {},
    // Resolver fields - not in GraphQLFieldConfig
    argsDef: args,
    argsType,
    asObjectField: (_name = name) => {
      const temp = new _graphql.GraphQLObjectType({
        fields: {
          [_name]: result
        },
        name: 'temp'
      });
      return temp.getFields()[_name];
    },
    kind,
    name,
    payloadType,
    resolve: resolveFunction,
    type: gqlType,
    typeDef: payloadType.definition
  };
  _GraphType.GraphType.resolvers.set(name, result);
  (_CircularDeps$typesWr = _CircularDeps.CircularDeps.typesWriter) === null || _CircularDeps$typesWr === void 0 ? void 0 : _CircularDeps$typesWr.BacklandWatchTypesPubSub.emit('created', {
    resolver: result
  });
  return result;
}
function isPossibleArgsDef(args) {
  return args && typeof args === 'object' && Object.keys(args).length;
}
function getResolver(name) {
  return _GraphType.GraphType.resolvers.get(name);
}
function createResolverFactory() {
  return function createResolver(config) {
    if (config.resolve) return _createResolver(config);
    return {
      resolver(resolve) {
        return _createResolver({
          ...config,
          resolve
        });
      }
    };
  };
}
const createResolver = createResolverFactory();
exports.createResolver = createResolver;
//# sourceMappingURL=Resolver.js.map