fields: () => ({
   id: globalIdField('User', (user) => user._id),
   login: { type: GraphQLString },
   name: { type: GraphQLString },
   surname: { type: GraphQLString },
   email: { type: GraphQLString },
   createdAt: {
     type: GraphQLString,
     resolve: (obj) => new Date(obj.createdAt).toISOString()
   },
   seedConnection: {
     type: seedConnection.connectionType,
     args: connectionArgsExt,
     resolve: (parent, args: IConnectionArgsExt, context) => {
       let findParams: any = { userId: `${parent._id}` };
       if (args.query) {
         findParams[args.field || 'name'] = new RegExp(args.query, 'i');
       }
       if (!args.limit || args.limit > 200) {
         args.limit = 100;
       }
       return connectionFromPromisedArray(
         context.db.collection('seeds')
           .find(findParams)
           .sort({ createdAt: -1 })
           .limit(Number(args.limit))
           .toArray(),
         args);
     }
   }
 }),

 fields: (): GQL.GraphQLFieldConfigMap => ({
     id: R.globalIdField('Message'),
     userId: { type: new GQL.GraphQLNonNull(GQL.GraphQLString) },
     createdAt: { type: GQL.GraphQLString },
     body: { type: GQL.GraphQLString },
     user: {
         type: UserType,
         resolve: async (msg, args): Promise<any> => await db.User.get(msg.userId).run()
     }
 }),

 fields: (): GQL.GraphQLFieldConfigMap => ({
     id: R.globalIdField(),
     name: { type: new GQL.GraphQLNonNull(GQL.GraphQLString) },
     email: { type: new GQL.GraphQLNonNull(GQL.GraphQLString) },
     createdAt: { type: GQL.GraphQLString },
     updatedAt: { type: GQL.GraphQLString },
     messages: {
         type: messageConnection.connectionType,
         args: R.connectionArgs,
         resolve: (user: any, args: any): Promise<R.Connection<any>> => {
             return R.connectionFromPromisedArray(db.Message.filter({ userId: user.id }).run(), args)
         }
     }
 }),

 fields: () => ({
   id: globalIdField('Store'),
   node: nodeDefs.nodeField,
   seedConnection: {
     type: seedConnection.connectionType,
     args: connectionArgsExt,
     resolve: (_, args: IConnectionArgsExt, context) => {
       let findParams: any = {};
       if (args.query) {
         findParams[args.field || 'name'] = new RegExp(args.query, 'i');
       }
       if (!args.limit || args.limit > 200) {
         args.limit = 100;
       }
       return connectionFromPromisedArray(
         context.db.collection('seeds')
           .find(findParams)
           .sort({ createdAt: -1 })
           .limit(Number(args.limit))
           .toArray(),
         args
       );
     }
   },
   userConnection: {
     type: userConnection.connectionType,
     args: connectionArgsExt,
     resolve: (_, args: IConnectionArgsExt, context) => {
       let findParams: any = {};
       if (args.query) {
         findParams[args.field || 'login'] = new RegExp(args.query, 'i');
       }
       if (!args.limit || args.limit > 200) {
         args.limit = 100;
       }
       return connectionFromPromisedArray(
         context.db.collection('users')
           .find(findParams)
           .sort({ createdAt: -1 })
           .limit(Number(args.limit))
           .toArray(),
         args
       );
     }
   }
 }),

 fields: () => ({
   id: globalIdField('Seed', (seed) => seed._id),
   name: { type: GraphQLString },
   description: { type: GraphQLString },
   index: { type: GraphQLInt },
   createdAt: {
     type: GraphQLString,
     resolve: (obj) => new Date(obj.createdAt).toISOString()
   },
   user: {
     type: userType,
     resolve: (parent, args, context) =>
       context.db.collection('users').find({ _id: new ObjectID(parent.userId) }).limit(1).next()
   },
   cross: {
     type: crossType,
     resolve: (parent, args) => parent.cross
   },
   location: { type: GraphQLString }
 }),

 fields: () => ({
     id: globalIdField(),
 }),

    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 "";
    },
    description: "d",
});
// An example usage of these methods from the test schema:
const {nodeInterface, nodeField} = nodeDefinitions(
    (globalId) => {
        var {type, id} = fromGlobalId(globalId);