atlasaction: support migrate/apply

atlasaction/action.go

@@ -9,11 +9,19 @@
 	_ "embed"
 	"errors"
 	"strconv"
+	"strings"
+	"text/template"
 
 	"ariga.io/atlas-go-sdk/atlasexec"
 	"github.com/sethvargo/go-githubactions"
 )
 
+var (
+	//go:embed atlas.hcl.tmpl
+	tmpl   string
+	config = template.Must(template.New("atlashcl").Parse(tmpl))
+)
+
 // MigrateApply runs the GitHub Action for "ariga/atlas-action/migrate/apply".
 func MigrateApply(ctx context.Context, client *atlasexec.Client, act *githubactions.Action) error {
 	params := &atlasexec.MigrateApplyParams{
@@ -24,6 +32,19 @@
 		TxMode:          act.GetInput("tx-mode"),  // Hidden param.
 		BaselineVersion: act.GetInput("baseline"), // Hidden param.
 	}
+	// If dir begins with atlas://, this is a cloud-based migration directory.
+	// If the user didn't provide a config URL and provided an env name, we'll
+	// generate a temporary config file containing a naked env block. This is
+	// done so Atlas can report the run to the cloud.
+	if strings.HasPrefix(params.DirURL, "atlas://") && params.Env != "" && params.ConfigURL == "" {
+		cfg, clean, err := atlasexec.TempFile(`env { name = atlas.env }`, "hcl")
+		if err != nil {
+			return err
+		}
+		// nolint:errcheck
+		defer clean()
+		params.ConfigURL = cfg
+	}
 	run, err := client.MigrateApply(ctx, params)
 	if err != nil {
 		act.SetOutput("error", err.Error())
@@ -40,3 +61,15 @@
 	act.Infof("Run complete: +%v", run)
 	return nil
 }
+
+type (
+	cloud struct {
+		Dir   string
+		Tag   string
+		Token string
+		URL   string
+	}
+	tmplParams struct {
+		Cloud cloud
+	}
+)

atlasaction/action_test.go

@@ -8,13 +8,19 @@ import (
 	"bytes"
 	"context"
 	"database/sql"
+	"encoding/base64"
 	"fmt"
+	"io"
+	"net/http"
+	"net/http/httptest"
 	"os"
 	"path/filepath"
 	"strings"
 	"testing"
+	"text/template"
 
 	"ariga.io/atlas-go-sdk/atlasexec"
+	"ariga.io/atlas/sql/migrate"
 	_ "github.com/mattn/go-sqlite3"
 	"github.com/sethvargo/go-githubactions"
 	"github.com/stretchr/testify/require"
@@ -87,6 +93,114 @@ func TestMigrateApply(t *testing.T) {
 	})
 }
 
