graph

type ASTVisitor ¶

type ASTVisitor struct {
	EnterField     func(field *ast.Field, ctx *ValidationContext) error
	LeaveField     func(field *ast.Field, ctx *ValidationContext) error
	EnterOperation func(op *ast.OperationDefinition, ctx *ValidationContext) error
	LeaveOperation func(op *ast.OperationDefinition, ctx *ValidationContext) error
	EnterFragment  func(frag *ast.FragmentDefinition, ctx *ValidationContext) error
	LeaveFragment  func(frag *ast.FragmentDefinition, ctx *ValidationContext) error
}

ASTVisitor allows traversing the AST with hooks

type ActionBuilder ¶

type ActionBuilder[T any, In any] struct {
	// contains filtered or unexported fields
}

func (b *ActionBuilder[T, In]) Build() MutationField

func (b *ActionBuilder[T, In]) WithResolver(
	fn func(ctx context.Context, in In) (*T, error),
) *ActionBuilder[T, In]

type ArgInfo ¶

type ArgInfo struct {
	Name         string          `json:"name"`
	Type         string          `json:"type"` // SDL-style
	Description  string          `json:"description,omitempty"`
	Required     bool            `json:"required,omitempty"`
	DefaultValue any             `json:"defaultValue,omitempty"`
	Validators   []ValidatorInfo `json:"validators,omitempty"`
}

ArgInfo describes one argument on a resolver. Required is true iff the underlying GraphQL type is NonNull. DefaultValue reflects whatever was supplied to WithArgDefault or struct-tag defaults; it's nil otherwise.

type ArgValidator ¶

type ArgValidator func(value any) error

ArgValidator is the runtime shape of a validator. Return nil when the value is acceptable; return an error whose message is user-facing.

type Args ¶

type Args struct {
	// contains filtered or unexported fields
}

Args provides type-safe access to GraphQL arguments

func NewArgs(raw map[string]interface{}) Args

func (a Args) GetArg(name string) (interface{}, bool)

func (a Args) Has(name string) bool

func (a Args) Raw() map[string]interface{}

type ArgsGetter ¶

type ArgsGetter interface {
	GetArg(name string) (interface{}, bool)
}

ArgsGetter is an interface for types that can provide arguments by name. This allows Get[T], GetE[T], GetOr[T], and MustGet[T] to work with both:

• graph.Args (from WithArg chainable API)
• graph.ArgsMap (from graphql.FieldConfigArgument / p.Args)

type ArgsMap ¶

type ArgsMap map[string]interface{}

ArgsMap wraps map[string]interface{} to implement ArgsGetter. This allows using p.Args directly with Get[T], GetE[T], etc.

Usage:

// In subscription resolvers with graphql.FieldConfigArgument
channelID := graph.Get[string](graph.ArgsMap(p.Args), "channelID")

func (m ArgsMap) GetArg(name string) (interface{}, bool)

type BaseRule ¶

type BaseRule struct {
	// contains filtered or unexported fields
}

BaseRule provides common functionality for all validation rules All custom rules should embed this struct

func NewBaseRule(name string) BaseRule

func (r *BaseRule) Disable()

func (r *BaseRule) Enable()

func (r *BaseRule) Enabled() bool

func (r *BaseRule) Name() string

func (r *BaseRule) NewError(message string) *ValidationError

func (r *BaseRule) NewErrorf(format string, args ...interface{}) *ValidationError

func (r *BaseRule) SetEnabled(enabled bool)

type BlockedFieldsRule ¶

type BlockedFieldsRule struct {
	BaseRule
	// contains filtered or unexported fields
}

BlockedFieldsRule blocks specific fields from being queried

func (r *BlockedFieldsRule) BlockField(field string, reason string) *BlockedFieldsRule

func (r *BlockedFieldsRule) Validate(ctx *ValidationContext) error

type Connection ¶

type Connection struct {
	// contains filtered or unexported fields
}

Connection represents a single WebSocket connection.

type CreateBuilder ¶

type CreateBuilder[T any, In any] struct {
	// contains filtered or unexported fields
}

func (b *CreateBuilder[T, In]) Build() MutationField

func (b *CreateBuilder[T, In]) WithResolver(
	fn func(ctx context.Context, in In) (*T, error),
) *CreateBuilder[T, In]

type DeleteBuilder ¶

type DeleteBuilder[T any, In any] struct {
	// contains filtered or unexported fields
}

func (b *DeleteBuilder[T, In]) Build() MutationField

func (b *DeleteBuilder[T, In]) WithResolver(
	fn func(ctx context.Context, in In) (*T, error),
) *DeleteBuilder[T, In]

type EchoInput ¶

type EchoInput struct {
	Message string `json:"message" graphql:"message,required" description:"Message to echo back"`
}

EchoInput is the input for the default echo mutation.

type ErrorCode ¶

type ErrorCode string

const (
	CodeInvalidInput ErrorCode = "INVALID_INPUT"
	CodeUnauthorized ErrorCode = "UNAUTHORIZED"
	CodeNotFound     ErrorCode = "NOT_FOUND"
	CodeConflict     ErrorCode = "CONFLICT"
	CodeInternal     ErrorCode = "INTERNAL"
)

type FieldConfig ¶

type FieldConfig struct {
	Resolver          graphql.FieldResolveFn
	Description       string
	Args              graphql.FieldConfigArgument
	DeprecationReason string
}

type FieldGenerator ¶

type FieldGenerator[T any] struct {
	// contains filtered or unexported fields
}

func NewFieldGenerator[T any]() *FieldGenerator[T]

type FieldInfo ¶

type FieldInfo struct {
	Name              string           `json:"name"`
	Description       string           `json:"description,omitempty"`
	Kind              FieldKind        `json:"kind"`
	ReturnType        string           `json:"returnType"` // SDL-style, e.g. "User!" or "[Advert]"
	List              bool             `json:"list,omitempty"`
	Paginated         bool             `json:"paginated,omitempty"`
	Deprecated        bool             `json:"deprecated,omitempty"`
	DeprecationReason string           `json:"deprecationReason,omitempty"`
	Args              []ArgInfo        `json:"args,omitempty"`
	Middlewares       []MiddlewareInfo `json:"middlewares,omitempty"`
	InputObject       *InputObjectInfo `json:"inputObject,omitempty"`
}

FieldInfo is a serializable snapshot of a resolver's declared metadata. It captures everything a tool would need to render documentation or a dashboard view of the field — without calling Serve() or parsing SDL.

func Inspect(f any) (FieldInfo, bool)

type FieldKind ¶

type FieldKind string

