gotosocial/vendor/github.com/uptrace/bun/migrate/migration.go

package migrate

import (
	"bufio"
	"bytes"
	"context"
	"fmt"
	"io"
	"io/fs"
	"sort"
	"strings"
	"time"

	"github.com/uptrace/bun"
)

type Migration struct {
	bun.BaseModel

	ID         int64 `bun:",pk,autoincrement"`
	Name       string
	Comment    string `bun:"-"`
	GroupID    int64
	MigratedAt time.Time `bun:",notnull,nullzero,default:current_timestamp"`

	Up   MigrationFunc `bun:"-"`
	Down MigrationFunc `bun:"-"`
}

func (m Migration) String() string {
	return fmt.Sprintf("%s_%s", m.Name, m.Comment)
}

func (m Migration) IsApplied() bool {
	return m.ID > 0
}

type MigrationFunc func(ctx context.Context, db *bun.DB) error

func NewSQLMigrationFunc(fsys fs.FS, name string) MigrationFunc {
	return func(ctx context.Context, db *bun.DB) error {
		f, err := fsys.Open(name)
		if err != nil {
			return err
		}

		isTx := strings.HasSuffix(name, ".tx.up.sql") || strings.HasSuffix(name, ".tx.down.sql")
		return Exec(ctx, db, f, isTx)
	}
}

// Exec reads and executes the SQL migration in the f.
func Exec(ctx context.Context, db *bun.DB, f io.Reader, isTx bool) error {
	scanner := bufio.NewScanner(f)
	var queries []string

	var query []byte
	for scanner.Scan() {
		b := scanner.Bytes()

		const prefix = "--bun:"
		if bytes.HasPrefix(b, []byte(prefix)) {
			b = b[len(prefix):]
			if bytes.Equal(b, []byte("split")) {
				queries = append(queries, string(query))
				query = query[:0]
				continue
			}
			return fmt.Errorf("bun: unknown directive: %q", b)
		}

		query = append(query, b...)
		query = append(query, '\n')
	}

	if len(query) > 0 {
		queries = append(queries, string(query))
	}
	if err := scanner.Err(); err != nil {
		return err
	}

	var idb bun.IConn

	if isTx {
		tx, err := db.BeginTx(ctx, nil)
		if err != nil {
			return err
		}
		idb = tx
	} else {
		conn, err := db.Conn(ctx)
		if err != nil {
			return err
		}
		idb = conn
	}

	var retErr error
	var execErr error

	defer func() {
		if tx, ok := idb.(bun.Tx); ok {
			if execErr != nil {
				retErr = tx.Rollback()
			} else {
				retErr = tx.Commit()
			}
			return
		}

		if conn, ok := idb.(bun.Conn); ok {
			retErr = conn.Close()
			return
		}

		panic("not reached")
	}()

	for _, q := range queries {
		_, execErr = idb.ExecContext(ctx, q)
		if execErr != nil {
			return execErr
		}
	}

	return retErr
}

const goTemplate = `package %s

import (
	"context"
	"fmt"

	"github.com/uptrace/bun"
)

func init() {
	Migrations.MustRegister(func(ctx context.Context, db *bun.DB) error {
		fmt.Print(" [up migration] ")
		return nil
	}, func(ctx context.Context, db *bun.DB) error {
		fmt.Print(" [down migration] ")
		return nil
	})
}
`

const sqlTemplate = `SET statement_timeout = 0;

--bun:split

SELECT 1

--bun:split

SELECT 2
`

//------------------------------------------------------------------------------

type MigrationSlice []Migration

func (ms MigrationSlice) String() string {
	if len(ms) == 0 {
		return "empty"
	}

	if len(ms) > 5 {
		return fmt.Sprintf("%d migrations (%s ... %s)", len(ms), ms[0].Name, ms[len(ms)-1].Name)
	}

	var sb strings.Builder

	for i := range ms {
		if i > 0 {
			sb.WriteString(", ")
		}
		sb.WriteString(ms[i].String())
	}

	return sb.String()
}

// Applied returns applied migrations in descending order
// (the order is important and is used in Rollback).
func (ms MigrationSlice) Applied() MigrationSlice {
	var applied MigrationSlice
	for i := range ms {
		if ms[i].IsApplied() {
			applied = append(applied, ms[i])
		}
	}
	sortDesc(applied)
	return applied
}

// Unapplied returns unapplied migrations in ascending order
// (the order is important and is used in Migrate).
func (ms MigrationSlice) Unapplied() MigrationSlice {
	var unapplied MigrationSlice
	for i := range ms {
		if !ms[i].IsApplied() {
			unapplied = append(unapplied, ms[i])
		}
	}
	sortAsc(unapplied)
	return unapplied
}

// LastGroupID returns the last applied migration group id.
// The id is 0 when there are no migration groups.
func (ms MigrationSlice) LastGroupID() int64 {
	var lastGroupID int64
	for i := range ms {
		groupID := ms[i].GroupID
		if groupID > lastGroupID {
			lastGroupID = groupID
		}
	}
	return lastGroupID
}

// LastGroup returns the last applied migration group.
func (ms MigrationSlice) LastGroup() *MigrationGroup {
	group := &MigrationGroup{
		ID: ms.LastGroupID(),
	}
	if group.ID == 0 {
		return group
	}
	for i := range ms {
		if ms[i].GroupID == group.ID {
			group.Migrations = append(group.Migrations, ms[i])
		}
	}
	return group
}

type MigrationGroup struct {
	ID         int64
	Migrations MigrationSlice
}

func (g MigrationGroup) IsZero() bool {
	return g.ID == 0 && len(g.Migrations) == 0
}

func (g MigrationGroup) String() string {
	if g.IsZero() {
		return "nil"
	}
	return fmt.Sprintf("group #%d (%s)", g.ID, g.Migrations)
}

type MigrationFile struct {
	Name    string
	Path    string
	Content string
}

//------------------------------------------------------------------------------

type migrationConfig struct {
	nop bool
}

func newMigrationConfig(opts []MigrationOption) *migrationConfig {
	cfg := new(migrationConfig)
	for _, opt := range opts {
		opt(cfg)
	}
	return cfg
}

type MigrationOption func(cfg *migrationConfig)

func WithNopMigration() MigrationOption {
	return func(cfg *migrationConfig) {
		cfg.nop = true
	}
}

//------------------------------------------------------------------------------

func sortAsc(ms MigrationSlice) {
	sort.Slice(ms, func(i, j int) bool {
		return ms[i].Name < ms[j].Name
	})
}

func sortDesc(ms MigrationSlice) {
	sort.Slice(ms, func(i, j int) bool {
		return ms[i].Name > ms[j].Name
	})
}