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 "";