private RegisteredType InitializeType( TypeSystemObjectBase typeSystemObject, string?scope, bool isInferred) { try { var discoveryContext = new TypeDiscoveryContext( typeSystemObject, scope, _serviceFactory.Services, _descriptorContext, _interceptor); typeSystemObject.Initialize(discoveryContext); var references = new List <ITypeReference>(); if (!isInferred) { references.Add(TypeReference.Create( typeSystemObject, scope: scope)); } if (!BaseTypes.IsNonGenericBaseType(typeSystemObject.GetType())) { references.Add(TypeReference.Create( typeSystemObject.GetType(), SchemaTypeReference.InferTypeContext(typeSystemObject), scope: scope)); } if (typeSystemObject is IHasTypeIdentity hasTypeIdentity && hasTypeIdentity.TypeIdentity is { }) { var reference = TypeReference.Create( hasTypeIdentity.TypeIdentity, SchemaTypeReference.InferTypeContext(typeSystemObject), scope: scope); if (!references.Contains(reference)) { references.Add(reference); } } var registeredType = new RegisteredType( references, typeSystemObject, discoveryContext, CollectDependencies(discoveryContext), isInferred); return(registeredType); }
public RegisteredType( IReadOnlyList <ITypeReference> references, TypeSystemObjectBase type, TypeDiscoveryContext discoveryContext, IReadOnlyList <TypeDependency> dependencies, bool isInferred) { References = references; Type = type; DiscoveryContext = discoveryContext; Dependencies = dependencies; IsInferred = isInferred; IsExtension = Type is INamedTypeExtensionMerger; IsNamedType = Type is INamedType; IsDirectiveType = Type is DirectiveType; }
public TypeCompletionContext( TypeDiscoveryContext initializationContext, TypeInitializer typeInitializer, IsOfTypeFallback isOfType, Func <ISchema> schemaResolver) { _initializationContext = initializationContext ?? throw new ArgumentNullException(nameof(initializationContext)); _typeInitializer = typeInitializer ?? throw new ArgumentNullException(nameof(typeInitializer)); IsOfType = isOfType; _schemaResolver = schemaResolver ?? throw new ArgumentNullException(nameof(schemaResolver)); GlobalComponents = new ReadOnlyCollection <FieldMiddleware>( _typeInitializer.GlobalComponents); _alternateNames.Add(_initializationContext.InternalName); }
public TypeCompletionContext( TypeDiscoveryContext initializationContext, TypeReferenceResolver typeReferenceResolver, IList <FieldMiddleware> globalComponents, IDictionary <FieldReference, RegisteredResolver> resolvers, IsOfTypeFallback isOfType, Func <ISchema> schemaResolver) { _initializationContext = initializationContext ?? throw new ArgumentNullException(nameof(initializationContext)); _typeReferenceResolver = typeReferenceResolver ?? throw new ArgumentNullException(nameof(typeReferenceResolver)); _resolvers = resolvers ?? throw new ArgumentNullException(nameof(resolvers)); IsOfType = isOfType; _schemaResolver = schemaResolver ?? throw new ArgumentNullException(nameof(schemaResolver)); GlobalComponents = new ReadOnlyCollection <FieldMiddleware>(globalComponents); _alternateNames.Add(_initializationContext.InternalName); }
private void MergeTypeExtension( IEnumerable <RegisteredType> extensions, RegisteredType registeredType, INamedType namedType) { foreach (RegisteredType extension in extensions) { if (extension.Type is INamedTypeExtensionMerger m) { if (m.Kind != namedType.Kind) { throw new SchemaException(SchemaErrorBuilder.New() .SetMessage(string.Format( CultureInfo.InvariantCulture, TypeInitializer_Merge_KindDoesNotMatch, namedType.Name)) .SetTypeSystemObject((ITypeSystemObject)namedType) .Build()); } TypeDiscoveryContext initContext = extension.DiscoveryContext; foreach (FieldReference reference in initContext.Resolvers.Keys) { _resolvers[reference] = initContext.Resolvers[reference].WithSourceType(registeredType.RuntimeType); } // merge TypeCompletionContext context = extension.CompletionContext; context.Status = TypeStatus.Named; m.Merge(context, namedType); // update dependencies context = registeredType.CompletionContext; registeredType.AddDependencies(extension.Dependencies); _typeRegistry.Register(registeredType); CopyAlternateNames(extension.CompletionContext, context); } } }
private RegisteredType InitializeType( TypeSystemObjectBase typeSystemObject, string?scope, bool isInferred) { try { var discoveryContext = new TypeDiscoveryContext( typeSystemObject, _typeRegistry, _typeLookup, _context, _interceptor, scope); typeSystemObject.Initialize(discoveryContext); var references = new List <ITypeReference>(); if (!isInferred) { references.Add(TypeReference.Create(typeSystemObject, scope)); } if (!ExtendedType.Tools.IsNonGenericBaseType(typeSystemObject.GetType())) { references.Add(_context.TypeInspector.GetTypeRef( typeSystemObject.GetType(), SchemaTypeReference.InferTypeContext(typeSystemObject), scope)); } if (typeSystemObject is IHasTypeIdentity hasTypeIdentity && hasTypeIdentity.TypeIdentity is not null) { ExtendedTypeReference reference = _context.TypeInspector.GetTypeRef( hasTypeIdentity.TypeIdentity, SchemaTypeReference.InferTypeContext(typeSystemObject), scope); if (!references.Contains(reference)) { references.Add(reference); } } var registeredType = new RegisteredType( typeSystemObject, references, CollectDependencies(discoveryContext), discoveryContext, isInferred); return(registeredType); } catch (Exception ex) { throw new SchemaException( SchemaErrorBuilder.New() .SetMessage(ex.Message) .SetException(ex) .SetTypeSystemObject(typeSystemObject) .Build()); } }