public static void Map(ClientModel model, IMapperContext context)
{
foreach (OperationModel modelOperation in model.Operations)
{
var arguments = modelOperation.Arguments.Select(
arg =>
{
NameString typeName = arg.Type.TypeName();
INamedTypeDescriptor namedTypeDescriptor =
context.Types.Single(type => type.Name.Equals(typeName));
return(new PropertyDescriptor(
arg.Name,
Rewrite(arg.Type, namedTypeDescriptor)));
})
.ToList();
var resultTypeName = CreateResultRootTypeName(modelOperation.ResultType.Name);
switch (modelOperation.OperationType)
{
case OperationType.Query:
context.Register(
modelOperation.Name,
new QueryOperationDescriptor(
modelOperation.Name,
context.Types.Single(t => t.RuntimeType.Name.Equals(resultTypeName)),
context.Namespace,
arguments,
modelOperation.Document.ToString()));
break;
case OperationType.Mutation:
context.Register(
modelOperation.Name,
new MutationOperationDescriptor(
modelOperation.Name,
context.Types.Single(t => t.RuntimeType.Name.Equals(resultTypeName)),
context.Namespace,
arguments,
modelOperation.Document.ToString()));
break;
case OperationType.Subscription:
context.Register(
modelOperation.Name,
new SubscriptionOperationDescriptor(
modelOperation.Name,
context.Types.Single(t => t.RuntimeType.Name.Equals(resultTypeName)),
context.Namespace,
arguments,
modelOperation.Document.ToString()));
break;
default:
throw new ArgumentOutOfRangeException();
}
}
}
public static void Map(ClientModel model, IMapperContext context)
{
var entities = new List <EntityIdDescriptor>();
foreach (var entity in model.Entities)
{
var fields = new List <ScalarEntityIdDescriptor>();
foreach (var field in entity.Fields)
{
if (field.Type.NamedType() is ILeafType leafType)
{
fields.Add(
new ScalarEntityIdDescriptor(
field.Name,
leafType.Name,
model.Schema.GetOrCreateTypeInfo(leafType.GetSerializationType())));
}
}
entities.Add(
new EntityIdDescriptor(entity.Name, entity.Name, fields));
}
context.Register(
new EntityIdFactoryDescriptor(
context.ClientName + "EntityIdFactory",
entities,
NamingConventions.CreateStateNamespace(context.Namespace)));
}
public static void Map(ClientModel model, IMapperContext context)
{
foreach (OperationModel modelOperation in model.Operations)
{
RuntimeTypeInfo resultType = context.GetRuntimeType(
modelOperation.ResultType.Name,
Descriptors.TypeDescriptors.TypeKind.ResultType);
context.Register(
modelOperation.Name,
new ResultBuilderDescriptor(
new RuntimeTypeInfo(
CreateResultBuilderName(modelOperation.Name),
CreateStateNamespace(context.Namespace)),
context.Types.Single(t => t.RuntimeType.Equals(resultType)),
modelOperation.LeafTypes.Select(
leafType =>
{
string runtimeType =
leafType.RuntimeType.Contains('.')
? leafType.RuntimeType
: $"{context.Namespace}.{leafType.RuntimeType}";
string serializationType =
leafType.SerializationType.Contains('.')
? leafType.SerializationType
: $"{context.Namespace}.{leafType.SerializationType}";
return(new ValueParserDescriptor(
leafType.Name,
TypeInfos.GetOrCreate(runtimeType),
TypeInfos.GetOrCreate(serializationType)));
}).ToList()));
}
}
public static void Map(
ClientModel model,
IMapperContext context)
{
foreach (var entityTypeDescriptor in CollectEntityTypes(model, context))
{
context.Register(entityTypeDescriptor.GraphQLTypeName, entityTypeDescriptor);
}
}
public static void Map(
ClientModel model,
IMapperContext context)
{
context.Register(
new StoreAccessorDescriptor(
NamingConventions.CreateStoreAccessor(context.ClientName),
NamingConventions.CreateStateNamespace(context.Namespace)));
}
public static void Map(
ClientModel model,
IMapperContext context)
{
foreach (var descriptor in CollectEnumDescriptors(model, context))
{
context.Register(descriptor.Name, descriptor);
}
}
public static void Map(ClientModel model, IMapperContext context)
{
context.Register(
new DependencyInjectionDescriptor(
context.ClientName,
context.Namespace,
context.EntityTypes.ToList(),
context.Operations.ToList(),
context.Types));
}
public static void Map(
ClientModel model,
IMapperContext context)
{
context.Register(
new ClientDescriptor(
context.ClientName,
context.Namespace,
context.Operations.ToList()));
}
public static void Map(
ClientModel model,
IMapperContext context)
{
context.Register(
new DependencyInjectionDescriptor(
context.Client,
context.EntityTypes.ToList(),
context.Operations.ToList(),
context.Types,
context.TransportProfiles,
context.EntityIdFactory,
context.StoreAccessor));
}
public static void Map(
ClientModel model,
IMapperContext context)
{
foreach (var(nameString, namedTypeDescriptor) in
CollectTypeDescriptors(
model,
context))
{
context.Register(
nameString,
namedTypeDescriptor);
}
}
public static void Map(
ClientModel model,
IMapperContext context)
{
context.Register(
new DependencyInjectionDescriptor(
context.ClientName,
context.Namespace,
EntityTypeDescriptorMapper.CollectEntityTypes(model, context).ToList(),
context.Operations.ToList(),
TypeDescriptorMapper
.CollectTypeDescriptors(model, context)
.Select(x => x.Item2)
.ToList(),
EnumDescriptorMapper.CollectEnumDescriptors(model, context).ToList()));
}
public static void Map(
ClientModel model,
IMapperContext context)
{
foreach (OperationModel modelOperation in model.Operations)
{
var resultTypeName = ResultRootTypeNameFromTypeName(modelOperation.ResultType.Name);
context.Register(
modelOperation.Name,
new ResultBuilderDescriptor(
modelOperation.Name,
context.Types.Single(t => t.Name.Equals(resultTypeName)),
modelOperation.LeafTypes.Select(
leafType => new ValueParserDescriptor(
leafType.SerializationType,
leafType.RuntimeType,
leafType.Name)).ToList()));
}
}
public static void Map(ClientModel model, IMapperContext context)
{
var entities = new List <EntityIdDescriptor>();
foreach (var entity in model.Entities)
{
var fields = new List <EntityIdDescriptor>();
foreach (var field in entity.Fields)
{
fields.Add(new EntityIdDescriptor(
field.Name,
((ILeafType)field.Type.NamedType()).GetSerializationType()));
}
entities.Add(new EntityIdDescriptor(entity.Name, entity.Name, fields));
}
context.Register(
new EntityIdFactoryDescriptor("EntityIdFactory", entities, context.Namespace));
}
public static void Map(ClientModel model, IMapperContext context)
{
context.Register(CollectDataTypes(model, context));
}
public static void Map(ClientModel model, IMapperContext context)
{
foreach (OperationModel modelOperation in model.Operations)
{
var arguments = modelOperation.Arguments.Select(
arg =>
{
NameString typeName = arg.Type.TypeName();
INamedTypeDescriptor namedTypeDescriptor =
context.Types.Single(type => type.Name.Equals(typeName));
return(new PropertyDescriptor(
arg.Name,
arg.Variable.Variable.Name.Value,
Rewrite(arg.Type, namedTypeDescriptor),
null));
})
.ToList();
RuntimeTypeInfo resultType = context.GetRuntimeType(
modelOperation.ResultType.Name,
Descriptors.TypeDescriptors.TypeKind.ResultType);
string bodyString = modelOperation.Document.ToString();
byte[] body = Encoding.UTF8.GetBytes(modelOperation.Document.ToString(false));
string hash = context.HashProvider.ComputeHash(body);
switch (modelOperation.OperationType)
{
case OperationType.Query:
context.Register(
modelOperation.Name,
new QueryOperationDescriptor(
modelOperation.Name,
context.Namespace,
context.Types.Single(t => t.RuntimeType.Equals(resultType)),
arguments,
body,
bodyString,
context.HashProvider.Name,
hash,
context.RequestStrategy));
break;
case OperationType.Mutation:
context.Register(
modelOperation.Name,
new MutationOperationDescriptor(
modelOperation.Name,
context.Namespace,
context.Types.Single(t => t.RuntimeType.Equals(resultType)),
arguments,
body,
bodyString,
context.HashProvider.Name,
hash,
context.RequestStrategy));
break;
case OperationType.Subscription:
context.Register(
modelOperation.Name,
new SubscriptionOperationDescriptor(
modelOperation.Name,
context.Namespace,
context.Types.Single(t => t.RuntimeType.Equals(resultType)),
arguments,
body,
bodyString,
context.HashProvider.Name,
hash,
context.RequestStrategy));
break;
default:
throw new ArgumentOutOfRangeException();
}
}
}
public static void Map(
ClientModel model,
IMapperContext context)
{
foreach (OperationModel modelOperation in model.Operations)
{
var arguments = modelOperation.Arguments.Select(
arg =>
{
if (arg.Type.IsEnumType())
{
var enumType =
context.EnumTypes.Single(type =>
type.Name == arg.Type.TypeName());
return(new PropertyDescriptor(
arg.Name,
Unwrap(arg.Type,
_ => new NamedTypeDescriptor(
enumType.Name,
enumType.Namespace,
false,
graphQLTypeName: enumType.Name,
isEnum: true))));
}
return(new PropertyDescriptor(
arg.Name,
Unwrap(arg.Type,
_ => context.Types.First(
type => type.GraphQLTypeName == arg.Type.TypeName()
))));
})
.ToList();
var resultTypeName = ResultRootTypeNameFromTypeName(modelOperation.ResultType.Name);
switch (modelOperation.OperationType)
{
case OperationType.Query:
context.Register(
modelOperation.Name,
new QueryOperationDescriptor(
modelOperation.Name,
context.Types.Single(
t => t.Name.Equals(resultTypeName)),
context.Namespace,
arguments,
modelOperation.Document.ToString()));
break;
case OperationType.Mutation:
context.Register(
modelOperation.Name,
new MutationOperationDescriptor(
modelOperation.Name,
context.Types.Single(
t => t.Name.Equals(resultTypeName)),
context.Namespace,
arguments,
modelOperation.Document.ToString()));
break;
case OperationType.Subscription:
context.Register(
modelOperation.Name,
new SubscriptionOperationDescriptor(
modelOperation.Name,
context.Types.Single(
t => t.Name.Equals(resultTypeName)),
context.Namespace,
arguments,
modelOperation.Document.ToString()));
break;
default:
throw new ArgumentOutOfRangeException();
}
}
}
public static void Map(ClientModel model, IMapperContext context)
{
context.Register(CollectTypeDescriptors(model, context));
}
