v1beta1

type ExecutableSchema struct {

	// The following directives are supported:
	// - @resolve(name: string)
	// - @cacheControl(maxAge: uint32, inheritMaxAge: bool, scope: unset/public/private)
	//
	// Define named resolvers on the `Executor.Local.resolutions` message, and reference them here using @resolve:
	// “`gql
	// type Query {
	// author: String @resolve(name: "authorResolver")
	// }
	//
	// Further, fields/types can be annotated with the @cacheControl directive, e.g.
	// “`gql
	// type Query @cacheControl(maxAge: 60) {
	// author: String @resolve(name: "authorResolver") @cacheControl(maxAge: 90, scope: private)
	// }
	// “`
	// Any type-level cache control defaults are overridden by field settings, if provided.
	// The most restrictive cache control setting (smallest maxAge and scope) across all fields in
	// an entire query will be returned to the client in the `Cache-Control` header with appropriate
	// `max-age` and  scope (unset, `public`, or `private`) directives.
	SchemaDefinition string `protobuf:"bytes,1,opt,name=schema_definition,json=schemaDefinition,proto3" json:"schema_definition,omitempty"`
	// how to execute the schema
	Executor *Executor `protobuf:"bytes,2,opt,name=executor,proto3" json:"executor,omitempty"`
	// Schema extensions
	GrpcDescriptorRegistry *GrpcDescriptorRegistry `` /* 129-byte string literal not displayed */
	// contains filtered or unexported fields
}

type Executor struct {

	// Types that are assignable to Executor:
	//
	//	*Executor_Local_
	//	*Executor_Remote_
	Executor isExecutor_Executor `protobuf_oneof:"executor"`
	// contains filtered or unexported fields
}

type Executor_Local struct {

	// Mapping of resolver name to resolver definition.
	// The names are used to reference the resolver in the graphql schema.
	// For example, a resolver with name "authorResolver" can be defined as
	// “`yaml
	// authorResolver:
	// restResolver:
	// upstreamRef: ...
	// request:
	// ...
	// response:
	// ...
	// “`
	// and referenced in the graphql schema as
	// “`gql
	// type Query {
	// author: String @resolve(name: "authorResolver")
	// }
	// “`
	Resolutions map[string]*Resolution `` /* 163-byte string literal not displayed */
	// Do we enable introspection for the schema? general recommendation is to
	// disable this for production and hence it defaults to false.
	EnableIntrospection bool `protobuf:"varint,2,opt,name=enable_introspection,json=enableIntrospection,proto3" json:"enable_introspection,omitempty"`
	// Options that apply to this local executable schema
	Options *Executor_Local_LocalExecutorOptions `protobuf:"bytes,3,opt,name=options,proto3" json:"options,omitempty"`
	// contains filtered or unexported fields
}

type Executor_Local_ struct {
	Local *Executor_Local `protobuf:"bytes,1,opt,name=local,proto3,oneof"`
}

type Executor_Local_LocalExecutorOptions struct {

	// Max GraphQL operation (query/mutation/subscription) depth. This sets a limitation on the max nesting on a query that runs against this schema.
	// any GraphQL operation that runs past the `max_depth` will add an error message to the response and will return as `null`.
	// As as simple example, if the schema is
	// “`gql
	//
	//	type Query {
	//	  employee: Employee
	//	}
	//
	//	type Employee {
	//	  manager: Employee
	//	  name: String
	//	}
	//
	// “`
	// and we set a `max_depth` of `3` and we run a query
	// “`gql
	// query {             # query depth : 0
	//
	//	  employee {        # query depth : 1
	//	    manager {       # query depth : 2
	//	      name          # query depth : 3
	//	      manager {     # query depth : 3
	//	        name        # query depth : 4
	//	      }
	//	    }
	//	  }
	//	}
	//
	// “`
	// the graphql server will respond with a response:
	// “`json
	//
	//	{ "data" : {
	//	    "employee" : {
	//	      "manager" : {
	//	        "name" : "Manager 1",
	//	        "manager"  : {
	//	          "name" : null
	//	  }}}},
	//	  "errors": [
	//	     {"message": "field 'name' exceeds the max operation depth of 3 for this schema"}
	//	   ]
	//	}
	//
	// If not configured, or the value is 0, the query depth will be unbounded.
	MaxDepth *wrappers.UInt32Value `protobuf:"bytes,1,opt,name=max_depth,json=maxDepth,proto3" json:"max_depth,omitempty"`
	// contains filtered or unexported fields
}

