migrator

type Action int

type ActionType int

type CanColumnDBType interface {
	DBType(*Column) dbtype.Type
}

type CanMigrate interface {
	CanMigrate() bool
}

type CanSQL[T any] interface {
	SQL(T) (string, []any)
}

type CantMigrate struct{}

type Changed[T any] struct {
	Old T `json:"old,omitempty"`
	New T `json:"new,omitempty"`
}

type Column struct {
	Table        Table              `json:"-"`
	Field        attrs.Field        `json:"-"`
	Name         string             `json:"name"`
	Column       string             `json:"column"`
	UseInDB      bool               `json:"use_in_db,omitempty"`
	MinLength    int64              `json:"min_length,omitempty"`
	MaxLength    int64              `json:"max_length,omitempty"`
	MinValue     float64            `json:"min_value,omitempty"`
	MaxValue     float64            `json:"max_value,omitempty"`
	Precision    int64              `json:"precision,omitempty"`
	Scale        int64              `json:"scale,omitempty"` // for decimal types
	Unique       bool               `json:"unique,omitempty"`
	Nullable     bool               `json:"nullable,omitempty"`
	Primary      bool               `json:"primary,omitempty"`
	Auto         bool               `json:"auto,omitempty"`
	Default      interface{}        `json:"default"`
	ReverseAlias string             `json:"reverse_alias,omitempty"`
	Rel          *MigrationRelation `json:"relation,omitempty"`
}

type Dependency struct {
	AppName   string
	ModelName string
	Name      string
}

type EngineOption func(*MigrationEngine)

type Index struct {
	Identifier string   `json:"name"`
	Type       string   `json:"type"`
	Fields     []string `json:"columns"`
	Unique     bool     `json:"unique,omitempty"`
	Comment    string   `json:"comment,omitempty"`
	// contains filtered or unexported fields
}

type IndexDefiner interface {
	DatabaseIndexes(obj attrs.Definer) []Index
}

type MigrationAction struct {
	ActionType ActionType            `json:"action"`
	Table      *Changed[*ModelTable] `json:"table,omitempty"`
	Field      *Changed[*Column]     `json:"field,omitempty"`
	Index      *Changed[*Index]      `json:"index,omitempty"`
}

type MigrationAppConfig interface {
	django.AppConfig
	GetMigrationFS() fs.FS
}

type MigrationEngine struct {
	// BasePath is the path to the migration directory where migration files are stored.
	//
	// This is used to read and write migration files.
	BasePath string

	// Fake indicates whether the migration engine is in fake mode.
	//
	// If true, the migration engine will not apply any migrations to the database,
	// nor will it write any migration files.
	//
	// It is useful for testing purposes or when you want to see what migrations would be applied without actually applying them.
	Fake bool

	// The path to the directory where the migration files are stored.
	//
	// This is used to load the migration files and apply them to the database.
	Paths []string

	// SchemaEditor is the schema editor used to apply the migrations to the database.
	//
	// This is used to execute SQL commands for creating, modifying, and deleting tables and columns.
	SchemaEditor SchemaEditor

	// MigrationFilesystems is the list of migration filesystems used to load the migration files.
	//
	// It is a map of application names to a slice of fs.FileSystem interfaces.
	MigrationFilesystems map[string]fs.FS

	// Migrations is the list of migration files that have been applied to the database.
	//
	// This is used to keep track of the migrations that have been applied and ensure that they are not applied again.
	Migrations map[string]map[string][]*MigrationFile

	// MigrationLog is the migration log used to log the actions taken by the migration engine.
	//
	// This is used to log the actions taken by the migration engine for debugging and auditing purposes.
	MigrationLog MigrationLog
	// contains filtered or unexported fields
}

type MigrationEngineConsoleLog struct {
	Prefix string
}

