git.sr.ht/~sircmpwn/gqlgen@v0.0.0-20200522192042-c84d29a1c940/codegen/testserver/resolver.go (about)

     1  package testserver
     2  
     3  // THIS CODE IS A STARTING POINT ONLY. IT WILL NOT BE UPDATED WITH SCHEMA CHANGES.
     4  
     5  import (
     6  	"context"
     7  
     8  	introspection1 "git.sr.ht/~sircmpwn/gqlgen/codegen/testserver/introspection"
     9  	invalid_packagename "git.sr.ht/~sircmpwn/gqlgen/codegen/testserver/invalid-packagename"
    10  )
    11  
    12  type Resolver struct{}
    13  
    14  func (r *backedByInterfaceResolver) ID(ctx context.Context, obj BackedByInterface) (string, error) {
    15  	panic("not implemented")
    16  }
    17  
    18  func (r *errorsResolver) A(ctx context.Context, obj *Errors) (*Error, error) {
    19  	panic("not implemented")
    20  }
    21  
    22  func (r *errorsResolver) B(ctx context.Context, obj *Errors) (*Error, error) {
    23  	panic("not implemented")
    24  }
    25  
    26  func (r *errorsResolver) C(ctx context.Context, obj *Errors) (*Error, error) {
    27  	panic("not implemented")
    28  }
    29  
    30  func (r *errorsResolver) D(ctx context.Context, obj *Errors) (*Error, error) {
    31  	panic("not implemented")
    32  }
    33  
    34  func (r *errorsResolver) E(ctx context.Context, obj *Errors) (*Error, error) {
    35  	panic("not implemented")
    36  }
    37  
    38  func (r *forcedResolverResolver) Field(ctx context.Context, obj *ForcedResolver) (*Circle, error) {
    39  	panic("not implemented")
    40  }
    41  
    42  func (r *modelMethodsResolver) ResolverField(ctx context.Context, obj *ModelMethods) (bool, error) {
    43  	panic("not implemented")
    44  }
    45  
    46  func (r *overlappingFieldsResolver) OldFoo(ctx context.Context, obj *OverlappingFields) (int, error) {
    47  	panic("not implemented")
    48  }
    49  
    50  func (r *panicsResolver) FieldScalarMarshal(ctx context.Context, obj *Panics) ([]MarshalPanic, error) {
    51  	panic("not implemented")
    52  }
    53  
    54  func (r *panicsResolver) ArgUnmarshal(ctx context.Context, obj *Panics, u []MarshalPanic) (bool, error) {
    55  	panic("not implemented")
    56  }
    57  
    58  func (r *primitiveResolver) Value(ctx context.Context, obj *Primitive) (int, error) {
    59  	panic("not implemented")
    60  }
    61  
    62  func (r *primitiveStringResolver) Value(ctx context.Context, obj *PrimitiveString) (string, error) {
    63  	panic("not implemented")
    64  }
    65  
    66  func (r *primitiveStringResolver) Len(ctx context.Context, obj *PrimitiveString) (int, error) {
    67  	panic("not implemented")
    68  }
    69  
    70  func (r *queryResolver) InvalidIdentifier(ctx context.Context) (*invalid_packagename.InvalidIdentifier, error) {
    71  	panic("not implemented")
    72  }
    73  
    74  func (r *queryResolver) Collision(ctx context.Context) (*introspection1.It, error) {
    75  	panic("not implemented")
    76  }
    77  
    78  func (r *queryResolver) MapInput(ctx context.Context, input map[string]interface{}) (*bool, error) {
    79  	panic("not implemented")
    80  }
    81  
    82  func (r *queryResolver) Recursive(ctx context.Context, input *RecursiveInputSlice) (*bool, error) {
    83  	panic("not implemented")
    84  }
    85  
    86  func (r *queryResolver) NestedInputs(ctx context.Context, input [][]*OuterInput) (*bool, error) {
    87  	panic("not implemented")
    88  }
    89  
    90  func (r *queryResolver) NestedOutputs(ctx context.Context) ([][]*OuterObject, error) {
    91  	panic("not implemented")
    92  }
    93  
    94  func (r *queryResolver) ModelMethods(ctx context.Context) (*ModelMethods, error) {
    95  	panic("not implemented")
    96  }
    97  
    98  func (r *queryResolver) User(ctx context.Context, id int) (*User, error) {
    99  	panic("not implemented")
   100  }
   101  
   102  func (r *queryResolver) NullableArg(ctx context.Context, arg *int) (*string, error) {
   103  	panic("not implemented")
   104  }
   105  
   106  func (r *queryResolver) InputSlice(ctx context.Context, arg []string) (bool, error) {
   107  	panic("not implemented")
   108  }
   109  
   110  func (r *queryResolver) ShapeUnion(ctx context.Context) (ShapeUnion, error) {
   111  	panic("not implemented")
   112  }
   113  
   114  func (r *queryResolver) Autobind(ctx context.Context) (*Autobind, error) {
   115  	panic("not implemented")
   116  }
   117  
   118  func (r *queryResolver) DeprecatedField(ctx context.Context) (string, error) {
   119  	panic("not implemented")
   120  }
   121  
   122  func (r *queryResolver) Overlapping(ctx context.Context) (*OverlappingFields, error) {
   123  	panic("not implemented")
   124  }
   125  
   126  func (r *queryResolver) DirectiveArg(ctx context.Context, arg string) (*string, error) {
   127  	panic("not implemented")
   128  }
   129  
   130  func (r *queryResolver) DirectiveNullableArg(ctx context.Context, arg *int, arg2 *int, arg3 *string) (*string, error) {
   131  	panic("not implemented")
   132  }
   133  
   134  func (r *queryResolver) DirectiveInputNullable(ctx context.Context, arg *InputDirectives) (*string, error) {
   135  	panic("not implemented")
   136  }
   137  
   138  func (r *queryResolver) DirectiveInput(ctx context.Context, arg InputDirectives) (*string, error) {
   139  	panic("not implemented")
   140  }
   141  
   142  func (r *queryResolver) DirectiveInputType(ctx context.Context, arg InnerInput) (*string, error) {
   143  	panic("not implemented")
   144  }
   145  
   146  func (r *queryResolver) DirectiveObject(ctx context.Context) (*ObjectDirectives, error) {
   147  	panic("not implemented")
   148  }
   149  
   150  func (r *queryResolver) DirectiveObjectWithCustomGoModel(ctx context.Context) (*ObjectDirectivesWithCustomGoModel, error) {
   151  	panic("not implemented")
   152  }
   153  
   154  func (r *queryResolver) DirectiveFieldDef(ctx context.Context, ret string) (string, error) {
   155  	panic("not implemented")
   156  }
   157  
   158  func (r *queryResolver) DirectiveField(ctx context.Context) (*string, error) {
   159  	panic("not implemented")
   160  }
   161  
   162  func (r *queryResolver) DirectiveDouble(ctx context.Context) (*string, error) {
   163  	panic("not implemented")
   164  }
   165  
   166  func (r *queryResolver) DirectiveUnimplemented(ctx context.Context) (*string, error) {
   167  	panic("not implemented")
   168  }
   169  
   170  func (r *queryResolver) EmbeddedCase1(ctx context.Context) (*EmbeddedCase1, error) {
   171  	panic("not implemented")
   172  }
   173  
   174  func (r *queryResolver) EmbeddedCase2(ctx context.Context) (*EmbeddedCase2, error) {
   175  	panic("not implemented")
   176  }
   177  
   178  func (r *queryResolver) EmbeddedCase3(ctx context.Context) (*EmbeddedCase3, error) {
   179  	panic("not implemented")
   180  }
   181  
   182  func (r *queryResolver) EnumInInput(ctx context.Context, input *InputWithEnumValue) (EnumTest, error) {
   183  	panic("not implemented")
   184  }
   185  
   186  func (r *queryResolver) Shapes(ctx context.Context) ([]Shape, error) {
   187  	panic("not implemented")
   188  }
   189  
   190  func (r *queryResolver) NoShape(ctx context.Context) (Shape, error) {
   191  	panic("not implemented")
   192  }
   193  
   194  func (r *queryResolver) Node(ctx context.Context) (Node, error) {
   195  	panic("not implemented")
   196  }
   197  
   198  func (r *queryResolver) NoShapeTypedNil(ctx context.Context) (Shape, error) {
   199  	panic("not implemented")
   200  }
   201  
   202  func (r *queryResolver) Animal(ctx context.Context) (Animal, error) {
   203  	panic("not implemented")
   204  }
   205  
   206  func (r *queryResolver) NotAnInterface(ctx context.Context) (BackedByInterface, error) {
   207  	panic("not implemented")
   208  }
   209  
   210  func (r *queryResolver) Issue896a(ctx context.Context) ([]*CheckIssue896, error) {
   211  	panic("not implemented")
   212  }
   213  
   214  func (r *queryResolver) MapStringInterface(ctx context.Context, in map[string]interface{}) (map[string]interface{}, error) {
   215  	panic("not implemented")
   216  }
   217  
   218  func (r *queryResolver) MapNestedStringInterface(ctx context.Context, in *NestedMapInput) (map[string]interface{}, error) {
   219  	panic("not implemented")
   220  }
   221  
   222  func (r *queryResolver) ErrorBubble(ctx context.Context) (*Error, error) {
   223  	panic("not implemented")
   224  }
   225  
   226  func (r *queryResolver) Errors(ctx context.Context) (*Errors, error) {
   227  	panic("not implemented")
   228  }
   229  
   230  func (r *queryResolver) Valid(ctx context.Context) (string, error) {
   231  	panic("not implemented")
   232  }
   233  
   234  func (r *queryResolver) Panics(ctx context.Context) (*Panics, error) {
   235  	panic("not implemented")
   236  }
   237  
   238  func (r *queryResolver) PrimitiveObject(ctx context.Context) ([]Primitive, error) {
   239  	panic("not implemented")
   240  }
   241  
   242  func (r *queryResolver) PrimitiveStringObject(ctx context.Context) ([]PrimitiveString, error) {
   243  	panic("not implemented")
   244  }
   245  
   246  func (r *queryResolver) DefaultScalar(ctx context.Context, arg string) (string, error) {
   247  	panic("not implemented")
   248  }
   249  
   250  func (r *queryResolver) Slices(ctx context.Context) (*Slices, error) {
   251  	panic("not implemented")
   252  }
   253  
   254  func (r *queryResolver) ScalarSlice(ctx context.Context) ([]byte, error) {
   255  	panic("not implemented")
   256  }
   257  
   258  func (r *queryResolver) Fallback(ctx context.Context, arg FallbackToStringEncoding) (FallbackToStringEncoding, error) {
   259  	panic("not implemented")
   260  }
   261  
   262  func (r *queryResolver) OptionalUnion(ctx context.Context) (TestUnion, error) {
   263  	panic("not implemented")
   264  }
   265  
   266  func (r *queryResolver) ValidType(ctx context.Context) (*ValidType, error) {
   267  	panic("not implemented")
   268  }
   269  
   270  func (r *queryResolver) WrappedStruct(ctx context.Context) (*WrappedStruct, error) {
   271  	panic("not implemented")
   272  }
   273  
   274  func (r *queryResolver) WrappedScalar(ctx context.Context) (WrappedScalar, error) {
   275  	panic("not implemented")
   276  }
   277  
   278  func (r *subscriptionResolver) Updated(ctx context.Context) (<-chan string, error) {
   279  	panic("not implemented")
   280  }
   281  
   282  func (r *subscriptionResolver) InitPayload(ctx context.Context) (<-chan string, error) {
   283  	panic("not implemented")
   284  }
   285  
   286  func (r *subscriptionResolver) DirectiveArg(ctx context.Context, arg string) (<-chan *string, error) {
   287  	panic("not implemented")
   288  }
   289  
   290  func (r *subscriptionResolver) DirectiveNullableArg(ctx context.Context, arg *int, arg2 *int, arg3 *string) (<-chan *string, error) {
   291  	panic("not implemented")
   292  }
   293  
   294  func (r *subscriptionResolver) DirectiveDouble(ctx context.Context) (<-chan *string, error) {
   295  	panic("not implemented")
   296  }
   297  
   298  func (r *subscriptionResolver) DirectiveUnimplemented(ctx context.Context) (<-chan *string, error) {
   299  	panic("not implemented")
   300  }
   301  
   302  func (r *subscriptionResolver) Issue896b(ctx context.Context) (<-chan []*CheckIssue896, error) {
   303  	panic("not implemented")
   304  }
   305  
   306  func (r *userResolver) Friends(ctx context.Context, obj *User) ([]*User, error) {
   307  	panic("not implemented")
   308  }
   309  
   310  // BackedByInterface returns BackedByInterfaceResolver implementation.
   311  func (r *Resolver) BackedByInterface() BackedByInterfaceResolver { return &backedByInterfaceResolver{r} }
   312  
   313  // Errors returns ErrorsResolver implementation.
   314  func (r *Resolver) Errors() ErrorsResolver { return &errorsResolver{r} }
   315  
   316  // ForcedResolver returns ForcedResolverResolver implementation.
   317  func (r *Resolver) ForcedResolver() ForcedResolverResolver { return &forcedResolverResolver{r} }
   318  
   319  // ModelMethods returns ModelMethodsResolver implementation.
   320  func (r *Resolver) ModelMethods() ModelMethodsResolver { return &modelMethodsResolver{r} }
   321  
   322  // OverlappingFields returns OverlappingFieldsResolver implementation.
   323  func (r *Resolver) OverlappingFields() OverlappingFieldsResolver { return &overlappingFieldsResolver{r} }
   324  
   325  // Panics returns PanicsResolver implementation.
   326  func (r *Resolver) Panics() PanicsResolver { return &panicsResolver{r} }
   327  
   328  // Primitive returns PrimitiveResolver implementation.
   329  func (r *Resolver) Primitive() PrimitiveResolver { return &primitiveResolver{r} }
   330  
   331  // PrimitiveString returns PrimitiveStringResolver implementation.
   332  func (r *Resolver) PrimitiveString() PrimitiveStringResolver { return &primitiveStringResolver{r} }
   333  
   334  // Query returns QueryResolver implementation.
   335  func (r *Resolver) Query() QueryResolver { return &queryResolver{r} }
   336  
   337  // Subscription returns SubscriptionResolver implementation.
   338  func (r *Resolver) Subscription() SubscriptionResolver { return &subscriptionResolver{r} }
   339  
   340  // User returns UserResolver implementation.
   341  func (r *Resolver) User() UserResolver { return &userResolver{r} }
   342  
   343  type backedByInterfaceResolver struct{ *Resolver }
   344  type errorsResolver struct{ *Resolver }
   345  type forcedResolverResolver struct{ *Resolver }
   346  type modelMethodsResolver struct{ *Resolver }
   347  type overlappingFieldsResolver struct{ *Resolver }
   348  type panicsResolver struct{ *Resolver }
   349  type primitiveResolver struct{ *Resolver }
   350  type primitiveStringResolver struct{ *Resolver }
   351  type queryResolver struct{ *Resolver }
   352  type subscriptionResolver struct{ *Resolver }
   353  type userResolver struct{ *Resolver }