drivers

type AarondlNull struct{}

type AarondlNullPointers struct{}

type Aliases map[string]TableAlias

type Check[Extra any] struct {
	Constraint[Extra] `yaml:",squash" json:"-"`
	Expression        string `yaml:"expression" json:"expression"`
}

type Column struct {
	Name      string `json:"name" yaml:"name"`
	DBType    string `json:"db_type" yaml:"db_type"`
	Default   string `json:"default" yaml:"default"`
	Comment   string `json:"comment" yaml:"comment"`
	Nullable  bool   `json:"nullable" yaml:"nullable"`
	Generated bool   `json:"generated" yaml:"generated"`
	AutoIncr  bool   `json:"autoincr" yaml:"autoincr"`

	// DomainName is the domain type name associated to the column. See here:
	// https://www.postgresql.org/docs/16/extend-type-system.html
	DomainName string `json:"domain_name" yaml:"domain_name"`

	Type       string   `json:"type" yaml:"type"`
	TypeLimits []string `json:"type_limits" yaml:"type_limits"`
}

type ColumnFilter map[string]Filter

type Constraint[Extra any] struct {
	Name    string   `yaml:"name" json:"name"`
	Columns []string `yaml:"columns" json:"columns"`
	Comment string   `json:"comment" yaml:"comment"`
	Extra   Extra    `yaml:"extra" json:"extra"`
}

type Constraints[Extra any] struct {
	Primary *Constraint[Extra]  `yaml:"primary" json:"primary"`
	Foreign []ForeignKey[Extra] `yaml:"foreign" json:"foreign"`
	Uniques []Constraint[Extra] `yaml:"uniques" json:"uniques"`
	Checks  []Check[Extra]      `yaml:"check" json:"check"`
}

type Constructor[ConstraintExtra, IndexExtra any] interface {
	// Load basic info about all tables
	TablesInfo(context.Context, Filter) (TablesInfo, error)
	// Load details about a single table
	TableDetails(ctx context.Context, info TableInfo, filter ColumnFilter) (schema, name string, _ []Column, _ error)
	// Load all table comments, keyed by TableInfo.Key
	Comments(ctx context.Context) (map[string]string, error)
	// Load all constraints in the database, keyed by TableInfo.Key
	Constraints(context.Context, ColumnFilter) (DBConstraints[ConstraintExtra], error)
	// Load all indexes in the database, keyed by TableInfo.Key
	Indexes(ctx context.Context) (DBIndexes[IndexExtra], error)
}

type DBConstraints[Extra any] struct {
	PKs     map[string]*Constraint[Extra]
	FKs     map[string][]ForeignKey[Extra]
	Uniques map[string][]Constraint[Extra]
	Checks  map[string][]Check[Extra]
}

type DBIndexes[Extra any] map[string][]Index[Extra]

type DBInfo[DBExtra, ConstraintExtra, IndexExtra any] struct {
	Tables       Tables[ConstraintExtra, IndexExtra] `json:"tables"`
	QueryFolders []QueryFolder                       `json:"query_folders"`
	Enums        []Enum                              `json:"enums"`
	ExtraInfo    DBExtra                             `json:"extra_info"`
	// Driver is the module name of the underlying `database/sql` driver
	Driver string `json:"driver"`
}

type DatabaseSqlNull struct{}

type Enum struct {
	Type   string
	Values []string
}

type Filter struct {
	Only   []string
	Except []string
}

type ForeignKey[Extra any] struct {
	Constraint[Extra] `yaml:",squash" json:"-"`
	ForeignTable      string   `yaml:"foreign_table" json:"foreign_table"`
	ForeignColumns    []string `yaml:"foreign_columns" json:"foreign_columns"`
}

type Index[Extra any] struct {
	Type    string        `yaml:"type" json:"type"`
	Name    string        `yaml:"name" json:"name"`
	Columns []IndexColumn `yaml:"columns" json:"columns"`
	Unique  bool          `yaml:"unique" json:"unique"`
	Comment string        `json:"comment" yaml:"comment"`
	Extra   Extra         `yaml:"extra" json:"extra"`
}

type IndexColumn struct {
	Name         string         `yaml:"name" json:"name"`
	Desc         null.Val[bool] `yaml:"desc" json:"desc"`
	IsExpression bool           `yaml:"is_expression" json:"is_expression"`
}

type Interface[DBExtra, ConstraintExtra, IndexExtra any] interface {
	// The dialect
	Dialect() string
	// Assemble the database information into a nice struct
	Assemble(ctx context.Context) (*DBInfo[DBExtra, ConstraintExtra, IndexExtra], error)
	// Custom types defined by the driver
	Types() Types
}

type NullType struct {
	// Name is the type to use for null values of this type
	Name string `yaml:"name"`
	// ValidExpr is used to check if a value of this type is valid
	// e.g. `SRC.Valid` for sql.Null[T] or `SRC.IsSet()` for null.Val[T]
	ValidExpr string `yaml:"valid_expr"`
	// UseExpr is used to convert a null value of this type
	// to a non-null value, if not provided it is assigned directly
	UseExpr string `yaml:"use_expr"`
	// Imports needed for the user expression
	UseExprImports []string `yaml:"use_expr_imports"`
	// CreateExpr is used to create a null value of this type
	// if not provided it is assigned directly
	CreateExpr string `yaml:"create_expr"`
	// Imports needed for the to null expression
	CreateExprImports []string `yaml:"create_expr_imports"`
}

