public void OnGraphInit(IObjectGraphType query, IObjectGraphType mutation)
{
var orderService = shopFactory.OrderService;
//var orderResolver = new OrderResolver(orderService);
var orderResolver = new FuncFieldResolver <IOrder>((ctx) => orderService.GetOrder(ctx.GetArgument <string>("id")));
//var orderArticleResolver = new FuncFieldResolver<IEnumerable<IOrderArticle>>((ctx) => (ctx.Source as IOrder).Articles);
var order = shopFactory.CreateInstance <IOrder>();
var orderArticle = shopFactory.CreateInstance <IOrderArticle>();
GraphTypeTypeRegistry.Register(typeof(IOrderArticle), typeof(ReflectionObjectGraphType <IOrderArticle>));
query.AddField(new FieldType()
{
Name = "orderarticle",
//Resolver = orderResolver,
Type = orderArticle.GetType(),
ResolvedType = new ReflectionObjectGraphType <IOrderArticle>()
});
query.AddField(new FieldType()
{
Name = "order",
Resolver = orderResolver,
Arguments = TinyQuery.GetIdQuery(),
Type = order.GetType(),
ResolvedType = new ReflectionObjectGraphType <IOrder>()
});
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
//services.AddDbContext<BlogDbContext>(options =>
// options.UseSqlServer(Configuration.GetConnectionString("MainDatabase")));
services.AddSingleton(_ => { return(BlogDbContextEfFactory.CreateDbContext(Configuration)); });
EfGraphQLConventions.RegisterInContainer(
services,
userContext => { return(BlogDbContextEfFactory.CreateDbContext(Configuration)); });
services.AddGraphQL(options => options.ExposeExceptions = true);
services.AddSingleton <MainSchema>();
services.AddSingleton <MainQuery>();
services.AddSingleton <CountryGraph>();
services.AddSingleton <AddressGraph>();
services.AddSingleton <UserGraph>();
services.AddSingleton <PostGraph>();
GraphTypeTypeRegistry.Register <Country, CountryGraph>();
GraphTypeTypeRegistry.Register <Address, AddressGraph>();
GraphTypeTypeRegistry.Register <User, UserGraph>();
GraphTypeTypeRegistry.Register <Post, PostGraph>();
services.AddSingleton <IDocumentExecuter, EfDocumentExecuter>();
services.AddSingleton <IDependencyResolver>(
provider => new FuncDependencyResolver(provider.GetRequiredService));
services.Configure <KestrelServerOptions>(o => { o.AllowSynchronousIO = true; });
services.Configure <IISServerOptions>(o => { o.AllowSynchronousIO = true; });
}
static IntegrationTests()
{
GraphTypeTypeRegistry.Register <FilterChildEntity, FilterChildGraph>();
GraphTypeTypeRegistry.Register <FilterParentEntity, FilterParentGraph>();
GraphTypeTypeRegistry.Register <WithManyChildrenEntity, WithManyChildrenGraph>();
GraphTypeTypeRegistry.Register <CustomTypeEntity, CustomTypeGraph>();
GraphTypeTypeRegistry.Register <Child1Entity, Child1Graph>();
GraphTypeTypeRegistry.Register <ChildEntity, ChildGraph>();
GraphTypeTypeRegistry.Register <ParentEntity, ParentGraph>();
GraphTypeTypeRegistry.Register <Level1Entity, Level1Graph>();
GraphTypeTypeRegistry.Register <Level2Entity, Level2Graph>();
GraphTypeTypeRegistry.Register <Level3Entity, Level3Graph>();
GraphTypeTypeRegistry.Register <WithMisNamedQueryParentEntity, WithMisNamedQueryParentGraph>();
GraphTypeTypeRegistry.Register <WithNullableEntity, WithNullableGraph>();
GraphTypeTypeRegistry.Register <NamedIdEntity, NamedIdGraph>();
GraphTypeTypeRegistry.Register <WithMisNamedQueryChildEntity, WithMisNamedQueryChildGraph>();
sqlInstance = new SqlInstance <IntegrationDbContext>(
buildTemplate: async dbContext =>
{
await dbContext.Database.EnsureCreatedAsync();
await dbContext.Database.ExecuteSqlRawAsync(
@"create view ParentEntityView as
select Property
from ParentEntities");
},
constructInstance: builder => new IntegrationDbContext(builder.Options));
}
public void ConfigureServices(IServiceCollection services)
{
GraphTypeTypeRegistry.Register <Employee, EmployeeGraph>();
GraphTypeTypeRegistry.Register <EmployeeSummary, EmployeeSummaryGraph>();
GraphTypeTypeRegistry.Register <Company, CompanyGraph>();
services.AddScoped(provider => DataContextBuilder.BuildDataContext());
EfGraphQLConventions.RegisterInContainer(services, DataContextBuilder.Model);
foreach (var type in GetGraphQlTypes())
{
services.AddSingleton(type);
}
services.AddGraphQL(options => options.ExposeExceptions = true).AddWebSockets();
services.AddSingleton <ContextFactory>();
services.AddSingleton <IDocumentExecuter, EfDocumentExecuter>();
services.AddSingleton <IDependencyResolver>(
provider => new FuncDependencyResolver(provider.GetRequiredService));
services.AddSingleton <ISchema, Schema>();
var mvc = services.AddMvc();
mvc.SetCompatibilityVersion(CompatibilityVersion.Latest);
}
public static IServiceCollection RegisterTypes(this IServiceCollection services)
{
var enumGraphType = typeof(EnumerationGraphType <>);
var coreAssembly = Assembly.Load("Galaxy.Api.Core");
var presentationAssembly = typeof(Startup).Assembly;
//add all enums
coreAssembly.GetEnumsForPath("Galaxy.Api.Core.Enums").ForEach(p =>
{
services.AddSingleton(enumGraphType.MakeGenericType(p));
GraphTypeTypeRegistry.Register(p, enumGraphType.MakeGenericType(p));
});
//add all helper graph types
presentationAssembly.GetTypesForPath("Galaxy.Api.Presentation.GraphQL.Helpers").ForEach(p =>
{
RuntimeHelpers.RunClassConstructor(p.TypeHandle);
services.AddScoped(p.UnderlyingSystemType);
});
//add all view models
presentationAssembly.GetTypesForPath("Galaxy.Api.Presentation.ViewModels").ForEach(p =>
{
services.AddScoped(p.UnderlyingSystemType);
});
//add all graphql queries and mutations
presentationAssembly.GetTypesForPath("Galaxy.Api.Presentation.GraphQl.Types").ForEach(p =>
{
services.AddScoped(p.UnderlyingSystemType);
});
//add all types
presentationAssembly.GetTypesForPath("Galaxy.Api.Presentation.GraphQl.Types.Schema").ForEach(p =>
{
services.AddScoped(p.GetInterfaces().First().UnderlyingSystemType, p.UnderlyingSystemType);
});
//add all mutations and queries
presentationAssembly.GetTypesForPath("Galaxy.Api.Presentation.GraphQl.RootSchema").ForEach(p =>
{
if (!typeof(Schema).IsAssignableFrom(p))
{
services.AddScoped(p.UnderlyingSystemType);
}
});
var sp = services.BuildServiceProvider();
//add schemas
presentationAssembly.GetTypesForPath("Galaxy.Api.Presentation.GraphQl.RootSchema").ForEach(p =>
{
if (typeof(Schema).IsAssignableFrom(p))
{
services.AddSingleton((ISchema)Activator.CreateInstance(p.UnderlyingSystemType,
new FuncDependencyResolver(type => sp.GetService(type))));
}
});
return(services);
}
public void auto_register()
{
GraphTypeTypeRegistry.Register <Direction, EnumerationGraphType <Direction> >();
GraphTypeTypeRegistry.Register <Money, AutoRegisteringObjectGraphType <Money> >();
var type = new AutoRegisteringObjectGraphType <TestObject>(o => o.valuePair, o => o.someEnumerable);
type.Fields.Count().ShouldBe(18);
type.Fields.First(f => f.Name == nameof(TestObject.someString)).Description.ShouldBe("Super secret");
type.Fields.First(f => f.Name == nameof(TestObject.someString)).Type.ShouldBe(typeof(StringGraphType));
type.Fields.First(f => f.Name == nameof(TestObject.someRequiredString)).Type.ShouldBe(typeof(NonNullGraphType <StringGraphType>));
type.Fields.First(f => f.Name == nameof(TestObject.someInt)).Type.ShouldBe(typeof(IntGraphType));
type.Fields.First(f => f.Name == nameof(TestObject.someNotNullInt)).Type.ShouldBe(typeof(NonNullGraphType <IntGraphType>));
type.Fields.First(f => f.Name == nameof(TestObject.someBoolean)).DeprecationReason.ShouldBe("Use someInt");
type.Fields.First(f => f.Name == nameof(TestObject.someDate)).DefaultValue.ShouldBe(new DateTime(2019, 3, 14));
type.Fields.First(f => f.Name == nameof(TestObject.someEnumerableOfString)).Type.ShouldBe(typeof(ListGraphType <StringGraphType>));
type.Fields.First(f => f.Name == nameof(TestObject.someEnum)).Type.ShouldBe(typeof(NonNullGraphType <EnumerationGraphType <Direction> >));
type.Fields.First(f => f.Name == nameof(TestObject.someNullableEnum)).Type.ShouldBe(typeof(EnumerationGraphType <Direction>));
type.Fields.First(f => f.Name == nameof(TestObject.someList)).Type.ShouldBe(typeof(ListGraphType <NonNullGraphType <IntGraphType> >));
type.Fields.First(f => f.Name == nameof(TestObject.someListWithNullable)).Type.ShouldBe(typeof(ListGraphType <IntGraphType>));
type.Fields.First(f => f.Name == nameof(TestObject.someRequiredList)).Type.ShouldBe(typeof(NonNullGraphType <ListGraphType <NonNullGraphType <IntGraphType> > >));
type.Fields.First(f => f.Name == nameof(TestObject.someRequiredListWithNullable)).Type.ShouldBe(typeof(NonNullGraphType <ListGraphType <IntGraphType> >));
type.Fields.First(f => f.Name == nameof(TestObject.someMoney)).Type.ShouldBe(typeof(AutoRegisteringObjectGraphType <Money>));
var enumType = new EnumerationGraphType <Direction>();
enumType.Values["RANDOM"].DeprecationReason.ShouldBe("Do not use Random. This makes no sense!");
}
public static ISchema AddStrongTypeId <TType>(this ISchema schema) where TType : IStrongTypeId
{
GraphTypeTypeRegistry.Register(typeof(TType), typeof(StrongTypeIdGraphType <TType>));
schema.RegisterValueConverter(new StrongTypeIdAstValueConverter <TType>());
return(schema);
}
public void auto_register_input_object_graph_type()
{
GraphTypeTypeRegistry.Register <Money, AutoRegisteringInputObjectGraphType <Money> >();
var type = new AutoRegisteringInputObjectGraphType <TestObject>(o => o.valuePair, o => o.someEnumerable);
type.Name.ShouldBe(nameof(TestObject));
type.Description.ShouldBe("Object for test");
type.DeprecationReason.ShouldBe("Obsolete for test");
type.Fields.Count.ShouldBe(18);
type.Fields.First(f => f.Name == nameof(TestObject.someString)).Description.ShouldBe("Super secret");
type.Fields.First(f => f.Name == nameof(TestObject.someString)).Type.ShouldBe(typeof(StringGraphType));
type.Fields.First(f => f.Name == nameof(TestObject.someRequiredString)).Type.ShouldBe(typeof(NonNullGraphType <StringGraphType>));
type.Fields.First(f => f.Name == nameof(TestObject.someInt)).Type.ShouldBe(typeof(IntGraphType));
type.Fields.First(f => f.Name == nameof(TestObject.someNotNullInt)).Type.ShouldBe(typeof(NonNullGraphType <IntGraphType>));
type.Fields.First(f => f.Name == nameof(TestObject.someBoolean)).DeprecationReason.ShouldBe("Use someInt");
type.Fields.First(f => f.Name == nameof(TestObject.someDate)).DefaultValue.ShouldBe(new DateTime(2019, 3, 14));
// disabled to make tests stable without touch GlobalSwitches
//type.Fields.First(f => f.Name == nameof(TestObject.someShort)).Description.ShouldBe("Description from xml comment");
type.Fields.First(f => f.Name == nameof(TestObject.someEnumerableOfString)).Type.ShouldBe(typeof(ListGraphType <StringGraphType>));
type.Fields.First(f => f.Name == nameof(TestObject.someEnum)).Type.ShouldBe(typeof(NonNullGraphType <EnumerationGraphType <Direction> >));
type.Fields.First(f => f.Name == nameof(TestObject.someNullableEnum)).Type.ShouldBe(typeof(EnumerationGraphType <Direction>));
type.Fields.First(f => f.Name == nameof(TestObject.someList)).Type.ShouldBe(typeof(ListGraphType <NonNullGraphType <IntGraphType> >));
type.Fields.First(f => f.Name == nameof(TestObject.someListWithNullable)).Type.ShouldBe(typeof(ListGraphType <IntGraphType>));
type.Fields.First(f => f.Name == nameof(TestObject.someRequiredList)).Type.ShouldBe(typeof(NonNullGraphType <ListGraphType <NonNullGraphType <IntGraphType> > >));
type.Fields.First(f => f.Name == nameof(TestObject.someRequiredListWithNullable)).Type.ShouldBe(typeof(NonNullGraphType <ListGraphType <IntGraphType> >));
type.Fields.First(f => f.Name == nameof(TestObject.someMoney)).Type.ShouldBe(typeof(AutoRegisteringInputObjectGraphType <Money>));
var enumType = new EnumerationGraphType <Direction>();
// disabled to make tests stable without touch GlobalSwitches
//enumType.Values["DESC"].Description.ShouldBe("Descending Order");
enumType.Values["RANDOM"].DeprecationReason.ShouldBe("Do not use Random. This makes no sense!");
}
public static void AddGraphQLConfig(this IServiceCollection services)
{
services.AddTransient <ShortGraphType>();
services.AddTransient <ObjectGraphType>();
services.AddTransient <StringSearchType>();
services.AddTransient <StringSearchMethodEnumType>();
services.AddTransient <NumberSearchMethodEnumType>();
services.AddTransient <SearchOperatorEnumType>();
services.AddTransient <SortOrderEnumType>();
services.AddTransient <IntSearchType>();
services.AddTransient <DateTimeSearchType>();
services.AddTransient <FloatSearchType>();
services.AddTransient <BooleanSearchType>();
services.AddTransient(typeof(ScalarSearchType <>));
services.AddGraphQL(options =>
{
options.EnableMetrics = false;
options.ExposeExceptions = true;
})
.AddWebSockets()
.AddDataLoader();
GraphTypeTypeRegistry.Register <short, ShortGraphType>();
GraphTypeTypeRegistry.Register <DateTime, DateTimeGraphType>();
}
public void ConfigureServices(IServiceCollection services)
{
GraphTypeTypeRegistry.Register <Employee, EmployeeGraph>();
GraphTypeTypeRegistry.Register <EmployeeSummary, EmployeeSummaryGraph>();
GraphTypeTypeRegistry.Register <Company, CompanyGraph>();
services.AddScoped(_ => DbContextBuilder.BuildDbContext());
EfGraphQLConventions.RegisterInContainer <GraphQlEfSampleDbContext>(
services,
model: GraphQlEfSampleDbContext.StaticModel);
EfGraphQLConventions.RegisterConnectionTypesInContainer(services);
foreach (var type in GetGraphQlTypes())
{
services.AddSingleton(type);
}
var graphQl = services.AddGraphQL(
options => options.ExposeExceptions = true);
graphQl.AddWebSockets();
services.AddSingleton <ContextFactory>();
services.AddSingleton <IDocumentExecuter, EfDocumentExecuter>();
services.AddSingleton <IDependencyResolver>(
provider => new FuncDependencyResolver(provider.GetRequiredService));
services.AddSingleton <ISchema, Schema>();
var mvc = services.AddMvc(option => option.EnableEndpointRouting = false);
mvc.SetCompatibilityVersion(CompatibilityVersion.Latest);
mvc.AddNewtonsoftJson();
}
private static bool IsEnabledForRegister(Type propertyType, bool firstCall)
{
if (propertyType == typeof(string))
{
return(true);
}
if (propertyType.IsValueType)
{
return(true); // TODO: requires discussion: Nullable<T>, enums, any struct
}
if (GraphTypeTypeRegistry.Contains(propertyType))
{
return(true);
}
if (firstCall)
{
var realType = GetRealType(propertyType);
if (realType != propertyType)
{
return(IsEnabledForRegister(realType, false));
}
}
return(false);
}
public void ConfigureServices(IServiceCollection services)
{
GraphTypeTypeRegistry.Register <Employee, EmployeeGraph>();
GraphTypeTypeRegistry.Register <EmployeeSummary, EmployeeSummaryGraph>();
GraphTypeTypeRegistry.Register <Company, CompanyGraph>();
EfGraphQLConventions.RegisterInContainer <SampleDbContext>(
services,
model: SampleDbContext.StaticModel);
EfGraphQLConventions.RegisterConnectionTypesInContainer(services);
foreach (var type in GetGraphQlTypes())
{
services.AddSingleton(type);
}
//TODO: re add for subscriptions
//var graphQl = services.AddGraphQL(
// options => options.ExposeExceptions = true);
//graphQl.AddWebSockets();
var dbContextBuilder = new DbContextBuilder();
services.AddSingleton <IHostedService>(dbContextBuilder);
services.AddSingleton <Func <SampleDbContext> >(_ => dbContextBuilder.BuildDbContext);
services.AddScoped(_ => dbContextBuilder.BuildDbContext());
services.AddSingleton <IDocumentExecuter, EfDocumentExecuter>();
services.AddSingleton <ISchema, Schema>();
var mvc = services.AddMvc(option => option.EnableEndpointRouting = false);
mvc.SetCompatibilityVersion(CompatibilityVersion.Latest);
mvc.AddNewtonsoftJson();
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
// FIXME: See https://github.com/graphql-dotnet/graphql-dotnet/issues/1116
services.Configure <KestrelServerOptions>(options =>
{
options.AllowSynchronousIO = true;
});
services.Configure <IISServerOptions>(options =>
{
options.AllowSynchronousIO = true;
});
// FIXME: See https://github.com/graphql-dotnet/graphql-dotnet/issues/1161#issuecomment-540306485
services.AddScoped <IServiceProvider>(
provider => new FuncServiceProvider(provider.GetRequiredService));
services.AddScoped <ISchema, GraphQLSchema>();
services.AddSingleton <IModelData, ModelData>();
services.AddSingleton <QueryType>();
services.AddSingleton <MutationType>();
GraphTypeTypeRegistry.Register(typeof(FooInput), typeof(FooInputType));
GraphTypeTypeRegistry.Register(typeof(Mutation), typeof(MutationType));
GraphTypeTypeRegistry.Register(typeof(Query), typeof(QueryType));
services.AddGraphQL(opts =>
{
opts.EnableMetrics = true;
opts.ExposeExceptions = true;
}).AddGraphTypes(ServiceLifetime.Scoped);
}
public static IServiceCollection DI_GraphQL(this IServiceCollection services)
{
services.AddSingleton <IDocumentExecuter, DocumentExecuter>();
services.AddSingleton <IDocumentWriter, DocumentWriter>();
services.AddSingleton(typeof(ISubscriptionService <>), typeof(SubscriptionService <>));
services.AddSingleton <RootQueries>();
services.AddSingleton <RootMutations>();
services.AddSingleton <RootSubscription>();
services.AddSingleton <RootSchema>();
GraphTypeTypeRegistry.Register(typeof(MutationActionType), typeof(EnumerationGraphType <MutationAction>));
services.AddGraphQL(options =>
{
options.EnableMetrics = false;
})
.AddErrorInfoProvider(options => options.ExposeExceptionStackTrace = true)
.AddSystemTextJson()
.AddUserContextBuilder(httpContext => new GraphQLUserContext {
User = httpContext.User
})
.AddWebSockets()
.AddDataLoader()
.AddGraphTypes(typeof(RootSchema));
return(services);
}
public ForteSchema()
{
ValueConverter.Register <DateTime, TimeWrapper>(time => new TimeWrapper(time));
RegisterValueConverter(new TimeWrapperAstValueConverter());
GraphTypeTypeRegistry.Register <TimeWrapper, TimeWrapperType>();
Query = new Query();
}
public void ConfigureServices(IServiceCollection services)
{
ConfigureBaseServices(services);
HostedDiscordBot.ConfigureServices(services);
services.AddHostedService <HostedDiscordBot>();
services.AddHostedService <ServicePreloader>();
services.Configure <CookiePolicyOptions>(options =>
{
// This lambda determines whether user consent for non-essential cookies is needed for a given request.
options.CheckConsentNeeded = context => false;
options.MinimumSameSitePolicy = SameSiteMode.None;
});
services.AddMemoryCache();
services.AddResponseCaching();
services.AddRouteAnalyzer();
services.AddMvc()
.SetCompatibilityVersion(CompatibilityVersion.Version_2_1)
.AddXmlSerializerFormatters();
services.AddAspAuth();
services.AddLogging(logging => {
//logging.AddConsole();
logging.AddDebug();
});
var config = JsonConvert.DeserializeObject <Configuration>(File.ReadAllText(Configuration["BotConfigPath"]));
services.AddSingleton(config);
services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme).AddCookie("Cookies").AddDiscord(d => {
d.AppId = config.Auth.ClientId;
d.AppSecret = config.Auth.ClientSecret;
d.Scope.Add("identify");
d.SaveTokens = true;
});
services.AddSingleton <IUserContextBuilder, GraphQLUserContextBuilder>();
//GraphQL setup
GraphTypeTypeRegistry.Register <TimeSpan, TimeSpanMillisecondsGraphType>();
services.AddSingleton <InjectedSchema>();
services.AddSingleton <InjectedSchema.IRootQuery, StatusSchema>();
services.AddSingleton <InjectedSchema.IRootQuery, RemindersQuerySchema>();
services.AddSingleton <InjectedSchema.IRootMutation, RemindersMutationSchema>();
services.AddGraphQLAuth();
services.AddGraphQL(options => {
options.EnableMetrics = true;
options.ExposeExceptions = true;
options.ComplexityConfiguration = new ComplexityConfiguration {
MaxDepth = 15
};
});
}
private static IEnumerable <PropertyInfo> GetAllPublicProperties()
{
var type = typeof(TSourceType);
return((new Type[] { type })
.Concat(type.GetInterfaces())
.SelectMany(i => i.GetProperties())
.Where(x => GraphTypeTypeRegistry.Get(x.PropertyType) != null));
}
private void RegisterCustomGraphTypes(IServiceLocator serviceLocator)
{
var customGraphTypes = GraphTypeLoader.GetCustomGraphTypes(serviceLocator).ToArray();
foreach (var customGraphType in customGraphTypes)
{
GraphTypeTypeRegistry.Register(customGraphType.TargetType, customGraphType.GetType());
}
}
static MappingTests()
{
ArgumentGraphs.Initialise();
GraphTypeTypeRegistry.Register <MappingParent, MappingParentGraph>();
GraphTypeTypeRegistry.Register <MappingChild, MappingChildGraph>();
sqlInstance = new SqlInstance <MappingContext>(
constructInstance: builder => new MappingContext(builder.Options));
}
static ArgumentGraphs()
{
GraphTypeTypeRegistry.Register(typeof(Comparison), typeof(ComparisonGraph));
GraphTypeTypeRegistry.Register(typeof(StringComparison), typeof(StringComparisonGraph));
Add <StringComparisonGraph>();
Add <WhereExpressionGraph>();
Add <OrderByGraph>();
Add <ComparisonGraph>();
}
static void Add <T>(Type type)
where T : ScalarGraphType, new()
{
if (GraphTypeTypeRegistry.Get(type) == null)
{
GraphTypeTypeRegistry.Register(type, typeof(GuidGraph));
var value = new T();
entries.Add(typeof(T), value);
}
}
/// <summary>
/// Gets the graph type for the indicated type.
/// </summary>
/// <param name="type">The type for which a graph type is desired.</param>
/// <param name="isNullable">if set to <c>false</c> if the type explicitly non-nullable.</param>
/// <returns>A Type object representing a GraphType that matches the indicated type.</returns>
/// <remarks>This can handle arrays, lists and other collections implementing IEnumerable.</remarks>
public static Type GetGraphTypeFromType(this Type type, bool isNullable = false)
{
while (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(IDataLoaderResult <>))
{
type = type.GetGenericArguments()[0];
}
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable <>))
{
type = type.GetGenericArguments()[0];
if (isNullable == false)
{
throw new ArgumentOutOfRangeException(nameof(isNullable),
$"Explicitly nullable type: Nullable<{type.Name}> cannot be coerced to a non nullable GraphQL type. \n");
}
}
Type graphType;
if (type.IsArray)
{
var clrElementType = type.GetElementType();
var elementType = GetGraphTypeFromType(clrElementType, clrElementType.IsNullable()); // isNullable from elementType, not from parent array
graphType = typeof(ListGraphType <>).MakeGenericType(elementType);
}
else if (IsAnIEnumerable(type))
{
var clrElementType = GetEnumerableElementType(type);
var elementType = GetGraphTypeFromType(clrElementType, clrElementType.IsNullable()); // isNullable from elementType, not from parent container
graphType = typeof(ListGraphType <>).MakeGenericType(elementType);
}
else
{
graphType = GraphTypeTypeRegistry.Get(type);
}
if (graphType == null)
{
if (type.IsEnum)
{
graphType = typeof(EnumerationGraphType <>).MakeGenericType(type);
}
else
{
throw new ArgumentOutOfRangeException(nameof(type), $"The type: {type.Name} cannot be coerced effectively to a GraphQL type");
}
}
if (!isNullable)
{
graphType = typeof(NonNullGraphType <>).MakeGenericType(graphType);
}
return(graphType);
}
public void Initialize(IServiceCollection services)
{
//Register .NET GraphQL server
var graphQlBuilder = services.AddGraphQL(_ =>
{
_.EnableMetrics = false;
}).AddNewtonsoftJson(deserializerSettings => { }, serializerSettings => { })
.AddErrorInfoProvider(options =>
{
options.ExposeExtensions = true;
options.ExposeExceptionStackTrace = true;
})
.AddUserContextBuilder(context => context.BuildGraphQLUserContext())
.AddRelayGraphTypes()
.AddDataLoader()
.AddGraphTypes(typeof(XCoreAnchor));
//Register custom GraphQL dependencies
services.AddPermissionAuthorization();
services.AddSingleton <ISchema, SchemaFactory>();
//Register all xApi boundaries
services.AddXCatalog(graphQlBuilder);
services.AddXProfile(graphQlBuilder);
services.AddXPurchase(graphQlBuilder);
services.AddXOrder(graphQlBuilder);
//TODO: Remove after update GraphQL.net to 3.2.0 version.
//VP-6356 DateTime field types for GraphQL schema do not return time in result
GraphTypeTypeRegistry.Register <DateTime, DateTimeGraphType>();
services.AddSingleton <IStoreCurrencyResolver, StoreCurrencyResolver>();
services.AddAutoMapper(ModuleInfo.Assembly);
#region Pipelines
services.AddPipeline <PromotionEvaluationContext>(builder =>
{
builder.AddMiddleware(typeof(LoadUserToEvalContextMiddleware));
builder.AddMiddleware(typeof(LoadCartToEvalContextMiddleware));
});
services.AddPipeline <TaxEvaluationContext>(builder =>
{
builder.AddMiddleware(typeof(LoadUserToEvalContextMiddleware));
builder.AddMiddleware(typeof(LoadCartToEvalContextMiddleware));
});
services.AddPipeline <PriceEvaluationContext>(builder =>
{
builder.AddMiddleware(typeof(LoadUserToEvalContextMiddleware));
builder.AddMiddleware(typeof(LoadCartToEvalContextMiddleware));
});
#endregion
}
public static Type FindGraphType <TReturn>()
where TReturn : class
{
var graphType = GraphTypeTypeRegistry.Get <TReturn>();
if (graphType != null)
{
return(graphType);
}
throw new Exception($"Could not resolve a GraphType for {typeof(TReturn).FullName}. Either pass in a GraphType explicitly or register a GraphType using GraphTypeTypeRegistry.Register<{typeof(TReturn).FullName},MyGraphType>().");
}
public static void InjectGraphQl(this IServiceCollection collection)
{
InjectForNamespace(collection, "HouseHub.Web.UserApi.Presentation.GraphQl.Schemas");
InjectForNamespace(collection, "HouseHub.Web.UserApi.Presentation.GraphQl.Queries");
InjectForNamespace(collection, "HouseHub.Web.UserApi.Presentation.GraphQl.Mutations");
collection.AddScoped <IDependencyResolver>(s => new FuncDependencyResolver(s.GetRequiredService));
collection.AddScoped <RootSchema>();
collection.AddScoped <RootMutation>();
collection.AddScoped <RootQuery>();
collection.AddScoped <ISchema, RootSchema>();
collection.AddScoped <GuidGraphType>();
collection.AddScoped <UriGraphType>();
collection.AddScoped <EnumerationGraphType <OrderDirection> >();
var coreAssembly = Assembly.Load("HouseHub.Web.UserApi.Core");
coreAssembly.GetTypesForPath("HouseHub.Web.UserApi.Core.GraphQl.Helpers").ForEach(p =>
{
RuntimeHelpers.RunClassConstructor(p.TypeHandle);
collection.AddScoped(p.UnderlyingSystemType);
});
coreAssembly.GetTypesForPath("HouseHub.Web.UserApi.Core.GraphQl.InputObjects").ForEach(p => { collection.AddScoped(p.UnderlyingSystemType); });
coreAssembly.GetTypesForPath("HouseHub.Web.UserApi.Core.GraphQl.OutputObjects").ForEach(p => { collection.AddScoped(p.UnderlyingSystemType); });
var enumGraphType = typeof(EnumerationGraphType <>);
coreAssembly.GetEnumsForPath("HouseHub.Web.UserApi.Core.Enums").ForEach(p =>
{
collection.AddSingleton(enumGraphType.MakeGenericType(p));
GraphTypeTypeRegistry.Register(p, enumGraphType.MakeGenericType(p));
collection.AddScoped(enumGraphType.MakeGenericType(p));
});
GraphTypeTypeRegistry.Register(typeof(OrderDirection), enumGraphType.MakeGenericType(typeof(OrderDirection)));
GraphTypeTypeRegistry.Register(typeof(Guid), typeof(GuidGraphType));
collection.AddGraphQL(opt => { opt.ExposeExceptions = true; })
.AddGraphTypes(ServiceLifetime.Scoped)
.AddDataLoader();
ValueConverter.Register(
typeof(double),
typeof(float),
value => Convert.ToSingle(value, NumberFormatInfo.InvariantInfo));
ValueConverter.Register(
typeof(float),
typeof(double),
value => Convert.ToDouble(value, NumberFormatInfo.InvariantInfo));
}
/// <summary>
/// Resolve the GraphType for a Type, first looking for any attributes
/// then falling back to the default library implementation.
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
private static Type GetGraphTypeInternal(Type type)
{
// Support enum types
if (type.GetTypeInfo().IsEnum)
{
return(typeof(EnumerationGraphType <>).MakeGenericType(type));
}
var graphqlType = GraphTypeTypeRegistry.Get(type);
return(graphqlType ?? typeof(InputObjectGraphType <>).MakeGenericType(type));
}
protected virtual bool IsEnabledForRegister(PropertyInfo propertyInfo, Type propertyType, bool firstCall)
{
if (propertyInfo.GetCustomAttribute <IgnoreAttribute>() != null)
{
return(false);
}
if (propertyType == typeof(string))
{
return(true);
}
if (propertyType.IsValueType)
{
return(true); // TODO: requires discussion: Nullable<T>, enums, any struct
}
if (GraphTypeTypeRegistry.Contains(propertyType))
{
return(true);
}
if (propertyType == typeof(ResolveFieldContext))
{
return(false);
}
if (firstCall)
{
var realType = GetRealType(propertyType);
if (realType != propertyType)
{
return(IsEnabledForRegister(propertyInfo, realType, false));
}
}
var fieldConfiguration = _typeConfiguration.GetFieldConfiguration(propertyInfo.Name);
if (fieldConfiguration?.Ignored == true || fieldConfiguration?.Output == false)
{
return(false);
}
if (!propertyType.IsValueType && propertyType.IsClass)
{
var type = typeof(AutoObjectGraphType <>).MakeGenericType(propertyType);
GraphTypeTypeRegistry.Register(propertyType, type);
return(true);
}
return(false);
}
public static IGraphQLBuilder AddEntityGraphQuery(this IGraphQLBuilder builder)
{
GraphTypeTypeRegistry.Register <DateTime, DateTimeGraphType>(); //fix DateTime GraphType mapping
builder.Services.TryAddSingleton <IEntityGraphTypeBuilder, EntityGraphTypeBuilder>();
builder.AddEntityGraphQueryTypes();
builder.AddEntityGraphQueryArguments();
builder.AddEntityGraphQueryResolver();
return(builder);
}
/// <summary>
/// Add Graphity with a user defined configuration
/// </summary>
/// <typeparam name="TContext"></typeparam>
/// <param name="services"></param>
/// <param name="setupAction">Use this to configure the graph.</param>
/// <returns></returns>
public static IServiceCollection AddGraphity <TContext>(
this IServiceCollection services,
Action <IQueryOptions <TContext> > setupAction)
where TContext : DbContext
{
var contextService = services.SingleOrDefault(sd => sd.ImplementationType == typeof(TContext));
if (contextService == null)
{
throw new GraphityException("Unable to configure Graphity when the context service hasn't been registered");
}
var queryOptions = new QueryOptions <TContext>();
setupAction?.Invoke(queryOptions);
DynamicQuery <TContext> .QueryOptions = queryOptions;
services.AddSingleton <IDocumentExecuter, DocumentExecuter>();
services.AddSingleton <IScopedDependencyResolver>(serviceProvider => new ScopedFuncDependencyResolver(serviceProvider.GetRequiredService, serviceProvider.CreateScope));
services.AddSingleton <ISchema, DynamicSchema <TContext> >();
services.AddSingleton <DynamicQuery <TContext> >();
services.AddSingleton <ObjectGraphType>();
services.AddSingleton <GuidGraphType>();
//Where
services.AddSingleton <WhereExpressionType>();
services.AddSingleton <ComparisonType>();
GraphTypeTypeRegistry.Register <Comparison, ComparisonType>();
GraphTypeTypeRegistry.Register <WhereExpression, WhereExpressionType>();
//Ordering
services.AddSingleton <OrderByExpressionType>();
services.AddSingleton <OrderByDirectionType>();
GraphTypeTypeRegistry.Register <OrderByDirection, OrderByDirectionType>();
GraphTypeTypeRegistry.Register <OrderByExpression, OrderByExpressionType>();
foreach (var field in queryOptions.GetAllFields())
{
var graphType = typeof(DynamicObjectGraphType <,>).MakeGenericType(typeof(TContext), field.Type);
services.AddSingleton(
graphType,
Activator.CreateInstance(graphType, field, (Action <Type>)TypeRegistrar));
}
AddGraphQLAuth(services, queryOptions.AuthorisationPolicies);
void TypeRegistrar(Type type) => services.AddSingleton(type);
return(services);
}
public static Type GetGraphTypeFromTypeOrNull(this Type type, bool isNullable = false)
{
TypeInfo info = type.GetTypeInfo();
if (info.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable <>))
{
type = type.GetGenericArguments()[0];
if (isNullable == false)
{
throw new ArgumentOutOfRangeException(nameof(isNullable),
$"Explicitly nullable type: Nullable<{type.Name}> cannot be coerced to a non nullable GraphQL type. \n");
}
}
var graphType = GraphTypeTypeRegistry.Get(type);
if (type.IsArray)
{
var elementType = GetGraphTypeFromTypeOrNull(type.GetElementType(), isNullable);
if (elementType != null)
{
var listType = typeof(ListGraphType <>);
graphType = listType.MakeGenericType(elementType);
}
}
if (IsAnIEnumerable(type))
{
var elementType = GetGraphTypeFromTypeOrNull(type.GenericTypeArguments.First(), isNullable);
if (elementType != null)
{
var listType = typeof(ListGraphType <>);
graphType = listType.MakeGenericType(elementType);
}
}
if (graphType == null)
{
return(null);
}
if (!isNullable)
{
var nullType = typeof(NonNullGraphType <>);
graphType = nullType.MakeGenericType(graphType);
}
return(graphType);
}
