@automattic/vip 4.1.5 → 4.1.8

package/internal/edgeworkers/deployment.go

@@ -1,156 +0,0 @@
-package edgeworkers
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"strings"
-)
-
-type ArtifactBuilder interface {
-	Build(context.Context, string, LocalWorker) (Artifact, error)
-}
-type Service struct {
-	API     API
-	Builder ArtifactBuilder
-}
-type PlanOptions struct {
-	AppID, EnvID                                int64
-	ProjectDir                                  string
-	Workers                                     []LocalWorker
-	SkipBuild, SkipValidate, SkipSource, Enable bool
-}
-type PlanItem struct {
-	Action                            string
-	Worker                            LocalWorker
-	Existing                          *Worker
-	Artifact                          Artifact
-	Validation                        string
-	Phases                            []string
-	Input                             WriteInput
-	CurrentLocation, ProposedLocation *Location
-	SourceMode                        string
-	EnableAfterDeploy, IntendedActive bool
-}
-type ApplyError struct {
-	AppliedNames      []string
-	FailedName        string
-	UnappliedNames    []string
-	Cause             error
-	Stage             string
-	UploadCompleted   bool
-	ActiveAfterUpload *bool
-}
-
-func (e *ApplyError) Error() string {
-	if e.Cause != nil {
-		return e.Cause.Error()
-	}
-	return "Deployment failed."
-}
-func (e *ApplyError) Unwrap() error { return e.Cause }
-
-func (s Service) PreparePlan(ctx context.Context, opts PlanOptions) ([]PlanItem, error) {
-	remote, err := s.API.List(ctx, opts.AppID, opts.EnvID)
-	if err != nil {
-		return nil, err
-	}
-	byName := map[string]*Worker{}
-	for i := range remote {
-		byName[remote[i].Name] = &remote[i]
-	}
-	items := make([]PlanItem, 0, len(opts.Workers))
-	for _, w := range opts.Workers {
-		item := PlanItem{Action: "create", Worker: w, Existing: byName[w.Manifest.Name], Validation: "skipped", Phases: []string{}, SourceMode: "store", EnableAfterDeploy: opts.Enable, IntendedActive: opts.Enable}
-		if opts.SkipBuild {
-			item.Artifact, err = ReadPrebuilt(opts.ProjectDir, w)
-		} else if s.Builder != nil {
-			item.Artifact, err = s.Builder.Build(ctx, opts.ProjectDir, w)
-		} else {
-			return nil, errors.New("No worker compiler configured.")
-		}
-		if err != nil {
-			return nil, err
-		}
-		if !opts.SkipValidate {
-			result, e := s.API.Validate(ctx, opts.EnvID, item.Artifact.Base64)
-			if e != nil {
-				return nil, e
-			}
-			if !result.Valid {
-				details := strings.Join(result.Errors, "; ")
-				if details == "" {
-					details = "unknown error"
-				}
-				return nil, fmt.Errorf("worker \"%s\" failed validation: %s", w.Manifest.Name, details)
-			}
-			item.Validation = "passed"
-			item.Phases = result.Phases
-		}
-		item.Input = WriteInput{Name: w.Manifest.Name, WASMBinary: item.Artifact.Base64, OnFailure: w.Manifest.OnFailure, Location: w.Manifest.Location}
-		if !opts.SkipSource {
-			source, e := ReadWorkerSource(w)
-			if e != nil {
-				return nil, e
-			}
-			item.Input.Source = &source
-		} else {
-			item.SourceMode = "omit"
-		}
-		item.ProposedLocation = w.Manifest.Location.Value
-		if item.Existing != nil {
-			item.Action = "update"
-			item.CurrentLocation = item.Existing.Location
-			item.IntendedActive = opts.Enable || item.Existing.Active
-			if !w.Manifest.Location.Present {
-				item.ProposedLocation = item.CurrentLocation
-			}
-			if opts.SkipSource {
-				item.SourceMode = "preserve"
-			}
-		} else if item.Input.Location.Value == nil {
-			item.Input.Location = LocationValue{}
-		}
-		items = append(items, item)
-	}
-	return items, nil
-}
-
-func newApplyError(items []PlanItem, index int, applied []string, stage string, uploaded bool, active *bool, cause error) *ApplyError {
-	e := &ApplyError{AppliedNames: append([]string{}, applied...), FailedName: items[index].Worker.Manifest.Name, UnappliedNames: []string{}, Stage: stage, UploadCompleted: uploaded, ActiveAfterUpload: active, Cause: cause}
-	for _, item := range items[index+1:] {
-		e.UnappliedNames = append(e.UnappliedNames, item.Worker.Manifest.Name)
-	}
-	return e
-}
-func (s Service) ApplyPlan(ctx context.Context, envID int64, items []PlanItem, onApplied func(PlanItem, Worker) error) error {
-	applied := []string{}
-	for i, item := range items {
-		var result Worker
-		var err error
-		if item.Action == "create" {
-			result, err = s.API.Create(ctx, envID, item.Input)
-		} else if item.Existing == nil {
-			err = fmt.Errorf("Update plan for \"%s\" has no existing worker.", item.Worker.Manifest.Name)
-		} else {
-			result, err = s.API.Update(ctx, envID, item.Existing.ID, item.Input)
-		}
-		if err != nil {
-			return newApplyError(items, i, applied, "upload", false, nil, err)
-		}
-		if item.EnableAfterDeploy && !result.Active {
-			active := result.Active
-			result, err = s.API.SetActive(ctx, envID, result.ID, true)
-			if err != nil {
-				return newApplyError(items, i, applied, "enable", true, &active, err)
-			}
-		}
-		applied = append(applied, item.Worker.Manifest.Name)
-		if onApplied != nil {
-			if err := onApplied(item, result); err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}

package/internal/edgeworkers/deployment_test.go

@@ -1,165 +0,0 @@
-package edgeworkers
-
-import (
-	"context"
-	"errors"
-	"reflect"
-	"testing"
-)
-
-type recordingAPI struct {
-	API
-	calls     []string
-	remote    []Worker
-	inputs    []WriteInput
-	failName  string
-	enableErr error
-	valid     bool
-}
-
-func (a *recordingAPI) List(context.Context, int64, int64) ([]Worker, error) {
-	a.calls = append(a.calls, "list")
-	return a.remote, nil
-}
-func (a *recordingAPI) Validate(_ context.Context, _ int64, binary string) (ValidationResult, error) {
-	a.calls = append(a.calls, "validate:"+binary)
-	return ValidationResult{Valid: a.valid, Phases: []string{"on_client_response"}}, nil
-}
-func (a *recordingAPI) Create(_ context.Context, _ int64, in WriteInput) (Worker, error) {
-	a.calls = append(a.calls, "create:"+in.Name)
-	a.inputs = append(a.inputs, in)
-	if in.Name == a.failName {
-		return Worker{}, errors.New("upload failed")
-	}
-	return Worker{ID: 9, Name: in.Name}, nil
-}
-func (a *recordingAPI) Update(_ context.Context, _ int64, id int64, in WriteInput) (Worker, error) {
-	a.calls = append(a.calls, "update:"+in.Name)
-	a.inputs = append(a.inputs, in)
-	for _, w := range a.remote {
-		if w.ID == id {
-			return w, nil
-		}
-	}
-	return Worker{ID: id, Name: in.Name}, nil
-}
-func (a *recordingAPI) SetActive(_ context.Context, _, _ int64, active bool) (Worker, error) {
-	a.calls = append(a.calls, "enable")
-	return Worker{ID: 9, Active: active}, a.enableErr
-}
-
-type buildFunc func(context.Context, string, LocalWorker) (Artifact, error)
-
-func (f buildFunc) Build(c context.Context, p string, w LocalWorker) (Artifact, error) {
-	return f(c, p, w)
-}
-
-func TestApplyStopsAfterEnableFailure(t *testing.T) {
-	api := &recordingAPI{enableErr: errors.New("timeout")}
-	s := Service{API: api}
-	items := []PlanItem{{Action: "create", Worker: LocalWorker{Manifest: Manifest{Name: "a"}}, Input: WriteInput{Name: "a"}, EnableAfterDeploy: true}, {Action: "create", Worker: LocalWorker{Manifest: Manifest{Name: "b"}}, Input: WriteInput{Name: "b"}}}
-	err := s.ApplyPlan(context.Background(), 7, items, nil)
-	var partial *ApplyError
-	if !errors.As(err, &partial) {
-		t.Fatalf("error %v", err)
-	}
-	if !reflect.DeepEqual(api.calls, []string{"create:a", "enable"}) {
-		t.Fatalf("calls %v", api.calls)
-	}
-	if partial.Stage != "enable" || !partial.UploadCompleted || partial.ActiveAfterUpload == nil || *partial.ActiveAfterUpload || !reflect.DeepEqual(partial.UnappliedNames, []string{"b"}) {
-		t.Fatalf("partial %#v", partial)
-	}
-	api = &recordingAPI{failName: "b"}
-	items = append(items, PlanItem{Worker: LocalWorker{Manifest: Manifest{Name: "c"}}})
-	items[0].EnableAfterDeploy = false
-	s.API = api
-	err = s.ApplyPlan(context.Background(), 7, items, nil)
-	if !errors.As(err, &partial) || !reflect.DeepEqual(partial.AppliedNames, []string{"a"}) || !reflect.DeepEqual(partial.UnappliedNames, []string{"c"}) || partial.Stage != "upload" {
-		t.Fatalf("partial %#v %v", partial, err)
-	}
-}
-
-func TestPrepareAllBeforeMutations(t *testing.T) {
-	for _, validationFailure := range []bool{false, true} {
-		t.Run(map[bool]string{true: "validation", false: "compile"}[validationFailure], func(t *testing.T) {
-			api := &recordingAPI{valid: !validationFailure}
-			count := 0
-			s := Service{API: api, Builder: buildFunc(func(_ context.Context, _ string, w LocalWorker) (Artifact, error) {
-				count++
-				if count == 2 && !validationFailure {
-					return Artifact{}, errors.New("compile failed")
-				}
-				return Artifact{Base64: w.Manifest.Name}, nil
-			})}
-			items, err := s.PreparePlan(context.Background(), PlanOptions{Workers: []LocalWorker{{Manifest: Manifest{Name: "a"}}, {Manifest: Manifest{Name: "b"}}}, SkipSource: true})
-			if err == nil || items != nil {
-				t.Fatalf("plan %v error %v", items, err)
-			}
-			for _, call := range api.calls {
-				if call != "list" && call != "validate:a" {
-					t.Fatalf("unexpected persistent operation: %v", api.calls)
-				}
-			}
-		})
-	}
-}
-
-func TestPreparePresenceAndActiveState(t *testing.T) {
-	dir := t.TempDir()
-	writeTestFile(t, dir, "source.ts", "")
-	current := &Location{Operator: "contains", Value: "/old"}
-	proposed := &Location{Operator: "equals", Value: "/new"}
-	for _, existing := range []bool{false, true} {
-		for _, active := range []bool{false, true} {
-			for _, enable := range []bool{false, true} {
-				for _, skipSource := range []bool{false, true} {
-					for _, location := range []LocationValue{{}, {Present: true}, {Present: true, Value: proposed}} {
-						api := &recordingAPI{valid: true}
-						if existing {
-							api.remote = []Worker{{ID: 4, Name: "a", Active: active, Location: current}}
-						}
-						s := Service{API: api, Builder: buildFunc(func(context.Context, string, LocalWorker) (Artifact, error) {
-							return Artifact{Base64: "binary", SizeBytes: 6}, nil
-						})}
-						items, err := s.PreparePlan(context.Background(), PlanOptions{Workers: []LocalWorker{{Dir: dir, Manifest: Manifest{Name: "a", Entry: "source.ts", Location: location}}}, Enable: enable, SkipSource: skipSource})
-						if err != nil || len(items) != 1 {
-							t.Fatalf("plan %v %v", items, err)
-						}
-						item := items[0]
-						if item.IntendedActive != (enable || existing && active) || item.EnableAfterDeploy != enable || item.Validation != "passed" {
-							t.Fatalf("plan %#v", item)
-						}
-						wantLocation := location.Value
-						if existing && !location.Present {
-							wantLocation = current
-						}
-						if !reflect.DeepEqual(item.ProposedLocation, wantLocation) {
-							t.Fatalf("scope %#v", item)
-						}
-						if (item.Input.Source == nil) != skipSource || item.Input.Source != nil && *item.Input.Source != "" {
-							t.Fatalf("source %#v", item.Input)
-						}
-						mode := "store"
-						if skipSource {
-							mode = "omit"
-							if existing {
-								mode = "preserve"
-							}
-						}
-						if item.SourceMode != mode {
-							t.Fatalf("mode %s", item.SourceMode)
-						}
-						if err := s.ApplyPlan(context.Background(), 7, items, nil); err != nil {
-							t.Fatal(err)
-						}
-						wantEnable := enable && !(existing && active)
-						gotEnable := api.calls[len(api.calls)-1] == "enable"
-						if wantEnable != gotEnable {
-							t.Fatalf("enable calls %v", api.calls)
-						}
-					}
-				}
-			}
-		}
-	}
-}

package/internal/edgeworkers/output.go

@@ -1,131 +0,0 @@
-package edgeworkers
-
-import (
-	"fmt"
-	"strconv"
-	"strings"
-
-	"github.com/Automattic/vip/internal/output"
-)
-
-func EscapeTerminalText(s string) string {
-	return escapeTerminalControls(s, false)
-}
-
-// EscapeTerminalSource preserves source layout. CRLF becomes LF; standalone
-// carriage returns remain escaped so source cannot overwrite terminal output.
-func EscapeTerminalSource(s string) string {
-	return escapeTerminalControls(strings.ReplaceAll(s, "\r\n", "\n"), true)
-}
-
-func escapeTerminalControls(s string, source bool) string {
-	var out strings.Builder
-	for _, r := range s {
-		if source && (r == '\n' || r == '\t') {
-			out.WriteRune(r)
-		} else if r <= 31 || r >= 127 && r <= 159 {
-			fmt.Fprintf(&out, `\u%04x`, r)
-		} else {
-			out.WriteRune(r)
-		}
-	}
-	return out.String()
-}
-func locationText(location *Location, escape func(string) string) string {
-	if location == nil {
-		return "all requests"
-	}
-	return escape(location.Operator) + ` "` + escape(location.Value) + `"`
-}
-func activeLabel(active bool) string {
-	if active {
-		return "active"
-	}
-	return "inactive"
-}
-func ListRows(workers []Worker, format string) output.OrderedRows {
-	escape := EscapeTerminalText
-	if format == "json" {
-		escape = func(s string) string { return s }
-	}
-	rows := make(output.OrderedRows, 0, len(workers))
-	for _, w := range workers {
-		phases := make([]string, len(w.Phases))
-		for i, p := range w.Phases {
-			phases[i] = escape(p)
-		}
-		active := "no"
-		if w.Active {
-			active = "yes"
-		}
-		rows = append(rows, output.OrderedRow{{Key: "id", Value: w.ID}, {Key: "name", Value: escape(w.Name)}, {Key: "active", Value: active}, {Key: "phases", Value: strings.Join(phases, ", ")}, {Key: "location", Value: locationText(w.Location, escape)}, {Key: "on_failure", Value: escape(w.OnFailure)}, {Key: "modified", Value: escape(w.UpdatedAt)}})
-	}
-	return rows
-}
-func DetailText(w Worker, source bool) string {
-	active := "no"
-	if w.Active {
-		active = "yes"
-	}
-	text := output.KeyValue([]output.Tuple{{Key: "ID", Value: strconv.FormatInt(w.ID, 10)}, {Key: "Name", Value: EscapeTerminalText(w.Name)}, {Key: "Active", Value: active}, {Key: "Phases", Value: escapedJoin(w.Phases, ", ", "")}, {Key: "Location", Value: locationText(w.Location, EscapeTerminalText)}, {Key: "On failure", Value: EscapeTerminalText(w.OnFailure)}, {Key: "Created", Value: EscapeTerminalText(w.CreatedAt)}, {Key: "Modified", Value: EscapeTerminalText(w.UpdatedAt)}})
-	if source {
-		value := "(no source stored)"
-		if w.Source != nil {
-			value = EscapeTerminalSource(*w.Source)
-		}
-		text += "\n\nSource:\n" + value
-	}
-	return text
-}
-func PlanRows(items []PlanItem) output.OrderedRows {
-	rows := make(output.OrderedRows, 0, len(items))
-	for _, item := range items {
-		current := "new"
-		if item.Existing != nil {
-			current = activeLabel(item.Existing.Active)
-		}
-		rows = append(rows, output.OrderedRow{{Key: "worker", Value: EscapeTerminalText(item.Worker.Manifest.Name)}, {Key: "action", Value: item.Action}, {Key: "current_active", Value: current}, {Key: "final_active", Value: activeLabel(item.IntendedActive)}, {Key: "current_scope", Value: locationText(item.CurrentLocation, EscapeTerminalText)}, {Key: "proposed_scope", Value: locationText(item.ProposedLocation, EscapeTerminalText)}, {Key: "validation", Value: item.Validation}, {Key: "phases", Value: escapedJoin(item.Phases, ", ", "none")}, {Key: "bytes", Value: strconv.FormatInt(item.Artifact.SizeBytes, 10)}, {Key: "source", Value: item.SourceMode}})
-	}
-	return rows
-}
-func AppliedMessage(item PlanItem, w Worker) string {
-	name := EscapeTerminalText(item.Worker.Manifest.Name)
-	result := ""
-	if item.Action == "create" {
-		result = fmt.Sprintf("created \"%s\"; inactive", name)
-		if w.Active {
-			result = fmt.Sprintf("created \"%s\" and enabled it", name)
-		}
-	} else if w.Active {
-		result = fmt.Sprintf("updated \"%s\" and enabled it", name)
-		if item.Existing != nil && item.Existing.Active {
-			result = fmt.Sprintf("updated \"%s\"; remains active", name)
-		}
-	} else {
-		result = fmt.Sprintf("updated \"%s\"; remains inactive", name)
-	}
-	return fmt.Sprintf("✓ %s (%d bytes, phases: %s)", result, item.Artifact.SizeBytes, escapedJoin(w.Phases, ", ", "none"))
-}
-func InactiveCreateGuidance(names []string) string {
-	quoted := make([]string, len(names))
-	for i, name := range names {
-		quoted[i] = `"` + EscapeTerminalText(name) + `"`
-	}
-	joined := strings.Join(quoted, ", ")
-	if len(names) == 1 {
-		return fmt.Sprintf("Review created inactive edge worker %s, then run `vip edge-workers enable <name>` when ready.", joined)
-	}
-	return fmt.Sprintf("Review created inactive edge workers %s, then run `vip edge-workers enable <name>` for each one when ready.", joined)
-}
-func PartialFailureMessage(e *ApplyError) string {
-	cause := EscapeTerminalText(e.Error())
-	name := EscapeTerminalText(e.FailedName)
-	if e.Stage == "enable" {
-		active := "unknown"
-		if e.ActiveAfterUpload != nil {
-			active = activeLabel(*e.ActiveAfterUpload)
-		}
-		return fmt.Sprintf("Deployment uploaded \"%s\" and its last confirmed state was %s, but the enable request failed. Final active state is unknown; verify with `vip edge-workers get %s` or `vip edge-workers list`. Completed: %s. Not attempted: %s. Cause: %s", name, active, name, escapedJoin(e.AppliedNames, ", ", "none"), escapedJoin(e.UnappliedNames, ", ", "none"), cause)
-	}
-	return fmt.Sprintf("Deployment stopped at \"%s\". Applied: %s. Not applied: %s. Cause: %s", name, escapedJoin(e.AppliedNames, ", ", "none"), escapedJoin(e.UnappliedNames, ", ", "none"), cause)
-}

package/internal/edgeworkers/output_test.go

@@ -1,98 +0,0 @@
-package edgeworkers
-
-import (
-	"bytes"
-	json "encoding/json/v2"
-	"errors"
-	"github.com/Automattic/vip/internal/output"
-	"strings"
-	"testing"
-)
-
-func TestListJSONPreservesControlValues(t *testing.T) {
-	var buf bytes.Buffer
-	name := "headers\x1b\n\u009b"
-	if err := output.Render(&buf, output.Format("json"), ListRows([]Worker{{Name: name}}, "json")); err != nil {
-		t.Fatal(err)
-	}
-	if !strings.Contains(buf.String(), `headers\u001b\n\u009b`) {
-		t.Fatalf("JSON bytes: %q", buf.String())
-	}
-	var rows []map[string]any
-	if err := json.Unmarshal(buf.Bytes(), &rows); err != nil || rows[0]["name"] != name {
-		t.Fatalf("JSON value: %v %v", rows, err)
-	}
-}
-
-func TestDetailSourcePreservesFormatting(t *testing.T) {
-	for _, tc := range []struct{ name, source, want string }{
-		{"newlines and tabs", "// café\n\nexport function run(): void {\n\treturn;\n}\n", "// café\n\nexport function run(): void {\n\treturn;\n}\n"},
-		{"Windows line endings", "export {};\r\n\t// comment\r\n", "export {};\n\t// comment\n"},
-		{"terminal controls", "\x00\a\b\v\f\r\x1b[2J\x7f\u0085\u009b31m", `\u0000\u0007\u0008\u000b\u000c\u000d\u001b[2J\u007f\u0085\u009b31m`},
-		{"literal escape sequences", `// literal \u000a and \t`, `// literal \u000a and \t`},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			text := DetailText(Worker{Name: "headers\n\tforged", Source: &tc.source}, true)
-			metadata, source, found := strings.Cut(text, "\n\nSource:\n")
-			if !found || source != tc.want {
-				t.Fatalf("source = %q, want %q", source, tc.want)
-			}
-			if !strings.Contains(metadata, `+ Name: headers\u000a\u0009forged`) {
-				t.Fatalf("metadata escaping changed: %q", metadata)
-			}
-		})
-	}
-}
-
-func TestOutputAndConfirmation(t *testing.T) {
-	if got := EscapeTerminalText("a\n\x1b\x7f\u009b"); got != `a\u000a\u001b\u007f\u009b` {
-		t.Fatalf("escaped %q", got)
-	}
-	for _, env := range []string{"develop", "production"} {
-		for _, skip := range []bool{false, true} {
-			for _, nonInteractive := range []bool{false, true} {
-				calls := 0
-				req := ProductionConfirmation{Action: "deploy", AppName: "app\n", EnvType: env, WorkerNames: []string{"a", "b"}, EnableAfterDeploy: true, SkipConfirmation: skip, NonInteractive: nonInteractive}
-				err := ConfirmProduction(req, func(message string) (bool, error) {
-					calls++
-					if message != `Deploy and enable 2 edge workers (a, b) on app\u000a.production?` {
-						t.Fatalf("prompt %s", message)
-					}
-					return true, nil
-				})
-				needs := env == "production" && !skip
-				if needs && nonInteractive {
-					if err == nil || !strings.Contains(err.Error(), "--skip-confirmation") {
-						t.Fatalf("refusal %v", err)
-					}
-				} else if err != nil {
-					t.Fatal(err)
-				}
-				if calls != btoi(needs && !nonInteractive) {
-					t.Fatalf("prompts %d", calls)
-				}
-			}
-		}
-	}
-	err := ConfirmProduction(ProductionConfirmation{EnvType: "production", Action: "enable", WorkerNames: []string{"a"}}, func(string) (bool, error) { return false, nil })
-	if err == nil || err.Error() != "Command cancelled by user." {
-		t.Fatalf("cancel %v", err)
-	}
-	if err := ConfirmDeletion("app", "develop", "a", false, func(string) (bool, error) { return false, nil }); err == nil {
-		t.Fatal("deletion not cancelled")
-	}
-	if err := ConfirmDeletion("app", "production", "a", true, func(string) (bool, error) { t.Fatal("prompted despite force"); return false, nil }); err != nil {
-		t.Fatal(err)
-	}
-	active := false
-	msg := PartialFailureMessage(&ApplyError{FailedName: "a", Stage: "enable", UploadCompleted: true, ActiveAfterUpload: &active, Cause: errors.New("bad\nerror"), UnappliedNames: []string{"b"}})
-	if !strings.Contains(msg, "Final active state is unknown") || !strings.Contains(msg, `Cause: bad\u000aerror`) {
-		t.Fatal(msg)
-	}
-}
-func btoi(b bool) int {
-	if b {
-		return 1
-	}
-	return 0
-}