type Executor_Remote struct {
	UpstreamRef *core.ResourceRef `protobuf:"bytes,1,opt,name=upstream_ref,json=upstreamRef,proto3" json:"upstream_ref,omitempty"`
	// map of header name to extraction type:
	// e.g.
	// ':path':   '/hard/coded/path'
	// ':method': '{$headers.method}'
	//
	//	':key':    '{$metadata.io.solo.transformation:endpoint_url}'
	Headers map[string]string `` /* 155-byte string literal not displayed */
	// map of query parameter name to extraction type:
	// e.g.
	//
	// 'query': '{$metadata.$KEY_NAME:$KEY_VALUE}'
	QueryParams map[string]string `` /* 182-byte string literal not displayed */
	SpanName    string            `protobuf:"bytes,4,opt,name=span_name,json=spanName,proto3" json:"span_name,omitempty"`
	// contains filtered or unexported fields
}

type Executor_Remote_ struct {
	Remote *Executor_Remote `protobuf:"bytes,2,opt,name=remote,proto3,oneof"`
}

type GraphQLApi struct {

	// NamespacedStatuses indicates the validation status of this resource.
	// NamespacedStatuses is read-only by clients, and set by gloo during validation
	NamespacedStatuses *core.NamespacedStatuses `protobuf:"bytes,1,opt,name=namespaced_statuses,json=namespacedStatuses,proto3" json:"namespaced_statuses,omitempty"`
	// Metadata contains the object metadata for this resource
	Metadata *core.Metadata `protobuf:"bytes,2,opt,name=metadata,proto3" json:"metadata,omitempty"`
	// Types that are assignable to Schema:
	//
	//	*GraphQLApi_ExecutableSchema
	//	*GraphQLApi_StitchedSchema
	Schema isGraphQLApi_Schema `protobuf_oneof:"schema"`
	// The stats prefix which will be used for this route config.
	// If empty, will generate a stats prefix ${GRAPHQLAPI_REF}
	StatPrefix *wrappers.StringValue `protobuf:"bytes,3,opt,name=stat_prefix,json=statPrefix,proto3" json:"stat_prefix,omitempty"`
	// Configuration settings for persisted query cache
	PersistedQueryCacheConfig *PersistedQueryCacheConfig `` /* 140-byte string literal not displayed */
	// Safelist: only allow queries to be executed that match these sha256 hashes.
	// The hash can be computed from the query string or provided (i.e. persisted queries).
	AllowedQueryHashes []string `protobuf:"bytes,5,rep,name=allowed_query_hashes,json=allowedQueryHashes,proto3" json:"allowed_query_hashes,omitempty"`
	// Options that apply to this GraphQLApi.
	Options *GraphQLApi_GraphQLApiOptions `protobuf:"bytes,8,opt,name=options,proto3" json:"options,omitempty"`
	// contains filtered or unexported fields
}

type GraphQLApiClient interface {
	BaseClient() clients.ResourceClient
	Register() error
	Read(namespace, name string, opts clients.ReadOpts) (*GraphQLApi, error)
	Write(resource *GraphQLApi, opts clients.WriteOpts) (*GraphQLApi, error)
	Delete(namespace, name string, opts clients.DeleteOpts) error
	List(namespace string, opts clients.ListOpts) (GraphQLApiList, error)
	GraphQLApiWatcher
}