FieldKind distinguishes query / mutation / subscription at the metadata level.

const (
	FieldKindQuery        FieldKind = "query"
	FieldKindMutation     FieldKind = "mutation"
	FieldKindSubscription FieldKind = "subscription"
)

type FieldMiddleware ¶

type FieldMiddleware func(next FieldResolveFn) FieldResolveFn

FieldMiddleware wraps a field resolver with additional functionality (auth, logging, caching, etc.)

func AuthMiddleware(requiredRole string) FieldMiddleware

func CacheMiddleware(cacheKey func(ResolveParams) string) FieldMiddleware

type FieldResolveFn ¶

type FieldResolveFn func(p ResolveParams) (interface{}, error)

func LoggingMiddleware(next FieldResolveFn) FieldResolveFn

type GenericTypeInfo ¶

type GenericTypeInfo struct {
	IsGeneric     bool
	IsWrapper     bool
	BaseTypeName  string
	ElementType   reflect.Type
	WrapperFields map[string]reflect.Type
}

GenericTypeInfo holds information about a generic type

type GraphContext ¶

type GraphContext struct {
	// Schema: Provide either Schema OR SchemaParams (not both)
	// If both are nil, a default "hello world" schema will be created
	Schema *graphql.Schema

	// SchemaParams: Alternative to Schema - will be built automatically
	// If nil and Schema is also nil, defaults to hello world query/mutation
	SchemaParams *SchemaBuilderParams

	// PubSub: PubSub system for subscriptions (optional, only needed for subscriptions)
	// Use NewInMemoryPubSub() for development or RedisPubSub for production
	PubSub PubSub

	// EnableSubscriptions: Enable WebSocket support for GraphQL subscriptions
	// Default: false (subscriptions disabled)
	// Requires PubSub to be configured
	EnableSubscriptions bool

	// WebSocketPath: Path for WebSocket endpoint (default: same as HTTP endpoint)
	// If not set, WebSocket connections will be handled on the same path as HTTP
	WebSocketPath string

	// WebSocketCheckOrigin: Custom function to check WebSocket upgrade origin
	// If not provided, all origins are allowed (only use in development!)
	WebSocketCheckOrigin func(r *http.Request) bool

	// Pretty: Pretty-print JSON responses
	Pretty bool

	// GraphiQL: Enable GraphiQL interface (deprecated, use Playground instead)
	GraphiQL bool

	// Playground: Enable GraphQL Playground interface
	Playground bool

	// DEBUG mode skips validation and sanitization for easier development
	// Default: false (validation enabled)
	DEBUG bool

	// RootObjectFn: Custom function to set up root object for each request
	// Called before token extraction and user details fetching
	RootObjectFn func(ctx context.Context, r *http.Request) map[string]interface{}

	// TokenExtractorFn: Custom token extraction from request
	// If not provided, default Bearer token extraction will be used
	TokenExtractorFn func(*http.Request) string

	// UserDetailsFn: Custom user details fetching based on token
	// If not provided, user details will not be added to rootValue
	// The details are accessible in resolvers via GetRootInfo(p, "details", &user)
	//
	// The function receives the request context and token, and returns:
	//   - ctx: Updated context with custom values (accessible via p.Context.Value() in resolvers)
	//   - details: User details (accessible via GetRootInfo(p, "details", &user) in resolvers)
	//   - error: Any error during user details fetching
	//
	// Example:
	//
	//	UserDetailsFn: func(ctx context.Context, token string) (context.Context, interface{}, error) {
	//	    user, err := validateJWT(token)
	//	    if err != nil {
	//	        return ctx, nil, err
	//	    }
	//	    // Add user ID to context for access in resolvers via p.Context.Value("userID")
	//	    ctx = context.WithValue(ctx, "userID", user.ID)
	//	    return ctx, user, nil
	//	}
	UserDetailsFn func(ctx context.Context, token string) (context.Context, interface{}, error)

	// EnableValidation: Enable query validation (depth, complexity, introspection checks)
	// Default: false (validation disabled)
	// When enabled: Max depth=10, Max aliases=4, Max complexity=200, Introspection blocked
	// DEPRECATED: Use ValidationRules for more control
	EnableValidation bool

	// ValidationRules: Custom validation rules (takes precedence over EnableValidation)
	// Set to nil or empty slice to disable validation
	// Example:
	//   ValidationRules: []ValidationRule{
	//       NewMaxDepthRule(10),
	//       NewRequireAuthRule("mutation"),
	//       NewRoleRules(map[string][]string{
	//           "deleteUser": {"admin"},
	//       }),
	//   }
	ValidationRules []ValidationRule

	// ValidationOptions: Configure validation behavior (optional)
	// Default: StopOnFirstError=false, SkipInDebug=true
	ValidationOptions *ValidationOptions

	// EnableSanitization: Enable response sanitization (removes field suggestions from errors)
	// Default: false (sanitization disabled)
	// Prevents information disclosure by removing "Did you mean X?" suggestions
	EnableSanitization bool
}

GraphContext configures a GraphQL handler with schema, authentication, and security settings.

Schema Configuration (choose one):

• Schema: Use a pre-built graphql.Schema
• SchemaParams: Use the builder pattern with QueryFields and MutationFields
• Neither: A default "hello world" schema will be created

Security Modes:

• DEBUG mode (DEBUG: true): Disables all validation and sanitization for development
• Production mode (DEBUG: false): Enables validation and sanitization based on configuration flags

Authentication:

• TokenExtractorFn: Extract tokens from requests (defaults to Bearer token extraction)
• UserDetailsFn: Fetch user details from the extracted token
• RootObjectFn: Custom root object setup for advanced use cases

Example Development Setup:

ctx := &graph.GraphContext{
    SchemaParams: &graph.SchemaBuilderParams{
        QueryFields: []graph.QueryField{getUserQuery()},
    },
    DEBUG:      true,
    Playground: true,
}

Example Production Setup:

ctx := &graph.GraphContext{
    SchemaParams:       &graph.SchemaBuilderParams{...},
    DEBUG:              false,
    EnableValidation:   true,  // Max depth: 10, Max aliases: 4, Max complexity: 200
    EnableSanitization: true,  // Remove field suggestions from errors
    Playground:         false,
    UserDetailsFn: func(ctx context.Context, token string) (context.Context, interface{}, error) {
        user, err := validateJWT(token)
        if err != nil {
            return ctx, nil, err
        }
        ctx = context.WithValue(ctx, "userID", user.ID)
        return ctx, user, nil
    },
}

type HasIDInterface ¶

