function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, 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; }

/* eslint-disable no-use-before-define, no-restricted-syntax */
import objectPath from 'object-path';
import util from 'util';
import { GraphQLInputObjectType, GraphQLNonNull, GraphQLEnumType, GraphQLObjectType, isInputType, getNamedType } from './graphql';
import { ObjectTypeComposer } from './ObjectTypeComposer';
import { InputTypeComposer, isComposeInputType } from './InputTypeComposer';
import { EnumTypeComposer } from './EnumTypeComposer';
import { SchemaComposer } from './SchemaComposer';
import deepmerge from './utils/deepmerge';
import { resolveArgConfigMapAsThunk, resolveOutputConfigAsThunk, resolveArgConfigAsThunk } from './utils/configAsThunk';
import { only, clearName, inspect } from './utils/misc';
import { isFunction, isString } from './utils/is';
import { filterByDotPaths } from './utils/filterByDotPaths';
import { getProjectionFromAST } from './utils/projection';
import { typeByPath } from './utils/typeByPath';
import GraphQLJSON from './type/json';
export class Resolver {
  constructor(opts, schemaComposer) {
    if (!(schemaComposer instanceof SchemaComposer)) {
      throw new Error('You must provide SchemaComposer instance as a second argument for `new Resolver(opts, SchemaComposer)`');
    }

    this.schemaComposer = schemaComposer;

    if (!opts.name) {
      throw new Error('For Resolver constructor the `opts.name` is required option.');
    }

    this.name = opts.name;
    this.displayName = opts.displayName;
    this.parent = opts.parent;
    this.kind = opts.kind;
    this.description = opts.description || '';
    this.extensions = opts.extensions;

    if (opts.type) {
      this.setType(opts.type);
    }

    this.args = opts.args || {};

    if (opts.resolve) {
      this.resolve = opts.resolve;
    } // alive proper Flow type casting in autosuggestions for class with Generics

    /* :: return this; */

  } // -----------------------------------------------
  // Output type methods
  // -----------------------------------------------


  getType() {
    if (!this.type) {
      return GraphQLJSON;
    }

    const fc = resolveOutputConfigAsThunk(this.schemaComposer, this.type, this.name, 'Resolver');
    return fc.type;
  }

  getTypeComposer() {
    const outputType = getNamedType(this.getType());

    if (!(outputType instanceof GraphQLObjectType)) {
      throw new Error(`Resolver ${this.name} cannot return its output type as ObjectTypeComposer instance. ` + `Cause '${this.type.toString()}' does not instance of GraphQLObjectType.`);
    }

    return new ObjectTypeComposer(outputType, this.schemaComposer);
  }

  setType(composeType) {
    // check that `composeType` has correct data
    this.schemaComposer.typeMapper.convertOutputFieldConfig(composeType, 'setType', 'Resolver');
    this.type = composeType;
    return this;
  } // -----------------------------------------------
  // Args methods
  // -----------------------------------------------


  hasArg(argName) {
    return !!this.args[argName];
  }

  getArg(argName) {
    if (!this.hasArg(argName)) {
      throw new Error(`Cannot get arg '${argName}' for resolver ${this.name}. Argument does not exist.`);
    }

    let arg = this.args[argName];
    if (isFunction(arg)) arg = arg();

    if (typeof arg === 'string' || isComposeInputType(arg) || Array.isArray(arg)) {
      return {
        type: arg
      };
    }

    return arg;
  }

  getArgConfig(argName) {
    const arg = this.getArg(argName);
    return resolveArgConfigAsThunk(this.schemaComposer, arg, argName, this.name, 'Resolver');
  }

  getArgType(argName) {
    const ac = this.getArgConfig(argName);
    return ac.type;
  }

  getArgTC(argName) {
    const argType = getNamedType(this.getArgType(argName));

    if (!(argType instanceof GraphQLInputObjectType)) {
      throw new Error(`Cannot get InputTypeComposer for arg '${argName}' in resolver ${this.getNestedName()}. ` + `This argument should be InputObjectType, but it has type '${argType.constructor.name}'`);
    }

    return new InputTypeComposer(argType, this.schemaComposer);
  }