type GraphQLApiList []*GraphQLApi

type GraphQLApiReconciler interface {
	Reconcile(namespace string, desiredResources GraphQLApiList, transition TransitionGraphQLApiFunc, opts clients.ListOpts) error
}

type GraphQLApiWatcher interface {
	// watch namespace-scoped GraphqlApis
	Watch(namespace string, opts clients.WatchOpts) (<-chan GraphQLApiList, <-chan error, error)
}

type GraphQLApi_ExecutableSchema struct {
	// An Executable Schema represents a single upstream, which could be a locally resolved
	// schema, or a remotely resolved schema.
	ExecutableSchema *ExecutableSchema `protobuf:"bytes,6,opt,name=executable_schema,json=executableSchema,proto3,oneof"`
}

type GraphQLApi_GraphQLApiOptions struct {

	// If true, includes information about request and response in the gateway-proxy debug and trace logs.
	// This is useful when debugging but is not recommended for security and performance reasons in
	// production scenarios.
	// Defaults to false.
	LogSensitiveInfo bool `protobuf:"varint,1,opt,name=log_sensitive_info,json=logSensitiveInfo,proto3" json:"log_sensitive_info,omitempty"`
	// contains filtered or unexported fields
}

type GraphQLApi_StitchedSchema struct {
	// A stitched schema represents the product of stitching multiple graphql subschemas together.
	StitchedSchema *StitchedSchema `protobuf:"bytes,7,opt,name=stitched_schema,json=stitchedSchema,proto3,oneof"`
}

type GrpcDescriptorRegistry struct {

	// Types that are assignable to DescriptorSet:
	//
	//	*GrpcDescriptorRegistry_ProtoDescriptor
	//	*GrpcDescriptorRegistry_ProtoDescriptorBin
	//	*GrpcDescriptorRegistry_ProtoRefsList
	DescriptorSet isGrpcDescriptorRegistry_DescriptorSet `protobuf_oneof:"descriptor_set"`
	// contains filtered or unexported fields
}

type GrpcDescriptorRegistry_ProtoDescriptor struct {
	// Supplies the filename of
	// :ref:`the proto descriptor set <config_grpc_json_generate_proto_descriptor_set>` for the gRPC
	// services.
	ProtoDescriptor string `protobuf:"bytes,1,opt,name=proto_descriptor,json=protoDescriptor,proto3,oneof"`
}

type GrpcDescriptorRegistry_ProtoDescriptorBin struct {
	// Supplies the binary content of
	// :ref:`the proto descriptor set <config_grpc_json_generate_proto_descriptor_set>` for the gRPC
	// services.
	// Note: in yaml, this must be provided as a base64 standard encoded string; yaml cannot handle binary bytes
	ProtoDescriptorBin []byte `protobuf:"bytes,2,opt,name=proto_descriptor_bin,json=protoDescriptorBin,proto3,oneof"`
}

type GrpcDescriptorRegistry_ProtoRefs struct {

	// List of references to config maps that contain proto data for this resolver.
	// For each of the config maps referenced here, they must contain keys in their data map with valid base64 encoded
	// proto descriptor set binaries as the values.
	// Also they must be in a namespace watched by gloo edge.
	ConfigMapRefs []*core.ResourceRef `protobuf:"bytes,1,rep,name=config_map_refs,json=configMapRefs,proto3" json:"config_map_refs,omitempty"`
	// contains filtered or unexported fields
}

type GrpcDescriptorRegistry_ProtoRefsList struct {
	// Allows the user to put proto descriptor set binary content in configmaps;
	// The descriptor set binary content in these config maps must be base64 encoded
	// Generating the proto descriptor binary and base64 encoding it can be done using the following command
	// `protoc ./your-proto-here.proto --proto_path . --descriptor_set_out="/dev/stdout" --include_imports | base64`
	ProtoRefsList *GrpcDescriptorRegistry_ProtoRefs `protobuf:"bytes,3,opt,name=proto_refs_list,json=protoRefsList,proto3,oneof"`
}

