Exemplo n.º 1
0
 public HeroType(IHeroesDatastore store)
 {
     Field(f => f.Id, type: typeof(IdGraphType));
     Field(f => f.Name);
     Field(f => f.SecretIdenitty);
     Field(f => f.Power);
     Field <HeroClassificationEnum>("Classification", "Hero classification", resolve: context => context.Source.Classification);
 }
        // Summary:
        //  Queries must inherit from ObjectGraphType, and the query itself is given a name inside of the constructor.
        //  Field<T> represents the different queries that can be executed.
        public HeroQuery(IHeroesDatastore store)
        {
            Name = "SuperHeroesQuery";
            Field <ListGraphType <HeroType> >(
                "heroes",
                resolve: context => store.GetHeroes());

            Field <HeroType>(
                "hero",
                arguments: new QueryArguments(new QueryArgument <NonNullGraphType <IdGraphType> > {
                Name = "id"
            }),
                resolve: context =>
            {
                var id       = context.GetArgument <Guid>("id");
                var objectId = context.Arguments["id"];

                return(store.GetHero(id));
            });
        }
Exemplo n.º 3
0
        // Summary:
        //  The same as Queries, mutations must inherit from ObjectGraphType<T>. Then in the constructor
        //  the mutation must be given a name, and as different Field<T> 's all the mutations that may be
        //  performed and their mappings are done here.

        // **NOTE** the following two Fields represent two ways that validation can happen on the input from users.
        //  You can specify which fields are required and which are optional in the input type, by specifying <NonNullGraphType<T>>
        //  which is what is done in the first example. You can also use a generic input type that doesn't specify which values are
        // nullable, and includes all the properties for the object, and then perform checks against the incoming data. This
        //  allows code reusability but means more is stuffed in each mutation resolve argument.
        public HeroMutation(IHeroesDatastore store, ILogger <HeroMutation> logger)
        {
            Name = "heroMutation";
            FieldAsync <HeroType>("createHero",
                                  arguments: new QueryArguments(new QueryArgument <NonNullGraphType <CreateHeroInputType> > {
                Name = "hero"
            }),
                                  resolve: async context =>
            {
                var data         = context.GetArgument <CreateHeroInput>("hero");
                var id           = Guid.NewGuid();
                var newSuperHero = new Hero(id, data.Name, data.Power, data.SecretIdentity, data.HeroClassification);

                //Summary:
                //  The TryAsyncResolve function available on FieldAsync<T> that this resolve parameter is
                //  being defined for, allows passing of exceptions to be handled inside the method we are
                //  calling
                return(await context.TryAsyncResolve(
                           async c => await store.AddSuperHero(newSuperHero)));
            });
        }