writers

type ExecutionBackend struct {
	Exec     func(context.Context, int, string) error
	Begin    func(context.Context) error
	Commit   func(context.Context) error
	Rollback func(context.Context) error
	// ScriptManaged means arbitrary scripts can commit/rollback internally.
	ScriptManaged bool
}

type ExecutionError struct {
	StatementNumber int    `json:"statement_number"`
	Statement       string `json:"statement"`
	Error           string `json:"error"`
}

type ExecutionFailure struct{ Report *ExecutionReport }

type ExecutionOperation struct {
	StatementNumber int    `json:"statement_number"`
	Name            string `json:"name,omitempty"`
	Statement       string `json:"statement"`
	Status          string `json:"status"` // applied, executed (raw script), failed, skipped, rolled_back, unknown
	Error           string `json:"error,omitempty"`
	Skip            bool   `json:"-"`
	StopOnFailure   bool   `json:"-"`
}

type ExecutionReport struct {
	Dialect              string               `json:"dialect,omitempty"`
	TotalStatements      int                  `json:"total_statements"`
	ExecutedStatements   int                  `json:"executed_statements"`
	FailedStatements     int                  `json:"failed_statements"`
	SkippedStatements    int                  `json:"skipped_statements"`
	RolledBackStatements int                  `json:"rolled_back_statements"`
	Outcome              string               `json:"outcome"`
	Operations           []ExecutionOperation `json:"operations"`
	Schemas              []SchemaReport       `json:"schemas"`
	Errors               []ExecutionError     `json:"errors,omitempty"`
	StartTime            string               `json:"start_time"`
	EndTime              string               `json:"end_time"`
}

type SchemaReport struct {
	Name   string        `json:"name"`
	Tables []TableReport `json:"tables"`
}

type TableReport struct {
	Name    string `json:"name"`
	Created bool   `json:"created"`
	Error   string `json:"error,omitempty"`
}

type Writer interface {
	// WriteDatabase takes a Database model and writes it to the desired format
	WriteDatabase(db *models.Database) error

	// WriteSchema takes a Schema model and writes it to the desired format
	WriteSchema(schema *models.Schema) error

	// WriteTable takes a Table model and writes it to the desired format
	WriteTable(table *models.Table) error
}

type WriterOptions struct {
	// StrictConversion rejects known lossy MySQL conversions before output or execution.
	StrictConversion bool
	// Warning receives conversion diagnostics. MySQL writes warnings to stderr when nil.
	Warning func(string)

	// OutputPath is the path where the output should be written
	OutputPath string

	// PackageName is the Go package name (for code generation)
	PackageName string

	// FlattenSchema disables schema.table dot notation and instead joins
	// schema and table with an underscore (e.g., "public_users").
	// Useful for databases like SQLite that do not support schemas.
	FlattenSchema bool

	// LowercaseIdentifiers lowercases PostgreSQL names and structured references before generation.
	LowercaseIdentifiers bool

	// NullableTypes selects the Go type package used for nullable columns in
	// code-generation writers (bun, gorm). Accepted values:
	//   "sqltypes"              — git.warky.dev/wdevs/relspecgo/pkg/sqltypes
	//   "stdlib"                — database/sql (sql.NullString, sql.NullInt32, …)
	//   "baselib" (default)     — plain Go pointer types (*string, *int32, …)
	NullableTypes string

	// NullableArrays selects how nullable PostgreSQL array columns are
	// represented in native-slice code-generation writers (bun). Accepted values:
	//   "slice" (default)      — plain slice for every array column
	//   "pointer_slice"        — pointer-to-slice for nullable array columns,
	//                            distinguishing SQL NULL from '{}'
	// Has no effect in "sqltypes" NullableTypes mode, which always uses the
	// SqlXxxArray wrapper types.
	NullableArrays string

	// TypeMappings overrides the SQL-to-Go type mapping of the code-generation
	// writers (bun, gorm). Keys are SQL base types (aliases are canonicalized,
	// see ParseTypeMappings), values are Go type expressions. Array columns
	// use the override for their element type. Unmapped types keep the
	// built-in defaults.
	TypeMappings map[string]string

	// Prisma7 enables Prisma 7-specific output for Prisma writers.
	Prisma7 bool

	// StrictDirectives makes dialect directive translation fail on an
	// unsupported key for the writer's own namespace instead of skipping it.
	StrictDirectives bool

	// ContinueOnError instructs SQL writers to prepend `\set ON_ERROR_STOP off`
	// to their output so that psql continues past errors instead of stopping.
	// Live SQL execution also continues when set, but still returns an error
	// if any statement fails.
	ContinueOnError bool

	// AtomicExecution applies generated DDL in one transaction. It cannot be
	// combined with ContinueOnError; raw script execution rejects it.
	AtomicExecution bool

	// Additional options can be added here as needed
	Metadata map[string]interface{}
}