Enum Code 

pub enum Code {
    GraphQLError,
    DuplicateSourceName,
    DuplicateIdName,
    InvalidSourceName,
    EmptySourceName,
    InvalidConnectorIdName,
    InvalidUrl,
    InvalidUrlScheme,
    SourceNameMismatch,
    SubscriptionInConnectors,
    AbsoluteConnectUrlWithSource,
    RelativeConnectUrlWithoutSource,
    NoSourcesDefined,
    NoSourceImport,
    MultipleHttpMethods,
    MissingHttpMethod,
    EntityNotOnRootQuery,
    EntityResolverArgumentMismatch,
    EntityTypeInvalid,
    MissingEntityConnector,
    InvalidSelection,
    InvalidBody,
    InvalidErrorsMessage,
    InvalidIsSuccess,
    CircularReference,
    SelectedFieldNotFound,
    GroupSelectionIsNotObject,
    HttpHeaderNameCollision,
    InvalidHeader,
    ConnectorsUnsupportedFederationDirective,
    ConnectorsUnsupportedAbstractType,
    GroupSelectionRequiredForObject,
    ConnectorsUnresolvedField,
    ConnectorsFieldWithArguments,
    ConnectorsBatchKeyNotInSelection,
    ConnectorsNonRootBatchKey,
    ConnectorsCannotResolveKey,
    UndefinedArgument,
    UndefinedField,
    UnsupportedVariableType,
    UnknownConnectorsVersion,
    ConnectOnTypeMustBeEntity,
    ConnectOnRoot,
    ConnectBatchAndThis,
    InvalidUrlProperty,
    MissingSchemaType,
}

The error code that will be shown to users when a validation fails during composition.

Note that these codes are global, not scoped to connectors, so they should attempt to be unique across all pieces of composition, including JavaScript components.

Variants

GraphQLError

A problem with GraphQL syntax or semantics was found. These will usually be caught before this validation process.

DuplicateSourceName

Indicates two connector sources with the same name were created.

DuplicateIdName

Indicates two connector IDs with the same name were created.

InvalidSourceName

The name provided for a @source was invalid.

EmptySourceName

No name was provided when creating a connector source with @source.

InvalidConnectorIdName

Connector ID name must be alphanumeric_.

InvalidUrl

A URL provided to @source or @connect was not valid.

InvalidUrlScheme

A URL scheme provided to @source or @connect was not http or https.

SourceNameMismatch

The source argument used in a @connect directive doesn’t match any named connector sources created with @source.

SubscriptionInConnectors

Connectors currently don’t support subscription operations.

AbsoluteConnectUrlWithSource

The @connect is using a source, but the URL is absolute. This is not allowed because the @source URL will be joined with the @connect URL, so the @connect URL should only be a path.

RelativeConnectUrlWithoutSource

The @connect directive is using a relative URL (path only) but does not define a source. This is a specialization of Self::InvalidUrl.

NoSourcesDefined

This is a specialization of Self::SourceNameMismatch that indicates no sources were defined.

NoSourceImport

The subgraph doesn’t import the @source directive. This isn’t necessarily a problem, but is likely a mistake.

MultipleHttpMethods

The @connect directive has multiple HTTP methods when only one is allowed.

MissingHttpMethod

The @connect directive is missing an HTTP method.

EntityNotOnRootQuery

The @connect directive’s entity argument should only be used on the root Query field.

EntityResolverArgumentMismatch

The arguments to the entity reference resolver do not match the entity type.

EntityTypeInvalid

The @connect directive’s entity argument should only be used with non-list, nullable, object types.

MissingEntityConnector

A @key was defined without a corresponding entity connector.

InvalidSelection

The provided selection mapping in a @connects selection was not valid.

InvalidBody

The http.body provided in @connect was not valid.

InvalidErrorsMessage

The errors.message provided in @connect or @source was not valid.

InvalidIsSuccess

The isSuccess mapping provided in @connect or @source was not valid.

CircularReference

A circular reference was detected in a @connect directive’s selection argument.

SelectedFieldNotFound

A field included in a @connect directive’s selection argument is not defined on the corresponding type.

GroupSelectionIsNotObject

A group selection mapping (a { b }) was used, but the field is not an object.

HttpHeaderNameCollision

The name mapping must be unique for all headers.

InvalidHeader

A provided header in @source or @connect was not valid.

ConnectorsUnsupportedFederationDirective

Certain directives are not allowed when using connectors.

ConnectorsUnsupportedAbstractType

Abstract types are not allowed when using connectors.

GroupSelectionRequiredForObject

Fields that return an object type must use a group selection mapping {}.

ConnectorsUnresolvedField

The schema includes fields that aren’t resolved by a connector.

ConnectorsFieldWithArguments

A field resolved by a connector has arguments defined.

ConnectorsBatchKeyNotInSelection

Connector batch key is not reflected in the output selection

ConnectorsNonRootBatchKey

Connector batch key is derived from a non-root variable such as $this or $context.

ConnectorsCannotResolveKey

A @key could not be resolved for the given combination of variables.

UndefinedArgument

Part of the @connect refers to an $args which is not defined.

UndefinedField

Part of the @connect refers to an $this which is not defined.

UnsupportedVariableType

A type used in a variable is not yet supported (i.e., unions).

UnknownConnectorsVersion

The version set in the connectors @link URL is not recognized.

ConnectOnTypeMustBeEntity

When @connect is applied to a type, entity can’t be set to false

ConnectOnRoot

@connect cannot be applied to a query, mutation, or subscription root type

ConnectBatchAndThis

Using both $batch and $this is not allowed

InvalidUrlProperty

Invalid URL property

MissingSchemaType

Any named type not found in a GraphQL schema where expected

Implementations

impl Code

pub fn severity(&self) -> Severity

Trait Implementations

impl Clone for Code

fn clone(&self) -> Code

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Code

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for Code

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'_derivative_strum> From<&'_derivative_strum Code> for &'static str

fn from(x: &'_derivative_strum Code) -> &'static str

Converts to this type from the input type.

impl From<Code> for &'static str

fn from(x: Code) -> &'static str

Converts to this type from the input type.

impl PartialEq for Code

fn eq(&self, other: &Code) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Code

impl Eq for Code

impl StructuralPartialEq for Code