github.com/operandinc/gqlgen@v0.16.1/codegen/testserver/followschema/resolver.go (about)

     1  package followschema
     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 "github.com/operandinc/gqlgen/codegen/testserver/followschema/introspection"
     9  	invalid_packagename "github.com/operandinc/gqlgen/codegen/testserver/followschema/invalid-packagename"
    10  	"github.com/operandinc/gqlgen/codegen/testserver/followschema/otherpkg"
    11  )
    12  
    13  type Resolver struct{}
    14  
    15  func (r *backedByInterfaceResolver) ID(ctx context.Context, obj BackedByInterface) (string, error) {
    16  	panic("not implemented")
    17  }
    18  
    19  func (r *errorsResolver) A(ctx context.Context, obj *Errors) (*Error, error) {
    20  	panic("not implemented")
    21  }
    22  
    23  func (r *errorsResolver) B(ctx context.Context, obj *Errors) (*Error, error) {
    24  	panic("not implemented")
    25  }
    26  
    27  func (r *errorsResolver) C(ctx context.Context, obj *Errors) (*Error, error) {
    28  	panic("not implemented")
    29  }
    30  
    31  func (r *errorsResolver) D(ctx context.Context, obj *Errors) (*Error, error) {
    32  	panic("not implemented")
    33  }
    34  
    35  func (r *errorsResolver) E(ctx context.Context, obj *Errors) (*Error, error) {
    36  	panic("not implemented")
    37  }
    38  
    39  func (r *forcedResolverResolver) Field(ctx context.Context, obj *ForcedResolver) (*Circle, error) {
    40  	panic("not implemented")
    41  }
    42  
    43  func (r *modelMethodsResolver) ResolverField(ctx context.Context, obj *ModelMethods) (bool, error) {
    44  	panic("not implemented")
    45  }
    46  
    47  func (r *mutationResolver) DefaultInput(ctx context.Context, input DefaultInput) (*DefaultParametersMirror, error) {
    48  	panic("not implemented")
    49  }
    50  
    51  func (r *mutationResolver) UpdateSomething(ctx context.Context, input SpecialInput) (string, error) {
    52  	panic("not implemented")
    53  }
    54  
    55  func (r *mutationResolver) UpdatePtrToPtr(ctx context.Context, input UpdatePtrToPtrOuter) (*PtrToPtrOuter, error) {
    56  	panic("not implemented")
    57  }
    58  
    59  func (r *overlappingFieldsResolver) OldFoo(ctx context.Context, obj *OverlappingFields) (int, error) {
    60  	panic("not implemented")
    61  }
    62  
    63  func (r *panicsResolver) FieldScalarMarshal(ctx context.Context, obj *Panics) ([]MarshalPanic, error) {
    64  	panic("not implemented")
    65  }
    66  
    67  func (r *panicsResolver) ArgUnmarshal(ctx context.Context, obj *Panics, u []MarshalPanic) (bool, error) {
    68  	panic("not implemented")
    69  }
    70  
    71  func (r *primitiveResolver) Value(ctx context.Context, obj *Primitive) (int, error) {
    72  	panic("not implemented")
    73  }
    74  
    75  func (r *primitiveStringResolver) Value(ctx context.Context, obj *PrimitiveString) (string, error) {
    76  	panic("not implemented")
    77  }
    78  
    79  func (r *primitiveStringResolver) Len(ctx context.Context, obj *PrimitiveString) (int, error) {
    80  	panic("not implemented")
    81  }
    82  
    83  func (r *queryResolver) InvalidIdentifier(ctx context.Context) (*invalid_packagename.InvalidIdentifier, error) {
    84  	panic("not implemented")
    85  }
    86  
    87  func (r *queryResolver) Collision(ctx context.Context) (*introspection1.It, error) {
    88  	panic("not implemented")
    89  }
    90  
    91  func (r *queryResolver) MapInput(ctx context.Context, input map[string]interface{}) (*bool, error) {
    92  	panic("not implemented")
    93  }
    94  
    95  func (r *queryResolver) Recursive(ctx context.Context, input *RecursiveInputSlice) (*bool, error) {
    96  	panic("not implemented")
    97  }
    98  
    99  func (r *queryResolver) NestedInputs(ctx context.Context, input [][]*OuterInput) (*bool, error) {
   100  	panic("not implemented")
   101  }
   102  
   103  func (r *queryResolver) NestedOutputs(ctx context.Context) ([][]*OuterObject, error) {
   104  	panic("not implemented")
   105  }
   106  
   107  func (r *queryResolver) ModelMethods(ctx context.Context) (*ModelMethods, error) {
   108  	panic("not implemented")
   109  }
   110  
   111  func (r *queryResolver) User(ctx context.Context, id int) (*User, error) {
   112  	panic("not implemented")
   113  }
   114  
   115  func (r *queryResolver) NullableArg(ctx context.Context, arg *int) (*string, error) {
   116  	panic("not implemented")
   117  }
   118  
   119  func (r *queryResolver) InputSlice(ctx context.Context, arg []string) (bool, error) {
   120  	panic("not implemented")
   121  }
   122  
   123  func (r *queryResolver) InputNullableSlice(ctx context.Context, arg []string) (bool, error) {
   124  	panic("not implemented")
   125  }
   126  
   127  func (r *queryResolver) ShapeUnion(ctx context.Context) (ShapeUnion, error) {
   128  	panic("not implemented")
   129  }
   130  
   131  func (r *queryResolver) Autobind(ctx context.Context) (*Autobind, error) {
   132  	panic("not implemented")
   133  }
   134  
   135  func (r *queryResolver) DeprecatedField(ctx context.Context) (string, error) {
   136  	panic("not implemented")
   137  }
   138  
   139  func (r *queryResolver) Overlapping(ctx context.Context) (*OverlappingFields, error) {
   140  	panic("not implemented")
   141  }
   142  
   143  func (r *queryResolver) DefaultParameters(ctx context.Context, falsyBoolean *bool, truthyBoolean *bool) (*DefaultParametersMirror, error) {
   144  	panic("not implemented")
   145  }
   146  
   147  func (r *queryResolver) DirectiveArg(ctx context.Context, arg string) (*string, error) {
   148  	panic("not implemented")
   149  }
   150  
   151  func (r *queryResolver) DirectiveNullableArg(ctx context.Context, arg *int, arg2 *int, arg3 *string) (*string, error) {
   152  	panic("not implemented")
   153  }
   154  
   155  func (r *queryResolver) DirectiveInputNullable(ctx context.Context, arg *InputDirectives) (*string, error) {
   156  	panic("not implemented")
   157  }
   158  
   159  func (r *queryResolver) DirectiveInput(ctx context.Context, arg InputDirectives) (*string, error) {
   160  	panic("not implemented")
   161  }
   162  
   163  func (r *queryResolver) DirectiveInputType(ctx context.Context, arg InnerInput) (*string, error) {
   164  	panic("not implemented")
   165  }
   166  
   167  func (r *queryResolver) DirectiveObject(ctx context.Context) (*ObjectDirectives, error) {
   168  	panic("not implemented")
   169  }
   170  
   171  func (r *queryResolver) DirectiveObjectWithCustomGoModel(ctx context.Context) (*ObjectDirectivesWithCustomGoModel, error) {
   172  	panic("not implemented")
   173  }
   174  
   175  func (r *queryResolver) DirectiveFieldDef(ctx context.Context, ret string) (string, error) {
   176  	panic("not implemented")
   177  }
   178  
   179  func (r *queryResolver) DirectiveField(ctx context.Context) (*string, error) {
   180  	panic("not implemented")
   181  }
   182  
   183  func (r *queryResolver) DirectiveDouble(ctx context.Context) (*string, error) {
   184  	panic("not implemented")
   185  }
   186  
   187  func (r *queryResolver) DirectiveUnimplemented(ctx context.Context) (*string, error) {
   188  	panic("not implemented")
   189  }
   190  
   191  func (r *queryResolver) EmbeddedCase1(ctx context.Context) (*EmbeddedCase1, error) {
   192  	panic("not implemented")
   193  }
   194  
   195  func (r *queryResolver) EmbeddedCase2(ctx context.Context) (*EmbeddedCase2, error) {
   196  	panic("not implemented")
   197  }
   198  
   199  func (r *queryResolver) EmbeddedCase3(ctx context.Context) (*EmbeddedCase3, error) {
   200  	panic("not implemented")
   201  }
   202  
   203  func (r *queryResolver) EnumInInput(ctx context.Context, input *InputWithEnumValue) (EnumTest, error) {
   204  	panic("not implemented")
   205  }
   206  
   207  func (r *queryResolver) Shapes(ctx context.Context) ([]Shape, error) {
   208  	panic("not implemented")
   209  }
   210  
   211  func (r *queryResolver) NoShape(ctx context.Context) (Shape, error) {
   212  	panic("not implemented")
   213  }
   214  
   215  func (r *queryResolver) Node(ctx context.Context) (Node, error) {
   216  	panic("not implemented")
   217  }
   218  
   219  func (r *queryResolver) NoShapeTypedNil(ctx context.Context) (Shape, error) {
   220  	panic("not implemented")
   221  }
   222  
   223  func (r *queryResolver) Animal(ctx context.Context) (Animal, error) {
   224  	panic("not implemented")
   225  }
   226  
   227  func (r *queryResolver) NotAnInterface(ctx context.Context) (BackedByInterface, error) {
   228  	panic("not implemented")
   229  }
   230  
   231  func (r *queryResolver) Issue896a(ctx context.Context) ([]*CheckIssue896, error) {
   232  	panic("not implemented")
   233  }
   234  
   235  func (r *queryResolver) MapStringInterface(ctx context.Context, in map[string]interface{}) (map[string]interface{}, error) {
   236  	panic("not implemented")
   237  }
   238  
   239  func (r *queryResolver) MapNestedStringInterface(ctx context.Context, in *NestedMapInput) (map[string]interface{}, error) {
   240  	panic("not implemented")
   241  }
   242  
   243  func (r *queryResolver) ErrorBubble(ctx context.Context) (*Error, error) {
   244  	panic("not implemented")
   245  }
   246  
   247  func (r *queryResolver) ErrorBubbleList(ctx context.Context) ([]*Error, error) {
   248  	panic("not implemented")
   249  }
   250  
   251  func (r *queryResolver) ErrorList(ctx context.Context) ([]*Error, error) {
   252  	panic("not implemented")
   253  }
   254  
   255  func (r *queryResolver) Errors(ctx context.Context) (*Errors, error) {
   256  	panic("not implemented")
   257  }
   258  
   259  func (r *queryResolver) Valid(ctx context.Context) (string, error) {
   260  	panic("not implemented")
   261  }
   262  
   263  func (r *queryResolver) Panics(ctx context.Context) (*Panics, error) {
   264  	panic("not implemented")
   265  }
   266  
   267  func (r *queryResolver) PrimitiveObject(ctx context.Context) ([]Primitive, error) {
   268  	panic("not implemented")
   269  }
   270  
   271  func (r *queryResolver) PrimitiveStringObject(ctx context.Context) ([]PrimitiveString, error) {
   272  	panic("not implemented")
   273  }
   274  
   275  func (r *queryResolver) PtrToSliceContainer(ctx context.Context) (*PtrToSliceContainer, error) {
   276  	panic("not implemented")
   277  }
   278  
   279  func (r *queryResolver) Infinity(ctx context.Context) (float64, error) {
   280  	panic("not implemented")
   281  }
   282  
   283  func (r *queryResolver) StringFromContextInterface(ctx context.Context) (*StringFromContextInterface, error) {
   284  	panic("not implemented")
   285  }
   286  
   287  func (r *queryResolver) StringFromContextFunction(ctx context.Context) (string, error) {
   288  	panic("not implemented")
   289  }
   290  
   291  func (r *queryResolver) DefaultScalar(ctx context.Context, arg string) (string, error) {
   292  	panic("not implemented")
   293  }
   294  
   295  func (r *queryResolver) Slices(ctx context.Context) (*Slices, error) {
   296  	panic("not implemented")
   297  }
   298  
   299  func (r *queryResolver) ScalarSlice(ctx context.Context) ([]byte, error) {
   300  	panic("not implemented")
   301  }
   302  
   303  func (r *queryResolver) Fallback(ctx context.Context, arg FallbackToStringEncoding) (FallbackToStringEncoding, error) {
   304  	panic("not implemented")
   305  }
   306  
   307  func (r *queryResolver) OptionalUnion(ctx context.Context) (TestUnion, error) {
   308  	panic("not implemented")
   309  }
   310  
   311  func (r *queryResolver) VOkCaseValue(ctx context.Context) (*VOkCaseValue, error) {
   312  	panic("not implemented")
   313  }
   314  
   315  func (r *queryResolver) VOkCaseNil(ctx context.Context) (*VOkCaseNil, error) {
   316  	panic("not implemented")
   317  }
   318  
   319  func (r *queryResolver) ValidType(ctx context.Context) (*ValidType, error) {
   320  	panic("not implemented")
   321  }
   322  
   323  func (r *queryResolver) WrappedStruct(ctx context.Context) (*WrappedStruct, error) {
   324  	panic("not implemented")
   325  }
   326  
   327  func (r *queryResolver) WrappedScalar(ctx context.Context) (otherpkg.Scalar, error) {
   328  	panic("not implemented")
   329  }
   330  
   331  func (r *queryResolver) WrappedMap(ctx context.Context) (WrappedMap, error) {
   332  	panic("not implemented")
   333  }
   334  
   335  func (r *queryResolver) WrappedSlice(ctx context.Context) (WrappedSlice, error) {
   336  	panic("not implemented")
   337  }
   338  
   339  func (r *subscriptionResolver) Updated(ctx context.Context) (<-chan string, error) {
   340  	panic("not implemented")
   341  }
   342  
   343  func (r *subscriptionResolver) InitPayload(ctx context.Context) (<-chan string, error) {
   344  	panic("not implemented")
   345  }
   346  
   347  func (r *subscriptionResolver) DirectiveArg(ctx context.Context, arg string) (<-chan *string, error) {
   348  	panic("not implemented")
   349  }
   350  
   351  func (r *subscriptionResolver) DirectiveNullableArg(ctx context.Context, arg *int, arg2 *int, arg3 *string) (<-chan *string, error) {
   352  	panic("not implemented")
   353  }
   354  
   355  func (r *subscriptionResolver) DirectiveDouble(ctx context.Context) (<-chan *string, error) {
   356  	panic("not implemented")
   357  }
   358  
   359  func (r *subscriptionResolver) DirectiveUnimplemented(ctx context.Context) (<-chan *string, error) {
   360  	panic("not implemented")
   361  }
   362  
   363  func (r *subscriptionResolver) Issue896b(ctx context.Context) (<-chan []*CheckIssue896, error) {
   364  	panic("not implemented")
   365  }
   366  
   367  func (r *userResolver) Friends(ctx context.Context, obj *User) ([]*User, error) {
   368  	panic("not implemented")
   369  }
   370  
   371  func (r *wrappedMapResolver) Get(ctx context.Context, obj WrappedMap, key string) (string, error) {
   372  	panic("not implemented")
   373  }
   374  
   375  func (r *wrappedSliceResolver) Get(ctx context.Context, obj WrappedSlice, idx int) (string, error) {
   376  	panic("not implemented")
   377  }
   378  
   379  // BackedByInterface returns BackedByInterfaceResolver implementation.
   380  func (r *Resolver) BackedByInterface() BackedByInterfaceResolver {
   381  	return &backedByInterfaceResolver{r}
   382  }
   383  
   384  // Errors returns ErrorsResolver implementation.
   385  func (r *Resolver) Errors() ErrorsResolver { return &errorsResolver{r} }
   386  
   387  // ForcedResolver returns ForcedResolverResolver implementation.
   388  func (r *Resolver) ForcedResolver() ForcedResolverResolver { return &forcedResolverResolver{r} }
   389  
   390  // ModelMethods returns ModelMethodsResolver implementation.
   391  func (r *Resolver) ModelMethods() ModelMethodsResolver { return &modelMethodsResolver{r} }
   392  
   393  // Mutation returns MutationResolver implementation.
   394  func (r *Resolver) Mutation() MutationResolver { return &mutationResolver{r} }
   395  
   396  // OverlappingFields returns OverlappingFieldsResolver implementation.
   397  func (r *Resolver) OverlappingFields() OverlappingFieldsResolver {
   398  	return &overlappingFieldsResolver{r}
   399  }
   400  
   401  // Panics returns PanicsResolver implementation.
   402  func (r *Resolver) Panics() PanicsResolver { return &panicsResolver{r} }
   403  
   404  // Primitive returns PrimitiveResolver implementation.
   405  func (r *Resolver) Primitive() PrimitiveResolver { return &primitiveResolver{r} }
   406  
   407  // PrimitiveString returns PrimitiveStringResolver implementation.
   408  func (r *Resolver) PrimitiveString() PrimitiveStringResolver { return &primitiveStringResolver{r} }
   409  
   410  // Query returns QueryResolver implementation.
   411  func (r *Resolver) Query() QueryResolver { return &queryResolver{r} }
   412  
   413  // Subscription returns SubscriptionResolver implementation.
   414  func (r *Resolver) Subscription() SubscriptionResolver { return &subscriptionResolver{r} }
   415  
   416  // User returns UserResolver implementation.
   417  func (r *Resolver) User() UserResolver { return &userResolver{r} }
   418  
   419  // WrappedMap returns WrappedMapResolver implementation.
   420  func (r *Resolver) WrappedMap() WrappedMapResolver { return &wrappedMapResolver{r} }
   421  
   422  // WrappedSlice returns WrappedSliceResolver implementation.
   423  func (r *Resolver) WrappedSlice() WrappedSliceResolver { return &wrappedSliceResolver{r} }
   424  
   425  type backedByInterfaceResolver struct{ *Resolver }
   426  type errorsResolver struct{ *Resolver }
   427  type forcedResolverResolver struct{ *Resolver }
   428  type modelMethodsResolver struct{ *Resolver }
   429  type mutationResolver struct{ *Resolver }
   430  type overlappingFieldsResolver struct{ *Resolver }
   431  type panicsResolver struct{ *Resolver }
   432  type primitiveResolver struct{ *Resolver }
   433  type primitiveStringResolver struct{ *Resolver }
   434  type queryResolver struct{ *Resolver }
   435  type subscriptionResolver struct{ *Resolver }
   436  type userResolver struct{ *Resolver }
   437  type wrappedMapResolver struct{ *Resolver }
   438  type wrappedSliceResolver struct{ *Resolver }