protected override void Configure(IObjectTypeDescriptor descriptor)
{
descriptor.Name("Query")
.Field("words")
.Type <ListType <ObjectType <Word> > >()
.Resolver(
new Word[] { new Word {
Value = "Hello"
}, new Word {
Value = "World"
} })
.Extend()
.OnBeforeCreate(d =>
{
var reference = TypeReference.Create(typeof(Word), TypeContext.Output);
ILazyTypeConfiguration lazyConfiguration =
LazyTypeConfigurationBuilder
.New <ObjectFieldDefinition>()
.Definition(d)
.Configure((context, definition) =>
{
ObjectType type = context.GetType <ObjectType>(reference);
if (!type.IsCompleted)
{
throw new Exception("Order should not matter");
}
})
.On(ApplyConfigurationOn.Completion)
.DependsOn(reference, true)
.Build();
d.Configurations.Add(lazyConfiguration);
});
}
private static IObjectFieldDescriptor ApplyMiddleware(
this IObjectFieldDescriptor descriptor,
string optionName,
Type middlewareDefinition)
{
if (descriptor is null)
{
throw new ArgumentNullException(nameof(descriptor));
}
FieldMiddleware placeholder = next => context => default;
descriptor
.Use(placeholder)
.Extend()
.OnBeforeCreate(
(context, definition) =>
{
definition.ContextData[optionName] = null;
if (definition.ResultType is null ||
!context.TypeInspector.TryCreateTypeInfo(
definition.ResultType,
out ITypeInfo? typeInfo))
{
Type resultType = definition.ResolverType ?? typeof(object);
throw new ArgumentException(
$"Cannot handle the specified type `{resultType.FullName}`.",
nameof(descriptor));
}
Type selectionType = typeInfo.NamedType;
definition.ResultType = selectionType;
definition.Type = RewriteToNonNullableType(
context.TypeInspector,
definition.Type);
ILazyTypeConfiguration lazyConfiguration =
LazyTypeConfigurationBuilder
.New <ObjectFieldDefinition>()
.Definition(definition)
.Configure(
(_, __) =>
{
CompileMiddleware(
selectionType,
definition,
placeholder,
middlewareDefinition);
})
.On(ApplyConfigurationOn.Completion)
.Build();
definition.Configurations.Add(lazyConfiguration);
});
return(descriptor);
}
public static IObjectFieldDescriptor UseAutoMapperProjection(
this IObjectFieldDescriptor descriptor,
Type objectType)
{
FieldMiddleware placeholder = next => context => default;
descriptor
.Use(placeholder)
.Extend()
.OnBeforeCreate(
(context, definition) =>
{
if (definition.ResultType is null ||
!context.TypeInspector.TryCreateTypeInfo(
definition.ResultType,
out ITypeInfo? typeInfo))
{
Type resultType = definition.ResolverType ?? typeof(object);
throw new ArgumentException(
$"Cannot handle the specified type `{resultType.FullName}`.",
nameof(descriptor));
}
if (!typeof(IQueryable).IsAssignableFrom(definition.ResultType))
{
throw new ArgumentException(
$"Cannot handle the specified type `{definition.ResultType.FullName}`.",
nameof(descriptor));
}
Type selectionType = typeInfo.NamedType;
definition.ResultType = typeof(IQueryable <>).MakeGenericType(objectType);
definition.Type = context.TypeInspector.GetTypeRef(definition.ResultType);
ILazyTypeConfiguration lazyConfiguration =
LazyTypeConfigurationBuilder
.New <ObjectFieldDefinition>()
.Definition(definition)
.Configure(
(_, __) =>
{
CompileMiddleware(
selectionType,
objectType,
definition,
placeholder,
_middlewareDefinition);
})
.On(ApplyConfigurationOn.Completion)
.Build();
definition.Configurations.Add(lazyConfiguration);
});
return(descriptor);
}
/// <summary>
/// Projects the selection set of the request onto the field. Registers a middleware that
/// uses the registered <see cref="ProjectionConvention"/> to apply the projections
/// </summary>
/// <param name="descriptor">The descriptor</param>
/// <param name="scope">
/// Specify which <see cref="ProjectionConvention"/> is used, based on the value passed in
/// <see cref="ProjectionsSchemaBuilderExtensions.AddProjections{T}"/>
/// </param>
/// <param name="type">
/// The <see cref="Type"/> of the resolved field
/// </param>
/// <returns>The descriptor passed in by <paramref name="descriptor"/></returns>
/// <exception cref="ArgumentNullException">
/// In case the descriptor is null
/// </exception>
public static IObjectFieldDescriptor UseProjection(
this IObjectFieldDescriptor descriptor,
Type?type,
string?scope = null)
{
if (descriptor is null)
{
throw new ArgumentNullException(nameof(descriptor));
}
FieldMiddleware placeholder = next => context => default;
descriptor
.Use(placeholder)
.Extend()
.OnBeforeCreate(
(context, definition) =>
{
Type?selectionType = type;
if (selectionType is null)
{
if (definition.ResultType is null ||
!context.TypeInspector.TryCreateTypeInfo(
definition.ResultType,
out ITypeInfo? typeInfo))
{
throw new ArgumentException(
"Cannot handle the specified type.",
nameof(descriptor));
}
selectionType = typeInfo.NamedType;
}
ILazyTypeConfiguration lazyConfiguration =
LazyTypeConfigurationBuilder
.New <ObjectFieldDefinition>()
.Definition(definition)
.Configure(
(context, definition) =>
CompileMiddleware(
selectionType,
definition,
placeholder,
context,
scope))
.On(ApplyConfigurationOn.Completion)
.Build();
definition.Configurations.Add(lazyConfiguration);
});
return(descriptor);
}
public static IObjectFieldDescriptor UseSorting(
this IObjectFieldDescriptor descriptor,
Type sortType,
ITypeSystemMember sortTypeInstance = null)
{
FieldMiddleware placeholder =
next => context => Task.CompletedTask;
descriptor
.Use(placeholder)
.Extend()
.OnBeforeCreate(definition =>
{
Type argumentType = GetArgumentType(definition, sortType);
ITypeReference argumentTypeReference =
sortTypeInstance is null
? (ITypeReference) new ClrTypeReference(
argumentType, TypeContext.Input)
: new SchemaTypeReference(sortTypeInstance);
var argumentDefinition = new ArgumentDefinition
{
Name = OrderByArgumentName,
Type = new ClrTypeReference(
argumentType, TypeContext.Input)
};
definition.Arguments.Add(argumentDefinition);
ILazyTypeConfiguration lazyConfiguration =
LazyTypeConfigurationBuilder
.New <ObjectFieldDefinition>()
.Definition(definition)
.Configure((context, defintion) =>
CompileMiddleware(
context,
definition,
argumentTypeReference,
placeholder))
.On(ApplyConfigurationOn.Completion)
.DependsOn(argumentTypeReference, true)
.Build();
definition.Configurations.Add(lazyConfiguration);
});
return(descriptor);
}
private static IObjectFieldDescriptor UseSelection(
IObjectFieldDescriptor descriptor,
Type?objectType)
{
FieldMiddleware placeholder =
next => context => Task.CompletedTask;
descriptor
.Use(placeholder)
.Extend()
.OnBeforeCreate(definition =>
{
Type?selectionType = objectType;
if (selectionType == null)
{
if (!TypeInspector.Default.TryCreate(
definition.ResultType, out TypeInfo typeInfo))
{
// TODO : resources
throw new ArgumentException(
"Cannot handle the specified type.",
nameof(descriptor));
}
selectionType = typeInfo.ClrType;
}
ILazyTypeConfiguration lazyConfiguration =
LazyTypeConfigurationBuilder
.New <ObjectFieldDefinition>()
.Definition(definition)
.Configure((context, defintion) =>
CompileMiddleware(
selectionType,
definition,
placeholder,
context))
.On(ApplyConfigurationOn.Completion)
.Build();
definition.Configurations.Add(lazyConfiguration);
});
return(descriptor);
}
private static ArgumentDefinition ConfigureArgumentName(
this ArgumentDefinition definition)
{
ILazyTypeConfiguration lazyArgumentConfiguration =
LazyTypeConfigurationBuilder
.New <ArgumentDefinition>()
.Definition(definition)
.Configure((context, definition) =>
{
IFilterNamingConvention convention = context.DescriptorContext.GetFilterNamingConvention();
definition.Name = convention.ArgumentName;
})
.On(ApplyConfigurationOn.Completion)
.Build();
definition.Configurations.Add(lazyArgumentConfiguration);
return(definition);
}
private static IObjectFieldDescriptor UseFiltering(
IObjectFieldDescriptor descriptor,
Type filterType,
ITypeSystemMember filterTypeInstance = null)
{
FieldMiddleware placeholder =
next => context => Task.CompletedTask;
descriptor
.Use(placeholder)
.Extend()
.OnBeforeCreate(definition =>
{
Type argumentType = filterType;
if (filterType == null)
{
if (!TypeInspector.Default.TryCreate(
definition.ResultType, out TypeInfo typeInfo))
{
// TODO : resources
throw new ArgumentException(
"Cannot handle the specified type.",
nameof(descriptor));
}
argumentType =
typeof(FilterInputType <>).MakeGenericType(
typeInfo.ClrType);
}
var argumentTypeReference = filterTypeInstance is null
? (ITypeReference) new ClrTypeReference(
argumentType, TypeContext.Input)
: new SchemaTypeReference(filterTypeInstance);
if (argumentType == typeof(object))
{
// TODO : resources
throw new SchemaException(
SchemaErrorBuilder.New()
.SetMessage(
"The filter type cannot be " +
"infered from `System.Object`.")
.SetCode(ErrorCodes.Filtering.FilterObjectType)
.Build());
}
var argumentDefinition = new ArgumentDefinition();
argumentDefinition.Name = _whereArgumentName;
argumentDefinition.Type = new ClrTypeReference(
argumentType, TypeContext.Input);
definition.Arguments.Add(argumentDefinition);
ILazyTypeConfiguration lazyConfiguration =
LazyTypeConfigurationBuilder
.New <ObjectFieldDefinition>()
.Definition(definition)
.Configure((context, defintion) =>
CompileMiddleware(
context,
definition,
argumentTypeReference,
placeholder))
.On(ApplyConfigurationOn.Completion)
.DependsOn(argumentTypeReference, true)
.Build();
definition.Configurations.Add(lazyConfiguration);
});
return(descriptor);
}
public static IObjectFieldDescriptor UseSorting(
this IObjectFieldDescriptor descriptor,
Type?sortType,
ITypeSystemMember?sortTypeInstance = null)
{
FieldMiddleware placeholder = next => context => default;
string argumentPlaceholder =
"_" + Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture);
descriptor
.Use(placeholder)
.Extend()
.OnBeforeCreate((c, definition) =>
{
Type argumentType = GetArgumentType(definition, sortType, c.TypeInspector);
ITypeReference argumentTypeReference = sortTypeInstance is null
? (ITypeReference)c.TypeInspector.GetTypeRef(
argumentType,
TypeContext.Input)
: TypeReference.Create(sortTypeInstance);
var argumentDefinition = new ArgumentDefinition
{
Name = argumentPlaceholder,
Type = c.TypeInspector.GetTypeRef(argumentType, TypeContext.Input)
};
ILazyTypeConfiguration lazyArgumentConfiguration =
LazyTypeConfigurationBuilder
.New <ArgumentDefinition>()
.Definition(argumentDefinition)
.Configure((context, definition) =>
{
ISortingNamingConvention convention =
context.DescriptorContext.GetSortingNamingConvention();
definition.Name = convention.ArgumentName;
})
.On(ApplyConfigurationOn.Completion)
.Build();
argumentDefinition.Configurations.Add(lazyArgumentConfiguration);
definition.Arguments.Add(argumentDefinition);
ILazyTypeConfiguration lazyConfiguration =
LazyTypeConfigurationBuilder
.New <ObjectFieldDefinition>()
.Definition(definition)
.Configure((context, definition) =>
CompileMiddleware(
context,
definition,
argumentTypeReference,
placeholder))
.On(ApplyConfigurationOn.Completion)
.DependsOn(argumentTypeReference, true)
.Build();
definition.Configurations.Add(lazyConfiguration);
});
return(descriptor);
}
private static IObjectFieldDescriptor UseFiltering(
IObjectFieldDescriptor descriptor,
Type?filterType,
ITypeSystemMember?filterTypeInstance = null)
{
FieldMiddleware placeholder = next => context => default;
string argumentPlaceholder =
"_" + Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture);
descriptor
.Use(placeholder)
.Extend()
.OnBeforeCreate((c, definition) =>
{
Type?argumentType = filterType;
if (argumentType is null)
{
if (definition.ResultType is null ||
definition.ResultType == typeof(object) ||
!c.TypeInspector.TryCreateTypeInfo(
definition.ResultType, out ITypeInfo? typeInfo))
{
throw new ArgumentException(
FilterResources.FilterObjectFieldDescriptor_InvalidType,
nameof(descriptor));
}
argumentType = typeof(FilterInputType <>)
.MakeGenericType(typeInfo.NamedType);
}
ITypeReference argumentTypeReference = filterTypeInstance is null
? (ITypeReference)c.TypeInspector.GetTypeRef(
argumentType,
TypeContext.Input)
: TypeReference.Create(filterTypeInstance);
if (argumentType == typeof(object))
{
throw new SchemaException(
SchemaErrorBuilder.New()
.SetMessage(
FilterResources.FilterObjectFieldDescriptor_InvalidType_Msg)
.SetCode(ErrorCodes.Filtering.FilterObjectType)
.Build());
}
var argumentDefinition = new ArgumentDefinition
{
Name = argumentPlaceholder,
Type = c.TypeInspector.GetTypeRef(argumentType, TypeContext.Input)
};
argumentDefinition.ConfigureArgumentName();
definition.Arguments.Add(argumentDefinition);
ILazyTypeConfiguration lazyConfiguration =
LazyTypeConfigurationBuilder
.New <ObjectFieldDefinition>()
.Definition(definition)
.Configure((context, definition) =>
CompileMiddleware(
context,
definition,
argumentTypeReference,
placeholder))
.On(ApplyConfigurationOn.Completion)
.DependsOn(argumentTypeReference, true)
.Build();
definition.Configurations.Add(lazyConfiguration);
});
return(descriptor);
}
private static IObjectFieldDescriptor UseFiltering(
IObjectFieldDescriptor descriptor,
Type?filterType,
ITypeSystemMember?filterTypeInstance = null)
{
FieldMiddleware placeholder =
_ => _ => Task.CompletedTask;
descriptor
.Use(placeholder)
.Extend()
.OnBeforeCreate(definition =>
{
Type?argumentType = filterType;
if (argumentType == null)
{
if (!TypeInspector.Default.TryCreate(
definition.ResultType,
out TypeInfo typeInfo))
{
throw new ArgumentException(
FilterResources.FilterObjectFieldDescriptor_InvalidType,
nameof(descriptor));
}
argumentType = typeof(FilterInputType <>).MakeGenericType(typeInfo.ClrType);
}
ITypeReference argumentTypeReference =
filterTypeInstance is null
? (ITypeReference) new ClrTypeReference(argumentType, TypeContext.Input)
: new SchemaTypeReference(filterTypeInstance);
if (argumentType == typeof(object))
{
throw new SchemaException(
SchemaErrorBuilder.New()
.SetMessage(
FilterResources.FilterObjectFieldDescriptor_InvalidType_Msg)
.SetCode(ErrorCodes.Filtering.FilterObjectType)
.Build());
}
var argumentDefinition = new ArgumentDefinition
{
Type = new ClrTypeReference(argumentType, TypeContext.Input)
};
argumentDefinition.ConfigureArgumentName();
definition.Arguments.Add(argumentDefinition);
ILazyTypeConfiguration lazyConfiguration =
LazyTypeConfigurationBuilder
.New <ObjectFieldDefinition>()
.Definition(definition)
.Configure((context, definition) =>
CompileMiddleware(
context,
definition,
argumentTypeReference,
placeholder))
.On(ApplyConfigurationOn.Completion)
.DependsOn(argumentTypeReference, true)
.Build();
definition.Configurations.Add(lazyConfiguration);
});
return(descriptor);
}
