cli.go

package imigrate

import (
	"errors"
	"flag"
	"os"
)

// HelpText is printed when no command is specified.
const HelpText = "Please specify up, down, redo, rollback, status, dry-run, or create."

// CLIErr is returned when no command is specified.
var CLIErr error = errors.New(HelpText)

// CLI parses os.Args[1:] and runs the appropriate migration command.
// It is a convenience wrapper around CLIWithArgs.
func CLI(migrator Migrator) error {
	return CLIWithArgs(migrator, os.Args[1:])
}

// CLIWithArgs parses the provided args and runs the appropriate migration command.
// Commands available are up, down, redo, rollback, status, dry-run, and create.
// Most commands accept a "steps" flag which is parsed as an int. Use -steps=1
// to set it.  Up, down, and redo accept a "version" flag which is parsed as
// int64. Use --version=1610069160 to set it.
func CLIWithArgs(migrator Migrator, args []string) error {
	type runner struct {
		cmd    *flag.FlagSet
		silent *bool
		run    func() error
	}

	upCmd := flag.NewFlagSet("up", flag.ContinueOnError)
	upSteps := upCmd.Int("steps", -1, "how many migrations to execute forward")
	upVersion := upCmd.Int64("version", 0, "which version to migrate")
	upSilent := upCmd.Bool("silent", false, "Do not print messages")

	dnCmd := flag.NewFlagSet("down", flag.ContinueOnError)
	dnSteps := dnCmd.Int("steps", -1, "how many migrations to execute backward")
	dnVersion := dnCmd.Int64("version", 0, "which version to migrate")
	dnSilent := dnCmd.Bool("silent", false, "Do not print messages")

	redoCmd := flag.NewFlagSet("redo", flag.ContinueOnError)
	redoSteps := redoCmd.Int("steps", 1, "how many migrations to redo")
	redoVersion := redoCmd.Int64("version", 0, "which version to migrate")
	redoSilent := redoCmd.Bool("silent", false, "Do not print messages")

	rollbackCmd := flag.NewFlagSet("rollback", flag.ContinueOnError)
	rollbackSteps := rollbackCmd.Int("steps", 1, "how many migrations to rollback")
	rollbackSilent := rollbackCmd.Bool("silent", false, "Do not print messages")

	statusCmd := flag.NewFlagSet("status", flag.ContinueOnError)
	statusSilent := statusCmd.Bool("silent", false, "Do not print messages")

	createCmd := flag.NewFlagSet("create", flag.ContinueOnError)
	createSilent := createCmd.Bool("silent", false, "Do not print messages")

	dryRunCmd := flag.NewFlagSet("dry-run", flag.ContinueOnError)
	dryRunSteps := dryRunCmd.Int("steps", -1, "how many migrations to preview")
	dryRunVersion := dryRunCmd.Int64("version", 0, "which version to preview")
	dryRunSilent := dryRunCmd.Bool("silent", false, "Do not print messages")

	runners := []runner{
		{upCmd, upSilent, func() error { return migrator.Up(*upSteps, *upVersion) }},
		{dnCmd, dnSilent, func() error { return migrator.Down(*dnSteps, *dnVersion) }},
		{redoCmd, redoSilent, func() error { return migrator.Redo(*redoSteps, *redoVersion) }},
		{rollbackCmd, rollbackSilent, func() error { return migrator.Rollback(*rollbackSteps) }},
		{statusCmd, statusSilent, func() error { return migrator.Status() }},
		{createCmd, createSilent, func() error { return migrator.Create(createCmd.Arg(0)) }},
		{dryRunCmd, dryRunSilent, func() error { return migrator.DryRun(*dryRunSteps, *dryRunVersion) }},
	}

	if len(args) < 1 {
		return CLIErr
	}

	for _, r := range runners {
		if args[0] == r.cmd.Name() {
			err := r.cmd.Parse(args[1:])
			if err == flag.ErrHelp {
				return nil
			}
			if err != nil {
				return err
			}

			if *r.silent {
				if m, ok := migrator.(*IMigrator); ok {
					m.Logger = DiscardLogger
				}
			}
			return r.run()
		}
	}

	return CLIErr
}