public static ISchemaBuilder AddConvention <T>(
this ISchemaBuilder builder, IConvention convention)
where T : IConvention
{
builder.AddConvention(typeof(T), convention);
return(builder);
}
public static ISchemaBuilder AddConvention(
this ISchemaBuilder builder,
Type convention,
IConvention concreteConvention,
string?scope = null)
{
if (builder is null)
{
throw new ArgumentNullException(nameof(builder));
}
if (convention is null)
{
throw new ArgumentNullException(nameof(convention));
}
if (concreteConvention is null)
{
throw new ArgumentNullException(nameof(concreteConvention));
}
if (!typeof(IConvention).IsAssignableFrom(convention))
{
throw new ArgumentException(
TypeResources.SchemaBuilder_Convention_NotSuppported,
nameof(convention));
}
return(builder.AddConvention(convention, (s) => concreteConvention, scope));
}
public static ISchemaBuilder AddConvention(
this ISchemaBuilder builder,
Type convention,
Type concreteConvention)
{
if (concreteConvention == null)
{
throw new ArgumentNullException(nameof(concreteConvention));
}
if (convention == null)
{
throw new ArgumentNullException(nameof(convention));
}
if (!typeof(IConvention).IsAssignableFrom(convention))
{
throw new ArgumentException(
TypeResources.SchemaBuilder_Convention_NotSuppported,
nameof(convention));
}
if (!typeof(IConvention).IsAssignableFrom(concreteConvention))
{
throw new ArgumentException(
TypeResources.SchemaBuilder_Convention_NotSuppported,
nameof(convention));
}
builder.AddConvention(convention, (s) => (IConvention)s.GetService(concreteConvention));
return(builder);
}
public static ISchemaBuilder AddSpatialFiltering(this ISchemaBuilder builder)
{
if (builder is null)
{
throw new ArgumentNullException(nameof(builder));
}
return(builder.AddConvention <IFilterConvention>(
new FilterConventionExtension(x => x.AddSpatialDefaults())));
}
public static ISchemaBuilder AddConvention <T>(
this ISchemaBuilder builder,
CreateConvention conventionFactory,
string?scope = null)
{
if (builder is null)
{
throw new ArgumentNullException(nameof(builder));
}
return(builder.AddConvention(typeof(T), conventionFactory, scope));
}
public static ISchemaBuilder AddSpatialProjections(this ISchemaBuilder builder)
{
if (builder is null)
{
throw new ArgumentNullException(nameof(builder));
}
return(builder.AddConvention <IProjectionConvention>(
new ProjectionConventionExtension(
x => x.AddProviderExtension(
new ProjectionProviderExtension(y => y.AddSpatialHandlers())))));
}
public static ISchemaBuilder AddConvention <TConvetion, TConcreteConvention>(
this ISchemaBuilder builder)
where TConvetion : IConvention
where TConcreteConvention : IConvention
{
builder.AddConvention(
typeof(TConvetion),
typeof(TConcreteConvention)
);
return(builder);
}
public static ISchemaBuilder AddConvention(
this ISchemaBuilder builder,
Type convention,
Type concreteConvention,
string?scope = null)
{
if (builder is null)
{
throw new ArgumentNullException(nameof(builder));
}
if (convention is null)
{
throw new ArgumentNullException(nameof(convention));
}
if (concreteConvention is null)
{
throw new ArgumentNullException(nameof(concreteConvention));
}
if (!typeof(IConvention).IsAssignableFrom(convention))
{
throw new ArgumentException(
TypeResources.SchemaBuilder_Convention_NotSuppported,
nameof(convention));
}
if (!typeof(IConvention).IsAssignableFrom(concreteConvention))
{
throw new ArgumentException(
TypeResources.SchemaBuilder_Convention_NotSuppported,
nameof(convention));
}
return(builder.AddConvention(
convention,
s =>
{
if (s.TryGetOrCreateService <IConvention>(
concreteConvention,
out IConvention convention))
{
return convention;
}
throw Convention_UnableToCreateConvention(concreteConvention);
},
scope));
}
protected ISchema CreateSchemaWith(
IFilterInputType type,
FilterConvention convention,
params FilterConventionExtension[] extensions)
{
ISchemaBuilder builder = SchemaBuilder.New()
.AddConvention <IFilterConvention>(convention)
.AddFiltering()
.AddQueryType(
c =>
c.Name("Query")
.Field("foo")
.Type <StringType>()
.Resolver("bar"))
.AddType(type);
foreach (var extension in extensions)
{
builder.AddConvention <IFilterConvention>(extension);
}
return(builder.Create());
}
protected ISchema CreateSchemaWithTypes(
ISortInputType type,
SortConvention convention,
params Type[] extensions)
{
ISchemaBuilder builder = SchemaBuilder.New()
.AddConvention <ISortConvention>(convention)
.AddSorting()
.AddQueryType(
c =>
c.Name("Query")
.Field("foo")
.Type <StringType>()
.Resolve("bar"))
.AddType(type);
foreach (var extension in extensions)
{
builder.AddConvention <ISortConvention>(extension);
}
return(builder.Create());
}
public static ISchemaBuilder AddConvention <TConvetion, TConcreteConvention>(
this ISchemaBuilder builder,
string?scope = null)
where TConvetion : IConvention
where TConcreteConvention : IConvention =>
builder.AddConvention(typeof(TConvetion), typeof(TConcreteConvention), scope);
public static ISchemaBuilder AddConvention <T>(
this ISchemaBuilder builder,
IConvention convention,
string?scope = null)
where T : IConvention =>
builder.AddConvention(typeof(T), convention, scope);
public IRequestExecutor CreateSchema <TEntity>(
TEntity[] entities,
ProjectionProvider?provider = null,
Action <ModelBuilder>?onModelCreating = null,
bool usePaging = false,
bool useOffsetPaging = false,
INamedType?objectType = null,
Action <ISchemaBuilder>?configure = null)
where TEntity : class
{
provider ??= new QueryableProjectionProvider(x => x.AddDefaults());
var convention = new ProjectionConvention(x => x.Provider(provider));
Func <IResolverContext, IQueryable <TEntity> > resolver =
BuildResolver(onModelCreating, entities);
ISchemaBuilder builder = SchemaBuilder.New();
if (objectType is not null)
{
builder.AddType(objectType);
}
configure?.Invoke(builder);
builder
.AddConvention <IProjectionConvention>(convention)
.AddProjections()
.AddFiltering()
.AddSorting()
.AddQueryType(
new ObjectType <StubObject <TEntity> >(
c =>
{
c.Name("Query");
ApplyConfigurationToFieldDescriptor <TEntity>(
c.Field(x => x.Root).Resolve(resolver),
usePaging,
useOffsetPaging);
ApplyConfigurationToFieldDescriptor <TEntity>(
c.Field("rootExecutable")
.Resolve(ctx => resolver(ctx).AsExecutable()),
usePaging,
useOffsetPaging);
}));
builder.ModifyOptions(o => o.ValidatePipelineOrder = false);
ISchema schema = builder.Create();
return(new ServiceCollection()
.Configure <RequestExecutorSetup>(Schema.DefaultName, o => o.Schema = schema)
.AddGraphQL()
.UseRequest(
next => async context =>
{
await next(context);
if (context.Result is IReadOnlyQueryResult result &&
context.ContextData.TryGetValue("sql", out object?queryString))
{
context.Result =
QueryResultBuilder
.FromResult(result)
.SetContextData("sql", queryString)
.Create();
}
})
.UseDefaultPipeline()
.Services
.BuildServiceProvider()
.GetRequiredService <IRequestExecutorResolver>()
.GetRequestExecutorAsync()
.Result);
}