public void SetBuilder(IValidationBuilder builder)
{
this.builder = builder;
}
/// <summary> /// Specifies that values must be a valid file path or directory, and the file path must already exist. /// </summary> /// <param name="builder">The builder.</param> /// <param name="errorMessage">A custom error message to display.</param> /// <returns>The builder.</returns> public static IValidationBuilder ExistingFileOrDirectory(this IValidationBuilder builder, string errorMessage = null) => builder.Satisfies <FileOrDirectoryExistsAttribute>(errorMessage);
/// <summary>
/// The target field of a field selection must be defined on the scoped
/// type of the selection set. There are no limitations on alias names.
///
/// http://spec.graphql.org/June2018/#sec-Field-Selections-on-Objects-Interfaces-and-Unions-Types
///
/// AND
///
/// Field selections on scalars or enums are never allowed,
/// because they are the leaf nodes of any GraphQL query.
///
/// Conversely the leaf field selections of GraphQL queries
/// must be of type scalar or enum. Leaf selections on objects,
/// interfaces, and unions without subfields are disallowed.
///
/// http://spec.graphql.org/June2018/#sec-Leaf-Field-Selections
/// </summary>
public static IValidationBuilder AddFieldRules(
this IValidationBuilder builder)
{
return(builder.TryAddValidationVisitor <FieldVisitor>());
}
/// <summary>
/// If any operation defines more than one variable with the same name,
/// it is ambiguous and invalid. It is invalid even if the type of the
/// duplicate variable is the same.
///
/// http://spec.graphql.org/June2018/#sec-Validation.Variables
///
/// AND
///
/// Variables can only be input types. Objects,
/// unions, and interfaces cannot be used as inputs.
///
/// http://spec.graphql.org/June2018/#sec-Variables-Are-Input-Types
///
/// AND
///
/// All variables defined by an operation must be used in that operation
/// or a fragment transitively included by that operation.
///
/// Unused variables cause a validation error.
///
/// http://spec.graphql.org/June2018/#sec-All-Variables-Used
///
/// AND
///
/// Variables are scoped on a per‐operation basis. That means that
/// any variable used within the context of an operation must be defined
/// at the top level of that operation
///
/// http://spec.graphql.org/June2018/#sec-All-Variable-Uses-Defined
///
/// AND
///
/// Variable usages must be compatible with the arguments
/// they are passed to.
///
/// Validation failures occur when variables are used in the context
/// of types that are complete mismatches, or if a nullable type in a
/// variable is passed to a non‐null argument type.
///
/// http://spec.graphql.org/June2018/#sec-All-Variable-Usages-are-Allowed
/// </summary>
public static IValidationBuilder AddVariableRules(
this IValidationBuilder builder)
{
return(builder.TryAddValidationVisitor <VariableVisitor>());
}
/// <summary>
/// GraphQL servers define what directives they support.
/// For each usage of a directive, the directive must be available
/// on that server.
///
/// http://spec.graphql.org/June2018/#sec-Directives-Are-Defined
///
/// AND
///
/// GraphQL servers define what directives they support and where they
/// support them.
///
/// For each usage of a directive, the directive must be used in a
/// location that the server has declared support for.
///
/// http://spec.graphql.org/June2018/#sec-Directives-Are-In-Valid-Locations
///
/// AND
///
/// Directives are used to describe some metadata or behavioral change on
/// the definition they apply to.
///
/// When more than one directive of the
/// same name is used, the expected metadata or behavior becomes ambiguous,
/// therefore only one of each directive is allowed per location.
///
/// http://spec.graphql.org/draft/#sec-Directives-Are-Unique-Per-Location
/// </summary>
public static IValidationBuilder AddDirectiveRules(
this IValidationBuilder builder)
{
return(builder.TryAddValidationVisitor <DirectiveVisitor>());
}
internal static IValidationBuilder UseMultipliers(
this IValidationBuilder builder, bool useMultipliers) =>
builder.ConfigureValidation(m =>
m.Modifiers.Add(o => o.UseComplexityMultipliers = useMultipliers));
/// <summary> /// Specifies that values must be a valid file path or directory, and the file path must not already exist. /// </summary> /// <param name="builder">The builder.</param> /// <param name="errorMessage">A custom error message to display.</param> /// <returns>The builder.</returns> public static IValidationBuilder NonExistingFileOrDirectory(this IValidationBuilder builder, string?errorMessage = null) => builder.Satisfies(new FileOrDirectoryNotExistsAttribute(), errorMessage);
/// <summary> /// Specifies that values must match a regular expression. /// </summary> /// <param name="builder">The builder.</param> /// <param name="pattern">The regular expression.</param> /// <param name="errorMessage">A custom error message to display.</param> /// <returns>The builder.</returns> public static IValidationBuilder RegularExpression(this IValidationBuilder builder, string pattern, string errorMessage = null) => builder.Satisfies <RegularExpressionAttribute>(errorMessage, pattern);
/// <summary>
/// Specifies that values must be one of the values in a given set.
/// </summary>
/// <param name="builder">The builder.</param>
/// <param name="comparer">The comparer used to determine if values match.</param>
/// <param name="allowedValues">Allowed values.</param>
/// <returns>The builder.</returns>
public static IValidationBuilder Values(this IValidationBuilder builder, StringComparison comparer, params string[] allowedValues)
{
return(builder.Satisfies(new AllowedValuesAttribute(comparer, allowedValues)));
}
/// <summary> /// Specifies that values must be a path to a directory that already exists. /// </summary> /// <param name="builder">The builder.</param> /// <param name="errorMessage">A custom error message to display.</param> /// <returns>The builder.</returns> public static IValidationBuilder ExistingDirectory(this IValidationBuilder builder, string?errorMessage = null) => builder.Satisfies(new DirectoryExistsAttribute(), errorMessage);
internal static IValidationBuilder SetAllowedExecutionDepth(
this IValidationBuilder builder, int allowedExecutionDepth) =>
builder.ConfigureValidation(m =>
m.Modifiers.Add(o => o.MaxAllowedExecutionDepth = allowedExecutionDepth));
/// <summary>
/// Every argument provided to a field or directive must be defined
/// in the set of possible arguments of that field or directive.
///
/// http://spec.graphql.org/June2018/#sec-Argument-Names
///
/// AND
///
/// Fields and directives treat arguments as a mapping of argument name
/// to value.
///
/// More than one argument with the same name in an argument set
/// is ambiguous and invalid.
///
/// http://spec.graphql.org/June2018/#sec-Argument-Uniqueness
///
/// AND
///
/// Arguments can be required. An argument is required if the argument
/// type is non‐null and does not have a default value. Otherwise,
/// the argument is optional.
///
/// http://spec.graphql.org/June2018/#sec-Required-Arguments
/// </summary>
public static IValidationBuilder AddArgumentRules(
this IValidationBuilder builder)
{
return(builder.TryAddValidationRule <ArgumentVisitor>());
}
/// <summary>
/// Every input field provided in an input object value must be defined in
/// the set of possible fields of that input object’s expected type.
///
/// http://spec.graphql.org/June2018/#sec-Input-Object-Field-Names
///
/// AND
///
/// Input objects must not contain more than one field of the same name,
/// otherwise an ambiguity would exist which includes an ignored portion
/// of syntax.
///
/// http://spec.graphql.org/June2018/#sec-Input-Object-Field-Uniqueness
///
/// AND
///
/// Input object fields may be required. Much like a field may have
/// required arguments, an input object may have required fields.
///
/// An input field is required if it has a non‐null type and does not have
/// a default value. Otherwise, the input object field is optional.
///
/// http://spec.graphql.org/June2018/#sec-Input-Object-Required-Fields
///
/// AND
///
/// Literal values must be compatible with the type expected in the position
/// they are found as per the coercion rules defined in the Type System
/// chapter.
///
/// http://spec.graphql.org/June2018/#sec-Values-of-Correct-Type
/// </summary>
public static IValidationBuilder AddValueRules(
this IValidationBuilder builder)
{
return(builder.TryAddValidationRule <ValueVisitor>());
}
/// <summary> /// Specifies that values must be legal file paths. /// </summary> /// <param name="builder">The builder.</param> /// <param name="errorMessage">A custom error message to display.</param> /// <returns>The builder.</returns> public static IValidationBuilder LegalFilePath(this IValidationBuilder builder, string errorMessage = null) => builder.Satisfies <LegalFilePathAttribute>(errorMessage);
/// <summary> /// Specifies that values must be a string no more than <paramref name="length"/> characters long. /// </summary> /// <param name="builder">The builder.</param> /// <param name="length">The maximum length.</param> /// <param name="errorMessage">A custom error message to display.</param> /// <returns>The builder.</returns> public static IValidationBuilder MaxLength(this IValidationBuilder builder, int length, string?errorMessage = null) => builder.Satisfies(new MaxLengthAttribute(length), errorMessage);
/// <summary> /// Specifies that values must be a string no more than <paramref name="length"/> characters long. /// </summary> /// <param name="builder">The builder.</param> /// <param name="length">The maximum length.</param> /// <param name="errorMessage">A custom error message to display.</param> /// <returns>The builder.</returns> public static IValidationBuilder MaxLength(this IValidationBuilder builder, int length, string errorMessage = null) => builder.Satisfies <MaxLengthAttribute>(errorMessage, length);
/// <summary> /// Specifies that values must match a regular expression. /// </summary> /// <param name="builder">The builder.</param> /// <param name="pattern">The regular expression.</param> /// <param name="errorMessage">A custom error message to display.</param> /// <returns>The builder.</returns> public static IValidationBuilder RegularExpression(this IValidationBuilder builder, string pattern, string?errorMessage = null) => builder.Satisfies(new RegularExpressionAttribute(pattern), errorMessage);
/// <summary>
/// Adds a validation rule that only allows requests to use `__schema` or `__type`
/// if the request carries an introspection allowed flag.
/// </summary>
public static IValidationBuilder AddIntrospectionAllowedRule(
this IValidationBuilder builder) =>
builder.TryAddValidationVisitor((_, _) => new IntrospectionVisitor(), false);
/// <summary> /// Specifies that values must be a path to a directory that does not already exist. /// </summary> /// <param name="builder">The builder.</param> /// <param name="errorMessage">A custom error message to display.</param> /// <returns>The builder.</returns> public static IValidationBuilder NonExistingDirectory(this IValidationBuilder builder, string?errorMessage = null) => builder.Satisfies <DirectoryNotExistsAttribute>(errorMessage);
public static IValidationBuilder SetComplexityCalculation(
this IValidationBuilder builder, ComplexityCalculation calculation) =>
builder.ConfigureValidation(m =>
m.Modifiers.Add(o => o.ComplexityCalculation = calculation));
/// <summary> /// <para> /// Specifies that values must be one of the values in a given set. /// </para> /// <para> /// By default, value comparison is case-sensitive. To make matches case-insensitive, use <see cref="Values(IValidationBuilder, bool, string[])"/>. /// </para> /// </summary> /// <param name="builder">The builder.</param> /// <param name="allowedValues">Allowed values.</param> /// <returns>The builder.</returns> public static IValidationBuilder Values(this IValidationBuilder builder, params string[] allowedValues) => builder.Values(ignoreCase: false, allowedValues: allowedValues);
internal static IValidationBuilder SetAllowedComplexity(
this IValidationBuilder builder, int allowedComplexity) =>
builder.ConfigureValidation(m =>
m.Modifiers.Add(o => o.MaxAllowedComplexity = allowedComplexity));
/// <summary>
/// Specifies that values must be one of the values in a given set.
/// </summary>
/// <param name="builder">The builder.</param>
/// <param name="comparer">The comparer used to determine if values match.</param>
/// <param name="allowedValues">Allowed values.</param>
/// <returns>The builder.</returns>
public static IValidationBuilder Values(this IValidationBuilder builder, StringComparison comparer, params string[] allowedValues)
{
return(builder.Satisfies <ValuesAttribute>(ctorArgs: new object[] { comparer, allowedValues }));
}
/// <summary>
/// Fragment definitions are referenced in fragment spreads by name.
/// To avoid ambiguity, each fragment’s name must be unique within a
/// document.
///
/// http://spec.graphql.org/June2018/#sec-Fragment-Name-Uniqueness
///
/// AND
///
/// Defined fragments must be used within a document.
///
/// http://spec.graphql.org/June2018/#sec-Fragments-Must-Be-Used
///
/// AND
///
/// Fragments can only be declared on unions, interfaces, and objects.
/// They are invalid on scalars.
/// They can only be applied on non‐leaf fields.
/// This rule applies to both inline and named fragments.
///
/// http://spec.graphql.org/June2018/#sec-Fragments-On-Composite-Types
///
/// AND
///
/// Fragments are declared on a type and will only apply when the
/// runtime object type matches the type condition.
///
/// They also are spread within the context of a parent type.
///
/// A fragment spread is only valid if its type condition could ever
/// apply within the parent type.
///
/// http://spec.graphql.org/June2018/#sec-Fragment-spread-is-possible
///
/// AND
///
/// Named fragment spreads must refer to fragments defined within the
/// document.
///
/// It is a validation error if the target of a spread is not defined.
///
/// http://spec.graphql.org/June2018/#sec-Fragment-spread-target-defined
///
/// AND
///
/// The graph of fragment spreads must not form any cycles including
/// spreading itself. Otherwise an operation could infinitely spread or
/// infinitely execute on cycles in the underlying data.
///
/// http://spec.graphql.org/June2018/#sec-Fragment-spreads-must-not-form-cycles
///
/// AND
///
/// Fragments must be specified on types that exist in the schema.
/// This applies for both named and inline fragments.
/// If they are not defined in the schema, the query does not validate.
///
/// http://spec.graphql.org/June2018/#sec-Fragment-Spread-Type-Existence
/// </summary>
public static IValidationBuilder AddFragmentRules(
this IValidationBuilder builder)
{
return(builder.TryAddValidationVisitor <FragmentVisitor>());
}
/// <summary> /// Specifies that values must be a valid email address. /// </summary> /// <param name="builder">The builder.</param> /// <param name="errorMessage">A custom error message to display.</param> /// <returns>The builder.</returns> public static IValidationBuilder EmailAddress(this IValidationBuilder builder, string errorMessage = null) => builder.Satisfies <EmailAddressAttribute>(errorMessage);
/// <summary>
/// GraphQL allows a short‐hand form for defining query operations
/// when only that one operation exists in the document.
///
/// http://spec.graphql.org/June2018/#sec-Lone-Anonymous-Operation
///
/// AND
///
/// Each named operation definition must be unique within a document
/// when referred to by its name.
///
/// http://spec.graphql.org/June2018/#sec-Operation-Name-Uniqueness
///
/// AND
///
/// Subscription operations must have exactly one root field.
///
/// http://spec.graphql.org/June2018/#sec-Single-root-field
/// </summary>
public static IValidationBuilder AddOperationRules(
this IValidationBuilder builder)
{
return(builder.TryAddValidationVisitor <OperationVisitor>());
}
public ValidationDirector(IValidationBuilder builder)
{
this.builder = builder;
}
