builders

type AggregateBuilder interface {
	Aggregate(field Field) (string, []interface{}, error)
}

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

type Builder interface {
	QueryBuilder
	AggregateBuilder
	MutationBuilder
}

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
}

type DialectDirective struct {
	Dialect       string
	ParentDialect 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 FilterContext string

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

type LogicalOperator string

type MutationBuilder interface {
	Create(field Field) (string, []interface{}, error)
	Delete(field Field) (string, []interface{}, error)
}

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 QueryBuilder interface {
	Query(field Field) (string, []interface{}, error)
}

type RelationDirective struct {
	RelType              RelationType
	BaseTable            string
	ReferenceTable       string
	Fields               []string
	References           []string
	ManyToManyTable      string
	ManyToManyReferences []string
	ManyToManyFields     []string
}

type RelationType string

type TableDirective struct {
	// Name of the table/collection
	Name string
	// Schema name table resides in, can be omitted
	Schema string
	// Dialect name the table resides in
	Dialect string
}

type TableNameGenerator interface {
	Generate(n int) string
}