  getArgs() {
    return this.args;
  }

  getArgNames() {
    return Object.keys(this.args);
  }

  setArgs(args) {
    this.args = args;
    return this;
  }

  setArg(argName, argConfig) {
    this.args[argName] = argConfig;
    return this;
  }

  extendArg(argName, partialArgConfig) {
    let prevArgConfig;

    try {
      prevArgConfig = this.getArgConfig(argName);
    } catch (e) {
      throw new Error(`Cannot extend arg '${argName}' in Resolver '${this.name}'. Argument does not exist.`);
    }

    this.setArg(argName, _objectSpread({}, prevArgConfig, partialArgConfig));
    return this;
  }

  addArgs(newArgs) {
    this.setArgs(_objectSpread({}, this.getArgs(), newArgs));
    return this;
  }

  removeArg(argNameOrArray) {
    const argNames = Array.isArray(argNameOrArray) ? argNameOrArray : [argNameOrArray];
    argNames.forEach(argName => {
      delete this.args[argName];
    });
    return this;
  }

  removeOtherArgs(argNameOrArray) {
    const keepArgNames = Array.isArray(argNameOrArray) ? argNameOrArray : [argNameOrArray];
    Object.keys(this.args).forEach(argName => {
      if (keepArgNames.indexOf(argName) === -1) {
        delete this.args[argName];
      }
    });
    return this;
  }

  reorderArgs(names) {
    const orderedArgs = {};
    names.forEach(name => {
      if (this.args[name]) {
        orderedArgs[name] = this.args[name];
        delete this.args[name];
      }
    });
    this.args = _objectSpread({}, orderedArgs, this.args);
    return this;
  }

  cloneArg(argName, newTypeName) {
    if (!{}.hasOwnProperty.call(this.args, argName)) {
      throw new Error(`Can not clone arg ${argName} for resolver ${this.name}. Argument does not exist.`);
    }

    let originalType = this.getArgType(argName);
    let isUnwrapped = false;

    if (originalType instanceof GraphQLNonNull) {
      originalType = originalType.ofType;
      isUnwrapped = true;
    }

    if (!(originalType instanceof GraphQLInputObjectType)) {
      throw new Error(`Can not clone arg ${argName} for resolver ${this.name}.` + 'Argument should be GraphQLInputObjectType (complex input type).');
    }

    if (!newTypeName || newTypeName !== clearName(newTypeName)) {
      throw new Error('You should provide new type name as second argument');
    }

    if (newTypeName === originalType.name) {
      throw new Error('You should provide new type name. It is equal to current name.');
    }

    let clonedType = InputTypeComposer.createTemp(originalType, this.schemaComposer).clone(newTypeName).getType();

    if (isUnwrapped) {
      clonedType = new GraphQLNonNull(clonedType);
    }

    this.extendArg(argName, {
      type: clonedType
    });
    return this;
  }

  isRequired(argName) {
    return this.getArgType(argName) instanceof GraphQLNonNull;
  }

  makeRequired(argNameOrArray) {
    const argNames = Array.isArray(argNameOrArray) ? argNameOrArray : [argNameOrArray];
    argNames.forEach(argName => {
      if (this.hasArg(argName)) {
        const argType = this.getArgType(argName);

        if (!isInputType(argType)) {
          throw new Error(`Cannot make argument ${argName} required. It should be InputType: ${JSON.stringify(argType)}`);
        }

        if (!(argType instanceof GraphQLNonNull)) {
          this.extendArg(argName, {
            type: new GraphQLNonNull(argType)
          });
        }
      }
    });
    return this;
  }

  makeOptional(argNameOrArray) {
    const argNames = Array.isArray(argNameOrArray) ? argNameOrArray : [argNameOrArray];
    argNames.forEach(argName => {
      if (this.hasArg(argName)) {
        const argType = this.getArgType(argName);

        if (argType instanceof GraphQLNonNull) {
          this.extendArg(argName, {
            type: argType.ofType
          });
        }
      }
    });
    return this;
  }