type HasIDInterface interface {
	GetID() string
}

HasIDInterface - implement this on your user struct for rate limiting

type HasPermissionsInterface ¶

type HasPermissionsInterface interface {
	HasPermission(permission string) bool
}

HasPermissionsInterface - implement this on your user struct for permission-based rules

type HasRolesInterface ¶

type HasRolesInterface interface {
	HasRole(role string) bool
}

HasRolesInterface - implement this on your user struct for role-based rules

type InMemoryPubSub ¶

type InMemoryPubSub struct {
	// contains filtered or unexported fields
}

InMemoryPubSub is a simple in-memory implementation of PubSub. It's suitable for development, testing, and single-instance deployments. For production multi-instance deployments, use RedisPubSub or similar.

func NewInMemoryPubSub() *InMemoryPubSub

pubsub := graph.NewInMemoryPubSub()
defer pubsub.Close()

ctx := context.Background()
sub := pubsub.Subscribe(ctx, "events")

go func() {
    for msg := range sub {
        fmt.Println("Event:", string(msg.Data))
    }
}()

pubsub.Publish(ctx, "events", map[string]string{"type": "user_created"})

func (p *InMemoryPubSub) Close() error

func (p *InMemoryPubSub) Publish(ctx context.Context, topic string, data interface{}) error

func (p *InMemoryPubSub) Subscribe(ctx context.Context, topic string) <-chan *Message

func (p *InMemoryPubSub) Unsubscribe(ctx context.Context, subscriptionID string) error

type InputAuthorizer ¶

type InputAuthorizer interface {
	Authorize(ctx context.Context) error
}

InputAuthorizer runs before Validate. Failures surface as UNAUTHORIZED.

type InputNormalizer ¶

type InputNormalizer interface{ Normalize() }

InputNormalizer lets an input struct normalize its fields (trim spaces, lowercase emails, etc.) after decoding and before validation.

type InputObjectInfo ¶

type InputObjectInfo struct {
	TypeName string `json:"typeName"`
	Nullable bool   `json:"nullable,omitempty"`
}

InputObjectInfo describes the input struct for mutations built with WithInputObject. TypeName is the Go type name; the dashboard can fetch field-level detail via standard graphql-go introspection.

type InputValidator ¶

type InputValidator interface {
	Validate(ctx context.Context) error
}

InputValidator runs after Normalize. A non-nil error short-circuits the resolver and is surfaced as INVALID_INPUT unless the returned error is already a *MutationError (in which case its Code is preserved).

type Introspectable ¶

type Introspectable interface {
	FieldInfo() FieldInfo
}

Introspectable is implemented by every QueryField, MutationField, and SubscriptionField this library produces. External tooling (dashboards, documentation generators, schema linters) can iterate a schema's fields and read their metadata without parsing Go source.

Because FieldInfo is a plain struct, the output is safe to JSON-serialize, pass across goroutines, and diff between builds.

Typical consumer:

for _, qf := range schemaParams.QueryFields {
    info, ok := graph.Inspect(qf)
    if !ok { continue }
    fmt.Printf("%s(%v) -> %s [mws=%d]\n",
        info.Name, info.Args, info.ReturnType, len(info.Middlewares))
}

type JSONTime ¶

type JSONTime time.Time

JSONTime is a custom time type that handles flexible JSON time formats. It supports both RFC3339 strings and array formats commonly used in some APIs.

Supported input formats:

• RFC3339 string: "2024-01-15T14:30:00Z"
• Array format: [year, month, day, hour, minute, second, nanosecond]
• Minimum array: [2024, 1, 15] (time components default to 0)

Output format:

• Always RFC3339 string: "2024-01-15T14:30:00Z"

Example usage:

type Event struct {
    Name      string         `json:"name"`
    StartTime graph.JSONTime `json:"startTime"`
}

// Accepts: {"startTime": "2024-01-15T14:30:00Z"}
// Accepts: {"startTime": [2024, 1, 15, 14, 30, 0]}
// Outputs: {"startTime": "2024-01-15T14:30:00Z"}

func (t JSONTime) MarshalJSON() ([]byte, error)

func (t JSONTime) Time() time.Time

var event Event
json.Unmarshal(data, &event)
standardTime := event.StartTime.Time()
// Now use standard time operations
if standardTime.After(time.Now()) { ... }

func (t *JSONTime) UnmarshalJSON(data []byte) error

type MaxAliasesRule ¶

type MaxAliasesRule struct {
	BaseRule
	// contains filtered or unexported fields
}

MaxAliasesRule validates number of aliases

func (r *MaxAliasesRule) Validate(ctx *ValidationContext) error

type MaxComplexityRule ¶

type MaxComplexityRule struct {
	BaseRule
	// contains filtered or unexported fields
}

MaxComplexityRule validates query complexity

func (r *MaxComplexityRule) Validate(ctx *ValidationContext) error

type MaxDepthRule ¶

type MaxDepthRule struct {
	BaseRule
	// contains filtered or unexported fields
}

MaxDepthRule validates maximum query depth

func (r *MaxDepthRule) Validate(ctx *ValidationContext) error

type MaxTokensRule ¶

type MaxTokensRule struct {
	BaseRule
	// contains filtered or unexported fields
}

MaxTokensRule limits query size by token count

func (r *MaxTokensRule) Validate(ctx *ValidationContext) error

type Message ¶

type Message struct {
	// Topic is the channel/topic name where this message was published
	Topic string

	// Data is the JSON-encoded payload
	Data []byte
}

Message represents a published message with its topic and data payload.

type MiddlewareInfo ¶

type MiddlewareInfo struct {
	Name        string `json:"name"`
	Description string `json:"description,omitempty"`
}

MiddlewareInfo is the metadata recorded by WithNamedMiddleware. Middlewares added via plain WithMiddleware have Name == "anonymous".

type MultiValidationError ¶

type MultiValidationError struct {
	Errors []error
}

MultiValidationError combines multiple validation errors

func NewMultiValidationError(errors []error) *MultiValidationError

func (e *MultiValidationError) Error() string

type MutationBuilder ¶

type MutationBuilder[T any, In any] struct {
	// contains filtered or unexported fields
}

MutationBuilder carries config common to every mutation kind. It deliberately exposes no WithResolver or Build — you must call Create/Update/Delete/Action/ Upsert to transition to a kind-specific builder.

func NewMutation[T any, In any](name string) *MutationBuilder[T, In]

graph.NewMutation[User, CreateUserInput]("createUser").
    Create().
    WithResolver(func(ctx context.Context, in CreateUserInput) (*User, error) {
        return userService.Create(ctx, in)
    }).
    Build()

