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