  addFilterArg(opts) {
    if (!opts.name) {
      throw new Error('For Resolver.addFilterArg the arg name `opts.name` is required.');
    }

    if (!opts.type) {
      throw new Error('For Resolver.addFilterArg the arg type `opts.type` is required.');
    }

    const resolver = this.wrap(null, {
      name: 'addFilterArg'
    }); // get filterTC or create new one argument

    const filter = resolver.hasArg('filter') ? resolver.getArgConfig('filter') : undefined;
    let filterITC;

    if (filter && filter.type instanceof GraphQLInputObjectType) {
      filterITC = new InputTypeComposer(filter.type, this.schemaComposer);
    } else {
      if (!opts.filterTypeNameFallback || !isString(opts.filterTypeNameFallback)) {
        throw new Error('For Resolver.addFilterArg needs to provide `opts.filterTypeNameFallback: string`. ' + 'This string will be used as unique name for `filter` type of input argument. ' + 'Eg. FilterXXXXXInput');
      }

      filterITC = InputTypeComposer.createTemp(opts.filterTypeNameFallback, this.schemaComposer);
    }

    let defaultValue;

    if (filter && filter.defaultValue) {
      defaultValue = filter.defaultValue;
    }

    if (opts.defaultValue) {
      if (!defaultValue) {
        defaultValue = {};
      }

      defaultValue[opts.name] = opts.defaultValue;
    }

    resolver.setArg('filter', {
      type: filterITC.getType(),
      description: filter && filter.description || undefined,
      defaultValue
    });
    filterITC.setField(opts.name, _objectSpread({}, only(opts, ['name', 'type', 'defaultValue', 'description'])));
    const resolveNext = resolver.getResolve();
    const query = opts.query;

    if (query && isFunction(query)) {
      resolver.setResolve(async resolveParams => {
        const value = objectPath.get(resolveParams, ['args', 'filter', opts.name]);

        if (value !== null && value !== undefined) {
          if (!resolveParams.rawQuery) {
            resolveParams.rawQuery = {}; // eslint-disable-line
          }

          await query(resolveParams.rawQuery, value, resolveParams);
        }

        return resolveNext(resolveParams);
      });
    }

    return resolver;
  }

  addSortArg(opts) {
    if (!opts.name) {
      throw new Error('For Resolver.addSortArg the `opts.name` is required.');
    }

    if (!opts.value) {
      throw new Error('For Resolver.addSortArg the `opts.value` is required.');
    }

    const resolver = this.wrap(null, {
      name: 'addSortArg'
    }); // get sortETC or create new one

    let sortETC;

    if (resolver.hasArg('sort')) {
      const sortConfig = resolver.getArgConfig('sort');

      if (sortConfig.type instanceof GraphQLEnumType) {
        sortETC = EnumTypeComposer.createTemp(sortConfig.type, this.schemaComposer);
      } else {
        throw new Error('Resolver must have `sort` arg with type GraphQLEnumType. ' + `But got: ${util.inspect(sortConfig.type, {
          depth: 2
        })} `);
      }
    } else {
      if (!opts.sortTypeNameFallback || !isString(opts.sortTypeNameFallback)) {
        throw new Error('For Resolver.addSortArg needs to provide `opts.sortTypeNameFallback: string`. ' + 'This string will be used as unique name for `sort` type of input argument. ' + 'Eg. SortXXXXXEnum');
      }

      sortETC = EnumTypeComposer.createTemp({
        name: opts.sortTypeNameFallback,
        values: {
          [opts.name]: {}
        }
      }, this.schemaComposer);
      resolver.setArg('sort', sortETC);
    } // extend sortETC with new sorting value


    sortETC.setField(opts.name, {
      description: opts.description,
      deprecationReason: opts.deprecationReason,
      value: isFunction(opts.value) ? opts.name : opts.value
    }); // If sort value is evaluable (function), then wrap resolve method

    const resolveNext = resolver.getResolve();

    if (isFunction(opts.value)) {
      const getValue = opts.value;
      resolver.setResolve(resolveParams => {
        const value = objectPath.get(resolveParams, ['args', 'sort']);

        if (value === opts.name) {
          const newSortValue = getValue(resolveParams);
          resolveParams.args.sort = newSortValue; // eslint-disable-line
        }

        return resolveNext(resolveParams);
      });
    }

    return resolver;
  } // -----------------------------------------------
  // Resolve methods
  // -----------------------------------------------

