isTypeOf: (obj): boolean => {
        try { new db.Message(obj).validate(); return true } catch (e) { return false }
    },
    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()
        }
    }),
    interfaces: [nodeDefinitions.nodeInterface]
})
const messageConnection = R.connectionDefinitions({nodeType: MessageType})

//============================== USER ================================//
const UserType = new GQL.GraphQLObjectType({
    name: 'User',
    isTypeOf: (obj): boolean => {
        try { new db.User(obj).validate(); return true } catch (e) { return false }
    },
    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,

  idFetcher,
  (obj) => {
    if (obj instanceof Store) {
      return storeType;

    } else if (obj.cross) {
      return seedType;

    } else if (obj.email) {
      return userType;
    }
    return null;
  }

);

userType = new GraphQLObjectType(new UserTypeConfig().getConfig());
export let userConnection: GraphQLConnectionDefinitions = connectionDefinitions({
  name: 'user',
  nodeType: userType
});


seedType = new GraphQLObjectType(new SeedTypeConfig().getConfig());
export let seedConnection: GraphQLConnectionDefinitions = connectionDefinitions({
  name: 'seed',
  nodeType: seedType
});

storeType = new GraphQLObjectType(new StoreTypeConfig().getConfig());

        { userId },
        _args,
        _context,
        { rootValue: { userByIDLoader } }
      ) => (userId ? userByIDLoader(userId) : null),
    },
    creditCard: {
      type: CreditCard.type,
      description: "Credit card on this order",
      resolve: (
        { creditCardId },
        _args,
        _context,
        { rootValue: { creditCardLoader } }
      ) => (creditCardId ? creditCardLoader(creditCardId) : null),
    },
    // TODO: The `date` resolver not typed correctly
    updatedAt: date as any,
    createdAt: date as any,
    stateUpdatedAt: date as any,
    stateExpiresAt: date as any,
  }),
})

export const {
  connectionType: OrderConnection,
  edgeType: OrderEdge,
} = connectionDefinitions({
  nodeType: OrderType,
})

// backwardConnectionArgs returns the arguments that fields should provide when they return a connection type that only supports backward pagination.
backwardConnectionArgs.before = "b";
backwardConnectionArgs.last = 10;
// connectionDefinitions returns a connectionType and its associated edgeType, given a node type.
const resolve: GraphQLFieldResolver<any, any> = (source, args, context, info) => {
    info.fieldName = "f";
};
const fields: GraphQLFieldConfigMap<any, any> = {};
let t: GraphQLObjectType;
let e: GraphQLObjectType;
const def = connectionDefinitions({
    connectionFields: fields,
    edgeFields: fields,
    name: "N",
    nodeType: new GraphQLObjectType({
        name: "N",
        fields: {},
    }),
    resolveCursor: resolve,
    resolveNode: resolve,
});
t = def.connectionType;
e = def.edgeType;
// connectionFromArray is a helper method that takes an array and the arguments from connectionArgs,
// does pagination and filtering, and returns an object in the shape expected by a connectionType's resolve function.
const conn = connectionFromArray([1, 2, 3], {
    after: "a",
    before: "b",
    first: 1,
    last: 5,
});