void INeedsInitialization.CompleteType(ISchemaContext schemaContext, Action <SchemaError> reportError)
{
if (_typesFactory == null)
{
reportError(new SchemaError(
"A Union type must define one or more unique member types.",
this));
}
else
{
foreach (ObjectType memberType in _typesFactory(schemaContext.Types))
{
_typeMap[memberType.Name] = memberType;
}
}
if (_typeResolver == null)
{
// if there is now custom type resolver we will use this default
// abstract type resolver.
_typeResolver = (c, r) =>
{
foreach (ObjectType type in _typeMap.Values)
{
if (type.IsOfType(c, r))
{
return(type);
}
}
return(null); // todo: should we throw instead?
};
}
}
void INeedsInitialization.RegisterDependencies(
ISchemaContext schemaContext,
Action <SchemaError> reportError)
{
if (!_completed)
{
if (_interfaces != null)
{
foreach (TypeReference typeReference in _interfaces)
{
schemaContext.Types.RegisterType(typeReference);
}
}
foreach (Field field in _fieldMap.Values)
{
field.RegisterDependencies(schemaContext, reportError, this);
}
if (_typeBinding != null)
{
schemaContext.Types.RegisterType(this, _typeBinding);
}
}
}
internal void RegisterDependencies(
ISchemaContext schemaContext,
Action <SchemaError> reportError,
INamedType parentType)
{
if (!_completed)
{
if (_typeReference != null)
{
schemaContext.Types.RegisterType(_typeReference);
}
if (_member != null)
{
schemaContext.Resolvers.RegisterResolver(
new MemberResolverBinding(parentType.Name, Name, _member));
}
foreach (InputField argument in _argumentMap.Values)
{
argument.RegisterDependencies(
schemaContext.Types, reportError, parentType);
}
}
}
public void ApplyBinding(
ISchemaContext schemaContext,
ResolverBindingInfo resolverBindingInfo)
{
if (resolverBindingInfo is ResolverDelegateBindingInfo b)
{
if (b.AsyncFieldResolver == null)
{
schemaContext.Resolvers.RegisterResolver(
new DelegateResolverBinding(
b.ObjectTypeName, b.FieldName, b.FieldResolver));
}
else
{
FieldResolverDelegate fieldResolverDelegate =
(ctx, ct) => b.AsyncFieldResolver(ctx, ct);
schemaContext.Resolvers.RegisterResolver(
new DelegateResolverBinding(
b.ObjectTypeName, b.FieldName, fieldResolverDelegate));
}
}
else
{
throw new NotSupportedException(
"The binding type is not supported by this handler.");
}
}
void INeedsInitialization.CompleteType(
ISchemaContext schemaContext,
Action <SchemaError> reportError)
{
CompleteNativeType(schemaContext.Types, reportError);
CompleteFields(schemaContext.Types, reportError);
}
private void RegisterFieldResolvers(ISchemaContext context)
{
var resolverRegistrar = new ResolverRegistrar(
_schemaConfiguration.ResolverBindings);
resolverRegistrar.RegisterResolvers(context);
}
void INeedsInitialization.CompleteType(
ISchemaContext schemaContext, Action <SchemaError> reportError)
{
foreach (Field field in _fieldMap.Values)
{
field.CompleteField(schemaContext, reportError, this);
}
if (_resolveAbstractType == null)
{
// if there is now custom type resolver we will use this default
// abstract type resolver.
List <ObjectType> types = null;
_resolveAbstractType = (c, r) =>
{
if (types == null)
{
types = schemaContext.Types.GetTypes()
.OfType <ObjectType>()
.Where(t => t.Interfaces.ContainsKey(Name))
.ToList();
}
foreach (ObjectType type in types)
{
if (type.IsOfType(c, r))
{
return(type);
}
}
return(null); // todo: should we throw instead?
};
}
}
void INeedsInitialization.CompleteType(
ISchemaContext schemaContext,
Action <SchemaError> reportError)
{
CompleteTypes(schemaContext.Types, reportError);
CompleteResolveAbstractType();
}
// tries to register resolvers for type bindings that at
// this point have no explicite resolver.
private static void TryRegisterMissingResolvers(
ISchemaContext schemaContext)
{
foreach (ObjectTypeBinding typeBinding in schemaContext.Types
.GetTypeBindings().OfType <ObjectTypeBinding>())
{
List <FieldMember> missingResolvers = new List <FieldMember>();
foreach (FieldBinding field in typeBinding.Fields.Values)
{
FieldReference fieldReference = new FieldReference(
typeBinding.Name, field.Name);
if (!schemaContext.Resolvers.ContainsResolver(
fieldReference))
{
missingResolvers.Add(new FieldMember(
typeBinding.Name, field.Name, field.Member));
}
}
foreach (IFieldResolverDescriptor descriptor in
FieldResolverDiscoverer.CreateResolverDescriptors(
null, typeBinding.Type, missingResolvers))
{
schemaContext.Resolvers.RegisterResolver(descriptor);
}
}
}
private void RegisterAllTypes(ISchemaContext context)
{
foreach (INamedType type in _queue)
{
context.Types.RegisterType(type);
}
}
public void ApplyBinding(
ISchemaContext schemaContext,
ResolverBindingInfo resolverBindingInfo)
{
if (resolverBindingInfo is ResolverCollectionBindingInfo b)
{
if (b.ObjectType == null)
{
b.ObjectType = typeof(object);
}
List <IFieldResolverDescriptor> descriptors =
CollectPossibleDescriptors(schemaContext.Types, b);
IEnumerable <IFieldResolverDescriptor>
mostSpecificFieldResolvers =
GetMostSpecificFieldResolvers(
schemaContext.Types, descriptors);
foreach (IFieldResolverDescriptor descriptor in
mostSpecificFieldResolvers)
{
schemaContext.Resolvers.RegisterResolver(descriptor);
}
}
else
{
throw new NotSupportedException(
"The binding type is not supported by this handler.");
}
}
void INeedsInitialization.RegisterDependencies(ISchemaContext schemaContext, Action <SchemaError> reportError)
{
foreach (InputField field in _fieldMap.Values)
{
field.RegisterDependencies(schemaContext.Types, reportError, this);
}
}
private void RegisterTypes(ISchemaContext context, string queryTypeName)
{
var typeRegistrar = new TypeRegistrar(
context.Types.GetTypes());
typeRegistrar.RegisterTypes(context, queryTypeName);
_errors.AddRange(typeRegistrar.Errors);
}
private static void RegisterDirectives(
ISchemaContext schemaContext)
{
schemaContext.Directives.RegisterDirectiveType(
new SkipDirective());
schemaContext.Directives.RegisterDirectiveType(
new IncludeDirectiveType());
}
private void RegisterTypeBindings(ISchemaContext context)
{
var typeBindingRegistrar = new TypeBindingRegistrar(
_schemaConfiguration.TypeBindings);
typeBindingRegistrar.RegisterTypeBindings(context.Types);
((TypeRegistry)context.Types).CompleteRegistartion();
}
public void RegisterTypes(
ISchemaContext schemaContext,
string queryTypeName)
{
RegisterAllTypes(schemaContext);
RegisterTypeDependencies(schemaContext, queryTypeName);
RegisterDirectiveDependencies(schemaContext);
}
void INeedsInitialization.CompleteType(ISchemaContext schemaContext, Action <SchemaError> reportError)
{
foreach (InputField field in Arguments.Values)
{
field.CompleteInputField(
schemaContext.Types, reportError, null);
}
}
private void RegisterTypes(ISchemaContext context)
{
TypeRegistrar typeRegistrar = new TypeRegistrar(
context.Types.GetTypes());
typeRegistrar.RegisterTypes(context);
_errors.AddRange(typeRegistrar.Errors);
}
public ColumnarDb(string DBName, ISchemaContext ctx, string UserName, string ClusterAddress = DefaultCluster)
{
this.UserName = UserName;
this.DBName = DBName;
this.ctx = ctx;
cluster = Cluster.Builder().AddContactPoint(ClusterAddress).Build();
SetDefaultConfig();
//ISession session = cluster.Connect("demo");
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="schemaContext"></param>
/// <param name="documentExecuter"></param>
/// <param name="options"></param>
/// <param name="listeners"></param>
/// <param name="validationRules"></param>
public TenantGraphQlExecuter(ISchemaContext schemaContext, IDocumentExecuter documentExecuter, IOptions <GraphQLOptions> options,
IEnumerable <IDocumentExecutionListener> listeners, IEnumerable <IValidationRule> validationRules)
{
_schemaContext = schemaContext;
_documentExecuter = documentExecuter;
_options = options;
_listeners = listeners;
_validationRules = validationRules;
}
public TypeInitializationContext(ISchemaContext schemaContext,
Action <SchemaError> reportError)
{
_schemaContext = schemaContext
?? throw new ArgumentNullException(nameof(schemaContext));
_reportError = reportError
?? throw new ArgumentNullException(nameof(reportError));
IsDirective = true;
}
public DBService()
{
if (ctx == null) { ctx = new SchemaDb(); }
if (Db.Count <= 0)
{
Db.Add(SchemaTypes.StreamData, new InMemoryDb(ctx));
Db.Add(SchemaTypes.RelationalData, new DocumentDb(ctx));
Db.Add(SchemaTypes.HistoricalData, new ColumnarDb(ctx));
}
}
void INeedsInitialization.CompleteType(
ISchemaContext schemaContext,
Action <SchemaError> reportError)
{
if (!Values.Any())
{
reportError(new SchemaError(
$"The enum type `{Name}` has no values."));
}
}
public DataService()
{
if (ctx == null) { ctx = new SchemaDb(); }
Db.Add(SchemaTypes.StreamData, new InMemoryDb(ctx));
Db.Add(SchemaTypes.RelationalData, new DocumentDb(ctx));
Db.Add(SchemaTypes.HistoricalData, new ColumnarDb(ctx));
//Uncomment the following line if using designed components
//InitializeComponent();
}
void INeedsInitialization.RegisterDependencies(
ISchemaContext schemaContext, Action <SchemaError> reportError)
{
if (_types != null)
{
foreach (TypeReference typeReference in _types)
{
schemaContext.Types.RegisterType(typeReference);
}
}
}
private void RegisterDirectiveDependencies(ISchemaContext schemaContext)
{
foreach (INeedsInitialization directive in schemaContext.Directives
.GetDirectiveTypes().Cast <INeedsInitialization>())
{
var initializationContext =
new TypeInitializationContext(schemaContext,
e => _errors.Add(e));
directive.RegisterDependencies(initializationContext);
}
}
void INeedsInitialization.CompleteType(
ISchemaContext schemaContext,
Action <SchemaError> reportError)
{
CompleteAbstractTypeResolver(schemaContext.Types);
foreach (Field field in _fieldMap.Values)
{
field.CompleteField(schemaContext, reportError, this);
}
}
void INeedsInitialization.RegisterDependencies(
ISchemaContext schemaContext, Action <SchemaError> reportError)
{
if (_typeInfos != null)
{
foreach (TypeInfo typeInfo in _typeInfos)
{
schemaContext.Types.RegisterType(typeInfo.NativeNamedType);
}
}
}
internal IEnumerable <SchemaError> RegisterTypes(ISchemaContext schemaContext)
{
if (schemaContext == null)
{
throw new ArgumentNullException(nameof(schemaContext));
}
IEnumerable <SchemaError> errors = RegisterTypesAndDependencies(schemaContext);
RegisterTypeBindings(schemaContext.Types);
return(errors);
}
private static void RegisterDirectives(
ISchemaContext schemaContext)
{
schemaContext.Types.RegisterType(
new TypeReference(typeof(MultiplierPathType)));
schemaContext.Directives.RegisterDirectiveType(
new SkipDirectiveType());
schemaContext.Directives.RegisterDirectiveType(
new IncludeDirectiveType());
schemaContext.Directives.RegisterDirectiveType(
new CostDirectiveType());
}
public TypeInitializationContext(ISchemaContext schemaContext,
Action <SchemaError> reportError, INamedType namedType,
bool isQueryType)
{
_schemaContext = schemaContext
?? throw new ArgumentNullException(nameof(schemaContext));
_reportError = reportError
?? throw new ArgumentNullException(nameof(reportError));
Type = namedType
?? throw new ArgumentNullException(nameof(namedType));
IsQueryType = isQueryType;
}
internal void RegisterResolvers(ISchemaContext schemaContext)
{
if (schemaContext == null)
{
throw new ArgumentNullException(nameof(schemaContext));
}
CompleteDelegateBindings(schemaContext.Types);
CompleteCollectionBindings(schemaContext.Types);
RegisterKnownFieldResolvers(schemaContext);
TryRegisterMissingResolvers(schemaContext);
}
private void RegisterDirectiveDependencies(ISchemaContext schemaContext)
{
foreach (DirectiveType directive in schemaContext.Directives
.GetDirectiveTypes())
{
var initializationContext = new TypeInitializationContext(
schemaContext, e => _errors.Add(e), directive, false);
((INeedsInitialization)directive)
.RegisterDependencies(initializationContext);
}
}
public InMemoryDb(ISchemaContext ctx)
{
this.ctx = ctx;
}
public InMemoryDb(string DBName, ISchemaContext ctx)
{
this.DBName = DBName;
this.ctx = ctx;
}
public ColumnarDb(ISchemaContext ctx)
{
cluster = Cluster.Builder().AddContactPoint(DefaultCluster).Build();
this.ctx = ctx;
SetDefaultConfig();
}
public DocumentDb(ISchemaContext SchemaContext)
{
_client = new MongoClient();
ctx = SchemaContext;
}
public DocumentDb(string DBName,ISchemaContext SchemaContext)
{
_client = new MongoClient();
_database = _client.GetDatabase(DBName);
ctx = SchemaContext;
this.DBName = DBName;
}
