public static ISchemaBuilder RegisterTypes(this ISchemaBuilder schemaBuilder)
{
schemaBuilder.AddType <ObjectType <User> >();
schemaBuilder.AddType <ObjectType <Address> >();
schemaBuilder.AddType <ObjectType <KeyValueEntity> >();
return(schemaBuilder);
}
public static ISchemaBuilder AddCatalogSchemaBuilder(this ISchemaBuilder schemaBuilder)
{
return(schemaBuilder
.AddType <CatalogQueries>()
//.AddType<CatalogMutations>()
.AddType <ProductType>());
}
public static ISchemaBuilder AddDirectiveType(
this ISchemaBuilder builder,
Type directiveType)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (directiveType == null)
{
throw new ArgumentNullException(nameof(directiveType));
}
if (directiveType == typeof(DirectiveType) ||
(directiveType.IsGenericType &&
directiveType.GetGenericTypeDefinition() ==
typeof(DirectiveType <>)))
{
// TODO : resources
throw new ArgumentException("df", nameof(directiveType));
}
if (!typeof(DirectiveType).IsAssignableFrom(directiveType))
{
// TODO : resources
throw new ArgumentException("df", nameof(directiveType));
}
return(builder.AddType(directiveType));
}
public static ISchemaBuilder AddSchemaRegistry(
this ISchemaBuilder builder,
bool addRootTypes = true)
{
if (addRootTypes)
{
builder
.AddQueryType(d => d.Name("Query"))
.AddMutationType(d => d.Name("Mutation"))
.AddSubscriptionType(d => d.Name("Subscription"));
}
return(builder
.AddType <EnvironmentQueries>()
.AddType <EnvironmentMutations>()
.AddType <SchemaQueries>()
.AddType <SchemaMutations>()
.AddType <SchemaSubscriptions>()
.AddType <SchemaExtension>()
.AddType <SchemaVersionExtension>()
.AddType <SchemaPublishReportExtension>()
.AddType <ClientQueries>()
.AddType <ClientMutations>()
.AddType <ClientExtension>()
.AddType <ClientVersionExtension>()
.AddType <QueryDocumentExtension>()
.BindClrType <string, StringType>()
.BindClrType <Guid, IdType>());
}
public static ISchemaBuilder AddDirectiveType(
this ISchemaBuilder builder,
Type directiveType)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (directiveType == null)
{
throw new ArgumentNullException(nameof(directiveType));
}
if (directiveType == typeof(DirectiveType) ||
(directiveType.IsGenericType &&
directiveType.GetGenericTypeDefinition() ==
typeof(DirectiveType <>)))
{
throw new ArgumentException(
TypeResources.SchemaBuilderExtensions_DirectiveTypeIsBaseType,
nameof(directiveType));
}
if (!typeof(DirectiveType).IsAssignableFrom(directiveType))
{
throw new ArgumentException(
TypeResources.SchemaBuilderExtensions_MustBeDirectiveType,
nameof(directiveType));
}
return(builder.AddType(directiveType));
}
/// <summary>
/// Adds GeoJSON compliant spatial types.
/// </summary>
/// <param name="builder">
/// The <see cref="ISchemaBuilder"/>.
/// </param>
/// <returns>
/// The <see cref="ISchemaBuilder"/>.
/// </returns>
/// <exception cref="ArgumentNullException">
/// The <paramref name="builder"/> is <c>null</c>.
/// </exception>
public static ISchemaBuilder AddSpatialTypes(this ISchemaBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
return(builder
.AddType <GeoJsonInterfaceType>()
.AddType <GeoJsonGeometryType>()
.AddType <GeoJsonPointInputType>()
.AddType <GeoJsonMultiPointInputType>()
.AddType <GeoJsonLineStringInputType>()
.AddType <GeoJsonMultiLineStringInputType>()
.AddType <GeoJsonPolygonInputType>()
.AddType <GeoJsonMultiPolygonInputType>()
.AddType <GeoJsonPointType>()
.AddType <GeoJsonMultiPointType>()
.AddType <GeoJsonLineStringType>()
.AddType <GeoJsonMultiLineStringType>()
.AddType <GeoJsonPolygonType>()
.AddType <GeoJsonMultiPolygonType>()
.AddType <GeoJsonGeometryEnumType>()
.AddType <GeometryType>()
.BindClrType <Coordinate, GeoJsonPositionType>());
}
/// <summary>
/// Add the <see cref="TimeSpanType"/> scalar to the schema builder.
/// </summary>
/// <param name="builder">The schema builder.</param>
/// <returns>The schema builder.</returns>
public static ISchemaBuilder AddTimeSpanScalar(this ISchemaBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
return(builder.AddType(typeof(TimeSpanType)));
}
public static ISchemaBuilder AddType <T>(
this ISchemaBuilder builder)
{
if (builder is null)
{
throw new ArgumentNullException(nameof(builder));
}
return(builder.AddType(typeof(T)));
}
public static ISchemaBuilder AddInputObjectType <T>(
this ISchemaBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
return(builder.AddType(new InputObjectType <T>()));
}
public static ISchemaBuilder AddOurCommonGraphQLTypes(this ISchemaBuilder schemaBuilder)
{
// Ensure string still defaults to StringType
schemaBuilder.BindClrType <string, StringType>();
// Set a maximum page size
schemaBuilder
.AddType(new PaginationAmountType(50))
.BindClrType <int, IntType>();
return(schemaBuilder);
}
/// <summary>
/// Add nodatime types to HotChocolate
/// </summary>
/// <param name="schemaBuilder"></param>
/// <returns></returns>
public static ISchemaBuilder AddNodaTime(this ISchemaBuilder schemaBuilder)
{
schemaBuilder
.AddFiltering()
.AddConvention <IFilterConvention>(
new FilterConventionExtension(
descriptor => descriptor
.BindRuntimeType <DateTimeZone, ComparableOperationFilterInputType <DateTimeZone> >()
.BindRuntimeType <Duration, ComparableOperationFilterInputType <Duration> >()
.BindRuntimeType <Duration?, ComparableOperationFilterInputType <Duration> >()
.BindRuntimeType <Instant, ComparableOperationFilterInputType <Instant> >()
.BindRuntimeType <Instant?, ComparableOperationFilterInputType <Instant> >()
.BindRuntimeType <IsoDayOfWeek, ComparableOperationFilterInputType <IsoDayOfWeek> >()
.BindRuntimeType <IsoDayOfWeek?, ComparableOperationFilterInputType <IsoDayOfWeek> >()
.BindRuntimeType <LocalDateTime, ComparableOperationFilterInputType <LocalDateTime> >()
.BindRuntimeType <LocalDateTime?, ComparableOperationFilterInputType <LocalDateTime> >()
.BindRuntimeType <LocalDate, ComparableOperationFilterInputType <LocalDate> >()
.BindRuntimeType <LocalDate?, ComparableOperationFilterInputType <LocalDate> >()
.BindRuntimeType <LocalTime, ComparableOperationFilterInputType <LocalTime> >()
.BindRuntimeType <LocalTime?, ComparableOperationFilterInputType <LocalTime> >()
.BindRuntimeType <OffsetDateTime, ComparableOperationFilterInputType <OffsetDateTime> >()
.BindRuntimeType <OffsetDateTime?, ComparableOperationFilterInputType <OffsetDateTime> >()
.BindRuntimeType <OffsetDate, ComparableOperationFilterInputType <OffsetDate> >()
.BindRuntimeType <OffsetDate?, ComparableOperationFilterInputType <OffsetDate> >()
.BindRuntimeType <OffsetTime, ComparableOperationFilterInputType <OffsetTime> >()
.BindRuntimeType <OffsetTime?, ComparableOperationFilterInputType <OffsetTime> >()
.BindRuntimeType <Offset, ComparableOperationFilterInputType <Offset> >()
.BindRuntimeType <Offset?, ComparableOperationFilterInputType <Offset> >()
.BindRuntimeType <Period, ComparableOperationFilterInputType <Period> >()
.BindRuntimeType <ZonedDateTime, ComparableOperationFilterInputType <ZonedDateTime> >()
.BindRuntimeType <ZonedDateTime?, ComparableOperationFilterInputType <ZonedDateTime> >()
)
);
return(schemaBuilder
.AddType <DateTimeZoneType>()
.AddType(new DurationType(DurationPattern.JsonRoundtrip, DurationPattern.Roundtrip))
.AddType(new InstantType(InstantPattern.General, InstantPattern.ExtendedIso, new InstantDateTimeOffsetPattern()))
.AddType <IsoDayOfWeekType>()
.AddType(new LocalDateTimeType(LocalDateTimePattern.GeneralIso, LocalDateTimePattern.ExtendedIso, LocalDateTimePattern.BclRoundtrip))
.AddType(new LocalDateType(LocalDatePattern.Iso, LocalDatePattern.FullRoundtrip))
.AddType(new LocalTimeType(LocalTimePattern.ExtendedIso, LocalTimePattern.GeneralIso))
.AddType(new OffsetDateTimeType(OffsetDateTimePattern.GeneralIso, OffsetDateTimePattern.FullRoundtrip))
.AddType(new OffsetDateType(OffsetDatePattern.GeneralIso, OffsetDatePattern.FullRoundtrip))
.AddType(new OffsetTimeType(OffsetTimePattern.Rfc3339, OffsetTimePattern.GeneralIso, OffsetTimePattern.ExtendedIso))
.AddType(new OffsetType(OffsetPattern.GeneralInvariant, OffsetPattern.GeneralInvariantWithZ))
.AddType(new PeriodType(PeriodPattern.Roundtrip, PeriodPattern.NormalizingIso))
.AddType <ZonedDateTimeType>());
}
public static ISchemaBuilder AddObjectType <T>(
this ISchemaBuilder builder,
Action <IObjectTypeDescriptor <T> > configure)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (configure == null)
{
throw new ArgumentNullException(nameof(configure));
}
return(builder.AddType(new ObjectType <T>(configure)));
}
public static ISchemaBuilder AddInputObjectType(
this ISchemaBuilder builder,
Action <IInputObjectTypeDescriptor> configure)
{
if (builder is null)
{
throw new ArgumentNullException(nameof(builder));
}
if (configure is null)
{
throw new ArgumentNullException(nameof(configure));
}
return(builder.AddType(new InputObjectType(configure)));
}
public static ISchemaBuilder AddEnumType(
this ISchemaBuilder builder,
Action <IEnumTypeDescriptor> configure)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (configure == null)
{
throw new ArgumentNullException(nameof(configure));
}
return(builder.AddType(new EnumType(configure)));
}
public static ISchemaBuilder ScanGraphTypes(this ISchemaBuilder builder, params Assembly[] assemblies)
{
var types = assemblies
.SelectMany(x => x.GetTypes()
.Where(t => t != typeof(ObjectType) && typeof(ObjectType).IsAssignableFrom(t) &&
t.GetCustomAttribute <GraphQueryTypeAttribute>() == null &&
t.GetCustomAttribute <GraphMutationTypeAttribute>() == null &&
t.GetCustomAttribute <GraphSubscriptionTypeAttribute>() == null)
);
foreach (var type in types)
{
builder.AddType(type);
}
return(builder);
}
public static ISchemaBuilder AddNodaTime(this ISchemaBuilder schemaBuilder)
{
return(schemaBuilder
.AddType <DateTimeZoneType>()
.AddType <DurationType>()
.AddType <InstantType>()
.AddType <IsoDayOfWeekType>()
.AddType <LocalDateTimeType>()
.AddType <LocalDateType>()
.AddType <LocalTimeType>()
.AddType <OffsetDateTimeType>()
.AddType <OffsetDateType>()
.AddType <OffsetTimeType>()
.AddType <OffsetType>()
.AddType <PeriodType>()
.AddType <ZonedDateTimeType>());
}
/// <summary>
/// Adds support for Apollo Federation to the schema.
/// </summary>
/// <param name="builder">
/// The <see cref="ISchemaBuilder"/>.
/// </param>
/// <returns>
/// Returns the <see cref="ISchemaBuilder"/>.
/// </returns>
/// <exception cref="ArgumentNullException">
/// The <paramref name="builder"/> is <c>null</c>.
/// </exception>
public static ISchemaBuilder AddApolloFederation(
this ISchemaBuilder builder)
{
if (builder is null)
{
throw new ArgumentNullException(nameof(builder));
}
builder.AddType <AnyType>();
builder.AddType <EntityType>();
builder.AddType <ServiceType>();
builder.AddType <ExternalDirectiveType>();
builder.AddType <ProvidesDirectiveType>();
builder.AddType <KeyDirectiveType>();
builder.AddType <FieldSetType>();
builder.AddType <RequiresDirectiveType>();
builder.TryAddTypeInterceptor <FederationTypeInterceptor>();
return(builder);
}
public static ISchemaBuilder AddInputObjectType <T>(
this ISchemaBuilder builder)
{
if (builder is null)
{
throw new ArgumentNullException(nameof(builder));
}
if (typeof(T).IsSchemaType() || typeof(T).IsNonGenericSchemaType())
{
throw new InvalidOperationException(
string.Format(
TypeResources.SchemaBuilderExtensions_AddInputObjectType_TIsSchemaType,
typeof(T).FullName));
}
return(builder.AddType(new InputObjectType <T>()));
}
public static ISchemaBuilder AddAllLocalTypes(this ISchemaBuilder builder)
{
var types = Assembly
.GetExecutingAssembly()
.GetTypes()
.Where(x => x.BaseType?.IsGenericType == true &&
(x.BaseType.GetGenericTypeDefinition() == typeof(ObjectType <>) ||
x.BaseType.GetGenericTypeDefinition() == typeof(InterfaceType <>) ||
x.BaseType.GetGenericTypeDefinition() == typeof(UnionType <>) ||
x.BaseType.GetGenericTypeDefinition() == typeof(InputObjectType <>) ||
x.BaseType.GetGenericTypeDefinition() == typeof(EnumType <>)));
foreach (var type in types)
{
builder.AddType(type);
}
return(builder);
}
public static ISchemaBuilder AddTypes(
this ISchemaBuilder builder,
params Type[] types)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (types == null)
{
throw new ArgumentNullException(nameof(types));
}
foreach (Type type in types)
{
builder.AddType(type);
}
return(builder);
}
public static ISchemaBuilder AddSpatialTypes(this ISchemaBuilder builder)
{
return(builder
.AddType <GeoJSONInterface>()
.AddType <GeoJSONGeometryType>()
.AddType <GeoJSONPointInput>()
.AddType <GeoJSONMultiPointInput>()
.AddType <GeoJSONLineStringInput>()
.AddType <GeoJSONMultiLineStringInput>()
.AddType <GeoJSONPolygonInput>()
.AddType <GeoJSONMultiPolygonInput>()
.AddType <GeoJSONPointType>()
.AddType <GeoJSONMultiPointType>()
.AddType <GeoJSONLineStringType>()
.AddType <GeoJSONMultiLineStringType>()
.AddType <GeoJSONPolygonType>()
.AddType <GeoJSONMultiPolygonType>()
.BindClrType <Coordinate, GeoJSONPositionScalar>());
}
public static ISchemaBuilder AddTypes(this ISchemaBuilder builder)
{
builder
.AddType <MediaTypeEnum>()
.AddType <InterviewType> ()
.AddType <UserType> ()
.AddType <MultipleChoiceQuestionType>()
.AddType <TextQuestionType>()
.AddType <RangeQuestionType>()
.AddType <TextAnswerFormatType>()
.AddType <VideoAnswerFormatType>()
.AddType <AudioAnswerFormatType>()
.AddType <RangeOptionInputType>()
.AddType <AttachmentInputType>()
.AddType <OptionInputType>()
.AddType <TextQuestionInputType>()
.AddType <InterchangeTemplateCreateCommandInputType>()
.AddType <InterviewRoundCreateCommandInputType>()
.AddType <InterviewCreateCommandInputType>()
.AddQueryType <RootQuery>()
.AddMutationType <Mutation>();
return(builder);
}
public static ISchemaBuilder AddInterfaceType <T>(
this ISchemaBuilder builder,
Action <IInterfaceTypeDescriptor <T> > configure)
{
if (builder is null)
{
throw new ArgumentNullException(nameof(builder));
}
if (configure is null)
{
throw new ArgumentNullException(nameof(configure));
}
if (typeof(T).IsSchemaType() || typeof(T).IsNonGenericSchemaType())
{
throw new InvalidOperationException(
string.Format(
TypeResources.SchemaBuilderExtensions_AddInterfaceType_TIsSchemaType,
typeof(T).FullName));
}
return(builder.AddType(new InterfaceType <T>(configure)));
}
public static void ModifySchemaDuringBuild(ISchemaBuilder schemaBuilder)
{
// add "relationToMe" to the User graph... but how?
schemaBuilder.AddType<PublicUserGraphTypeExtension>();
}
public static ISchemaBuilder AddInventorySchemaBuilder(this ISchemaBuilder schemaBuilder)
{
return(schemaBuilder
.AddType <InventoryQueries>()
.AddType <InventoryType>());
}
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);
}
public static ISchemaBuilder AddRoot <TRootType>(this ISchemaBuilder schemaBuilder, IServiceCollection services)
{
ConfigureDependencyInjectionForType(typeof(TRootType), services);
schemaBuilder.AddType <TRootType>();
return(schemaBuilder);
}
public static void ModifySchemaDuringBuild(ISchemaBuilder schemaBuilder)
{
// add "forAdminEyesOnly" to the User graph... but how?
schemaBuilder.AddType <PrivateUserGraphTypeExtension>();
}
/// <summary>
/// Add rich scalars to the schema builder.
/// </summary>
/// <param name="builder">The schema builder.</param>
/// <param name="units">The rich scalars to add.</param>
/// <returns>The schema builder.</returns>
public static ISchemaBuilder AddRichScalars(this ISchemaBuilder builder, params Unit[] units)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
foreach (var unit in units)
{
switch (unit)
{
case Unit.Seconds:
builder.AddType(typeof(SecondsType));
break;
case Unit.Hours:
builder.AddType(typeof(HoursType));
break;
case Unit.Days:
builder.AddType(typeof(DaysType));
break;
case Unit.Degrees:
builder.AddType(typeof(DegreesType));
break;
case Unit.Radians:
builder.AddType(typeof(RadiansType));
break;
case Unit.Meters:
builder.AddType(typeof(MetersType));
break;
case Unit.MetersPerSecond:
builder.AddType(typeof(MetersPerSecondType));
break;
case Unit.SquareMeters:
builder.AddType(typeof(SquareMetersType));
break;
case Unit.Kilometers:
builder.AddType(typeof(KilometersType));
break;
case Unit.KilometersPerHour:
builder.AddType(typeof(KilometersPerHourType));
break;
case Unit.SquareKilometers:
builder.AddType(typeof(SquareKilometersType));
break;
case Unit.Miles:
builder.AddType(typeof(MilesType));
break;
case Unit.MilesPerHour:
builder.AddType(typeof(MilesPerHourType));
break;
case Unit.SquareMiles:
builder.AddType(typeof(SquareMilesType));
break;
default:
break;
}
}
return(builder);
}
