mirror of https://github.com/pressly/goose.git
105 lines
3.2 KiB
Go
105 lines
3.2 KiB
Go
package goose
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"path/filepath"
|
|
)
|
|
|
|
var (
|
|
registeredGoMigrations = make(map[int64]*Migration)
|
|
)
|
|
|
|
// ResetGlobalMigrations resets the global Go migrations registry.
|
|
//
|
|
// Not safe for concurrent use.
|
|
func ResetGlobalMigrations() {
|
|
registeredGoMigrations = make(map[int64]*Migration)
|
|
}
|
|
|
|
// SetGlobalMigrations registers Go migrations globally. It returns an error if a migration with the
|
|
// same version has already been registered. Go migrations must be constructed using the
|
|
// [NewGoMigration] function.
|
|
//
|
|
// Not safe for concurrent use.
|
|
func SetGlobalMigrations(migrations ...*Migration) error {
|
|
for _, m := range migrations {
|
|
if _, ok := registeredGoMigrations[m.Version]; ok {
|
|
return fmt.Errorf("go migration with version %d already registered", m.Version)
|
|
}
|
|
if err := checkGoMigration(m); err != nil {
|
|
return fmt.Errorf("invalid go migration: %w", err)
|
|
}
|
|
registeredGoMigrations[m.Version] = m
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func checkGoMigration(m *Migration) error {
|
|
if !m.construct {
|
|
return errors.New("must use NewGoMigration to construct migrations")
|
|
}
|
|
if !m.Registered {
|
|
return errors.New("must be registered")
|
|
}
|
|
if m.Type != TypeGo {
|
|
return fmt.Errorf("type must be %q", TypeGo)
|
|
}
|
|
if m.Version < 1 {
|
|
return errors.New("version must be greater than zero")
|
|
}
|
|
if m.Source != "" {
|
|
if filepath.Ext(m.Source) != ".go" {
|
|
return fmt.Errorf("source must have .go extension: %q", m.Source)
|
|
}
|
|
// If the source is set, expect it to be a path with a numeric component that matches the
|
|
// version. This field is not intended to be used for descriptive purposes.
|
|
version, err := NumericComponent(m.Source)
|
|
if err != nil {
|
|
return fmt.Errorf("invalid source: %w", err)
|
|
}
|
|
if version != m.Version {
|
|
return fmt.Errorf("version:%d does not match numeric component in source %q", m.Version, m.Source)
|
|
}
|
|
}
|
|
if err := checkGoFunc(m.goUp); err != nil {
|
|
return fmt.Errorf("up function: %w", err)
|
|
}
|
|
if err := checkGoFunc(m.goDown); err != nil {
|
|
return fmt.Errorf("down function: %w", err)
|
|
}
|
|
if m.UpFnContext != nil && m.UpFnNoTxContext != nil {
|
|
return errors.New("must specify exactly one of UpFnContext or UpFnNoTxContext")
|
|
}
|
|
if m.UpFn != nil && m.UpFnNoTx != nil {
|
|
return errors.New("must specify exactly one of UpFn or UpFnNoTx")
|
|
}
|
|
if m.DownFnContext != nil && m.DownFnNoTxContext != nil {
|
|
return errors.New("must specify exactly one of DownFnContext or DownFnNoTxContext")
|
|
}
|
|
if m.DownFn != nil && m.DownFnNoTx != nil {
|
|
return errors.New("must specify exactly one of DownFn or DownFnNoTx")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func checkGoFunc(f *GoFunc) error {
|
|
if f.RunTx != nil && f.RunDB != nil {
|
|
return errors.New("must specify exactly one of RunTx or RunDB")
|
|
}
|
|
switch f.Mode {
|
|
case TransactionEnabled, TransactionDisabled:
|
|
// No functions, but mode is set. This is not an error. It means the user wants to
|
|
// record a version with the given mode but not run any functions.
|
|
default:
|
|
return fmt.Errorf("invalid mode: %d", f.Mode)
|
|
}
|
|
if f.RunDB != nil && f.Mode != TransactionDisabled {
|
|
return fmt.Errorf("transaction mode must be disabled or unspecified when RunDB is set")
|
|
}
|
|
if f.RunTx != nil && f.Mode != TransactionEnabled {
|
|
return fmt.Errorf("transaction mode must be enabled or unspecified when RunTx is set")
|
|
}
|
|
return nil
|
|
}
|