func (b *MutationBuilder[T, In]) Action() *ActionBuilder[T, In]

func (b *MutationBuilder[T, In]) Create() *CreateBuilder[T, In]

func (b *MutationBuilder[T, In]) Delete() *DeleteBuilder[T, In]

func (b *MutationBuilder[T, In]) Update() *UpdateBuilder[T, In]

func (b *MutationBuilder[T, In]) Upsert() *UpsertBuilder[T, In]

func (b *MutationBuilder[T, In]) Use(mw ...FieldMiddleware) *MutationBuilder[T, In]

func (b *MutationBuilder[T, In]) WithDescription(d string) *MutationBuilder[T, In]

func (b *MutationBuilder[T, In]) WithInputName(n string) *MutationBuilder[T, In]

type MutationError ¶

type MutationError struct {
	Code    ErrorCode
	Field   string
	Message string
	Cause   error
}

func (e *MutationError) Error() string

func (e *MutationError) Extensions() map[string]interface{}

func (e *MutationError) Unwrap() error

type MutationField ¶

type MutationField interface {
	// Serve returns the GraphQL field configuration
	Serve() *graphql.Field

	// Name returns the field name used in the GraphQL schema
	Name() string
}

MutationField represents a GraphQL mutation field with its configuration. Implementations must provide both the field configuration and its name.

Use NewResolver to create MutationField instances:

mutation := graph.NewResolver[User]("createUser").
    WithInputObject(CreateUserInput{}).
    WithResolver(...).
    BuildMutation()

type NoIntrospectionRule ¶

type NoIntrospectionRule struct {
	BaseRule
}

NoIntrospectionRule blocks introspection queries

func (r *NoIntrospectionRule) Validate(ctx *ValidationContext) error

type PageInfo ¶

type PageInfo struct {
	HasNextPage     bool   `json:"hasNextPage" description:"Whether there are more pages"`
	HasPreviousPage bool   `json:"hasPreviousPage" description:"Whether there are previous pages"`
	StartCursor     string `json:"startCursor" description:"Cursor for the first item"`
	EndCursor       string `json:"endCursor" description:"Cursor for the last item"`
}

PageInfo contains pagination information

type PaginatedResponse ¶

type PaginatedResponse[T any] struct {
	Items      []T      `json:"items" description:"List of items"`
	TotalCount int      `json:"totalCount" description:"Total number of items"`
	PageInfo   PageInfo `json:"pageInfo" description:"Pagination information"`
}

PaginatedResponse represents a paginated response structure

type PaginationArgs ¶

type PaginationArgs struct {
	First  *int    `json:"first" description:"Number of items to fetch"`
	After  *string `json:"after" description:"Cursor to start after"`
	Last   *int    `json:"last" description:"Number of items to fetch from end"`
	Before *string `json:"before" description:"Cursor to start before"`
}

PaginationArgs contains pagination arguments

type Patch ¶

type Patch[T any] struct {
	// contains filtered or unexported fields
}

Patch wraps a decoded input with the set of fields the client sent. Only Update and Upsert resolvers receive a Patch — the framework constructs it from the raw args, so "omitted" and "set to zero value" are distinguishable.

func (p Patch[T]) Apply(dst *T)

func (p Patch[T]) Fields() []string

func (p Patch[T]) Get() T

func (p Patch[T]) Has(field string) bool

func (p Patch[T]) Presence() PresenceSet

type PatchInputValidator ¶

type PatchInputValidator interface {
	ValidatePatch(ctx context.Context, present PresenceSet) error
}

PatchInputValidator is preferred over InputValidator for Update and Upsert kinds, because it receives the set of fields the client actually sent.

type PermissionRule ¶

type PermissionRule struct {
	BaseRule
	// contains filtered or unexported fields
}

PermissionRule validates a single field requires specific permissions

func (r *PermissionRule) Validate(ctx *ValidationContext) error

type PermissionRules ¶

type PermissionRules struct {
	BaseRule
	// contains filtered or unexported fields
}

PermissionRules validates multiple fields with permission requirements

func (r *PermissionRules) Validate(ctx *ValidationContext) error

type PresenceSet ¶

type PresenceSet interface {
	Has(field string) bool
	Fields() []string
}

PresenceSet reports which fields were included in the client request. It is populated from the raw args map, not from the decoded struct, so "field sent with zero value" and "field omitted" are distinguishable.

type PubSub ¶

type PubSub interface {
	// Publish sends data to all subscribers of a topic.
	// The data will be JSON-marshaled automatically.
	//
	// Returns an error if:
	//   - JSON marshaling fails
	//   - Context is canceled
	//   - PubSub is closed
	Publish(ctx context.Context, topic string, data interface{}) error

	// Subscribe creates a new subscription to a topic.
	// Returns a channel that receives messages published to the topic.
	//
	// The subscription remains active until:
	//   - The context is canceled
	//   - Unsubscribe is called with the subscription ID
	//   - The PubSub is closed
	//
	// The returned channel will be closed when the subscription ends.
	Subscribe(ctx context.Context, topic string) <-chan *Message

	// Unsubscribe removes a subscription by its ID.
	// The subscription's message channel will be closed.
	Unsubscribe(ctx context.Context, subscriptionID string) error

	// Close shuts down the PubSub system and closes all active subscriptions.
	Close() error
}

PubSub defines the interface for publishing and subscribing to events. Implementations can use in-memory channels, Redis, Kafka, or other message brokers.

Example Usage:

pubsub := graph.NewInMemoryPubSub()
defer pubsub.Close()

// Subscribe to a topic
ctx := context.Background()
subscription := pubsub.Subscribe(ctx, "messages:channel1")

// Publish an event
pubsub.Publish(ctx, "messages:channel1", map[string]string{"text": "Hello"})

// Receive events
for msg := range subscription {
    fmt.Println("Received:", string(msg.Data))
}

type QueryASTCache ¶

type QueryASTCache struct {
	// contains filtered or unexported fields
}

QueryASTCache caches parsed GraphQL ASTs keyed by the raw query string. It is safe for concurrent use. When the cache reaches its configured max size, the entire map is replaced — a coarse eviction that keeps the implementation lock-simple and predictable for steady-state traffic.

Rules walk the AST read-only; callers MUST NOT mutate cached ASTs.

func NewQueryASTCache(maxEntries int) *QueryASTCache

type QueryField ¶

type QueryField interface {
	// Serve returns the GraphQL field configuration
	Serve() *graphql.Field

	// Name returns the field name used in the GraphQL schema
	Name() string
}

