public async Task GraphQLFieldQuery_Test()
        {
            var root         = new RootQuery();
            var mutation     = new RootMutation();
            var schema       = new GraphQLRootSchema(root, mutation);
            var queryBuilder = new BasicQueryBuilder();
            var executor     = new DocumentExecuter();


            schema.Register(queryBuilder);
            Assert.True(schema.Query.HasField("defaultTest"));

            var result = await executor.ExecuteAsync(new ExecutionOptions()
            {
                Schema        = schema,
                Query         = "query TestQuery { defaultTest(returnOne: 5, returnTwo: 5) }",
                OperationName = "TestQuery"
            }).ConfigureAwait(false);


            Assert.NotNull(result);
            Assert.NotNull(result?.Data);
            Assert.Equal(10, ((Dictionary <string, object>)result?.Data)["defaultTest"]);
        }
        public void Inline_Fragment()
        {
            var expression = new RootQuery()
                             .Data
                             .OfType <NestedData>()
                             .Select(x => new
            {
                x.Id,
                Items = x.Items.Select(i => i.Name),
            });

            Expression <Func <JObject, object> > expected = data =>
                                                            ExpressionMethods.Select(
                ExpressionMethods.ChildrenOfType(data["data"]["data"], "NestedData"),
                x => new
            {
                Id    = x["id"].ToObject <string>(),
                Items = ExpressionMethods.SelectEntity(x["items"], i => i["name"].ToObject <string>())
            });

            var query = new QueryBuilder().Build(expression);

            Assert.Equal(expected.ToString(), query.Expression.ToString());
        }
        public void MutationValue_Test()
        {
            var root         = new RootQuery();
            var mutation     = new RootMutation();
            var schema       = new GraphQLRootSchema(root, mutation);
            var queryBuilder = new BasicQueryBuilder();

            schema.Register(queryBuilder);
            var actual = schema.Mutation.Fields.First(p => p.Name == "mutationTest").Resolver.Resolve(
                new ResolveFieldContext()
            {
                Arguments = new Dictionary <string, object>()
                {
                    {
                        "input", new TestInputType()
                        {
                            Input = "Hello World",
                        }
                    },
                },
            });

            Assert.Equal("Hello World", actual);
        }
Example #4
0
 public void SetGroup(RootQuery query)
 {
     query.Field <ArticleQuery>(
         name: "articles",
         resolve: context => new { });
 }
Example #5
0
 public void SetGroup(RootQuery query)
 {
     query.Field <RobotQueries>(
         "robots",
         resolve: context => new { });
 }
 public static void SelectFromTable(RootQuery queryBuilder, string tableName)
 {
     queryBuilder.QueryD("SELECT * FROM " + tableName);
 }
 /// <summary>
 ///     Creates a QueryCommand that uses the * Operator to select all date from the inner query
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="query">The query.</param>
 /// <returns></returns>
 public static SelectQuery <T> SelectStar <T>(this RootQuery query)
 {
     return
         (new SelectQuery <T>(
              query.QueryText("SELECT * FROM " + query.ContainerObject.AccessLayer.GetClassInfo(typeof(T)).TableName)));
 }
Example #8
0
 public T Query <T>(RootQuery query)
 {
     Queries?.Invoke(this, query);
     return((T)query.Result);
 }
Example #9
0
 public void SetGroup(RootQuery query)
 {
     query.Field <AccountQuery>(
         "account",
         resolve: _ => new { });
 }
Example #10
0
 public void SetGroup(RootQuery query)
 {
     query.Field <UserQueries>(
         "user",
         resolve: context => new { });
 }
 public void SetGroup(RootQuery query)
 {
     query.Field <MaterialExpenditureQueries>(
         "expenditures",
         resolve: _ => new { });
 }
Example #12
0
 public void SetGroup(RootQuery query)
 {
     query.Field <ReportQuery>(
         "report",
         resolve: _ => new { });
 }
Example #13
0
		public static void GetSelectStatement(RootQuery builder, long whereId)
		{
			builder.Select<Users_StaticQueryFactoryForSelectWithArugments>()
				.Where()
				.Column(s => s.UserId)
				.Is(whereId);
		}