type Query struct {
	Name   string        `json:"name"`
	SQL    string        `json:"raw"`
	Type   bob.QueryType `json:"type"`
	Config QueryConfig   `json:"config"`

	Columns QueryCols       `json:"columns"`
	Args    []QueryArg      `json:"args"`
	Mods    TemplateInclude `json:"mods"`
}

type QueryArg struct {
	Col       QueryCol   `json:"col"`
	Children  []QueryArg `json:"children"`
	Positions [][2]int   `json:"positions"`

	CanBeMultiple bool `json:"can_be_multiple"`
}

type QueryCol struct {
	Name       string   `json:"name"`
	DBName     string   `json:"db_name"`
	Nullable   *bool    `json:"nullable"`
	TypeName   string   `json:"type"`
	TypeLimits []string `json:"type_limits"`
}

type QueryCols []QueryCol

type QueryConfig struct {
	ResultTypeOne     string `json:"result_type_one"`
	ResultTypeAll     string `json:"result_type_all"`
	ResultTransformer string `json:"result_type_transformer"`
}

type QueryFile struct {
	Path    string  `json:"path"`
	Queries []Query `json:"queries"`
}

type QueryFolder struct {
	Path  string      `json:"path"`
	Files []QueryFile `json:"files"`
}

type Table[ConstraintExtra, IndexExtra any] struct {
	Key string `yaml:"key" json:"key"`
	// For dbs with real schemas, like Postgres.
	// Example value: "schema_name"."table_name"
	Schema      string                       `yaml:"schema" json:"schema"`
	Name        string                       `yaml:"name" json:"name"`
	Columns     []Column                     `yaml:"columns" json:"columns"`
	Indexes     []Index[IndexExtra]          `yaml:"indexes" json:"indexes"`
	Constraints Constraints[ConstraintExtra] `yaml:"constraints" json:"constraints"`
	Comment     string                       `json:"comment" yaml:"comment"`
}

type TableAlias struct {
	UpPlural     string `yaml:"up_plural,omitempty" json:"up_plural,omitempty"`
	UpSingular   string `yaml:"up_singular,omitempty" json:"up_singular,omitempty"`
	DownPlural   string `yaml:"down_plural,omitempty" json:"down_plural,omitempty"`
	DownSingular string `yaml:"down_singular,omitempty" json:"down_singular,omitempty"`

	Columns       map[string]string `yaml:"columns,omitempty" json:"columns,omitempty"`
	Relationships map[string]string `yaml:"relationships,omitempty" json:"relationships,omitempty"`
	Indexes       map[string]string `yaml:"indexes,omitempty" json:"indexes,omitempty"`
	Constraints   map[string]string `yaml:"constraints,omitempty" json:"constraints,omitempty"`
}

type TableInfo struct {
	Key     string
	Schema  string
	Name    string
	Comment string
}

type Tables[C, I any] []Table[C, I]

type TablesInfo []TableInfo

type TemplateInclude interface {
	IncludeInTemplate(language.Importer) string
}

type Type struct {
	// If this type is an alias of another type
	// this is useful to have custom randomization for a type e.g. xml
	// NOTE: If an alias is set,
	// the only other relevant fields are RandomExpr and RandomExprImports
	AliasOf string `yaml:"alias_of"`
	// Imports needed for the type
	Imports []string `yaml:"imports"`
	// Any other types that this type depends on
	DependsOn []string `yaml:"depends_on"`
	// To be used in factory.random_type
	// Use BASETYPE to reference the name of the type
	// * A variable `f` of type `faker.Faker` is available
	// * Another variable `limits` which is a slice of strings with any limits
	//   for example, a VARCHAR(255) would have limits = ["255"]
	//   another example, a DECIMAL(10,2) would have limits = ["10", "2"]
	RandomExpr string `yaml:"random_expr"`
	// Additional imports for the randomize expression
	RandomExprImports []string `yaml:"random_expr_imports"`

	// CompareExpr is used to compare two values of this type
	// if not provided, == is used
	// Use AAA and BBB as placeholders for the two values
	CompareExpr string `yaml:"compare_expr"`
	// Imports needed for the compare expression
	CompareExprImports []string `yaml:"compare_expr_imports"`

	// NullType configures the type to use for null values of this type
	// if not provided, the type is wrapped in `sql.Null[T]`
	// the method of creating a null type can be customized
	NullType NullType `yaml:"null_type"`

	// Set this to true if the randomization should not be tested
	// this is useful for low-cardinality types like bool
	NoRandomizationTest bool `yaml:"no_randomization_test"`
	// Set this to true if the test to see if the type implements
	// the scanner and valuer interfaces should be skipped
	// this is useful for types that are based on a primitive type
	NoScannerValuerTest bool `yaml:"no_scanner_valuer_test"`
}

type TypeModifier interface {
	// NullType returns the type to use for null values of the given type
	NullType(string) NullType
	// NullTypeImport
	NullTypeImports(Type) []string
	// OptionalType returns the type to use for optional values of the given type
	// fromOrToNull may be used to modify the behaviour of the `UseExpr` and `CreateExpr`
	// When `fromOrToNull` is false
	// * the `UseExpr` should convert the optional value to a non-optional value
	// * the `CreateExpr` should convert a non-optional value to an optional value
	// When `fromOrToNull` is true
	// * the `UseExpr` should convert the optional value to a non-optional but nullable value
	// * the `CreateExpr` should convert a non-optional but nullable value to an optional value
	OptionalType(typName string, def Type, isNull, fromOrToNull bool) (NullType, []string)
}

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