builders

type AggregatorOperator func(table exp.AliasedExpression, fields []Field) (goqu.Expression, error)

type Builder interface {
	// Query generates a read query from the GraphQL field
	Query(field Field) (Query, error)
	// Create generates an insert/create mutation query
	Create(field Field) (Query, error)
	// Update generates an update mutation query
	Update(field Field) (Query, error)
	// Delete generates a delete mutation query
	Delete(field Field) (Query, error)
	// Capabilities returns what this database supports
	Capabilities() Capabilities
}

type Capabilities struct {
	// SupportsJoins indicates if the database can perform JOIN operations.
	// False for Cassandra, true for SQL databases.
	SupportsJoins bool

	// SupportsReturning indicates if mutations can return affected rows.
	// PostgreSQL supports INSERT...RETURNING, some databases don't.
	SupportsReturning bool

	// SupportsTransactions indicates if the database supports ACID transactions.
	SupportsTransactions bool

	// MaxRelationDepth limits nested relation queries.
	// -1 = unlimited, 0 = no relations (use DataLoader pattern), N = max depth
	MaxRelationDepth int
}

type ColumnCaseConverter func(c string) string

type Config struct {
	Schema *ast.Schema
	Logger log.Logger
	// CustomOperators are user defined operators, can also be used to override existing default operators.
	CustomOperators map[string]Operator

	// TableNameGenerator allows defining how aliases "Table" names are generated in the query, this is mostly used for test
	TableNameGenerator TableNameGenerator

	// ColumnCaseConverter converts columns from ast.Field Name to database field name, by default it converts to snake case
	// but sometimes as a user you want to override this logic / define special abbreviations etc'
	ColumnCaseConverter ColumnCaseConverter

	// Dialect specifies the SQL dialect to use (e.g., "postgres", "mysql", "snowflake").
	// Defaults to "postgres" if not specified.
	Dialect string
}

type Driver interface {
	// Execute runs the query and scans results into dest
	Execute(ctx context.Context, query Query, dest any) error
	// Close closes the database connection
	Close() error
	// Dialect returns the database dialect name (e.g., "postgres", "mongodb")
	Dialect() string
}

type Field struct {
	// Original *ast.Field
	*ast.Field
	// Field sub selection, if field type is TypeScalar, selections will be empty
	Selections Fields
	// FieldType i.e Scalar/Relation/Aggregate/Object etc'
	FieldType fieldType
	// Arguments passed to this field if any.
	Arguments map[string]interface{}
	// TypeDefinition is the ast.Schema Type, this is saved for easier access
	TypeDefinition *ast.Definition
	// Parent field of this field
	Parent *Field
}

type Fields []Field

type FilterFieldContext struct {
	Filters map[string]interface{}
}

type LogicalOperator string

type OperationType string

type Operator func(table exp.AliasedExpression, key string, value interface{}) goqu.Expression

type OrderField struct {
	Key  string
	Type OrderingTypes
}

type OrderingTypes string

type Query interface {
	// Native returns the dialect-specific query object.
	// For SQL: SQLQuery{sql, args}
	// For MongoDB: mongo.Pipeline
	// For Cypher: string
	Native() any
	// String returns a human-readable representation for logging/debugging
	String() string
}

type TableNameGenerator interface {
	Generate(n int) string
}