Example #14
0
		public static void GetSelectStatement(RootQuery builder)
		{
			builder.Select<Users_StaticQueryFactoryForSelect>();
		}
Example #15
0
 public void SetGroup(RootQuery query)
 {
     query.Field <PlanetQueries>(
         "planets",
         resolve: context => new { });
 }
 /// <summary>
 ///     Creates an TSQL Count(1) statement
 /// </summary>
 /// <typeparam name="TPoco">The type of the poco.</typeparam>
 /// <param name="query">The query.</param>
 /// <returns></returns>
 public static ElementProducer <long> Count <TPoco>(this RootQuery query)
 {
     return(new ElementProducer <long>(query.QueryText("SELECT COUNT(1) FROM {0}",
                                                       query.ContainerObject.AccessLayer.Config.GetOrCreateClassInfoCache(typeof(TPoco)).TableName), null));
 }
 /// <summary>
 ///     Creates an TSQL Apply statement
 /// </summary>
 /// <param name="query">The query.</param>
 /// <param name="mode">The mode.</param>
 /// <param name="innerText">The inner text.</param>
 /// <returns></returns>
 public static RootQuery Apply(this RootQuery query,
                               ApplyMode mode,
                               Func <RootQuery, IQueryBuilder> innerText)
 {
     return(new RootQuery(query.QueryText(mode.ApplyType).InBracket(innerText)));
 }
Example #18
0
 public void SetGroup(RootQuery query)
 {
     query.Field <ExplorersTeamQueries>(
         FIELD_NAME,
         resolve: context => new { });
 }
Example #19
0
 public void SetGroup(RootQuery query)
 {
     query.Field <ShuttleQueries>(
         "shuttles",
         resolve: context => new { });
 }
Example #20
0
 public void SetGroup(RootQuery query)
 {
 }
Example #21
0
 public void SetGroup(RootQuery query)
 {
     query.Field <PublisherQuery>(
         "publishers",
         resolve: context => new { });
 }
Example #22
0
 public EntriesSchema(RootQuery query, RootMutation mutation, IDependencyResolver resolver)
 {
     Query              = query;
     Mutation           = mutation;
     DependencyResolver = resolver;
 }
Example #23
0
 public void SetGroup(RootQuery query)
 {
     query.Field <RoomJobQueries>(
         "roomJob",
         resolve: _ => new { });
 }
Example #24
0
 public void SetGroup(RootQuery query)
 {
     query.Field <PermissionQueries>(
         "permissions",
         resolve: context => new { });
 }
Example #25
0
 public TestSchema()
     : base()
 {
     Query = new RootQuery();
 }
 /// <summary>
 ///     Creates an closed sub select
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="query">The query.</param>
 /// <param name="subSelect">The sub select.</param>
 /// <param name="identifyer">The Identifyer for this SubQuery</param>
 /// <returns></returns>
 public static ElementProducer <T> SubSelect <T>(this RootQuery query,
                                                 Func <ElementProducer <T> > subSelect, string identifyer)
 {
     return(new ElementProducer <T>(new ElementProducer <T>(query.QueryD("SELECT * FROM ").InBracket(f => f.Append(subSelect()))).As(identifyer)));
 }
Example #27
0
 public void SetGroup(RootQuery query)
 {
     query.Field <HouseQueries>(
         "house",
         resolve: _ => new { });
 }
 public AfishaSchema(RootQuery query, IDependencyResolver resolver)
 {
     Query = query;
     DependencyResolver = resolver;
 }
 public void SetGroup(RootQuery query)
 {
     query.Field <RoomWallObjectQueries>(
         "wallObject",
         resolve: _ => new { });
 }
Example #30
0
 public static IQueryBuilder GetSelectStatement(RootQuery builder)
 {
     return(builder.Select.Table <Users_StaticQueryFactoryForSelect>());
 }
Example #31
0
 public void SetGroup(RootQuery query)
 {
     query.Field <ExplorationQueries>(
         "explorations",
         resolve: context => new { });
 }
 public void SetGroup(RootQuery query)
 {
     query.Field <PlanetQueries>(
         FIELD_NAME,
         resolve: context => new { });
 }