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);