QueryField represents a GraphQL query field with its configuration. Implementations must provide both the field configuration and its name.

Use NewResolver to create QueryField instances:

query := graph.NewResolver[User]("user").
    WithArgs(...).
    WithResolver(...).
    BuildQuery()

type RateLimitOption ¶

type RateLimitOption func(*RateLimitRule)

RateLimitOption configures rate limiting behavior

func WithBudgetFunc(fn func(userID string) (int, error)) RateLimitOption

func WithBypassRoles(roles ...string) RateLimitOption

func WithCostPerUnit(cost int) RateLimitOption

type RateLimitRule ¶

type RateLimitRule struct {
	BaseRule
	// contains filtered or unexported fields
}

RateLimitRule implements per-user rate limiting based on query complexity

func (r *RateLimitRule) Validate(ctx *ValidationContext) error

type RequireAuthRule ¶

type RequireAuthRule struct {
	BaseRule
	// contains filtered or unexported fields
}

RequireAuthRule requires authentication for specific operations or fields Simply checks if ctx.UserDetails != nil

func (r *RequireAuthRule) Validate(ctx *ValidationContext) error

type ResolveParams ¶

type ResolveParams graphql.ResolveParams

type Result ¶

type Result[T any] struct {
	Value   *T
	Created bool
}

Result is the return value for an Upsert resolver. Created distinguishes insert from update so the generated payload type can expose it to clients.

type RoleRule ¶

type RoleRule struct {
	BaseRule
	// contains filtered or unexported fields
}

RoleRule validates a single field requires specific roles

func (r *RoleRule) Validate(ctx *ValidationContext) error

type RoleRules ¶

type RoleRules struct {
	BaseRule
	// contains filtered or unexported fields
}

RoleRules validates multiple fields with role requirements

func (r *RoleRules) Validate(ctx *ValidationContext) error

type RootInfo ¶

type RootInfo map[string]interface{}

RootInfo wraps map[string]interface{} to implement RootInfoGetter. This allows using p.Info.RootValue with type-safe generic functions.

Usage:

// Extract user details from root value
user := graph.GetRoot[UserDetails](graph.NewRootInfo(p), "details")

// With error handling
user, err := graph.GetRootE[UserDetails](graph.NewRootInfo(p), "details")

// With default value
token := graph.GetRootOr[string](graph.NewRootInfo(p), "token", "")

func NewRootInfo(p ResolveParams) RootInfo

rootInfo := graph.NewRootInfo(p)
user := graph.GetRoot[UserDetails](rootInfo, "details")

func (r RootInfo) GetRootValue(name string) (interface{}, bool)

type RootInfoGetter ¶

type RootInfoGetter interface {
	GetRootValue(name string) (interface{}, bool)
}

RootInfoGetter is an interface for types that can provide root value data by name. This allows GetRoot[T], GetRootE[T], GetRootOr[T], and MustGetRoot[T] to work with root value data extracted from ResolveParams.

type SchemaBuilder ¶

type SchemaBuilder struct {
	// contains filtered or unexported fields
}

SchemaBuilder builds GraphQL schemas from QueryFields and MutationFields. Use NewSchemaBuilder to create an instance and Build() to generate the schema.

func NewSchemaBuilder(params SchemaBuilderParams) *SchemaBuilder

params := graph.SchemaBuilderParams{
    QueryFields:    []graph.QueryField{getUserQuery()},
    MutationFields: []graph.MutationField{createUserMutation()},
}
builder := graph.NewSchemaBuilder(params)
schema, err := builder.Build()

func (sb *SchemaBuilder) Build() (graphql.Schema, error)

type SchemaBuilderParams ¶

type SchemaBuilderParams struct {
	// QueryFields: List of query fields to include in the schema
	QueryFields []QueryField `group:"query_fields"`

	// MutationFields: List of mutation fields to include in the schema
	MutationFields []MutationField `group:"mutation_fields"`

	// SubscriptionFields: List of subscription fields to include in the schema
	// Requires WebSocket support and PubSub configuration
	SubscriptionFields []SubscriptionField `group:"subscription_fields"`
}

SchemaBuilderParams configures the fields for building a GraphQL schema. Use this with NewSchemaBuilder to construct schemas using the builder pattern.

Example:

params := graph.SchemaBuilderParams{
    QueryFields: []graph.QueryField{
        getUserQuery(),
        listUsersQuery(),
    },
    MutationFields: []graph.MutationField{
        createUserMutation(),
        updateUserMutation(),
    },
}
schema, err := graph.NewSchemaBuilder(params).Build()

type SubscriptionField ¶

type SubscriptionField interface {
	// Serve returns the GraphQL field configuration
	Serve() *graphql.Field

	// Name returns the subscription field name
	Name() string
}

SubscriptionField represents a GraphQL subscription field that can be added to a schema. It follows the same interface pattern as QueryField and MutationField.

Create subscription fields using NewSubscription:

sub := NewSubscription[MessageEvent]("messageAdded").
    WithArgs(...).
    WithResolver(...).
    BuildSubscription()

type SubscriptionFilterFn ¶

type SubscriptionFilterFn[T any] func(ctx context.Context, data *T, p ResolveParams) bool

SubscriptionFilterFn filters events before sending them to clients. Return true to send the event, false to skip it.

This is useful for:

• User-specific filtering based on permissions
• Content-based filtering based on subscription arguments
• Rate limiting or throttling

Example:

func(ctx context.Context, data *MessageEvent, p ResolveParams) bool {
    userID, _ := GetRootString(p, "userID")
    return canUserViewMessage(userID, data.ID)
}

type SubscriptionResolveFn ¶

type SubscriptionResolveFn[T any] func(ctx context.Context, p ResolveParams) (<-chan *T, error)

SubscriptionResolveFn is the resolver function for subscriptions. It returns a channel that emits events of type T.

The resolver should:

• Create a buffered channel to prevent blocking
• Start a goroutine to handle event publishing
• Close the channel when done or context is canceled
• Handle errors by returning nil channel and an error

Example:

func(ctx context.Context, p ResolveParams) (<-chan *MessageEvent, error) {
    channelID, _ := GetArgString(p, "channelID")
    events := make(chan *MessageEvent, 10)

    subscription := pubsub.Subscribe(ctx, "messages:"+channelID)

    go func() {
        defer close(events)
        for msg := range subscription {
            var event MessageEvent
            if err := json.Unmarshal(msg.Data, &event); err == nil {
                events <- &event
            }
        }
    }()

    return events, nil
}

type SubscriptionResolver ¶

