Add support for git metadata on deployment resource + data source (#387)

* Support meta field on deployment resource

Closes #292

* Add support for git metadata on deployment resource + data source

Author: dglsparsons

client/deployment.go

@@ -30,6 +30,18 @@ type gitSource struct {
 	Ref       string `json:"ref"`
 }
 
+// GitMetadata mirrors the fields used by the Vercel CLI when sending gitMetadata
+// to the deployments API. All fields are optional and omitted when empty.
+type GitMetadata struct {
+	CommitAuthorName  string `json:"commitAuthorName,omitempty"`
+	CommitAuthorEmail string `json:"commitAuthorEmail,omitempty"`
+	CommitMessage     string `json:"commitMessage,omitempty"`
+	CommitRef         string `json:"commitRef,omitempty"`
+	CommitSha         string `json:"commitSha,omitempty"`
+	Dirty             bool   `json:"dirty,omitempty"`
+	RemoteUrl         string `json:"remoteUrl,omitempty"`
+}
+
 // CreateDeploymentRequest defines the request the Vercel API expects in order to create a deployment.
 type CreateDeploymentRequest struct {
 	Files       []DeploymentFile  `json:"files,omitempty"`
@@ -47,6 +59,7 @@ type CreateDeploymentRequest struct {
 	GitSource                 *gitSource        `json:"gitSource,omitempty"`
 	CustomEnvironmentSlugOrID string            `json:"customEnvironmentSlugOrId,omitempty"`
 	Meta                      map[string]string `json:"meta,omitempty"`
+	GitMetadata               *GitMetadata      `json:"gitMetadata,omitempty"`
 	Ref                       string            `json:"-"`
 }
 

vercel/data_source_deployment_test.go

@@ -2,6 +2,9 @@ package vercel_test
 
 import (
 	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
 	"testing"
 
 	"github.com/hashicorp/terraform-plugin-testing/helper/acctest"
@@ -124,3 +127,80 @@ data "vercel_deployment" "test" {
 }
 `, name)
 }
+
+// runGitDS executes a git command in the given directory for the data source tests.
+func runGitDS(t *testing.T, dir string, args ...string) {
+	t.Helper()
+	cmd := exec.Command("git", args...)
+	cmd.Dir = dir
+	cmd.Env = os.Environ()
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("git %v failed: %v\n%s", args, err, string(out))
+	}
+}
+
+func TestAcc_DeploymentDataSource_GitMetadata(t *testing.T) {
+	name := acctest.RandString(8)
+
+	// Prepare a real git repo in the examples/one directory
+	repoDir := filepath.Join("..", "vercel", "examples", "one")
+	_ = os.RemoveAll(filepath.Join(repoDir, ".git"))
+	runGitDS(t, repoDir, "init")
+	runGitDS(t, repoDir, "checkout", "-b", "main")
+	runGitDS(t, repoDir, "config", "user.email", "test@example.com")
+	runGitDS(t, repoDir, "config", "user.name", "Test User")
+	runGitDS(t, repoDir, "add", ".")
+	runGitDS(t, repoDir, "commit", "-m", "e2e: git metadata ds test")
+	runGitDS(t, repoDir, "remote", "add", "origin", fmt.Sprintf("https://github.com/%s", testGithubRepo(t)))
+	t.Cleanup(func() {
+		_ = os.RemoveAll(filepath.Join(repoDir, ".git"))
+	})
+
+	cfgHCL := fmt.Sprintf(`
+resource "vercel_project" "test" {
+  name = "test-acc-deployment-ds-gitmeta-%[1]s"
+  git_repository = {
+    type = "github"
+    repo = "%[2]s"
+  }
+}
+
+data "vercel_project_directory" "test" {
+  path = "%[3]s"
+}
+
+resource "vercel_deployment" "test" {
+  project_id  = vercel_project.test.id
+  files       = data.vercel_project_directory.test.files
+  path_prefix = data.vercel_project_directory.test.path
+}
+
+data "vercel_deployment" "by_id" {
+  id = vercel_deployment.test.id
+}
+
+data "vercel_deployment" "by_url" {
+  id = vercel_deployment.test.url
+}
+`, name, testGithubRepo(t), filepath.Clean(repoDir))
+
+	resource.Test(t, resource.TestCase{
+		ProtoV6ProviderFactories: testAccProtoV6ProviderFactories,
+		Steps: []resource.TestStep{
+			{
+				Config: cfg(cfgHCL),
+				Check: resource.ComposeAggregateTestCheckFunc(
+					// by_id assertions
+					resource.TestCheckResourceAttrSet("data.vercel_deployment.by_id", "id"),
+					resource.TestCheckResourceAttrSet("data.vercel_deployment.by_id", "meta.githubCommitSha"),
+					resource.TestCheckResourceAttrSet("data.vercel_deployment.by_id", "meta.githubCommitMessage"),
+					// by_url assertions
+					resource.TestCheckResourceAttrSet("data.vercel_deployment.by_url", "id"),
+					resource.TestCheckResourceAttrSet("data.vercel_deployment.by_url", "meta.githubCommitSha"),
+					resource.TestCheckResourceAttrSet("data.vercel_deployment.by_url", "meta.githubCommitMessage"),
+				),
+			},
+		},
+	})
+}

vercel/git_metadata.go

@@ -0,0 +1,263 @@
+package vercel
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/hashicorp/terraform-plugin-log/tflog"
+	"github.com/vercel/terraform-provider-vercel/v3/client"
+)
+
+// findRepoRoot traverses upward from startDir until it finds either
+// - .vercel/repo.json (treat as repo root), OR
+// - .git/config (or a .git file for worktrees/submodules)
+// Returns the directory path or empty string if not found.
+func findRepoRoot(startDir string) string {
+	curr := startDir
+	for {
+		if curr == "/" || curr == "." || len(curr) == 0 {
+			return ""
+		}
+
+		// .vercel/repo.json
+		if fileExists(filepath.Join(curr, ".vercel", "repo.json")) || fileExists(filepath.Join(curr, ".now", "repo.json")) {
+			return curr
+		}
+		// .git/config directory or .git file
+		if fileExists(filepath.Join(curr, ".git", "config")) || fileExists(filepath.Join(curr, ".git")) {
+			return curr
+		}
+
+		parent := filepath.Dir(curr)
+		if parent == curr {
+			return ""
+		}
+		curr = parent
+	}
+}
+
+func fileExists(path string) bool {
+	info, err := os.Lstat(path)
+	if err != nil {
+		return false
+	}
+	return info.Mode()&os.ModeSymlink != 0 || info.IsDir() || info.Mode().IsRegular()
+}
+
+// runGit executes a git command in cwd with the given timeout.
+func runGit(ctx context.Context, cwd string, timeout time.Duration, args ...string) (string, error) {
+	cctx, cancel := context.WithTimeout(ctx, timeout)
+	defer cancel()
+	cmd := exec.CommandContext(cctx, "git", args...)
+	cmd.Dir = cwd
+	var stdout, stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+	err := cmd.Run()
+	if cctx.Err() == context.DeadlineExceeded {
+		return "", fmt.Errorf("git %v timed out", args)
+	}
+	if err != nil {
+		if stderr.Len() > 0 {
+			return "", fmt.Errorf("git %v failed: %s", args, strings.TrimSpace(stderr.String()))
+		}
+		return "", err
+	}
+	return strings.TrimSpace(stdout.String()), nil
+}
+
+// collectGitMetadata collects Git metadata from repoRoot, preferring a remote url that contains
+// linkRepo (e.g. "org/repo") when provided.
+func collectGitMetadata(ctx context.Context, repoRoot string, linkRepo string) (*client.GitMetadata, error) {
+	if repoRoot == "" {
+		return nil, nil
+	}
+	// Determine remote URL(s)
+	remoteURL := ""
+	remotesOut, err := runGit(ctx, repoRoot, 2*time.Second, "remote", "-v")
+	if err == nil && remotesOut != "" {
+		lines := strings.Split(remotesOut, "\n")
+		remoteMap := map[string]string{}
+		for _, line := range lines {
+			parts := strings.Fields(line)
+			if len(parts) >= 2 {
+				name := parts[0]
+				url := parts[1]
+				// Only set if not set yet to prefer first occurrence
+				if _, ok := remoteMap[name]; !ok {
+					remoteMap[name] = url
+				}
+			}
+		}
+		if linkRepo != "" {
+			for _, url := range remoteMap {
+				if strings.Contains(url, linkRepo) {
+					remoteURL = url
+					break
+				}
+			}
+		}
+		if remoteURL == "" {
+			if u, ok := remoteMap["origin"]; ok {
+				remoteURL = u
+			} else {
+				// pick any deterministic remote (alphabetical)
+				keys := make([]string, 0, len(remoteMap))
+				for k := range remoteMap {
+					keys = append(keys, k)
+				}
+				sort.Strings(keys)
+				if len(keys) > 0 {
+					remoteURL = remoteMap[keys[0]]
+				}
+			}
+		}
+	}
+	if remoteURL == "" {
+		// Fallback to git config get origin
+		if u, err := runGit(ctx, repoRoot, 2*time.Second, "config", "--get", "remote.origin.url"); err == nil {
+			remoteURL = u
+		}
+	}
+
+	// Get last commit info
+	an, err1 := runGit(ctx, repoRoot, 2*time.Second, "log", "-1", "--pretty=%an")
+	ae, err2 := runGit(ctx, repoRoot, 2*time.Second, "log", "-1", "--pretty=%ae")
+	sub, err3 := runGit(ctx, repoRoot, 2*time.Second, "log", "-1", "--pretty=%s")
+	branch, err4 := runGit(ctx, repoRoot, 2*time.Second, "rev-parse", "--abbrev-ref", "HEAD")
+	sha, err5 := runGit(ctx, repoRoot, 2*time.Second, "rev-parse", "HEAD")
+
+	// Dirty state
+	dirtyOut, err6 := runGit(ctx, repoRoot, 2*time.Second, "--no-optional-locks", "status", "-s")
+	if err6 != nil {
+		// fallback without flag
+		dirtyOut, _ = runGit(ctx, repoRoot, 2*time.Second, "status", "-s")
+	}
+
+	// If commit info or dirty check failed entirely, skip metadata (mirror CLI best-effort)
+	if err1 != nil || err2 != nil || err3 != nil || err4 != nil || err5 != nil {
+		return nil, nil
+	}
+
+	gm := &client.GitMetadata{
+		CommitAuthorName:  an,
+		CommitAuthorEmail: ae,
+		CommitMessage:     sub,
+		CommitRef:         branch,
+		CommitSha:         sha,
+		Dirty:             strings.TrimSpace(dirtyOut) != "",
+	}
+	if remoteURL != "" {
+		gm.RemoteUrl = remoteURL
+	}
+	return gm, nil
+}
+
+// startingDirsFromFiles returns candidate starting directories ordered by shallowness
+// (fewest path separators). It resolves absolute path and symlinks.
+func startingDirsFromFiles(files []client.DeploymentFile) []string {
+	type cand struct {
+		dir   string
+		depth int
+	}
+	seen := map[string]struct{}{}
+	cands := []cand{}
+	for _, f := range files {
+		if f.File == "" { // skip
+			continue
+		}
+		abs, err := filepath.Abs(f.File)
+		if err != nil {
+			continue
+		}
+		abs, _ = filepath.EvalSymlinks(abs)
+		dir := filepath.Dir(abs)
+		if _, ok := seen[dir]; ok {
+			continue
+		}
+		seen[dir] = struct{}{}
+		depth := strings.Count(filepath.ToSlash(dir), "/")
+		cands = append(cands, cand{dir: dir, depth: depth})
+	}
+	sort.Slice(cands, func(i, j int) bool { return cands[i].depth < cands[j].depth })
+	out := make([]string, 0, len(cands))
+	for _, c := range cands {
+		out = append(out, c.dir)
+	}
+	return out
+}
+
+// detectRepoRootFromFiles picks a small number of shallowest candidates and tries to
+// discover a repo root by traversing upwards from each.
+func detectRepoRootFromFiles(files []client.DeploymentFile) string {
+	cands := startingDirsFromFiles(files)
+	limit := min(len(cands), 5)
+	for i := range limit {
+		root := findRepoRoot(cands[i])
+		if root != "" {
+			return root
+		}
+	}
+	return ""
+}
+
+// getLinkRepo returns the "org/repo" string for a linked project when available.
+func getLinkRepo(pr client.ProjectResponse) string {
+	if pr.Link == nil {
+		return ""
+	}
+	switch pr.Link.Type {
+	case "github":
+		return fmt.Sprintf("%s/%s", pr.Link.Org, pr.Link.Repo)
+	case "gitlab":
+		if pr.Link.ProjectNamespace != "" && pr.Link.ProjectURL != "" {
+			// For GitLab the CLI matches by org/repo; construct a best-effort "namespace/repo"
+			// repo name inferred from URL is handled elsewhere in client.Repository(), but here
+			// a simple contains match on namespace is still useful, so return namespace.
+			return pr.Link.ProjectNamespace
+		}
+	case "bitbucket":
+		if pr.Link.Owner != "" && pr.Link.Slug != "" {
+			return fmt.Sprintf("%s/%s", pr.Link.Owner, pr.Link.Slug)
+		}
+	}
+	return ""
+}
+
+// prepareGitMetadata best-effort detects repo root and collects git metadata.
+func prepareGitMetadata(ctx context.Context, files []client.DeploymentFile, _ string, project client.ProjectResponse) *client.GitMetadata {
+	var startRoot string
+	if len(files) > 0 {
+		startRoot = detectRepoRootFromFiles(files)
+	}
+	if startRoot == "" {
+		// Ref-only deployments or failed detection: try from current working dir
+		cwd, _ := os.Getwd()
+		startRoot = findRepoRoot(cwd)
+	}
+	if startRoot == "" {
+		return nil
+	}
+	linkRepo := getLinkRepo(project)
+	gm, err := collectGitMetadata(ctx, startRoot, linkRepo)
+	if err != nil {
+		// Log and proceed without metadata
+		tflog.Debug(ctx, fmt.Sprintf("skipping git metadata: %v", err))
+		return nil
+	}
+	if gm != nil {
+		short := gm.CommitSha
+		if len(short) > 7 {
+			short = short[:7]
+		}
+		tflog.Debug(ctx, fmt.Sprintf("attached git metadata (sha=%s, ref=%s, dirty=%t)", short, gm.CommitRef, gm.Dirty))
+	}
+	return gm
+}