type GrpcRequestTemplate struct {

	// json representation of outgoing gRPC message to be sent to gRPC service
	OutgoingMessageJson *_struct.Value `protobuf:"bytes,1,opt,name=outgoing_message_json,json=outgoingMessageJson,proto3" json:"outgoing_message_json,omitempty"`
	// request has shape matching service with name registered in registry
	// is the full_name(), e.g. main.Bookstore
	ServiceName string `protobuf:"bytes,2,opt,name=service_name,json=serviceName,proto3" json:"service_name,omitempty"`
	// make request to method with this name on the grpc service defined above
	// is just the name(), e.g. GetBook
	MethodName string `protobuf:"bytes,3,opt,name=method_name,json=methodName,proto3" json:"method_name,omitempty"`
	// in the future, we may want to make this a map<string, ValueProvider>
	// once we know better what the use cases are
	RequestMetadata map[string]string `` /* 194-byte string literal not displayed */
	// contains filtered or unexported fields
}

type GrpcResolver struct {
	UpstreamRef *core.ResourceRef `protobuf:"bytes,1,opt,name=upstream_ref,json=upstreamRef,proto3" json:"upstream_ref,omitempty"`
	// configuration used to compose the outgoing request to a REST API
	RequestTransform *GrpcRequestTemplate `protobuf:"bytes,2,opt,name=request_transform,json=requestTransform,proto3" json:"request_transform,omitempty"`
	SpanName         string               `protobuf:"bytes,4,opt,name=span_name,json=spanName,proto3" json:"span_name,omitempty"`
	// The timeout to use for this resolver. If unset, the upstream connection timeout
	// or a default of 1 second will be used.
	Timeout *duration.Duration `protobuf:"bytes,5,opt,name=timeout,proto3" json:"timeout,omitempty"`
	// contains filtered or unexported fields
}

type MockResolver struct {

	// Types that are assignable to Response:
	//
	//	*MockResolver_SyncResponse
	//	*MockResolver_AsyncResponse_
	//	*MockResolver_ErrorResponse
	Response isMockResolver_Response `protobuf_oneof:"response"`
	// contains filtered or unexported fields
}

type MockResolver_AsyncResponse struct {

	// The response from the resolver as a JSON.
	Response *_struct.Value `protobuf:"bytes,1,opt,name=response,proto3" json:"response,omitempty"`
	// The delay time before this response is sent back to the graphql server
	Delay *duration.Duration `protobuf:"bytes,2,opt,name=delay,proto3" json:"delay,omitempty"`
	// contains filtered or unexported fields
}

type MockResolver_AsyncResponse_ struct {
	// Used to create a asynchronous JSON response from the Mock resolver.
	AsyncResponse *MockResolver_AsyncResponse `protobuf:"bytes,2,opt,name=async_response,json=asyncResponse,proto3,oneof"`
}

type MockResolver_ErrorResponse struct {
	// Responds as an error with the given message. This can be any string message.
	ErrorResponse string `protobuf:"bytes,3,opt,name=error_response,json=errorResponse,proto3,oneof"`
}

type MockResolver_SyncResponse struct {
	// The JSON response from the resolver that will be "responded" immediately.
	SyncResponse *_struct.Value `protobuf:"bytes,1,opt,name=sync_response,json=syncResponse,proto3,oneof"`
}

type PersistedQueryCacheConfig struct {

	// The unit is number of queries to store, default to 1000.
	CacheSize uint32 `protobuf:"varint,1,opt,name=cache_size,json=cacheSize,proto3" json:"cache_size,omitempty"`
	// contains filtered or unexported fields
}