type SubscriptionResolver[T any] struct {
	// contains filtered or unexported fields
}

SubscriptionResolver builds type-safe subscription fields with extensive customization capabilities. It provides a fluent API similar to UnifiedResolver for building subscriptions.

Type Parameters:

• T: The Go struct type that will be sent to subscribers

The resolver function should return a channel that emits events of type T. When the channel is closed or the context is canceled, the subscription ends.

Basic Usage:

type MessageEvent struct {
    ID        string    `json:"id"`
    Content   string    `json:"content"`
    Timestamp time.Time `json:"timestamp"`
}

sub := NewSubscription[MessageEvent]("messageAdded").
    WithDescription("Subscribe to new messages").
    WithArgs(graphql.FieldConfigArgument{
        "channelID": &graphql.ArgumentConfig{
            Type: graphql.NewNonNull(graphql.String),
        },
    }).
    WithResolver(func(ctx context.Context, p ResolveParams) (<-chan *MessageEvent, error) {
        channelID, _ := GetArgString(p, "channelID")
        events := make(chan *MessageEvent)
        subscription := pubsub.Subscribe(ctx, "messages:"+channelID)

        go func() {
            defer close(events)
            for msg := range subscription {
                var event MessageEvent
                json.Unmarshal(msg.Data, &event)
                events <- &event
            }
        }()

        return events, nil
    }).
    WithFilter(func(ctx context.Context, data *MessageEvent, p ResolveParams) bool {
        // Optional: filter events before sending to client
        return true
    }).
    WithMiddleware(AuthMiddleware("user")).
    BuildSubscription()

Advanced Features:

// Middleware support
sub := NewSubscription[Event]("events").
    WithMiddleware(LoggingMiddleware).
    WithMiddleware(AuthMiddleware("admin")).
    // ... rest of configuration

// Field-level customization (like UnifiedResolver)
sub := NewSubscription[ComplexEvent]("complexEvent").
    WithFieldResolver("computedField", func(p ResolveParams) (interface{}, error) {
        event := p.Source.(ComplexEvent)
        return computeValue(event), nil
    }).
    // ... rest of configuration

func NewSubscription[T any](name string) *SubscriptionResolver[T]

type UserStatusEvent struct {
    UserID string `json:"userID"`
    Status string `json:"status"`
    Timestamp time.Time `json:"timestamp"`
}

sub := NewSubscription[UserStatusEvent]("userStatusChanged").
    WithArgs(graphql.FieldConfigArgument{
        "userID": &graphql.ArgumentConfig{Type: graphql.String},
    }).
    WithResolver(func(ctx context.Context, p ResolveParams) (<-chan *UserStatusEvent, error) {
        // Implementation
    }).
    BuildSubscription()

func (s *SubscriptionResolver[T]) BuildSubscription() SubscriptionField

sub := NewSubscription[MessageEvent]("messageAdded").
    WithArgs(...).
    WithResolver(...).
    BuildSubscription()

// Add to schema
schema := graph.NewSchemaBuilder(graph.SchemaBuilderParams{
    SubscriptionFields: []graph.SubscriptionField{sub},
})

func (s *SubscriptionResolver[T]) WithArgs(args graphql.FieldConfigArgument) *SubscriptionResolver[T]

WithArgs(graphql.FieldConfigArgument{
    "channelID": &graphql.ArgumentConfig{
        Type:        graphql.NewNonNull(graphql.String),
        Description: "Channel to subscribe to",
    },
    "filter": &graphql.ArgumentConfig{
        Type:        graphql.String,
        Description: "Optional filter pattern",
    },
})

func (s *SubscriptionResolver[T]) WithDescription(desc string) *SubscriptionResolver[T]

func (s *SubscriptionResolver[T]) WithFieldMiddleware(fieldName string, middleware FieldMiddleware) *SubscriptionResolver[T]

WithFieldMiddleware("sensitiveData", AuthMiddleware("admin"))

func (s *SubscriptionResolver[T]) WithFieldResolver(fieldName string, resolver graphql.FieldResolveFn) *SubscriptionResolver[T]

WithFieldResolver("author", func(p ResolveParams) (interface{}, error) {
    event := p.Source.(MessageEvent)
    return userService.GetByID(event.AuthorID), nil
})

func (s *SubscriptionResolver[T]) WithFilter(fn SubscriptionFilterFn[T]) *SubscriptionResolver[T]

WithFilter(func(ctx context.Context, data *MessageEvent, p ResolveParams) bool {
    userID, _ := GetRootString(p, "userID")
    return data.AuthorID != userID // Don't send user's own messages
})

func (s *SubscriptionResolver[T]) WithMiddleware(middleware FieldMiddleware) *SubscriptionResolver[T]

WithMiddleware(LoggingMiddleware).
WithMiddleware(AuthMiddleware("user"))

func (s *SubscriptionResolver[T]) WithResolver(fn SubscriptionResolveFn[T]) *SubscriptionResolver[T]

WithResolver(func(ctx context.Context, p ResolveParams) (<-chan *MessageEvent, error) {
    channelID, _ := GetArgString(p, "channelID")

    events := make(chan *MessageEvent, 10)
    subscription := pubsub.Subscribe(ctx, "messages:"+channelID)

    go func() {
        defer close(events)
        for msg := range subscription {
            var event MessageEvent
            if err := json.Unmarshal(msg.Data, &event); err == nil {
                events <- &event
            }
        }
    }()

    return events, nil
})

type UnifiedResolver ¶

type UnifiedResolver[T any] struct {
	// contains filtered or unexported fields
}

UnifiedResolver handles all GraphQL resolver scenarios with field-level customization

func NewResolver[T any](name string) *UnifiedResolver[T]

func NewResolverFromType(name string, returnType reflect.Type) *UnifiedResolver[any]

func (r *UnifiedResolver[T]) AsList() *UnifiedResolver[T]

func (r *UnifiedResolver[T]) AsMutation() *UnifiedResolver[T]

func (r *UnifiedResolver[T]) AsPaginated() *UnifiedResolver[T]

func (r *UnifiedResolver[T]) Build() interface{}

func (r *UnifiedResolver[T]) BuildMutation() MutationField

func (r *UnifiedResolver[T]) BuildQuery() QueryField

func (r *UnifiedResolver[T]) FieldInfo() FieldInfo

func (r *UnifiedResolver[T]) GetArgsDefinition() graphql.FieldConfigArgument

func (r *UnifiedResolver[T]) GetMiddlewareCount() int

func (r *UnifiedResolver[T]) GetMiddlewareInfos() []MiddlewareInfo