  /*
   * This method should be overriden via constructor
   */

  /* eslint-disable */


  resolve(resolveParams) {
    return Promise.resolve();
  }
  /* eslint-enable */


  getResolve() {
    return this.resolve;
  }

  setResolve(resolve) {
    this.resolve = resolve;
    return this;
  } // -----------------------------------------------
  // Wrap methods
  // -----------------------------------------------


  withMiddlewares(middlewares) {
    if (!Array.isArray(middlewares)) {
      throw new Error(`You should provide array of middlewares '(resolve, source, args, context, info) => any', but provided ${inspect(middlewares)}.`);
    }

    let resolver = this;
    middlewares.reverse().forEach(mw => {
      let name;

      if (mw.name) {
        name = mw.name;
      } else if (mw.constructor && mw.constructor.name) {
        name = mw.constructor.name;
      } else {
        name = 'middleware';
      }

      const newResolver = this.clone({
        name,
        parent: resolver
      });
      const resolve = resolver.getResolve();
      newResolver.setResolve(rp => mw((source, args, context, info) => {
        return resolve(_objectSpread({}, rp, {
          source,
          args,
          context,
          info
        }));
      }, rp.source, rp.args, rp.context, rp.info));
      resolver = newResolver;
    });
    return resolver;
  }

  wrap(cb, newResolverOpts = {}) {
    const prevResolver = this;
    const newResolver = this.clone(_objectSpread({
      name: 'wrap',
      parent: prevResolver
    }, newResolverOpts));

    if (isFunction(cb)) {
      const resolver = cb(newResolver, prevResolver);
      if (resolver) return resolver;
    }

    return newResolver;
  }

  wrapResolve(cb, wrapperName = 'wrapResolve') {
    return this.wrap((newResolver, prevResolver) => {
      const newResolve = cb(prevResolver.getResolve());
      newResolver.setResolve(newResolve);
      return newResolver;
    }, {
      name: wrapperName
    });
  }

  wrapArgs(cb, wrapperName = 'wrapArgs') {
    return this.wrap((newResolver, prevResolver) => {
      // clone prevArgs, to avoid changing args in callback
      const prevArgs = _objectSpread({}, prevResolver.getArgs());

      const newArgs = cb(prevArgs);
      newResolver.setArgs(newArgs);
      return newResolver;
    }, {
      name: wrapperName
    });
  }

  wrapCloneArg(argName, newTypeName) {
    return this.wrap(newResolver => newResolver.cloneArg(argName, newTypeName), {
      name: 'cloneFilterArg'
    });
  }

  wrapType(cb, wrapperName = 'wrapType') {
    return this.wrap((newResolver, prevResolver) => {
      const prevType = prevResolver.getType();
      const newType = cb(prevType);
      newResolver.setType(newType);
      return newResolver;
    }, {
      name: wrapperName
    });
  } // -----------------------------------------------
  // Misc methods
  // -----------------------------------------------


  getFieldConfig(opts = {}) {
    const resolve = this.getResolve();
    return {
      type: this.getType(),
      args: resolveArgConfigMapAsThunk(this.schemaComposer, this.getArgs(), this.name, 'Resolver'),
      description: this.description,
      resolve: (source, args, context, info) => {
        let projection = getProjectionFromAST(info);

        if (opts.projection) {
          projection = deepmerge(projection, opts.projection);
        }

        return resolve({
          source,
          args,
          context,
          info,
          projection
        });
      }
    };
  }

  getKind() {
    return this.kind;
  }

  setKind(kind) {
    if (kind !== 'query' && kind !== 'mutation' && kind !== 'subscription') {
      throw new Error(`You provide incorrect value '${kind}' for Resolver.setKind method. ` + 'Valid values are: query | mutation | subscription');
    }

    this.kind = kind;
    return this;
  }

  getDescription() {
    return this.description;
  }

