public void ApplyConfiguration(ParameterInfo parameter, ObjectFieldDescriptor descriptor)
{
switch (_kind)
{
case ServiceKind.Pooled:
UseDbContext <TDbContext>(descriptor.Extend().Definition);
break;
case ServiceKind.Synchronized:
ServiceExpressionHelper.ApplyConfiguration(parameter, descriptor, _kind);
break;
case ServiceKind.Resolver:
ServiceExpressionHelper.ApplyConfiguration(parameter, descriptor, _kind);
ObjectFieldDefinition definition = descriptor.Extend().Definition;
FieldMiddlewareDefinition placeholderMiddleware =
new(_ => _ => throw new NotSupportedException(), key : ToList);
FieldMiddlewareDefinition serviceMiddleware =
definition.MiddlewareDefinitions.Last(t => t.Key == PooledService);
var index = definition.MiddlewareDefinitions.IndexOf(serviceMiddleware) + 1;
definition.MiddlewareDefinitions.Insert(index, placeholderMiddleware);
AddCompletionMiddleware(definition, placeholderMiddleware);
break;
}
}
public override void OnBeforeCompleteName(ITypeCompletionContext context, DefinitionBase?definitionBase, IDictionary <string, object?> contextData)
{
if (definitionBase is not ObjectTypeDefinition definition)
{
return;
}
if (definition.RuntimeType.IsSubclassOf(typeof(BaseEntity)))
{
foreach (PropertyInfo property in definition.RuntimeType.GetProperties())
{
if (property.PropertyType != typeof(string) && typeof(IEnumerable).IsAssignableFrom(property.PropertyType) && property.PropertyType != typeof(NpgsqlTsVector))
{
ObjectFieldDefinition fieldDefinition = definition.Fields.First(e => e.Name == context.DescriptorContext.Naming.GetMemberName(property, MemberKind.ObjectField));
ObjectFieldDescriptor fieldDescriptor = ObjectFieldDescriptor.From(context.DescriptorContext, fieldDefinition);
fieldDescriptor
.UseSorting()
.UseFiltering();
int index = definition.Fields.IndexOf(fieldDefinition);
definition.Fields.RemoveAt(index);
definition.Fields.Insert(index, fieldDescriptor.CreateDefinition());
}
}
}
}
public override void OnBeforeCompleteType(
ITypeCompletionContext completionContext,
DefinitionBase?definition,
IDictionary <string, object?> contextData)
{
// when we are visiting the query type we will add the schema definition field.
if (_publishOnSchema &&
(completionContext.IsQueryType ?? false) &&
definition is ObjectTypeDefinition objectTypeDefinition &&
!objectTypeDefinition.Fields.Any(t => t.Name.Equals(SchemaDefinitionField)))
{
ObjectFieldDefinition typeNameField = objectTypeDefinition.Fields.First(
t => t.Name.Equals(IntrospectionFields.TypeName) && t.IsIntrospectionField);
var index = objectTypeDefinition.Fields.IndexOf(typeNameField) + 1;
var descriptor = ObjectFieldDescriptor.New(
completionContext.DescriptorContext,
SchemaDefinitionField);
descriptor
.Argument(ConfigurationArgument, a => a.Type <NonNullType <StringType> >())
.Type <SchemaDefinitionType>()
.Resolve(ctx =>
{
string name = ctx.ArgumentValue <string>(ConfigurationArgument);
return(ctx.Schema.ContextData
.GetSchemaDefinitions()
.FirstOrDefault(t => t.Name.Equals(name)));
});
objectTypeDefinition.Fields.Insert(index, descriptor.CreateDefinition());
}
private static ObjectFieldDefinition CreateDefinition(ObjectFieldDescriptor descriptor)
{
ObjectFieldDefinition definition = descriptor.CreateDefinition();
definition.IsIntrospectionField = true;
return(definition);
}
private static ObjectFieldDefinition CreateDefinition(
IDescriptorContext context)
{
var descriptor = ObjectFieldDescriptor
.New(context, "node");
descriptor
.Argument("id", a => a.Type <NonNullType <IdType> >())
.Type <NonNullType <NodeType> >()
.Resolver(async ctx =>
{
string id = ctx.Argument <string>("id");
IdValue deserializedId = _idSerializer.Deserialize(id);
if (ctx.Schema.TryGetType(deserializedId.TypeName,
out ObjectType type) &&
type.ContextData.TryGetValue(
RelayConstants.NodeResolverFactory,
out object o) &&
o is Func <IServiceProvider, INodeResolver> factory)
{
INodeResolver resolver =
factory.Invoke(ctx.Service <IServiceProvider>());
return(await resolver.ResolveAsync(
ctx, deserializedId.Value)
.ConfigureAwait(false));
}
return(null);
});
return(descriptor.CreateDefinition());
}
internal static ObjectFieldDefinition CreateSchemaField(IDescriptorContext context)
{
var descriptor = ObjectFieldDescriptor.New(context, Schema);
descriptor
.Description(TypeResources.SchemaField_Description)
.Type <NonNullType <__Schema> >();
descriptor.Definition.PureResolver = Resolve;
internal static ObjectFieldDefinition CreateSchemaField(IDescriptorContext context)
{
var descriptor = ObjectFieldDescriptor.New(context, Schema);
descriptor
.Description(TypeResources.SchemaField_Description)
.Type <NonNullType <__Schema> >()
.Resolver(ctx => ctx.Schema);
return(CreateDefinition(descriptor));
}
private static ObjectFieldDefinition CreateDefinition(IDescriptorContext context)
{
var descriptor = ObjectFieldDescriptor
.New(context, IntrospectionFields.TypeName);
descriptor.Description(TypeResources.TypeNameField_Description)
.Type <NonNullType <StringType> >()
.Resolver(ctx => ctx.ObjectType.Name.Value);
return(descriptor.CreateDefinition());
}
public void UseSorting_WithoutTypeParam_ShouldRegisterPlaceholderMiddleware()
{
// arrange
var descriptor = ObjectFieldDescriptor.New(Context, "field");
// act
descriptor.UseSorting <object>();
// assert
Assert.Single(descriptor.CreateDefinition().MiddlewareDefinitions);
}
protected ObjectTypeDescriptor(
IDescriptorContext context,
ObjectTypeDefinition definition)
: base(context)
{
Definition = definition ?? throw new ArgumentNullException(nameof(definition));
foreach (ObjectFieldDefinition field in definition.Fields)
{
Fields.Add(ObjectFieldDescriptor.From(Context, field));
}
}
private static ObjectFieldDefinition CreateDefinition(
IDescriptorContext context)
{
var descriptor = ObjectFieldDescriptor
.New(context, IntrospectionFields.Schema);
descriptor.Description(TypeResources.SchemaField_Description)
.Type <NonNullType <__Schema> >()
.Resolver(ctx => ctx.Schema);
return(descriptor.CreateDefinition());
}
public void UseSorting_WithoutParams_ShouldRegisterPlaceholderMiddleware()
{
// arrange
ObjectFieldDescriptor descriptor = ObjectFieldDescriptor.New(Context, "field");
descriptor.Resolve("abc");
// act
descriptor.UseSorting();
// assert
Assert.Single(descriptor.CreateDefinition().MiddlewareComponents);
}
private static ObjectFieldDefinition CreateDefinition(
IDescriptorContext context)
{
var descriptor = ObjectFieldDescriptor
.New(context, IntrospectionFields.TypeName);
descriptor.Description(
"The name of the current Object type at runtime.")
.Type <NonNullType <StringType> >()
.Resolver(ctx => ctx.ObjectType.Name.Value);
return(descriptor.CreateDefinition());
}
public void UseSorting_WithoutTypeParam_ShouldRegisterPlaceholderMiddleware()
{
// arrange
ObjectFieldDescriptor descriptor =
ObjectFieldDescriptor.New(Context, "field");
FieldMiddleware placeholder = next => context => default;
// act
descriptor.UseSorting <object>();
// assert
Assert.Single(descriptor.CreateDefinition().MiddlewareComponents);
}
private static ObjectFieldDefinition CreateDefinition(
IDescriptorContext context)
{
var descriptor = ObjectFieldDescriptor
.New(context, IntrospectionFields.Schema);
descriptor.Description(
"Access the current type schema of this server.")
.Type <NonNullType <__Schema> >()
.Resolver(ctx => ctx.Schema);
return(descriptor.CreateDefinition());
}
public override void OnBeforeCompleteType(
ITypeCompletionContext completionContext,
DefinitionBase definition,
IDictionary <string, object> contextData)
{
if ((completionContext.IsQueryType ?? false) &&
definition is ObjectTypeDefinition objectTypeDefinition)
{
ObjectFieldDefinition typeNameField = objectTypeDefinition.Fields.First(
t => t.Name.Equals(IntrospectionFields.TypeName) && t.IsIntrospectionField);
var index = objectTypeDefinition.Fields.IndexOf(typeNameField) + 1;
var descriptor = ObjectFieldDescriptor.New(
completionContext.DescriptorContext,
_node);
IIdSerializer serializer =
completionContext.Services.GetService <IIdSerializer>() ??
new IdSerializer();
descriptor
.Argument(_id, a => a.Type <NonNullType <IdType> >())
.Type <NodeType>()
.Resolve(async ctx =>
{
var id = ctx.ArgumentValue <string>(_id);
IdValue deserializedId = serializer.Deserialize(id);
ctx.LocalContextData = ctx.LocalContextData
.SetItem(WellKnownContextData.Id, deserializedId.Value)
.SetItem(WellKnownContextData.Type, deserializedId.TypeName);
if (ctx.Schema.TryGetType(deserializedId.TypeName,
out ObjectType type) &&
type.ContextData.TryGetValue(
RelayConstants.NodeResolverFactory,
out object?o) &&
o is Func <IServiceProvider, INodeResolver> factory)
{
INodeResolver resolver = factory.Invoke(ctx.Services);
return(await resolver.ResolveAsync(ctx, deserializedId.Value)
.ConfigureAwait(false));
}
return(null);
});
objectTypeDefinition.Fields.Insert(index, descriptor.CreateDefinition());
}
}
private static ObjectFieldDefinition CreateDefinition(
IDescriptorContext context)
{
var descriptor = ObjectFieldDescriptor
.New(context, IntrospectionFields.Type);
descriptor.Description(
TypeResources.TypeField_Description)
.Argument("name", a => a.Type <NonNullType <StringType> >())
.Type <__Type>()
.Resolver(ctx => ctx.Schema.GetType <INamedType>(
ctx.Argument <string>("name")));
return(descriptor.CreateDefinition());
}
internal static ObjectFieldDefinition CreateTypeField(IDescriptorContext context)
{
var descriptor = ObjectFieldDescriptor.New(context, Type);
descriptor
.Description(TypeResources.TypeField_Description)
.Argument("name", a => a.Type <NonNullType <StringType> >())
.Type <__Type>()
.Resolver(ctx =>
{
var name = ctx.ArgumentValue <string>("name");
return(ctx.Schema.TryGetType(name, out INamedType type) ? type : null);
});
return(CreateDefinition(descriptor));
}
private static ObjectFieldDefinition CreateDefinition(
IDescriptorContext context)
{
var descriptor = ObjectFieldDescriptor
.New(context, _node);
IIdSerializer _serializer = null;
descriptor
.Argument(_id, a => a.Type <NonNullType <IdType> >())
.Type <NonNullType <NodeType> >()
.Resolver(async ctx =>
{
IServiceProvider services = ctx.Service <IServiceProvider>();
if (_serializer is null)
{
_serializer =
services.GetService(typeof(IIdSerializer)) is IIdSerializer s
? s
: new IdSerializer();
}
var id = ctx.Argument <string>(_id);
IdValue deserializedId = _serializer.Deserialize(id);
ctx.LocalContextData = ctx.LocalContextData
.SetItem(WellKnownContextData.Id, deserializedId.Value)
.SetItem(WellKnownContextData.Type, deserializedId.TypeName);
if (ctx.Schema.TryGetType(deserializedId.TypeName,
out ObjectType type) &&
type.ContextData.TryGetValue(
RelayConstants.NodeResolverFactory,
out var o) &&
o is Func <IServiceProvider, INodeResolver> factory)
{
INodeResolver resolver = factory.Invoke(services);
return(await resolver.ResolveAsync(ctx, deserializedId.Value)
.ConfigureAwait(false));
}
return(null);
});
return(descriptor.CreateDefinition());
}
public override void OnBeforeCompleteType(
ITypeCompletionContext completionContext,
DefinitionBase?definition,
IDictionary <string, object?> contextData)
{
if ((completionContext.IsQueryType ?? false) &&
definition is ObjectTypeDefinition objectTypeDefinition)
{
ObjectFieldDefinition typeNameField = objectTypeDefinition.Fields.First(
t => t.Name.Equals(IntrospectionFields.TypeName) && t.IsIntrospectionField);
var index = objectTypeDefinition.Fields.IndexOf(typeNameField) + 1;
var descriptor = ObjectFieldDescriptor.New(
completionContext.DescriptorContext,
Node);
IIdSerializer serializer =
completionContext.Services.GetService <IIdSerializer>() ??
new IdSerializer();
descriptor
.Argument(Id, a => a.Type <NonNullType <IdType> >().ID())
.Type <NodeType>()
.Resolve(async ctx =>
{
StringValueNode id = ctx.ArgumentLiteral <StringValueNode>(Id);
IdValue deserializedId = serializer.Deserialize(id.Value);
ctx.SetLocalValue(NodeId, id.Value);
ctx.SetLocalValue(InternalId, deserializedId.Value);
ctx.SetLocalValue(InternalType, deserializedId.TypeName);
ctx.SetLocalValue(WellKnownContextData.IdValue, deserializedId);
if (ctx.Schema.TryGetType(deserializedId.TypeName, out ObjectType type) &&
type.ContextData.TryGetValue(NodeResolver, out object?o) &&
o is FieldResolverDelegate resolver)
{
return(await resolver.Invoke(ctx).ConfigureAwait(false));
}
return(null);
});
objectTypeDefinition.Fields.Insert(index, descriptor.CreateDefinition());
}
}
private static ObjectFieldDefinition CreateDefinition(
IDescriptorContext context)
{
var descriptor = ObjectFieldDescriptor
.New(context, IntrospectionFields.Type);
descriptor.Description(
TypeResources.TypeField_Description)
.Argument("name", a => a.Type <NonNullType <StringType> >())
.Type <__Type>()
.Resolver(ctx =>
{
string name = ctx.ArgumentValue <string>("name");
if (ctx.Schema.TryGetType(name, out INamedType type))
{
return(type);
}
return(null);
});
return(descriptor.CreateDefinition());
}
public override void OnBeforeCompleteName(ITypeCompletionContext context, DefinitionBase?definitionBase, IDictionary <string, object?> contextData)
{
if (definitionBase is ObjectTypeDefinition objectTypeDefinition)
{
if (objectTypeDefinition.RuntimeType.IsSubclassOf(typeof(BaseEntity)))
{
PropertyInfo idProperty = objectTypeDefinition.RuntimeType.GetProperty(nameof(BaseEntity.Id)) !;
ObjectFieldDefinition fieldDefinition = objectTypeDefinition.Fields.First(e => e.Name == context.DescriptorContext.Naming.GetMemberName(idProperty, MemberKind.ObjectField));
ObjectFieldDescriptor fieldDescriptor = ObjectFieldDescriptor.From(context.DescriptorContext, fieldDefinition);
fieldDescriptor
.IsProjected(true);
int index = objectTypeDefinition.Fields.IndexOf(fieldDefinition);
objectTypeDefinition.Fields.RemoveAt(index);
objectTypeDefinition.Fields.Insert(index, fieldDescriptor.CreateDefinition());
}
return;
}
}
public void OnBeforeCompleteType(ICompletionContext context, DefinitionBase definition, IDictionary <string, object> contextData)
{
var def = (ObjectTypeDefinition)definition;
var autoList = ((List <ObjectFieldDefinition>)context.ContextData[AutoSubscriptionContext]);
foreach (var mutationDef in autoList)
{
string subscriptionName = $"on{mutationDef.Name.Value.ToPascalCase()}";
ITypeReference mutationType = mutationDef.Type;
IOutputType type = context.GetType <IOutputType>(mutationType);
var descriptor = ObjectFieldDescriptor.New(context.DescriptorContext, subscriptionName);
descriptor
.Type(type)
.Description($"Subscription for the {mutationDef.Name.Value} mutation.")
.Resolver(ctx =>
{
return(ctx.GetEventMessage().Payload);
});
def.Fields.Add(descriptor.CreateDefinition());
}
def.Description +=
@"
Snowflake provides two types of definition in its framework queries:
* `onVerbObject`
* `onObjectVerb(Uuid!)`
`onVerbObject` subscriptions are global, and are broadcast whenever the corresponding mutation occurs. These can be used to subscribe to mutations that are triggered by the client.
`onObjectVerb(Uuid!)` subscriptions are primarily used by scraping, installation, and orchestration mutations. These are used to subscribe to events happening on a specific long-existing object that may or may not be the result of a client request.
There is some subtlely in the different types of subscriptions that one should be aware about.
For example, `onStopEmulation` is broadcast when the `stopEmulation` mutation responds to some client. However, `onEmulationStop` is broadcast when the emulation process exits. Hence, `onStopEmulation` may never be broadcast, even if `onEmulationStop` was.
In most cases, it is more useful to subscribe to the `onObjectVerb` subscription for an object whenever feasible.
";
}
public static void ApplyConfiguration(
ParameterInfo parameter,
ObjectFieldDescriptor descriptor,
ServiceKind serviceKind)
{
if (parameter is null)
{
throw new ArgumentNullException(nameof(parameter));
}
if (descriptor is null)
{
throw new ArgumentNullException(nameof(descriptor));
}
switch (serviceKind)
{
case ServiceKind.Default:
return;
case ServiceKind.Synchronized:
descriptor.Extend().Definition.IsParallelExecutable = false;
break;
case ServiceKind.Pooled:
ServiceHelper.UsePooledService(descriptor.Definition, parameter.ParameterType);
break;
case ServiceKind.Resolver:
ServiceHelper.UseResolverService(descriptor.Definition, parameter.ParameterType);
return;
default:
throw new NotSupportedException(
$"Service kind `{serviceKind}` is not supported.");
}
}
public void ApplyConfiguration(ParameterInfo parameter, ObjectFieldDescriptor descriptor) => ServiceExpressionHelper.ApplyConfiguration(parameter, descriptor, _kind);
protected override void OnCompleteFields(
IDictionary <NameString, ObjectFieldDefinition> fields,
ISet <MemberInfo> handledMembers)
{
HashSet <string> subscribeResolver = null;
if (Definition.Fields.IsImplicitBinding() &&
Definition.FieldBindingType is not null)
{
FieldDescriptorUtilities.AddImplicitFields(
this,
Definition.FieldBindingType,
p =>
{
var descriptor = ObjectFieldDescriptor.New(
Context, p, Definition.RuntimeType, Definition.FieldBindingType);
if (Definition.IsExtension && Context.TypeInspector.IsMemberIgnored(p))
{
descriptor.Ignore();
}
Fields.Add(descriptor);
return(descriptor.CreateDefinition());
},
fields,
handledMembers,
include: IncludeField,
includeIgnoredMembers
: Definition.IsExtension);
}
base.OnCompleteFields(fields, handledMembers);
bool IncludeField(IReadOnlyList <MemberInfo> all, MemberInfo current)
{
NameString name = Context.Naming.GetMemberName(current, MemberKind.ObjectField);
if (Fields.Any(t => t.Definition.Name.Equals(name)))
{
return(false);
}
if (subscribeResolver is null)
{
subscribeResolver = new HashSet <string>();
foreach (MemberInfo member in all)
{
HandlePossibleSubscribeMember(member);
}
}
return(!subscribeResolver.Contains(current.Name));
}
void HandlePossibleSubscribeMember(MemberInfo member)
{
if (member.IsDefined(typeof(SubscribeAttribute)))
{
if (member.GetCustomAttribute <SubscribeAttribute>() is { With : not null } attr)
{
subscribeResolver.Add(attr.With);
}
}
}
}
public static ObjectFieldDescriptor ToDescriptor(
this ObjectFieldDefinition definition,
IDescriptorContext context)
=> ObjectFieldDescriptor.From(context, definition);