type RESTResolver struct {
	UpstreamRef *core.ResourceRef `protobuf:"bytes,1,opt,name=upstream_ref,json=upstreamRef,proto3" json:"upstream_ref,omitempty"`
	// configuration used to compose the outgoing request to a REST API
	Request *RequestTemplate `protobuf:"bytes,2,opt,name=request,proto3" json:"request,omitempty"`
	// configuration used to modify the response from the REST API
	// before being handled by the graphql server.
	Response *ResponseTemplate `protobuf:"bytes,3,opt,name=response,proto3" json:"response,omitempty"`
	SpanName string            `protobuf:"bytes,4,opt,name=span_name,json=spanName,proto3" json:"span_name,omitempty"`
	// The timeout to use for this resolver. If unset, the upstream connection timeout
	// or a default of 1 second will be used.
	Timeout *duration.Duration `protobuf:"bytes,5,opt,name=timeout,proto3" json:"timeout,omitempty"`
	// contains filtered or unexported fields
}

type RequestTemplate struct {

	// Use this attribute to set request headers to your REST service. It consists of a
	// map of strings to templated value strings. The string key determines the name of the
	// resulting header, the value provided will be the value.
	//
	// The least needed here is the ":method" and ":path" headers.
	// for example, if a header is an authorization token, taken from the graphql args,
	// we can use the following configuration:
	// headers:
	//
	//	Authorization: "Bearer {$args.token}"
	Headers map[string]string `` /* 155-byte string literal not displayed */
	// Use this attribute to set query parameters to your REST service. It consists of a
	// map of strings to templated value strings. The string key determines the name of the
	// query param, the provided value will be the value. This value is appended to any
	// value set to the :path header in `headers`.
	//
	// for example, if a query parameter is an id, taken from the graphql parent object,
	// we can use the following configuration:
	// queryParams:
	//
	//	id: "{$parent.id}"
	QueryParams map[string]string `` /* 182-byte string literal not displayed */
	// Used to construct the outgoing body to the upstream from the
	// graphql value providers.
	// All string values can be templated strings.
	Body *_struct.Value `protobuf:"bytes,3,opt,name=body,proto3" json:"body,omitempty"`
	// contains filtered or unexported fields
}

type Resolution struct {

	// The resolver to use.
	//
	// Types that are assignable to Resolver:
	//
	//	*Resolution_RestResolver
	//	*Resolution_GrpcResolver
	//	*Resolution_MockResolver
	Resolver isResolution_Resolver `protobuf_oneof:"resolver"`
	// The stats prefix which will be used for this resolver.
	// If empty, will generate a stats prefix ${RESOLVER_NAME}
	StatPrefix *wrappers.StringValue `protobuf:"bytes,3,opt,name=stat_prefix,json=statPrefix,proto3" json:"stat_prefix,omitempty"`
	// contains filtered or unexported fields
}

type Resolution_GrpcResolver struct {
	// gRPC resolver used to translate and send graphql requests
	// to a gRPC upstream.
	GrpcResolver *GrpcResolver `protobuf:"bytes,2,opt,name=grpc_resolver,json=grpcResolver,proto3,oneof"`
}

type Resolution_MockResolver struct {
	// Resolver used to mock responses from an upstream.
	// This resolver does not make a call out to an upstream, but can mock responses
	// either synchronously or with a delay.
	// Additionally, can be used to mock errors from an upstream.
	MockResolver *MockResolver `protobuf:"bytes,4,opt,name=mock_resolver,json=mockResolver,proto3,oneof"`
}

type Resolution_RestResolver struct {
	// REST resolver used to translate and send graphql requests
	// to a REST upstream.
	RestResolver *RESTResolver `protobuf:"bytes,1,opt,name=rest_resolver,json=restResolver,proto3,oneof"`
}