  setDescription(description) {
    this.description = description;
    return this;
  }

  get(path) {
    return typeByPath(this, path);
  }

  clone(opts = {}) {
    const oldOpts = {};
    const self = this;

    for (const key in self) {
      if (self.hasOwnProperty(key)) {
        // $FlowFixMe
        oldOpts[key] = self[key];
      }
    }

    oldOpts.displayName = undefined;
    oldOpts.args = _objectSpread({}, this.args);
    return new Resolver(_objectSpread({}, oldOpts, opts), this.schemaComposer);
  } // -----------------------------------------------
  // Debug methods
  // -----------------------------------------------


  getNestedName() {
    const name = this.displayName || this.name;

    if (this.parent) {
      return `${name}(${this.parent.getNestedName()})`;
    }

    return name;
  }

  toString(colors = true) {
    return util.inspect(this.toDebugStructure(false), {
      depth: 20,
      colors
    }).replace(/\\n/g, '\n');
  }

  setDisplayName(name) {
    this.displayName = name;
    return this;
  }

  toDebugStructure(colors = true) {
    const info = {
      name: this.name,
      displayName: this.displayName,
      type: util.inspect(this.type, {
        depth: 2,
        colors
      }),
      args: this.args,
      resolve: this.resolve ? this.resolve.toString() : this.resolve
    };

    if (this.parent) {
      info.resolve = [info.resolve, {
        'Parent resolver': this.parent.toDebugStructure(colors)
      }];
    }

    return info;
  }

  debugExecTime() {
    /* eslint-disable no-console */
    return this.wrapResolve(next => async rp => {
      const name = `Execution time for ${this.getNestedName()}`;
      console.time(name);
      const res = await next(rp);
      console.timeEnd(name);
      return res;
    }, 'debugExecTime');
    /* eslint-enable no-console */
  }

  debugParams(filterPaths, opts = {
    colors: true,
    depth: 5
  }) {
    /* eslint-disable no-console */
    return this.wrapResolve(next => rp => {
      console.log(`ResolveParams for ${this.getNestedName()}:`);
      const data = filterByDotPaths(rp, filterPaths, {
        // is hidden (use debugParams(["info"])) or debug({ params: ["info"]})
        // `is hidden (use debugParams(["context.*"])) or debug({ params: ["context.*"]})`,
        hideFields: rp && rp.context && rp.context.res && rp.context.params && rp.context.headers ? {
          // looks like context is express request, colapse it
          info: '[[hidden]]',
          context: '[[hidden]]'
        } : {
          info: '[[hidden]]',
          'context.*': '[[hidden]]'
        },
        hideFieldsNote: 'Some data was [[hidden]] to display this fields use debugParams("%fieldNames%")'
      });
      console.dir(data, opts);
      return next(rp);
    }, 'debugParams');
    /* eslint-enable no-console */
  }

  debugPayload(filterPaths, opts = {
    colors: true,
    depth: 5
  }) {
    /* eslint-disable no-console */
    return this.wrapResolve(next => async rp => {
      try {
        const res = await next(rp);
        console.log(`Resolved Payload for ${this.getNestedName()}:`);

        if (Array.isArray(res) && res.length > 3 && !filterPaths) {
          console.dir([filterPaths ? filterByDotPaths(res[0], filterPaths) : res[0], `[debug note]: Other ${res.length - 1} records was [[hidden]]. ` + 'Use debugPayload("0 1 2 3 4") or debug({ payload: "0 1 2 3 4" }) for display this records'], opts);
        } else {
          console.dir(filterPaths ? filterByDotPaths(res, filterPaths) : res, opts);
        }

        return res;
      } catch (e) {
        console.log(`Rejected Payload for ${this.getNestedName()}:`);
        console.log(e);
        throw e;
      }
    }, 'debugPayload');
    /* eslint-enable no-console */
  }

  debug(filterDotPaths, opts = {
    colors: true,
    depth: 2
  }) {
    return this.debugExecTime().debugParams(filterDotPaths ? filterDotPaths.params : null, opts).debugPayload(filterDotPaths ? filterDotPaths.payload : null, opts);
  }

}