public Task <IReadOnlyList <Schema> > GetSchemasByIdAsync(
[GraphQLType(typeof(NonNullType <ListType <NonNullType <IdType> > >))] string[] ids,
[Service] IIdSerializer idSerializer,
[DataLoader] SchemaByIdDataLoader dataLoader,
CancellationToken cancellationToken)
{
if (ids.Length == 0)
{
throw new GraphQLException("No ids where provided.");
}
var deserializedIds = new Guid[ids.Length];
for (int i = 0; i < ids.Length; i++)
{
IdValue deserializedId = idSerializer.Deserialize(ids[i]);
if (!deserializedId.TypeName.Equals(nameof(Schema), StringComparison.Ordinal))
{
throw new GraphQLException("The specified id type is invalid.");
}
deserializedIds[i] = (Guid)deserializedId.Value;
}
return(dataLoader.LoadAsync(deserializedIds, cancellationToken));
}
public async Task <CreateClientPayload> CreateClientAsync(
CreateClientInput input,
[Service] IClientRepository repository,
[Service] IIdSerializer idSerializer,
[DataLoader] SchemaByIdDataLoader dataLoader,
CancellationToken cancellationToken)
{
IdValue deserializedId = idSerializer.Deserialize(input.SchemaId);
if (!deserializedId.TypeName.Equals(nameof(Schema), StringComparison.Ordinal))
{
throw new GraphQLException("The specified id type is invalid.");
}
Schema schema = await dataLoader.LoadAsync(
(Guid)deserializedId.Value, cancellationToken)
.ConfigureAwait(false);
var client = new Client(schema.Id, input.Name, input.Description);
await repository.AddClientAsync(
client, cancellationToken)
.ConfigureAwait(false);
return(new CreateClientPayload(schema, client, input.ClientMutationId));
}
private static void AddSerializerToObjectField(
ITypeCompletionContext completionContext,
ObjectFieldDefinition definition,
FieldMiddleware placeholder,
NameString typeName)
{
ITypeInspector typeInspector = completionContext.TypeInspector;
IExtendedType? resultType;
if (definition.ResultType is not null)
{
resultType = typeInspector.GetType(definition.ResultType);
}
else if (definition.Type is ExtendedTypeReference typeReference)
{
resultType = typeReference.Type;
}
else
{
throw new SchemaException(SchemaErrorBuilder.New()
.SetMessage("Unable to resolve type from field `{0}`.", definition.Name)
.SetTypeSystemObject(completionContext.Type)
.Build());
}
NameString schemaName = default;
completionContext.DescriptorContext.SchemaCompleted += (sender, args) =>
schemaName = args.Schema.Name;
IIdSerializer serializer =
completionContext.Services.GetService <IIdSerializer>() ??
new IdSerializer();
var index = definition.MiddlewareComponents.IndexOf(placeholder);
definition.MiddlewareComponents[index] = next => async context =>
{
await next(context).ConfigureAwait(false);
if (context.Result is not null)
{
if (resultType.IsArrayOrList)
{
var list = new List <object?>();
foreach (object?element in (IEnumerable)context.Result)
{
list.Add(element is null
? element
: serializer.Serialize(schemaName, typeName, element));
}
context.Result = list;
}
else
{
context.Result = serializer.Serialize(schemaName, typeName, context.Result);
}
}
};
}
public Task <Schema> GetSchemaByNameAsync(
string name,
[Service] IIdSerializer idSerializer,
[DataLoader] SchemaByNameDataLoader dataLoader,
CancellationToken cancellationToken)
{
return(dataLoader.LoadAsync(name, cancellationToken));
}
internal StoreListItem(Domain.Store user, IIdSerializer serializer)
{
Address = new AddressItem(user.Address);
Id = serializer.Serialize("Query", nameof(Store), user.Id);
Name = user.Name;
Picture = user.Picture;
HasProducers = user.ProducersCount > 0;
Producers = user.ProducersCount;
}
public PickingOrderExportProcessingEventHandler(
IAppDbContext context,
IIdSerializer idSerializer,
IEmailService emailService,
ISignalrService signalrService)
: base(context, emailService, signalrService)
{
_idSerializer = idSerializer;
}
private static IInputValueFormatter CreateSerializer(
ITypeCompletionContext completionContext)
{
IIdSerializer serializer =
completionContext.Services.GetService <IIdSerializer>() ??
(_idSerializer ??= new IdSerializer());
return(new FilterGlobalIdInputValueFormatter(serializer));
}
public BillingExportSucceededEventHandler(
IAppDbContext context,
IEmailService emailService,
IIdSerializer idSerializer,
ISignalrService signalrService)
: base(context, emailService, signalrService)
{
_idSerializer = idSerializer;
}
public PolymorphicGlobalIdInputValueFormatter(
NameString nodeTypeName,
Type idRuntimeType,
IIdSerializer idSerializer)
{
_schemaName = null; // not needed during deserialization
_nodeTypeName = nodeTypeName;
_idRuntimeType = idRuntimeType;
_idSerializer = idSerializer;
}
public OrderValidatedEventHandler(
IAppDbContext context,
IIdSerializer idSerializer,
IEmailService emailService,
IConfiguration configuration,
ISignalrService signalrService)
: base(context, emailService, signalrService)
{
_idSerializer = idSerializer;
_configuration = configuration;
}
public GenerateStoresFileCommandHandler(
IAppDbContext context,
ISheaftMediatr mediatr,
IBlobService blobService,
IIdSerializer idSerializer,
ILogger <GenerateStoresFileCommandHandler> logger)
: base(mediatr, context, logger)
{
_blobService = blobService;
_idSerializer = idSerializer;
}
public ProductImportSucceededEventHandler(
IConfiguration configuration,
IAppDbContext context,
IEmailService emailService,
IIdSerializer idSerializer,
ISignalrService signalrService)
: base(context, emailService, signalrService)
{
_configuration = configuration;
_idSerializer = idSerializer;
}
public GlobalIdInputValueFormatter(
NameString typeName,
IIdSerializer idSerializer,
IExtendedType resultType,
bool validateType)
{
_typeName = typeName;
_idSerializer = idSerializer;
_validateType = validateType;
_createList = CreateListFactory(resultType);
}
public PickingOrderExportFailedEventHandler(
IConfiguration configuration,
IAppDbContext context,
IIdSerializer idSerializer,
IEmailService emailService,
ISignalrService signalrService)
: base(context, emailService, signalrService)
{
_configuration = configuration;
_idSerializer = idSerializer;
}
public AgreementAcceptedEventHandler(
IConfiguration configuration,
IAppDbContext context,
IEmailService emailService,
IIdSerializer idSerializer,
ISignalrService signalrService)
: base(context, emailService, signalrService)
{
_configuration = configuration;
_idSerializer = idSerializer;
}
public PurchaseOrderWithdrawnedEventHandler(
IConfiguration configuration,
IAppDbContext context,
IIdSerializer idSerializer,
IEmailService emailService,
ISignalrService signalrService)
: base(context, emailService, signalrService)
{
_configuration = configuration;
_idSerializer = idSerializer;
}
public DeliveryBatchPostponedEventHandler(
IConfiguration configuration,
IAppDbContext context,
IIdSerializer idSerializer,
IEmailService emailService,
ISignalrService signalrService)
: base(context, emailService, signalrService)
{
_configuration = configuration;
_idSerializer = idSerializer;
}
public Task <IReadOnlyList <Schema> > GetSchemasByNameAsync(
string[] names,
[Service] IIdSerializer idSerializer,
[DataLoader] SchemaByNameDataLoader dataLoader,
CancellationToken cancellationToken)
{
if (names.Length == 0)
{
throw new GraphQLException("No names where provided.");
}
return(dataLoader.LoadAsync(names, cancellationToken));
}
public GlobalIdInputValueFormatter(
NameString typeName,
IIdSerializer idSerializer,
IExtendedType resultType,
bool validateType)
{
_typeName = typeName;
_idSerializer = idSerializer;
_validateType = validateType;
#if !NETSTANDARD2_0
_resultTypeSource = resultType.Source;
#endif
_createList = CreateListFactory(resultType);
}
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 IInputValueFormatter CreateSerializer(
ITypeCompletionContext completionContext,
IExtendedType resultType,
NameString typeName)
{
IIdSerializer serializer =
completionContext.Services.GetService <IIdSerializer>() ??
new IdSerializer();
return(new GlobalIdInputValueFormatter(
typeName.HasValue ? typeName : completionContext.Type.Name,
serializer,
resultType,
typeName.HasValue));
}
public Task <SchemaVersion> GetSchemaVersionByIdAsync(
[GraphQLType(typeof(NonNullType <IdType>))] string id,
[Service] IIdSerializer idSerializer,
[DataLoader] SchemaVersionByIdDataLoader dataLoader,
CancellationToken cancellationToken)
{
IdValue deserializedId = idSerializer.Deserialize(id);
if (!deserializedId.TypeName.Equals(nameof(SchemaVersion), StringComparison.Ordinal))
{
throw new GraphQLException("The specified id type is invalid.");
}
return(dataLoader.LoadAsync((Guid)deserializedId.Value, cancellationToken));
}
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());
}
}
public override void OnBeforeCompleteType(
ITypeCompletionContext completionContext,
DefinitionBase?definition,
IDictionary <string, object?> contextData)
{
if ((completionContext.IsQueryType ?? false) &&
definition is ObjectTypeDefinition objectTypeDefinition)
{
ITypeInspector typeInspector = completionContext.TypeInspector;
IIdSerializer serializer =
completionContext.Services.GetService <IIdSerializer>() ??
new IdSerializer();
ObjectFieldDefinition typeNameField = objectTypeDefinition.Fields.First(
t => t.Name.Equals(IntrospectionFields.TypeName) && t.IsIntrospectionField);
var index = objectTypeDefinition.Fields.IndexOf(typeNameField);
CreateNodeField(typeInspector, serializer, objectTypeDefinition.Fields, index + 1);
CreateNodesField(serializer, objectTypeDefinition.Fields, index + 2);
}
}
private static void CreateNodesField(
IIdSerializer serializer,
IList <ObjectFieldDefinition> fields,
int index)
{
SyntaxTypeReference nodes = TypeReference.Parse("[Node]!");
SyntaxTypeReference ids = TypeReference.Parse("[ID!]!");
var field = new ObjectFieldDefinition(
Nodes,
Relay_NodesField_Description,
nodes,
ResolveNodeAsync)
{
Arguments = { new(Ids, Relay_NodesField_Ids_Description, ids) }
};
fields.Insert(index, field);
ValueTask <object?> ResolveNodeAsync(IResolverContext ctx)
=> ResolveManyNode(ctx, serializer);
}
public async Task <UpdateEnvironmentPayload?> UpdateEnvironmentAsync(
UpdateEnvironmentInput input,
[Service] IIdSerializer idSerializer,
[Service] IEnvironmentRepository repository,
CancellationToken cancellationToken)
{
IdValue deserializedId = idSerializer.Deserialize(input.Id);
if (!deserializedId.TypeName.Equals(nameof(Environment), StringComparison.Ordinal))
{
throw new GraphQLException("The specified id type is invalid.");
}
var environment = new Environment(
(Guid)deserializedId.Value,
input.Name,
input.Description);
await repository.UpdateEnvironmentAsync(environment, cancellationToken)
.ConfigureAwait(false);
return(new UpdateEnvironmentPayload(environment, input.ClientMutationId));
}
public async Task <UpdateSchemaPayload> UpdateSchema(
UpdateSchemaInput input,
[Service] IIdSerializer idSerializer,
[Service] ISchemaRepository repository,
CancellationToken cancellationToken)
{
IdValue deserializedId = idSerializer.Deserialize(input.Id);
if (!deserializedId.TypeName.Equals(nameof(Schema), StringComparison.Ordinal))
{
throw new GraphQLException(Resources.General_IdTypeInvalid);
}
var schema = new Schema(
(Guid)deserializedId.Value,
input.Name,
input.Description);
await repository.UpdateSchemaAsync(schema, cancellationToken)
.ConfigureAwait(false);
return(new UpdateSchemaPayload(schema, input.ClientMutationId));
}
private static async ValueTask <object?> ResolveSingleNode(
IResolverContext context,
IIdSerializer serializer,
NameString argumentName)
{
StringValueNode nodeId = context.ArgumentLiteral <StringValueNode>(argumentName);
IdValue deserializedId = serializer.Deserialize(nodeId.Value);
NameString typeName = deserializedId.TypeName;
context.SetLocalValue(NodeId, nodeId.Value);
context.SetLocalValue(InternalId, deserializedId.Value);
context.SetLocalValue(InternalType, typeName);
context.SetLocalValue(WellKnownContextData.IdValue, deserializedId);
if (context.Schema.TryGetType <ObjectType>(typeName, out ObjectType? type) &&
type.ContextData.TryGetValue(NodeResolver, out var o) &&
o is FieldResolverDelegate resolver)
{
return(await resolver.Invoke(context).ConfigureAwait(false));
}
return(null);
}
private static void CreateNodeField(
ITypeInspector typeInspector,
IIdSerializer serializer,
IList <ObjectFieldDefinition> fields,
int index)
{
ExtendedTypeReference node = typeInspector.GetTypeRef(typeof(NodeType));
ExtendedTypeReference id = typeInspector.GetTypeRef(typeof(NonNullType <IdType>));
var field = new ObjectFieldDefinition(
Node,
Relay_NodeField_Description,
node,
ResolveNodeAsync)
{
Arguments = { new(Id, Relay_NodeField_Id_Description, id) }
};
fields.Insert(index, field);
ValueTask <object?> ResolveNodeAsync(IResolverContext ctx)
=> ResolveSingleNode(ctx, serializer, Id);
}
