diff options
Diffstat (limited to 'vendor/github.com/graphql-go/graphql/schema.go')
| -rw-r--r-- | vendor/github.com/graphql-go/graphql/schema.go | 566 |
1 files changed, 0 insertions, 566 deletions
diff --git a/vendor/github.com/graphql-go/graphql/schema.go b/vendor/github.com/graphql-go/graphql/schema.go deleted file mode 100644 index f0e6a954..00000000 --- a/vendor/github.com/graphql-go/graphql/schema.go +++ /dev/null @@ -1,566 +0,0 @@ -package graphql - -import ( - "fmt" -) - -type SchemaConfig struct { - Query *Object - Mutation *Object - Subscription *Object - Types []Type - Directives []*Directive -} - -type TypeMap map[string]Type - -// Schema Definition -// A Schema is created by supplying the root types of each type of operation, -// query, mutation (optional) and subscription (optional). A schema definition is then supplied to the -// validator and executor. -// Example: -// myAppSchema, err := NewSchema(SchemaConfig({ -// Query: MyAppQueryRootType, -// Mutation: MyAppMutationRootType, -// Subscription: MyAppSubscriptionRootType, -// }); -// Note: If an array of `directives` are provided to GraphQLSchema, that will be -// the exact list of directives represented and allowed. If `directives` is not -// provided then a default set of the specified directives (e.g. @include and -// @skip) will be used. If you wish to provide *additional* directives to these -// specified directives, you must explicitly declare them. Example: -// -// const MyAppSchema = new GraphQLSchema({ -// ... -// directives: specifiedDirectives.concat([ myCustomDirective ]), -// }) -type Schema struct { - typeMap TypeMap - directives []*Directive - - queryType *Object - mutationType *Object - subscriptionType *Object - implementations map[string][]*Object - possibleTypeMap map[string]map[string]bool -} - -func NewSchema(config SchemaConfig) (Schema, error) { - var err error - - schema := Schema{} - - err = invariant(config.Query != nil, "Schema query must be Object Type but got: nil.") - if err != nil { - return schema, err - } - - // if schema config contains error at creation time, return those errors - if config.Query != nil && config.Query.err != nil { - return schema, config.Query.err - } - if config.Mutation != nil && config.Mutation.err != nil { - return schema, config.Mutation.err - } - - schema.queryType = config.Query - schema.mutationType = config.Mutation - schema.subscriptionType = config.Subscription - - // Provide specified directives (e.g. @include and @skip) by default. - schema.directives = config.Directives - if len(schema.directives) == 0 { - schema.directives = SpecifiedDirectives - } - // Ensure directive definitions are error-free - for _, dir := range schema.directives { - if dir.err != nil { - return schema, dir.err - } - } - - // Build type map now to detect any errors within this schema. - typeMap := TypeMap{} - initialTypes := []Type{} - if schema.QueryType() != nil { - initialTypes = append(initialTypes, schema.QueryType()) - } - if schema.MutationType() != nil { - initialTypes = append(initialTypes, schema.MutationType()) - } - if schema.SubscriptionType() != nil { - initialTypes = append(initialTypes, schema.SubscriptionType()) - } - if SchemaType != nil { - initialTypes = append(initialTypes, SchemaType) - } - - for _, ttype := range config.Types { - // assume that user will never add a nil object to config - initialTypes = append(initialTypes, ttype) - } - - for _, ttype := range initialTypes { - if ttype.Error() != nil { - return schema, ttype.Error() - } - typeMap, err = typeMapReducer(&schema, typeMap, ttype) - if err != nil { - return schema, err - } - } - - schema.typeMap = typeMap - - // Keep track of all implementations by interface name. - if schema.implementations == nil { - schema.implementations = map[string][]*Object{} - } - for _, ttype := range schema.typeMap { - if ttype, ok := ttype.(*Object); ok { - for _, iface := range ttype.Interfaces() { - impls, ok := schema.implementations[iface.Name()] - if impls == nil || !ok { - impls = []*Object{} - } - impls = append(impls, ttype) - schema.implementations[iface.Name()] = impls - } - } - } - - // Enforce correct interface implementations - for _, ttype := range schema.typeMap { - if ttype, ok := ttype.(*Object); ok { - for _, iface := range ttype.Interfaces() { - err := assertObjectImplementsInterface(&schema, ttype, iface) - if err != nil { - return schema, err - } - } - } - } - - return schema, nil -} - - - -//Added Check implementation of interfaces at runtime.. -//Add Implementations at Runtime.. -func (gq *Schema) AddImplementation() error{ - - // Keep track of all implementations by interface name. - if gq.implementations == nil { - gq.implementations = map[string][]*Object{} - } - for _, ttype := range gq.typeMap { - if ttype, ok := ttype.(*Object); ok { - for _, iface := range ttype.Interfaces() { - impls, ok := gq.implementations[iface.Name()] - if impls == nil || !ok { - impls = []*Object{} - } - impls = append(impls, ttype) - gq.implementations[iface.Name()] = impls - } - } - } - - // Enforce correct interface implementations - for _, ttype := range gq.typeMap { - if ttype, ok := ttype.(*Object); ok { - for _, iface := range ttype.Interfaces() { - err := assertObjectImplementsInterface(gq, ttype, iface) - if err != nil { - return err - } - } - } - } - - return nil -} - - -//Edited. To check add Types at RunTime.. -//Append Runtime schema to typeMap -func (gq *Schema)AppendType(objectType Type) error { - if objectType.Error() != nil { - return objectType.Error() - } - var err error - gq.typeMap, err = typeMapReducer(gq, gq.typeMap, objectType) - if err != nil { - return err - } - //Now Add interface implementation.. - return gq.AddImplementation() -} - - - - -func (gq *Schema) QueryType() *Object { - return gq.queryType -} - -func (gq *Schema) MutationType() *Object { - return gq.mutationType -} - -func (gq *Schema) SubscriptionType() *Object { - return gq.subscriptionType -} - -func (gq *Schema) Directives() []*Directive { - return gq.directives -} - -func (gq *Schema) Directive(name string) *Directive { - for _, directive := range gq.Directives() { - if directive.Name == name { - return directive - } - } - return nil -} - -func (gq *Schema) TypeMap() TypeMap { - return gq.typeMap -} - -func (gq *Schema) Type(name string) Type { - return gq.TypeMap()[name] -} - -func (gq *Schema) PossibleTypes(abstractType Abstract) []*Object { - if abstractType, ok := abstractType.(*Union); ok { - return abstractType.Types() - } - if abstractType, ok := abstractType.(*Interface); ok { - if impls, ok := gq.implementations[abstractType.Name()]; ok { - return impls - } - } - return []*Object{} -} -func (gq *Schema) IsPossibleType(abstractType Abstract, possibleType *Object) bool { - possibleTypeMap := gq.possibleTypeMap - if possibleTypeMap == nil { - possibleTypeMap = map[string]map[string]bool{} - } - - if typeMap, ok := possibleTypeMap[abstractType.Name()]; !ok { - typeMap = map[string]bool{} - for _, possibleType := range gq.PossibleTypes(abstractType) { - typeMap[possibleType.Name()] = true - } - possibleTypeMap[abstractType.Name()] = typeMap - } - - gq.possibleTypeMap = possibleTypeMap - if typeMap, ok := possibleTypeMap[abstractType.Name()]; ok { - isPossible, _ := typeMap[possibleType.Name()] - return isPossible - } - return false -} -func typeMapReducer(schema *Schema, typeMap TypeMap, objectType Type) (TypeMap, error) { - var err error - if objectType == nil || objectType.Name() == "" { - return typeMap, nil - } - - switch objectType := objectType.(type) { - case *List: - if objectType.OfType != nil { - return typeMapReducer(schema, typeMap, objectType.OfType) - } - case *NonNull: - if objectType.OfType != nil { - return typeMapReducer(schema, typeMap, objectType.OfType) - } - case *Object: - if objectType.err != nil { - return typeMap, objectType.err - } - } - - if mappedObjectType, ok := typeMap[objectType.Name()]; ok { - err = invariantf( - mappedObjectType == objectType, - `Schema must contain unique named types but contains multiple types named "%v".`, objectType.Name()) - - if err != nil { - return typeMap, err - } - return typeMap, err - } - if objectType.Name() == "" { - return typeMap, nil - } - - typeMap[objectType.Name()] = objectType - - switch objectType := objectType.(type) { - case *Union: - types := schema.PossibleTypes(objectType) - if objectType.err != nil { - return typeMap, objectType.err - } - for _, innerObjectType := range types { - if innerObjectType.err != nil { - return typeMap, innerObjectType.err - } - typeMap, err = typeMapReducer(schema, typeMap, innerObjectType) - if err != nil { - return typeMap, err - } - } - case *Interface: - types := schema.PossibleTypes(objectType) - if objectType.err != nil { - return typeMap, objectType.err - } - for _, innerObjectType := range types { - if innerObjectType.err != nil { - return typeMap, innerObjectType.err - } - typeMap, err = typeMapReducer(schema, typeMap, innerObjectType) - if err != nil { - return typeMap, err - } - } - case *Object: - interfaces := objectType.Interfaces() - if objectType.err != nil { - return typeMap, objectType.err - } - for _, innerObjectType := range interfaces { - if innerObjectType.err != nil { - return typeMap, innerObjectType.err - } - typeMap, err = typeMapReducer(schema, typeMap, innerObjectType) - if err != nil { - return typeMap, err - } - } - } - - switch objectType := objectType.(type) { - case *Object: - fieldMap := objectType.Fields() - if objectType.err != nil { - return typeMap, objectType.err - } - for _, field := range fieldMap { - for _, arg := range field.Args { - typeMap, err = typeMapReducer(schema, typeMap, arg.Type) - if err != nil { - return typeMap, err - } - } - typeMap, err = typeMapReducer(schema, typeMap, field.Type) - if err != nil { - return typeMap, err - } - } - case *Interface: - fieldMap := objectType.Fields() - if objectType.err != nil { - return typeMap, objectType.err - } - for _, field := range fieldMap { - for _, arg := range field.Args { - typeMap, err = typeMapReducer(schema, typeMap, arg.Type) - if err != nil { - return typeMap, err - } - } - typeMap, err = typeMapReducer(schema, typeMap, field.Type) - if err != nil { - return typeMap, err - } - } - case *InputObject: - fieldMap := objectType.Fields() - if objectType.err != nil { - return typeMap, objectType.err - } - for _, field := range fieldMap { - typeMap, err = typeMapReducer(schema, typeMap, field.Type) - if err != nil { - return typeMap, err - } - } - } - return typeMap, nil -} - -func assertObjectImplementsInterface(schema *Schema, object *Object, iface *Interface) error { - objectFieldMap := object.Fields() - ifaceFieldMap := iface.Fields() - - // Assert each interface field is implemented. - for fieldName := range ifaceFieldMap { - objectField := objectFieldMap[fieldName] - ifaceField := ifaceFieldMap[fieldName] - - // Assert interface field exists on object. - err := invariantf( - objectField != nil, - `"%v" expects field "%v" but "%v" does not `+ - `provide it.`, iface, fieldName, object) - - if err != nil { - return err - } - - // Assert interface field type is satisfied by object field type, by being - // a valid subtype. (covariant) - err = invariant( - isTypeSubTypeOf(schema, objectField.Type, ifaceField.Type), - fmt.Sprintf(`%v.%v expects type "%v" but `+ - `%v.%v provides type "%v".`, - iface, fieldName, ifaceField.Type, - object, fieldName, objectField.Type), - ) - if err != nil { - return err - } - - // Assert each interface field arg is implemented. - for _, ifaceArg := range ifaceField.Args { - argName := ifaceArg.PrivateName - var objectArg *Argument - for _, arg := range objectField.Args { - if arg.PrivateName == argName { - objectArg = arg - break - } - } - // Assert interface field arg exists on object field. - err = invariant( - objectArg != nil, - fmt.Sprintf(`%v.%v expects argument "%v" but `+ - `%v.%v does not provide it.`, - iface, fieldName, argName, - object, fieldName), - ) - if err != nil { - return err - } - - // Assert interface field arg type matches object field arg type. - // (invariant) - err = invariant( - isEqualType(ifaceArg.Type, objectArg.Type), - fmt.Sprintf( - `%v.%v(%v:) expects type "%v" `+ - `but %v.%v(%v:) provides `+ - `type "%v".`, - iface, fieldName, argName, ifaceArg.Type, - object, fieldName, argName, objectArg.Type), - ) - if err != nil { - return err - } - } - // Assert additional arguments must not be required. - for _, objectArg := range objectField.Args { - argName := objectArg.PrivateName - var ifaceArg *Argument - for _, arg := range ifaceField.Args { - if arg.PrivateName == argName { - ifaceArg = arg - break - } - } - - if ifaceArg == nil { - _, ok := objectArg.Type.(*NonNull) - err = invariant( - !ok, - fmt.Sprintf(`%v.%v(%v:) is of required type `+ - `"%v" but is not also provided by the interface %v.%v.`, - object, fieldName, argName, - objectArg.Type, iface, fieldName), - ) - if err != nil { - return err - } - } - } - } - return nil -} - -func isEqualType(typeA Type, typeB Type) bool { - // Equivalent type is a valid subtype - if typeA == typeB { - return true - } - // If either type is non-null, the other must also be non-null. - if typeA, ok := typeA.(*NonNull); ok { - if typeB, ok := typeB.(*NonNull); ok { - return isEqualType(typeA.OfType, typeB.OfType) - } - } - // If either type is a list, the other must also be a list. - if typeA, ok := typeA.(*List); ok { - if typeB, ok := typeB.(*List); ok { - return isEqualType(typeA.OfType, typeB.OfType) - } - } - // Otherwise the types are not equal. - return false -} - -// isTypeSubTypeOf Provided a type and a super type, return true if the first type is either -// equal or a subset of the second super type (covariant). -func isTypeSubTypeOf(schema *Schema, maybeSubType Type, superType Type) bool { - // Equivalent type is a valid subtype - if maybeSubType == superType { - return true - } - - // If superType is non-null, maybeSubType must also be nullable. - if superType, ok := superType.(*NonNull); ok { - if maybeSubType, ok := maybeSubType.(*NonNull); ok { - return isTypeSubTypeOf(schema, maybeSubType.OfType, superType.OfType) - } - return false - } - if maybeSubType, ok := maybeSubType.(*NonNull); ok { - // If superType is nullable, maybeSubType may be non-null. - return isTypeSubTypeOf(schema, maybeSubType.OfType, superType) - } - - // If superType type is a list, maybeSubType type must also be a list. - if superType, ok := superType.(*List); ok { - if maybeSubType, ok := maybeSubType.(*List); ok { - return isTypeSubTypeOf(schema, maybeSubType.OfType, superType.OfType) - } - return false - } else if _, ok := maybeSubType.(*List); ok { - // If superType is not a list, maybeSubType must also be not a list. - return false - } - - // If superType type is an abstract type, maybeSubType type may be a currently - // possible object type. - if superType, ok := superType.(*Interface); ok { - if maybeSubType, ok := maybeSubType.(*Object); ok && schema.IsPossibleType(superType, maybeSubType) { - return true - } - } - if superType, ok := superType.(*Union); ok { - if maybeSubType, ok := maybeSubType.(*Object); ok && schema.IsPossibleType(superType, maybeSubType) { - return true - } - } - - // Otherwise, the child type is not a valid subtype of the parent type. - return false -} |