private static IEnumerable <INamedTypeDescriptor> CollectTypeDescriptors(
ClientModel model,
IMapperContext context)
{
var typeDescriptors = new Dictionary <NameString, TypeDescriptorModel>();
var inputTypeDescriptors = new Dictionary <NameString, InputTypeDescriptorModel>();
var leafTypeDescriptors = new Dictionary <NameString, INamedTypeDescriptor>();
// first we create type descriptor for the leaf types ...
CollectLeafTypes(model, context, leafTypeDescriptors);
// after that we collect all the output types that we have ...
CollectTypes(model, context, typeDescriptors);
// with these two completed we can create the properties for all output
// types and complete them since we know now all the property types.
AddProperties(model, context, typeDescriptors, leafTypeDescriptors);
// last but not least we will collect all the input object types ...
CollectInputTypes(model, context, inputTypeDescriptors);
// and in a second step complete the input object types since we now know all
// the possible property types.
AddInputTypeProperties(inputTypeDescriptors, leafTypeDescriptors);
return(typeDescriptors.Values
.Select(t => t.Descriptor)
.Concat(inputTypeDescriptors.Values
.Select(t => t.Descriptor)
.Concat(leafTypeDescriptors.Values)));
}
private static void RegisterType(
ClientModel model,
IMapperContext context,
Dictionary <NameString, TypeDescriptorModel> typeDescriptors,
OutputTypeModel outputType,
List <UnionType> unionTypes,
TypeKind?kind = null,
OperationModel?operationModel = null)
{
if (typeDescriptors.TryGetValue(
outputType.Name,
out TypeDescriptorModel descriptorModel))
{
return;
}
if (operationModel is not null && outputType.IsInterface)
{
descriptorModel = CreateInterfaceTypeModel(
model,
context,
typeDescriptors,
outputType,
unionTypes,
descriptorModel,
operationModel,
kind);
}
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)
{
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)
{
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();
}
}
}
/// <summary>
/// <para> Map an object </para>
/// </summary>
/// <typeparam name="TFrom"> Type to map from </typeparam>
/// <typeparam name="TTo"> Type to map to </typeparam>
/// <param name="from"> Object to map from </param>
/// <param name="toExpression"> Expression for the target </param>
/// <param name="context"> Context </param>
public void Map <TFrom, TTo>(
TFrom from,
Expression <Func <TTo> > toExpression,
IMapperContext context)
where TTo : class
{
if (toExpression == null)
{
throw new ArgumentNullException("toExpression");
}
if (Equals(from, default(TFrom)))
{
return;
}
var toMember
= new CollapseMembersExpressionVisitor()
.Modify(toExpression);
var to = toMember.GetValue();
if (to == null)
{
to = context.Create <TTo>();
toMember.SetValue(to);
}
var mapper = Get <TFrom, TTo>();
mapper(from, to, context);
context.Update(to);
}
private static void CollectInputTypes(
ClientModel model,
IMapperContext context,
Dictionary <NameString, InputTypeDescriptorModel> typeDescriptors)
{
foreach (OperationModel operation in model.Operations)
{
foreach (var inputType in operation.InputObjectTypes)
{
if (!typeDescriptors.TryGetValue(
inputType.Name,
out InputTypeDescriptorModel descriptorModel))
{
descriptorModel = new InputTypeDescriptorModel(
inputType,
new NamedTypeDescriptor(
inputType.Name,
context.Namespace,
false,
new List <NameString>(),
kind: TypeKind.InputType,
graphQLTypeName: inputType.Type.Name));
typeDescriptors.Add(
inputType.Name,
descriptorModel);
}
}
}
}
public static void Map <TFrom, TTo>(
this IMapperContext context,
TFrom from,
Expression <Func <TTo> > toExpression) where TTo : class
{
context.Container
.Map(from, toExpression, context);
}
public a_multi_depth_supplied_mapping_matcher()
{
_updatedEntities = new List<IEntity>();
_deletedEntities = new List<IEntity>();
_mapperContext = new MapperContext(
new MapperContainer()
.Register<Person, PersonEntity>(
(f, t, c) =>
{
c.Map(f.Name, () => t.Name);
c.MapAll(f.Addresses, () => t.Addresses, (fa, ta) => fa.Name == ta.Name);
}
)
.Register<Name, NameEntity>(
(f, t, c) =>
{
t.First = f.First;
t.Last = f.Last;
}
)
.Register<Address, AddressEntity>(
(f, t, c) => { t.Name = f.Name; }
),
new MapperContext.Parameters
{
Deleter = o => _deletedEntities.Add((IEntity) o),
Updater = o =>
{
var e = o as IEntity;
if (e != null) _updatedEntities.Add(e);
}
}
);
_from = new Person
{
Name = new Name {First = "Person"},
Addresses = new[]
{
new Address {Name = "Keep"},
new Address {Name = "New"}
}
};
_to = new PersonEntity
{
Name = new NameEntity {First = "Overwite"},
Addresses = new[]
{
new AddressEntity {Name = "Keep"},
new AddressEntity {Name = "Delete"}
}
};
_mapperContext.Map(_from, () => _to);
}
public static void Map(
ClientModel model,
IMapperContext context)
{
foreach (var entityTypeDescriptor in CollectEntityTypes(model, context))
{
context.Register(entityTypeDescriptor.GraphQLTypeName, entityTypeDescriptor);
}
}
public a_single_depth_supplied_mapping()
{
_mapperContext = new MapperContext(
new MapperContainer()
.Register<Person, PersonEntity>(
(f, t, c) => { t.Email = f.Email; }
)
);
}
public static void Map(
ClientModel model,
IMapperContext context)
{
foreach (var descriptor in CollectEnumDescriptors(model, context))
{
context.Register(descriptor.Name, descriptor);
}
}
public calling_map()
{
_mapperContext = new MapperContext(
new MapperContainer()
.Register<Person, PersonEntity>(
(f, t, c) => { t.Name = new NameEntity(); }
)
);
}
public register_a_mapping()
{
_mapperContext = new MapperContext(
new MapperContainer()
.Register <Person, PersonEntity>(
(f, t, c) => { }
)
);
}
public static void Map(
ClientModel model,
IMapperContext context)
{
context.Register(
new StoreAccessorDescriptor(
NamingConventions.CreateStoreAccessor(context.ClientName),
NamingConventions.CreateStateNamespace(context.Namespace)));
}
public calling_map_all()
{
_mapperContext = new MapperContext(
new MapperContainer()
.Register<Person, PersonEntity>(
(f, t, c) => { }
)
);
}
public register_a_mapping()
{
_mapperContext = new MapperContext(
new MapperContainer()
.Register<Person, PersonEntity>(
(f, t, c) => { }
)
);
}
public calling_map()
{
_mapperContext = new MapperContext(
new MapperContainer()
.Register <Person, PersonEntity>(
(f, t, c) => { t.Name = new NameEntity(); }
)
);
}
private static void CollectTypes(
ClientModel model,
IMapperContext context,
Dictionary <NameString, TypeDescriptorModel> typeDescriptors)
{
var unionTypes = model.Schema.Types.OfType <UnionType>().ToList();
foreach (OperationModel operation in model.Operations)
{
foreach (OutputTypeModel outputType in operation.GetImplementations(
operation.ResultType))
{
RegisterType(
model,
context,
typeDescriptors,
outputType,
unionTypes,
TypeKind.ResultType);
}
foreach (var outputType in operation.OutputTypes.Where(t => !t.IsInterface))
{
RegisterType(
model,
context,
typeDescriptors,
outputType,
unionTypes);
}
RegisterType(
model,
context,
typeDescriptors,
operation.ResultType,
unionTypes,
TypeKind.ResultType,
operation);
foreach (var outputType in operation.OutputTypes.Where(t => t.IsInterface))
{
if (!typeDescriptors.TryGetValue(
outputType.Name,
out TypeDescriptorModel _))
{
RegisterType(
model,
context,
typeDescriptors,
outputType,
unionTypes,
operationModel: operation);
}
}
}
}
public calling_map_all()
{
_mapperContext = new MapperContext(
new MapperContainer()
.Register <Person, PersonEntity>(
(f, t, c) => { }
)
);
}
public a_single_depth_supplied_mapping()
{
_mapperContext = new MapperContext(
new MapperContainer()
.Register <Person, PersonEntity>(
(f, t, c) => { t.Email = f.Email; }
)
);
}
public a_multi_depth_supplied_mapping_no_matcher()
{
new List <IEntity>();
new List <IEntity>();
_mapperContext = new MapperContext(
new MapperContainer()
.Register <Person, PersonEntity>(
(f, t, c) =>
{
c.Map(f.Name, () => t.Name);
c.MapAll(f.Addresses, () => t.Addresses);
})
.Register <Name, NameEntity>(
(f, t, c) =>
{
t.First = f.First;
t.Last = f.Last;
}
)
.Register <Address, AddressEntity>(
(f, t, c) => { t.Name = f.Name; }
)
);
_from = new Person
{
Name = new Name {
First = "Person"
},
Addresses = new[]
{
new Address {
Name = "Address"
}
}
};
_to = new PersonEntity
{
Name = new NameEntity {
First = "Overwite"
},
Addresses = new[]
{
new AddressEntity {
Name = "Overwite"
},
new AddressEntity {
Name = "Overwite"
}
}
};
_mapperContext.Map(_from, () => _to);
}
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()));
}
private static IEnumerable <EntityTypeDescriptor> CollectEntityTypes(
ClientModel model,
IMapperContext context)
{
var entityTypes = new Dictionary <NameString, HashSet <NameString> >();
var descriptions = new Dictionary <NameString, string?>();
foreach (OperationModel operation in model.Operations)
{
foreach (var outputType in operation.OutputTypes.Where(t => !t.IsInterface))
{
INamedType namedType = outputType.Type.NamedType();
descriptions[namedType.Name] = outputType.Description;
if (outputType.Type.NamedType().IsEntity())
{
if (!entityTypes.TryGetValue(
namedType.Name,
out HashSet <NameString>?components))
{
components = new HashSet <NameString>();
entityTypes.Add(namedType.Name, components);
}
components.Add(outputType.Name);
}
}
}
foreach (KeyValuePair <NameString, HashSet <NameString> > entityType in entityTypes)
{
RuntimeTypeInfo runtimeType =
CreateEntityType(entityType.Key, context.Namespace);
descriptions.TryGetValue(entityType.Key, out var description);
var possibleTypes = entityType.Value
.Select(name => context.Types.Single(t => t.RuntimeType.Name.Equals(name)))
.OfType <ComplexTypeDescriptor>()
.ToList();
var entityTypeDescriptor = new EntityTypeDescriptor(
entityType.Key,
runtimeType,
possibleTypes,
description);
foreach (var type in possibleTypes.OfType <ObjectTypeDescriptor>())
{
type.CompleteEntityType(entityTypeDescriptor);
}
yield return(entityTypeDescriptor);
}
}
public MappingEngine(IMapperContext mapperContext,
Internal.IDictionary<TypePair, IObjectMapper> objectMapperCache,
Func<Type, object> serviceCtor)
{
/* Never, ever carry a previously configured engine forward:
that's the whole point of facilitating micro-mapping. */
_mapperContext = mapperContext;
ObjectMapperCache = objectMapperCache;
ServiceCtor = serviceCtor;
_mapperContext.ConfigurationProvider.TypeMapCreated += ClearTypeMap;
}
public static void MapAll <TFrom, TTo>(
this IMapperContext context,
IEnumerable <TFrom> from,
Expression <Func <IEnumerable <TTo> > > toExpression)
where TTo : class
{
context.Container
.MapAll(
from, toExpression,
null,
context);
}
public static IEnumerable <(NameString, NamedTypeDescriptor)> CollectTypeDescriptors(
ClientModel model,
IMapperContext context)
{
var typeDescriptors = new Dictionary <NameString, TypeDescriptorModel>();
var inputTypeDescriptors = new Dictionary <NameString, InputTypeDescriptorModel>();
var scalarTypeDescriptors = new Dictionary <NameString, NamedTypeDescriptor>();
CollectTypes(
model,
context,
typeDescriptors);
AddProperties(
model,
context,
typeDescriptors,
scalarTypeDescriptors);
CollectInputTypes(
model,
context,
inputTypeDescriptors);
AddInputTypeProperties(
model,
context,
inputTypeDescriptors,
scalarTypeDescriptors);
foreach (TypeDescriptorModel descriptorModel in typeDescriptors.Values)
{
yield return(
descriptorModel.NamedTypeDescriptor.Name,
descriptorModel.NamedTypeDescriptor);
}
foreach (InputTypeDescriptorModel descriptorModel in inputTypeDescriptors.Values)
{
yield return(
descriptorModel.NamedTypeDescriptor.Name,
descriptorModel.NamedTypeDescriptor);
}
foreach (NamedTypeDescriptor typeDescriptor in scalarTypeDescriptors.Values)
{
yield return(
typeDescriptor.Name + "_" + typeDescriptor.GraphQLTypeName !.Value,
typeDescriptor);
}
}
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 IEnumerable <EnumDescriptor> CollectEnumDescriptors(
ClientModel model,
IMapperContext context)
{
return(model.LeafTypes
.OfType <EnumTypeModel>()
.Select(
enumType =>
new EnumDescriptor(
enumType.Name,
context.Namespace,
enumType.Values
.Select(value =>
new EnumValueDescriptor(value.Name, value.Value.Name))
.ToList())));
}
public a_multi_depth_supplied_mapping_no_matcher()
{
new List<IEntity>();
new List<IEntity>();
_mapperContext = new MapperContext(
new MapperContainer()
.Register<Person, PersonEntity>(
(f, t, c) =>
{
c.Map(f.Name, () => t.Name);
c.MapAll(f.Addresses, () => t.Addresses);
})
.Register<Name, NameEntity>(
(f, t, c) =>
{
t.First = f.First;
t.Last = f.Last;
}
)
.Register<Address, AddressEntity>(
(f, t, c) => { t.Name = f.Name; }
)
);
_from = new Person
{
Name = new Name {First = "Person"},
Addresses = new[]
{
new Address {Name = "Address"}
}
};
_to = new PersonEntity
{
Name = new NameEntity {First = "Overwite"},
Addresses = new[]
{
new AddressEntity {Name = "Overwite"},
new AddressEntity {Name = "Overwite"}
}
};
_mapperContext.Map(_from, () => _to);
}
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 SampleRepository(int numberOfObjects)
{
//Make the mock objects and fill them with data.
baseModelA = new BaseModelA();
List<BaseModelC> baseModelCList = new List<BaseModelC>();
for (int count = 0; count < numberOfObjects; count++)
{
BaseModelC baseModelC = new BaseModelC();
baseModelC.ModelCProprtyA = Guid.NewGuid().ToString();
baseModelC.ModelA = baseModelA;
baseModelC.ModelB = new BaseModelB();
baseModelC.ModelB.ModelBPropertyA = "PropertyAValue";
baseModelC.ModelB.ModelC = baseModelC;
baseModelCList.Add(baseModelC);
}
var list = baseModelCList.ToList();
//Assign the data to different types of lists for testing purposes.
baseModelA.ModelCArray = baseModelCList.ToArray();
baseModelA.ModelCList = list;
baseModelA.ModelCIEnumerable = baseModelCList.AsEnumerable();
baseModelA.ModelCCollection = list;
baseModelA.ModelCIList = list;
//Now define the mapping rules
mapper = new MapperFactory().GetContext();
mapper.AddMap<BaseModelA, RepositoryModelA>();
mapper.AddMap<BaseModelB, RepositoryModelB>();
mapper.AddMap<BaseModelC, RepositoryModelC>();
//Define the conversion hierarchy
mapper.AddHierarchy<BaseModelA>().Include<BaseModelC>();
mapper.AddHierarchy<BaseModelC>().Include<BaseModelA>();
mapper.AddHierarchy<BaseModelC>().Include<BaseModelB>();
mapper.AddHierarchy<BaseModelB>().Include<BaseModelC>();
}
private static void CollectInputTypes(
ClientModel model,
IMapperContext context,
Dictionary <NameString, InputTypeDescriptorModel> typeDescriptors)
{
foreach (var inputType in model.InputObjectTypes)
{
if (!typeDescriptors.TryGetValue(
inputType.Name,
out InputTypeDescriptorModel descriptorModel))
{
descriptorModel = new InputTypeDescriptorModel(
inputType,
new InputObjectTypeDescriptor(
inputType.Type.Name,
new (inputType.Name, context.Namespace)));
typeDescriptors.Add(inputType.Name, descriptorModel);
}
}
}
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 IEnumerable <EntityTypeDescriptor> CollectEntityTypes(
ClientModel model,
IMapperContext context)
{
{
var entityTypes = new Dictionary <NameString, HashSet <NameString> >();
foreach (OperationModel operation in model.Operations)
{
foreach (var outputType in operation.OutputTypes.Where(t => !t.IsInterface))
{
INamedType namedType = outputType.Type.NamedType();
if (outputType.Type.NamedType().IsEntity())
{
if (!entityTypes.TryGetValue(
namedType.Name,
out HashSet <NameString>?components))
{
components = new HashSet <NameString>();
entityTypes.Add(namedType.Name, components);
}
components.Add(outputType.Name);
}
}
}
foreach (KeyValuePair <NameString, HashSet <NameString> > entityType in entityTypes)
{
yield return(new EntityTypeDescriptor(
entityType.Key,
context.Namespace,
entityType.Value
.Select(name => context.Types.Single(t => t.Name.Equals(name)))
.ToList()));
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="MapperFactory"/> class.
/// </summary>
public MapperFactory()
{
_mapperContext = new MapperContext();
}
protected override void Establish_context()
{
_context = new MapperContext();
_context.Configuration.ClearPrefixes();
_context.CreateMap<Source, Destination>();
}
public MappingEngine(IMapperContext mapperContext)
: this(mapperContext,
DictionaryFactory.CreateDictionary<TypePair, IObjectMapper>(),
mapperContext.ConfigurationProvider.ServiceCtor)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="MapperFactory"/> class.
/// </summary>
/// <param name="context">The context.</param>
public MapperFactory(IMapperContext context)
{
_mapperContext = context;
}
protected override void Establish_context()
{
_context = new MapperContext();
var parentMapping = _context.CreateMap<Source, Target>();
parentMapping.ForMember(dest => dest.Value, opt => opt.MapFrom(s => (TargetEnumValue) s.Value));
}