func (r *UnifiedResolver[T]) IsDeprecated() bool

func (r *UnifiedResolver[T]) IsList() bool

func (r *UnifiedResolver[T]) IsMutation() bool

func (r *UnifiedResolver[T]) IsPaginated() bool

func (r *UnifiedResolver[T]) Name() string

func (r *UnifiedResolver[T]) Serve() *graphql.Field

func (r *UnifiedResolver[T]) WithArg(name string, argType interface{}) *UnifiedResolver[T]

// With Go primitive types (recommended)
NewResolver[User]("user").
	WithArg("id", "").           // string
	WithArg("limit", 0).         // int
	WithArg("active", false).    // bool
	WithResolver(func(p ResolveParams) (*User, error) {
		id := Get[string](ArgsMap(p.Args), "id")
		return userService.GetByID(id)
	})

// With struct type (deeply nested supported)
type AddressInput struct {
	Street  string `json:"street"`
	City    string `json:"city"`
}
type UserInput struct {
	Name    string       `json:"name"`
	Address AddressInput `json:"address"`
}

NewResolver[User]("createUser").
	WithArg("input", UserInput{}).
	WithResolver(func(p ResolveParams) (*User, error) {
		input := Get[UserInput](ArgsMap(p.Args), "input")
		return userService.Create(input)
	})

func (r *UnifiedResolver[T]) WithArgDefault(name string, argType interface{}, defaultValue interface{}) *UnifiedResolver[T]

func (r *UnifiedResolver[T]) WithArgRequired(name string, argType interface{}) *UnifiedResolver[T]

func (r *UnifiedResolver[T]) WithArgValidator(argName string, validators ...Validator) *UnifiedResolver[T]

r.WithArgValidator("title", graph.Required(), graph.StringLength(1, 100))
r.WithArgValidator("email", graph.StringMatch(`^\S+@\S+$`, "must be an email"))

func (r *UnifiedResolver[T]) WithArgs(args graphql.FieldConfigArgument) *UnifiedResolver[T]

func (r *UnifiedResolver[T]) WithArgsFromStruct(structType interface{}) *UnifiedResolver[T]

func (r *UnifiedResolver[T]) WithAsyncField(fieldName string, resolver graphql.FieldResolveFn) *UnifiedResolver[T]

func (r *UnifiedResolver[T]) WithCachedField(fieldName string, cacheKeyFunc func(graphql.ResolveParams) string, resolver graphql.FieldResolveFn) *UnifiedResolver[T]

func (r *UnifiedResolver[T]) WithComputedField(name string, fieldType graphql.Output, resolver graphql.FieldResolveFn) *UnifiedResolver[T]

func (r *UnifiedResolver[T]) WithCustomField(name string, field *graphql.Field) *UnifiedResolver[T]

func (r *UnifiedResolver[T]) WithDeprecated(reason string) *UnifiedResolver[T]

func (r *UnifiedResolver[T]) WithDescription(desc string) *UnifiedResolver[T]

func (r *UnifiedResolver[T]) WithFieldMiddleware(fieldName string, middleware FieldMiddleware) *UnifiedResolver[T]

func (r *UnifiedResolver[T]) WithFieldResolver(fieldName string, resolver graphql.FieldResolveFn) *UnifiedResolver[T]

func (r *UnifiedResolver[T]) WithFieldResolvers(overrides map[string]graphql.FieldResolveFn) *UnifiedResolver[T]

func (r *UnifiedResolver[T]) WithInputObject(inputType interface{}) *UnifiedResolver[T]

func (r *UnifiedResolver[T]) WithInputObjectFieldName(name string) *UnifiedResolver[T]

func (r *UnifiedResolver[T]) WithInputObjectNullable() *UnifiedResolver[T]

func (r *UnifiedResolver[T]) WithLazyField(fieldName string, loader func(interface{}) (interface{}, error)) *UnifiedResolver[T]

func (r *UnifiedResolver[T]) WithMiddleware(middleware FieldMiddleware) *UnifiedResolver[T]

NewResolver[User]("user").
	WithMiddleware(LoggingMiddleware).
	WithMiddleware(AuthMiddleware("admin")).
	WithResolver(func(p ResolveParams) (*User, error) {
		return userService.GetByID(p.Args["id"].(int))
	}).
	BuildQuery()

func (r *UnifiedResolver[T]) WithNamedMiddleware(name, description string, middleware FieldMiddleware) *UnifiedResolver[T]

r.WithNamedMiddleware("auth", "Bearer token validation", AuthMiddleware)
r.WithNamedMiddleware("permission:admin", "Admin role required",
    PermissionMiddleware([]string{"admin"}))

func (r *UnifiedResolver[T]) WithPermission(middleware FieldMiddleware) *UnifiedResolver[T]

func (r *UnifiedResolver[T]) WithRawResolver(resolver func(ResolveParams) (any, error)) *UnifiedResolver[T]

func (r *UnifiedResolver[T]) WithResolver(resolver func(ResolveParams) (*T, error)) *UnifiedResolver[T]

NewResolver[User]("user").
	WithArg("id", graph.String).
	WithResolver(func(p graph.ResolveParams) (*User, error) {
		id := graph.Get[string](graph.ArgsMap(p.Args), "id")
		return userService.GetByID(id)
	}).BuildQuery()

NewResolver[User]("users").
	AsList().
	WithResolver(func(p graph.ResolveParams) (*[]User, error) {
		users := userService.List()
		return &users, nil
	}).BuildQuery()

NewResolver[string]("hello").
	WithResolver(func(p graph.ResolveParams) (*string, error) {
		msg := "Hello, World!"
		return &msg, nil
	}).BuildQuery()

func (r *UnifiedResolver[T]) WithTypedResolver(typedResolver interface{}) *UnifiedResolver[T]

func resolveUser(args GetUserArgs) (*User, error) {
    return &User{ID: args.ID, Name: "User"}, nil
}

NewResolver[User]("user", "User").
    WithTypedResolver(resolveUser).
    BuildQuery()

type UpdateBuilder ¶

type UpdateBuilder[T any, In any] struct {
	// contains filtered or unexported fields
}

func (b *UpdateBuilder[T, In]) Build() MutationField

func (b *UpdateBuilder[T, In]) WithResolver(
	fn func(ctx context.Context, p Patch[In]) (*T, error),
) *UpdateBuilder[T, In]

type UpsertBuilder ¶

type UpsertBuilder[T any, In any] struct {
	// contains filtered or unexported fields
}

func (b *UpsertBuilder[T, In]) Build() MutationField