type ResponseTemplate struct {

	// Sets the "root" of the upstream response to be turned into a graphql type by the graphql server.
	// For example, if the graphql type is:
	//
	// type Simple {
	// name String
	// }
	//
	// and the upstream response is `{"data": {"simple": {"name": "simple name"}}}`,
	// the graphql server will not be able to marshal the upstream response into the Simple graphql type
	// because it does not know where the relevant data is. If we set result_root to "data.simple", we can give the
	// graphql server a hint of where to look in the upstream response for the relevant data that graphql type wants.
	ResultRoot string `protobuf:"bytes,1,opt,name=result_root,json=resultRoot,proto3" json:"result_root,omitempty"`
	// Field-specific mapping for a graphql field to a JSON path in the upstream response.
	// For example, if the graphql type is:
	//
	// type Person {
	// firstname String
	// lastname String
	// fullname String
	// }
	//
	// and the upstream response is `{"firstname": "Joe", "details": {"lastname": "Smith"}}`,
	// the graphql server will not be able to marshal the upstream response into the Person graphql type because of the
	// nested `lastname` field. We can use a simple setter here:
	//
	// setters:
	// lastname: '{$body.details.lastname}'
	// fullname: '{$body.details.firstname} {$body.details.lastname}'
	//
	// and the graphql server will be able to extract data for a field given the path to the relevant data
	// in the upstream JSON response. We do not need to have a setter for the `firstname` field because the
	// JSON response has that field in a position the graphql server can understand automatically.
	//
	// So far only the $body keyword is supported, but in the future we may add support for others such as $headers.
	Setters map[string]string `` /* 155-byte string literal not displayed */
	// contains filtered or unexported fields
}

type StitchedSchema struct {

	// List of GraphQLApis that compose this stitched GraphQL schema.
	Subschemas []*StitchedSchema_SubschemaConfig `protobuf:"bytes,1,rep,name=subschemas,proto3" json:"subschemas,omitempty"`
	// contains filtered or unexported fields
}

type StitchedSchema_SubschemaConfig struct {

	// name of the GraphQLApi subschema
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// namespace of the GraphQLApi subschema
	Namespace string `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	// Type merge configuration for this subschema. Let's say this subschema is a Users service schema
	// and provides the User type (with a query to fetch a user given the username)
	//
	// “`gql
	// type Query {
	// GetUser(username: String): User
	// }
	// type User {
	// username: String
	// firstName: String
	// lastName: String
	// }
	// “`
	//
	// and another subschema, e.g. Reviews schema, may have a partial User type:
	// “`gql
	// type Review {
	// author: User
	// }
	//
	// type User {
	// username: String
	// }
	// “`
	// We want to provide the relevant information from this Users service schema,
	// so that another API that can give us a partial User type (with the username) will then
	// be able to have access to the full user type. With the correct type merging config under the Users subschema, e.g.:
	//
	// “`yaml
	// type_merge:
	// User:
	// selection_set: '{ username }'
	// query_name: 'GetUser'
	// args:
	// username: username
	// “`
	// the stitched schema will now be able to provide the full user type to all types that require it. In this case,
	// we can now get the first name of an author from the Review.author field even though the Reviews schema does not
	// provide the full User type.
	TypeMerge map[string]*StitchedSchema_SubschemaConfig_TypeMergeConfig `` /* 176-byte string literal not displayed */
	// contains filtered or unexported fields
}

type StitchedSchema_SubschemaConfig_TypeMergeConfig struct {

	// This specifies one or more key fields required from other services to perform this query.
	// Query planning will automatically resolve these fields from other subschemas in dependency order.
	// This is a graphql selection set specified as a string
	// e.g. '{ username }'
	SelectionSet string `protobuf:"bytes,1,opt,name=selection_set,json=selectionSet,proto3" json:"selection_set,omitempty"`
	// specifies the root field from this subschema used to request the local type
	QueryName string            `protobuf:"bytes,2,opt,name=query_name,json=queryName,proto3" json:"query_name,omitempty"`
	Args      map[string]string `` /* 149-byte string literal not displayed */
	// contains filtered or unexported fields
}

type TransitionGraphQLApiFunc func(original, desired *GraphQLApi) (bool, error)