type MigrationFile struct {
	// The name of the application for this migration.
	//
	// This is used to identify the application that the migration is for.
	AppName string `json:"-"`

	// The name of the model for this migration.
	//
	// This is used to identify the model that the migration is for.
	ModelName string `json:"-"`

	// The name of the migration file.
	//
	// This is used to identify the migration and apply it in the correct order.
	Name string `json:"-"`

	// The order of the migration file.
	//
	// This is used to ensure that the migrations are applied in the correct order.
	Order int `json:"-"`

	// ContentType is the content type for the model of this migration.
	//
	// This is used to identify the model that the migration is for.
	ContentType *contenttypes.BaseContentType[attrs.Definer] `json:"-"`

	// Dependencies are the migration files that this migration depends on.
	//
	// This is used to ensure that the migrations are applied in the correct order.
	// If a migration file has dependencies, it will not be applied until all of its dependencies have been applied.
	Dependencies []Dependency `json:"dependencies,omitempty"`

	// Lazy dependencies exist in case a relation is lazy loaded - these get special handling to ensure
	// proper dependency management, as the model should be considered "generic", i.e. for defining 2 separate user models,
	// but maintaining the same relation.
	//
	// These lazy dependencies will be loaded using contenttypes.LoadModel().
	LazyDependencies []string `json:"lazy_dependencies,omitempty"`

	// The SQL commands to be executed in the
	// migration file.
	//
	// This is used to apply the migration to the database.
	Table *ModelTable `json:"table"`

	// Actions are the actions that have been taken in this migration file.
	//
	// This is used to keep track of the actions that have been taken in the migration file.
	// These actions are used to generate the migration file name, and can be used to
	// migrate the database to a different state.
	Actions []MigrationAction `json:"actions"`
}

type MigrationLog interface {
	Log(action ActionType, file *MigrationFile, table *Changed[*ModelTable], column *Changed[*Column], index *Changed[*Index])
}

type MigrationModel struct {
	CType        *contenttypes.BaseContentType[attrs.Definer] `json:"content_type"`   // The content type of the model
	LazyModelKey string                                       `json:"lazy_model_key"` // The lazy model key of the model, in case it is a lazy relation.
	// contains filtered or unexported fields
}

type MigrationRelation struct {
	Type        attrs.RelationType        `json:"type"`                // The type of the relation
	TargetModel *MigrationModel           `json:"model"`               // The target model of the relation
	TargetField attrs.FieldDefinition     `json:"field,omitempty"`     // The field in the target model
	Through     *MigrationRelationThrough `json:"through,omitempty"`   // The through model of the relation
	OnDelete    Action                    `json:"on_delete,omitempty"` // The on delete action of the relation
	OnUpdate    Action                    `json:"on_update,omitempty"` // The on update action of the relation
}

type MigrationRelationThrough struct {
	Model       *MigrationModel `json:"model"`        // The through model of the relation
	SourceField string          `json:"source_field"` // The source field of the relation
	TargetField string          `json:"target_field"` // The target field of the relation
}

type MigratorAppConfig struct {
	django.AppConfig
	MigrationFS fs.FS
}

type ModelTable struct {
	Object attrs.Definer
	Table  string
	Desc   string
	Fields *orderedmap.OrderedMap[string, Column]
	Index  []Index
}

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

type SchemaEditor interface {
	Setup(ctx context.Context) error
	StartTransaction(ctx context.Context) (drivers.Transaction, error)
	StoreMigration(ctx context.Context, appName string, modelName string, migrationName string) error
	HasMigration(ctx context.Context, appName string, modelName string, migrationName string) (bool, error)
	RemoveMigration(ctx context.Context, appName string, modelName string, migrationName string) error

	Execute(ctx context.Context, query string, args ...any) (sql.Result, error)

	CreateTable(ctx context.Context, table Table, ifNotExists bool) error
	DropTable(ctx context.Context, table Table, ifExists bool) error
	RenameTable(ctx context.Context, table Table, newName string) error

	AddIndex(ctx context.Context, table Table, index Index, ifNotExists bool) error
	DropIndex(ctx context.Context, table Table, index Index, ifExists bool) error
	RenameIndex(ctx context.Context, table Table, oldName string, newName string) error

	AddField(ctx context.Context, table Table, col Column) error
	AlterField(ctx context.Context, table Table, old Column, newCol Column) error
	RemoveField(ctx context.Context, table Table, col Column) error
}

type Table interface {
	TableName() string
	Model() attrs.Definer
	Columns() []*Column
	Comment() string
	Indexes() []Index
}