Allow using plain object for GraphQLResolveInfo or some way to automate it about prisma-binding HOT 11 CLOSED

async function resolver (parent, { input }, ctx, info) {
  const resp = await ctx.db.mutation.createSite(
      {
        data: {
          name,
        },
      },
      info, // Info is provided by the user
  )
  // ID will only be available if the user requested it
  // but I may want to use the ID
  const id = resp.id
  return resp
}

import {merge} from "lodash";
import {parse} from "graphql";
import {EnumType, VariableType} from "json-to-graphql-query";

export default function graphQLQueryToJson() {
  let tree;
  let info = arguments[0];
  let keepRoot = arguments[1];
  let fieldNodes = info && (info.fieldASTs || info.fieldNodes);
  // let querySelections = info.operation?.selectionSet?.selections;
  if (fieldNodes) {
    // (info, keepRoot)
    tree = fieldTreeFromAST([...fieldNodes], info.fragments);
    if (!keepRoot) {
      let key = Object.keys(tree)[0];
      tree = tree[key]
    }
  } else if (typeof info === "string") {
    const ast = parse(info);
    tree = fieldTreeFromAST(ast.definitions[0].selectionSet.selections);
    if (!keepRoot) {
      let key = Object.keys(tree)[0];
      tree = tree[key]
    }
  } else {
    // (asts, fragments, fieldTree)
    tree = fieldTreeFromAST(...arguments)
  }
  return tree
}

function fieldTreeFromAST (asts, fragments = {}, init = {}) {
  asts = asts instanceof Array ? asts : [asts];
  return asts.reduce(function (tree, val) {
    // console.log(val);
    let kind = val.kind;
    let name = val.name && val.name.value;
    let fragment;
    if (kind === 'Field') {
      if (val.selectionSet) {
        tree[name] = tree[name] || {};
        fieldTreeFromAST(val.selectionSet.selections, fragments, tree[name]);
        if (val.arguments?.length) {
          tree[name].__args = graphQLArgumentsToJson(val.arguments);
        }
      } else {
        tree[name] = true
      }
    } else if (kind === 'FragmentSpread') {
      fragment = fragments[name];
      fieldTreeFromAST(fragment.selectionSet.selections, fragments, tree)
    } else if (kind === 'InlineFragment') {
      fragment = val;
      fieldTreeFromAST(fragment.selectionSet.selections, fragments, tree)
    } // else ignore
    return tree
  }, init)
}

function graphQLArgumentsToJson(args) {
  let tree = {};
  // this will ensure that it is a graphql ast collecton or an array
  if (!args.forEach) args = [args];
  args.forEach(arg => {
    let tmp = [];
    let fields = arg.value.fields;
    if (!fields) {
      tree[arg.name.value] = arg.value.kind === 'EnumValue' ? new EnumType(arg.value.value) : arg.value.value;
    } else {
      fields.forEach(f => {
        if (f.value.fields) {
          tree[arg.name.value] = merge(tree[arg.name.value] || {}, graphQLArgumentsToJson(f));
        } else {
          let value;
          switch (f.value.kind) {
            case 'Variable':
              value = new VariableType(f.value.name.value);
              break;
            case 'EnumValue':
              value = new EnumType(f.value.value);
              break;
            case 'ListValue':
              value = [];
              f.value.values.forEach(v => value.push(v.value));
              break;
            case 'ObjectValue':
              value = graphQLArgumentsToJson({value: f});
              break;
            default:
              value = f.value.value;
          }
          tmp.push({[f.name.value]: value});
          tree[arg.name.value] = merge(tree[arg.name.value] || {}, ...tmp);
        }
      });
    }
  });
  return tree;
}

import {graphQLQueryToJson, jsonToGraphQLQuery} from "../graphql/query";
import {merge, head} from "lodash";
import {GraphQLResolveInfo, parse, print, visit, Kind, Source} from "graphql";

export function copyFieldNodes({fieldNodes, operation}) {
  return print(fieldNodes)
      .map(i => {
        const parsedSource = parse(new Source(`${operation.operation} { ${i} }`));
        return parsedSource.definitions[0].selectionSet.selections[0];
      })
}

export function copyResolverInfo(info: GraphQLResolveInfo, overrides = {}): GraphQLResolveInfo {
  return Object.assign({}, info,
      {
        fieldNodes: copyFieldNodes(info),
        fieldName: info.fieldName,
        ...overrides
      }
  )
}

export function transformResolverInfoSelection(info: GraphQLResolveInfo, actions: {forceSelection?: string, rootFieldOverride?: string}) {
  const {forceSelection, rootFieldOverride} = actions;
  const {fieldName} = info;
  let resultSelection = graphQLQueryToJson(info, true);

  if (forceSelection) {
    const requiredSelection = graphQLQueryToJson(`{ ${fieldName} ${forceSelection} }`, true);
    resultSelection = merge(resultSelection, requiredSelection);
  }

  if (rootFieldOverride) {
    resultSelection = {[rootFieldOverride]: head(Object.values(resultSelection))};
  }

  const parsed = parse(`{ ${jsonToGraphQLQuery(resultSelection)} }`);
  const infoCopy = copyResolverInfo(info);
  infoCopy.fieldNodes[0].selectionSet = parsed.definitions[0].selectionSet.selections[0].selectionSet;
  if (rootFieldOverride) {
    infoCopy.fieldNodes[0].name.value = rootFieldOverride;
  }
  return infoCopy;
}