const nodeDefinitions = R.nodeDefinitions(globalId => {
    const modelTypes = ['User', 'Message']
    const idInfo = R.fromGlobalId(globalId)
    const typeIndex = modelTypes.indexOf(idInfo.type)
    if (typeIndex !== -1) { return db[modelTypes[typeIndex]].get(idInfo.id).run() }
    return null
})

    return (async () => {
      seed.createdAt = Date.now();
      seed.userId = fromGlobalId(seed.userId).id;
      let counter: ISequenceValue = await getSeedNextSequence('seedCounter', context.db);
      seed.index = counter.value.seq;
      if (seed.cross.first !== undefined) {
        let firstSeed: ISeed = await context.db.collection('seeds').find({ index: seed.cross.first }).limit(1).next();

        seed.cross.secondIndex = firstSeed.cross.secondIndex;

        if (seed.cross.type === 'G') {
          seed.cross.name = firstSeed.cross.name;
          seed.cross.index = firstSeed.cross.index + 1;

        } else {
          seed.cross.name = seed.cross.type;
          seed.cross.index = 1;

          if (seed.cross.type === 'BC' || seed.cross.type === 'OC') {
            seed.cross.secondIndex = (firstSeed.cross.secondIndex || 0) + 1;
          }
        }
      } else {
        seed.cross.index = 0;
        seed.cross.name = seed.cross.type;
      }

      return context.db.collection('seeds').insertOne(seed);
    })();

async function idFetcher(globalId: any, context: IContext) {
  let global: ResolvedGlobalId = fromGlobalId(globalId);
  if (global.type === 'Store') {
    return store;

  } else if (global.type === 'Seed') {
    return await context.db.collection('seeds').find({ _id: new ObjectID(global.id) }).limit(1).next();

  } else if (global.type === 'User') {
    return await context.db.collection('users').find({ _id: new ObjectID(global.id) }).limit(1).next();

  }
  return null;

}

 mutateAndGetPayload: (user: IUser, context: IContext) => {
   user.updatedAt = Date.now();
   let id: ObjectID = new ObjectID(fromGlobalId(user.id).id);
   console.log(user);
   return context.db.collection('users').updateOne(
     { _id: id },
     {
       $set: {
         login: user.login,
         email: user.email,
         name: user.name,
         surname: user.surname,
         updatedAt: user.updatedAt
       }
     }
   );
 }

 (globalId) => {
     var {type, id} = fromGlobalId(globalId);
     return "data[type][id]";
 },

const resolver: GraphQLTypeResolver<any, any> = () => {
    return new GraphQLObjectType({
        name: "T",
        fields: {},
    });
};
const idFetcher = (id: string, context: number, info: GraphQLResolveInfo) => {
    info.fieldName = "f";
};
const nodeDef = nodeDefinitions<number>(idFetcher, resolver);
const fieldConfig: GraphQLFieldConfig<any, any> = nodeDef.nodeField;
const interfaceType: GraphQLInterfaceType = nodeDef.nodeInterface;
// toGlobalId takes a type name and an ID specific to that type name, and returns a "global ID" that is unique among all types.
toGlobalId("t", "i").toLowerCase();
// fromGlobalId takes the "global ID" created by toGlobalID, and returns the type name and ID used to create it.
const fgi = fromGlobalId("gid");
fgi.id.toLowerCase();
fgi.type.toUpperCase();
// globalIdField creates the configuration for an id field on a node.
const idFetcher2 = (object: any, context: any, info: GraphQLResolveInfo) => {
    return "";
};
const gif: GraphQLFieldConfig<any, any> = globalIdField("t", idFetcher2);
// pluralIdentifyingRootField creates a field that accepts a list of non-ID identifiers (like a username) and maps them to their corresponding objects.
const input: GraphQLInputType = GraphQLString;
const prf: GraphQLFieldConfig<any, any> = pluralIdentifyingRootField({
    argName: "a",
    inputType: input,
    outputType: input,
    resolveSingleInput: (input: any, context: any, info: GraphQLResolveInfo) => {
        return "";