+func TestMigrateApplyCloud(t *testing.T) {
+	handler := func(payloads *[]string) http.HandlerFunc {
+		return func(w http.ResponseWriter, r *http.Request) {
+			require.Equal(t, "Bearer token", r.Header.Get("Authorization"))
+			body := readBody(t, r.Body)
+			*payloads = append(*payloads, body)
+			switch b := body; {
+			case strings.Contains(b, "query dirState"):
+				dir := testDir(t, "./testdata/migrations")
+				ad, err := migrate.ArchiveDir(&dir)
+				require.NoError(t, err)
+				// nolint:errcheck
+				fmt.Fprintf(w, `{"data":{"dirState":{"content":%q}}}`, base64.StdEncoding.EncodeToString(ad))
+			case strings.Contains(b, "mutation ReportMigration"):
+				// nolint:errcheck
+				fmt.Fprintf(w, `{"data":{"reportMigration":{"url":"https://atlas.com"}}}`)
+			case strings.Contains(b, "query {\\n\\t\\t\\tme"):
+			default:
+				t.Log("Unhandled call: ", body)
+			}
+		}
+	}
+	t.Run("with-dir", func(t *testing.T) {
+		tt := newT(t)
+		tt.setInput("url", "sqlite://"+tt.db)
+		tt.setInput("dir", "fail")
+		tt.setInput("dir-name", "cloud-project")
+
+		err := MigrateApply(context.Background(), tt.cli, tt.act)
+		require.ErrorContains(t, err, "dir and dir-name are mutually exclusive")
+	})
+	t.Run("with-config", func(t *testing.T) {
+		tt := newT(t)
+		tt.setInput("url", "sqlite://"+tt.db)
+		tt.setInput("dir-name", "fail")
+		tt.setInput("config", "file://atlas.hcl")
+
+		err := MigrateApply(context.Background(), tt.cli, tt.act)
+		require.ErrorContains(t, err, "config and dir-name are mutually exclusive")
+	})
+	t.Run("basic", func(t *testing.T) {
+		var payloads []string
+		srv := httptest.NewServer(handler(&payloads))
+		t.Cleanup(srv.Close)
+
+		tt := newT(t)
+		tt.setInput("url", "sqlite://"+tt.db)
+		tt.setInput("dir", "atlas://cloud-project")
+		tt.setInput("env", "atlas")
+
+		// This isn't simulating a user input but is a workaround for testing Cloud API calls.
+		cfgURL := generateHCL(t, srv.URL, "token")
+		tt.setInput("config", cfgURL)
+
+		err := MigrateApply(context.Background(), tt.cli, tt.act)
+		require.NoError(t, err)
+
+		require.Len(t, payloads, 3)
+		require.Contains(t, payloads[0], "query {\\n\\t\\t\\tme")
+		require.Contains(t, payloads[1], "query dirState")
+		require.Contains(t, payloads[2], "mutation ReportMigration")
+
+		m, err := tt.outputs()
+		require.NoError(t, err)
+		require.EqualValues(t, map[string]string{
+			"current":       "",
+			"applied_count": "1",
+			"pending_count": "1",
+			"target":        "20230922132634",
+		}, m)
+	})
+	t.Run("no-env", func(t *testing.T) {
+		var payloads []string
+		srv := httptest.NewServer(handler(&payloads))
+		t.Cleanup(srv.Close)
+
+		tt := newT(t)
+		tt.setInput("url", "sqlite://"+tt.db)
+		tt.setInput("dir", "atlas://cloud-project")
+
+		// This isn't simulating a user input but is a workaround for testing Cloud API calls.
+		cfgURL := generateHCL(t, srv.URL, "token")
+		tt.setInput("config", cfgURL)
+
+		err := MigrateApply(context.Background(), tt.cli, tt.act)
+		require.NoError(t, err)
+
+		require.Len(t, payloads, 2)
+		require.Contains(t, payloads[0], "query {\\n\\t\\t\\tme")
+		require.Contains(t, payloads[1], "query dirState")
+
+		m, err := tt.outputs()
+		require.NoError(t, err)
+		require.EqualValues(t, map[string]string{
+			"current":       "",
+			"applied_count": "1",
+			"pending_count": "1",
+			"target":        "20230922132634",
+		}, m)
+	})
+}
+
+func readBody(t *testing.T, r io.Reader) string {
+	b, err := io.ReadAll(r)
+	require.NoError(t, err)
+	return string(b)
+}
+
 // sqlitedb returns a path to an initialized sqlite database file. The file is
 // created in a temporary directory and will be deleted when the test finishes.
 func sqlitedb(t *testing.T) string {
@@ -179,3 +293,49 @@ func TestSetInput(t *testing.T) {
 	require.Equal(t, "greetings", tt.act.GetInput("hello-world"))
 	require.Equal(t, "farewell", tt.act.GetInput("goodbye-friends"))
 }
+
+// testDir returns a migrate.MemDir from the given path.
+func testDir(t *testing.T, path string) (d migrate.MemDir) {
+	rd, err := os.ReadDir(path)
+	require.NoError(t, err)
+	for _, f := range rd {
+		fp := filepath.Join(path, f.Name())
+		b, err := os.ReadFile(fp)
+		require.NoError(t, err)
+		require.NoError(t, d.WriteFile(f.Name(), b))
+	}
+	return d
+}
+
+func generateHCL(t *testing.T, url, token string) string {
+	tmpl := `
+	atlas {
+		cloud {
+			token = "{{ .Token }}"
+		{{- if .URL }}
+			url = "{{ .URL }}"
+		{{- end }}
+		}	  
+	}
+	env {
+      name = atlas.env
+  	}
+	`
+	config := template.Must(template.New("atlashcl").Parse(tmpl))
+	templateParams := struct {
+		URL   string
+		Token string
+	}{
+		URL:   url,
+		Token: token,
+	}
+	var buf bytes.Buffer
+	err := config.Execute(&buf, templateParams)
+	require.NoError(t, err)
+	atlasConfigURL, clean, err := atlasexec.TempFile(buf.String(), "hcl")
+	require.NoError(t, err)
+	t.Cleanup(func() {
+		require.NoError(t, clean())
+	})
+	return atlasConfigURL
+}

atlasaction/atlas.hcl.tmpl

@@ -0,0 +1,26 @@
+{{- with .Cloud }}
+atlas {
+  cloud {
+  {{- if .Token }}
+    token = "{{ .Token }}"
+  {{- end }}
+  {{- if .URL }}
+    url = "{{ .URL }}"
+  {{- end }}
+  }
+}
+data "remote_dir" "this" {
+  name = "{{ .Dir }}"
+  {{- if .Tag }}
+  tag = "{{ .Tag }}"
+  {{- end }}
+}
+{{- end }}
+env {
+  name = atlas.env
+  migration {
+{{- with .Cloud }}
+    dir = data.remote_dir.this.url
+{{- end }}
+  }
+}