func (b *UpsertBuilder[T, In]) WithResolver(
	fn func(ctx context.Context, p Patch[In]) (Result[T], error),
) *UpsertBuilder[T, In]

type ValidationContext ¶

type ValidationContext struct {
	// GraphQL query components
	Query     string
	Document  *ast.Document
	Schema    *graphql.Schema
	Variables map[string]interface{}

	// Request context
	Request *http.Request

	// User details from UserDetailsFn (can be nil if not authenticated)
	// Validation rules can type-assert this to whatever structure they need
	UserDetails interface{}
}

ValidationContext provides all necessary information for validation

type ValidationError ¶

type ValidationError struct {
	Rule     string
	Message  string
	Location *ast.Location
	Path     []string
}

ValidationError provides detailed error information

func (e *ValidationError) Error() string

type ValidationOptions ¶

type ValidationOptions struct {
	// StopOnFirstError stops validation after first error
	StopOnFirstError bool

	// SkipInDebug skips validation when DEBUG=true
	SkipInDebug bool

	// QueryCache, when non-nil, caches parsed ASTs keyed by query string so
	// repeated requests with the same query skip the parser.
	QueryCache *QueryASTCache
}

ValidationOptions configures validation behavior

type ValidationRule ¶

type ValidationRule interface {
	// Name returns a unique identifier for this rule
	Name() string

	// Validate executes the rule against the parsed query
	// Returns nil if valid, error if validation fails
	Validate(ctx *ValidationContext) error

	// Enabled checks if this rule should be executed
	Enabled() bool

	// Enable enables the rule
	Enable()

	// Disable disables the rule
	Disable()
}

ValidationRule represents a single validation rule that can be applied to GraphQL queries

func CombineRules(ruleSets ...[]ValidationRule) []ValidationRule

rules := CombineRules(
    SecurityRules,
    []ValidationRule{NewRequireAuthRule("mutation")},
)

func DefaultValidationRules() []ValidationRule

func DevelopmentValidationRules() []ValidationRule

func NewBlockedFieldsRule(fields ...string) ValidationRule

NewBlockedFieldsRule("internalUsers", "deprecatedField")

func NewMaxAliasesRule(maxAliases int) ValidationRule

func NewMaxComplexityRule(maxComplexity int) ValidationRule

func NewMaxDepthRule(maxDepth int) ValidationRule

func NewMaxTokensRule(maxTokens int) ValidationRule

func NewNoIntrospectionRule() ValidationRule

func NewPermissionRule(field string, permissions ...string) ValidationRule

NewPermissionRule("sensitiveData", "read:sensitive")
NewPermissionRule("exportData", "export:data", "admin:all")

func NewPermissionRules(config map[string][]string) ValidationRule

NewPermissionRules(map[string][]string{
    "sensitiveData": {"read:sensitive"},
    "exportData":    {"export:data"},
    "adminPanel":    {"admin:access"},
})

func NewRateLimitRule(opts ...RateLimitOption) ValidationRule

NewRateLimitRule(
    WithBudgetFunc(getBudgetFromRedis),
    WithCostPerUnit(2),
    WithBypassRoles("admin", "service"),
)

func NewRequireAuthRule(targets ...string) ValidationRule

NewRequireAuthRule("mutation", "subscription")  // Require auth for all mutations and subscriptions
NewRequireAuthRule("deleteUser", "updateUser")  // Require auth for specific fields

func NewRoleRule(field string, roles ...string) ValidationRule

NewRoleRule("deleteUser", "admin")
NewRoleRule("viewAuditLog", "admin", "auditor")

func NewRoleRules(config map[string][]string) ValidationRule

NewRoleRules(map[string][]string{
    "deleteUser":    {"admin"},
    "viewAuditLog":  {"admin", "auditor"},
    "approveOrder":  {"admin", "manager"},
})

func ProductionValidationRules() []ValidationRule

type Validator ¶

type Validator struct {
	Info ValidatorInfo
	Fn   ArgValidator
}

Validator pairs a runtime function with its metadata. Use the helpers in validators.go (Required, StringLength, StringMatch, ...) to construct these rather than populating by hand.

func Custom(name, message string, fn ArgValidator) Validator

r.WithArgValidator("slug", graph.Custom("kebab-case", "lowercase letters and hyphens only",
    func(v any) error { ... }))

func IntRange(min, max int) Validator

func OneOf(allowed ...any) Validator

func Required() Validator

func StringLength(min, max int) Validator

func StringMatch(pattern string, message ...string) Validator

type ValidatorInfo ¶

type ValidatorInfo struct {
	Kind    string `json:"kind"`
	Message string `json:"message,omitempty"`
	Details any    `json:"details,omitempty"`
}

ValidatorInfo describes a per-argument validator for dashboard display. The Kind field identifies the validator family (so a UI can render a matching icon or tooltip); Details holds the parameters (e.g. {"min":1,"max":100} for StringLength).

type WSMessage ¶

type WSMessage struct {
	ID      string                 `json:"id,omitempty"`
	Type    string                 `json:"type"`
	Payload map[string]interface{} `json:"payload,omitempty"`
}

WSMessage represents a GraphQL WebSocket Protocol message. This follows the graphql-ws protocol specification.

type WebSocketManager ¶

type WebSocketManager struct {
	// contains filtered or unexported fields
}

WebSocketManager manages WebSocket connections for GraphQL subscriptions. It handles connection lifecycle, authentication, and message routing.

func (m *WebSocketManager) CloseAllConnections()

func (m *WebSocketManager) HandleWebSocket(w http.ResponseWriter, r *http.Request)

type WebSocketParams ¶

type WebSocketParams struct {
	// Schema: The GraphQL schema with subscription fields
	Schema *graphql.Schema

	// PubSub: The PubSub system for event distribution
	PubSub PubSub

	// CheckOrigin: Function to check WebSocket upgrade origin
	// If nil, all origins are allowed (development only!)
	CheckOrigin func(r *http.Request) bool

	// AuthFn: Authentication function to extract user details from request
	// Called during connection_init phase
	AuthFn func(r *http.Request) (interface{}, error)

	// RootObjectFn: Custom function to set up root object for each connection
	// Similar to HTTP handler's RootObjectFn
	RootObjectFn func(ctx context.Context, r *http.Request) map[string]interface{}

	// PingInterval: Interval for sending ping messages (default: 30 seconds)
	// Set to 0 to disable automatic pinging
	PingInterval time.Duration

	// ConnectionTimeout: Timeout for connection_init message (default: 10 seconds)
	ConnectionTimeout time.Duration
}

WebSocketParams configures the WebSocket handler for subscriptions.