Directives API Reference¶

class BaseExtraGraphQLDirective(GraphQLDirective)

@staticmethod
def get_args():
    return {
        "format": GraphQLArgument(
            GraphQLString,
            description="Format string"
        )
    }

@default(to: "fallback value")

@base64(op: "encode")

@lowercase

@uppercase

@capitalize

@title_case

@swap_case

@camel_case

@snake_case

@kebab_case

@strip(chars: " ")

@center(width: 20, fillchar: "-")

@replace(old: "GraphQL", new: "GQL", count: 1)

@truncate(length: 20, end: "...", killwords: false)

@slugify

@number(as: ".2f")

@currency(symbol: "$")

@floor

@ceil

@round(precision: 2)

@abs

@date(format: "YYYY-MM-DD")

@shuffle

@sample(k: 3)

@unique

class ExtraGraphQLDirectiveMiddleware:
    def resolve(self, next, root, info, **args):
        # Process directives on field resolution
        pass

GRAPHENE = {
    'SCHEMA': 'myapp.schema.schema',
    'MIDDLEWARE': [
        'django_graphex.ExtraGraphQLDirectiveMiddleware',
    ],
}

from django_graphex.directives.base import BaseExtraGraphQLDirective
from graphql import GraphQLArgument, GraphQLNonNull, GraphQLString, GraphQLInt

class MaskGraphQLDirective(BaseExtraGraphQLDirective):
    """Keep the last `visible` characters, masking the rest with `char`."""

    @staticmethod
    def get_args():
        return {
            "visible": GraphQLArgument(
                GraphQLNonNull(GraphQLInt),
                description="Number of trailing characters to leave visible",
            ),
            "char": GraphQLArgument(
                GraphQLString,
                description="Masking character (default: '*')",
            ),
        }

    @staticmethod
    def resolve(value, args, directive, root, info, **kwargs):
        if not value:
            return value
        text = str(value)
        visible = args.get("visible") or 0
        char = args.get("char") or "*"
        if visible >= len(text):
            return text
        return char * (len(text) - visible) + text[len(text) - visible:]

import graphene
from django_graphex import all_directives

# Add custom directive to the list (all_directives already includes the
# built-in @skip / @include / @deprecated directives).
custom_directives = [
    *all_directives,
    MaskGraphQLDirective()
]

schema = graphene.Schema(
    query=Query,
    directives=custom_directives
)

@staticmethod
def resolve(value, args, directive, root, info, **kwargs):
    precision = args.get("precision") or 0   # default + variable aware
    ...

def ensure_string(value):
    """Ensure value is a string."""
    if isinstance(value, str):
        return value
    return str(value) if value is not None else ""

class SafeDirective(BaseExtraGraphQLDirective):
    @staticmethod
    def resolve(value, args, directive, root, info, **kwargs):
        try:
            # Directive processing logic
            return process_value(value)
        except Exception as e:
            # Log error and return original value
            logger.warning(f"Directive processing failed: {e}")
            return value

class ValidatedDirective(BaseExtraGraphQLDirective):
    @staticmethod
    def resolve(value, args, directive, root, info, **kwargs):
        if value is None:
            return None

        if not isinstance(value, (str, int, float)):
            raise ValueError("Directive only accepts string/number values")

        return process_value(value)

from django.core.cache import cache

class CachedDirective(BaseExtraGraphQLDirective):
    @staticmethod
    def resolve(value, args, directive, root, info, **kwargs):
        cache_key = f"directive_{hash(str(value))}"
        cached_result = cache.get(cache_key)

        if cached_result is not None:
            return cached_result

        result = expensive_processing(value)
        cache.set(cache_key, result, 300)  # 5 minutes
        return result

# Directives are processed in the order they appear
query {
  field @strip @uppercase @truncate(length: 50)
  # 1. Strip whitespace
  # 2. Convert to uppercase
  # 3. Truncate to 50 characters
}

class SecureDirective(BaseExtraGraphQLDirective):
    @staticmethod
    def resolve(value, args, directive, root, info, **kwargs):
        # Validate permissions
        user = info.context.user
        if not user.is_authenticated:
            return value  # Don't process for unauthenticated users

        # Sanitize input
        safe_value = escape_html(str(value))

        return process_value(safe_value)

import pytest
from graphene.test import Client

def test_uppercase_directive():
    schema = graphene.Schema(
        query=Query,
        directives=all_directives
    )
    client = Client(schema)

    query = '''
        query {
            user {
                name @uppercase
            }
        }
    '''

    result = client.execute(query)
    assert result['data']['user']['name'] == 'JOHN DOE'