codegen

type CatalogOptions struct {
	// PackageName is the package of the generated catalog file. Required.
	PackageName string

	// FileName is the output file name (default "schema.go").
	FileName string

	// Tables, when non-empty, restricts generation to these table names.
	Tables []string

	// Dialect ("postgres" or "mysql", default postgres) selects how engine
	// type names map back to decl package types.
	Dialect string
}

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

type File struct {
	Name    string
	Content []byte
}

type GoType = meta.GoType

type Options struct {
	// PackageName is the package of the generated files. Required.
	PackageName string

	// Tables, when non-empty, restricts generation to these table names.
	Tables []string

	// Dialect overrides Schema.Dialect ("postgres" or "mysql"); it selects the
	// default SQL→Go type table.
	Dialect string

	// FilePerTable writes one file per table (named "<table>.go") instead of a
	// single combined file. Use FileNameFor to customize the per-table path or
	// split tables across subdirectories.
	FilePerTable bool

	// FileName overrides the single-file output name (default "tables.go").
	// Ignored when FilePerTable or FileNameFor is set.
	FileName string

	// FileNameFor, when set, derives each table's generated file path relative to
	// the output directory, implying one file per table (FilePerTable). The
	// returned path may contain slashes to nest the file in a subdirectory, which
	// Write creates. Defaults to "<table>.go". When DTOSeparateFile is set, the
	// DTO file sits beside it with "_dto" inserted before the extension
	// (e.g. "users.go" -> "users_dto.go").
	FileNameFor func(table meta.Table) string

	// EmitRelations generates the relation-aware surface: foreign-key relation
	// metadata (table.Rels) implementing sqlkit.Relation, Query/Q entry points
	// returning a sqlkit.SelectQuery, and a columns/table struct split. Off by
	// default, so the binding stays pure metadata unless asked.
	EmitRelations bool

	// EmitDTO additionally generates a row struct (DTO) per table.
	EmitDTO bool

	// DTOSeparateFile writes the DTOs into their own file(s), separate from the
	// table bindings.
	DTOSeparateFile bool

	// TypeMapper customizes the SQL→Go type mapping. Defaults to the zero
	// DefaultTypeMapper (equivalent to NewDefaultTypeMapper(TypeMapperConfig{})).
	TypeMapper TypeMapper

	// DTOName derives the DTO type name from a table. Defaults to a singular,
	// collision-avoiding name (e.g. table "users" -> "User"). When the derived
	// name collides with a binding identifier, "Row" is appended.
	DTOName func(table meta.Table) string

	// BindingName derives the table binding's base Go identifier from a table.
	// The returned name backs every binding identifier: the package var
	// ("Users"), its table type ("UsersTable"), and—in the relation-aware
	// layout—the columns type ("UsersColumns"), its constructor
	// ("newUsersColumns"), the relations type ("UsersRels"), and the filter
	// bundle ("UsersFilter"). It is the caller's responsibility to keep the
	// returned names valid and distinct across tables.
	//
	// Returning the empty string for a table (or leaving BindingName nil) falls
	// back to the default: the exported camel-case of the table name (e.g. table
	// "users" -> "Users"). A decl catalog exposes its declared overrides as a
	// ready-made hook via Catalog.BindingNames.
	BindingName func(table meta.Table) string
}

type TypeMapper interface {
	GoTypeFor(table meta.Table, column meta.Column, dialect string) (meta.GoType, error)
}

type TypeMapperConfig struct {
	// Overrides maps a lowercase SQL/engine type name to a Go type, e.g. to map
	// every "numeric" column to a decimal type:
	//
	//	Overrides: map[string]codegen.GoType{
	//		"numeric": {ImportPath: "github.com/shopspring/decimal", Name: "decimal.Decimal"},
	//	}
	Overrides map[string]meta.GoType
	// ColumnOverrides maps a specific column to a Go type, keyed by
	// "schema.table.column", "table.column", or bare "column" (most specific
	// match wins), regardless of the column's SQL type:
	//
	//	ColumnOverrides: map[string]codegen.GoType{
	//		"users.id": {ImportPath: "github.com/google/uuid", Name: "uuid.UUID"},
	//		"metadata": {ImportPath: "encoding/json", Name: "json.RawMessage"},
	//	}
	ColumnOverrides map[string]meta.GoType
	// OverrideFunc, when set, is consulted first for each column. Return ok=true
	// with the resolved Go type to use it, ok=false to fall through to the maps,
	// pinned types, and built-in tables, or a non-nil error to fail generation.
	// It receives the table so it can decide on the table and column names.
	OverrideFunc func(table meta.Table, column meta.Column, dialect string) (gt meta.GoType, ok bool, err error)
}

type TypeMapperFunc func(table meta.Table, column meta.Column, dialect string) (meta.GoType, error)