@automattic/vip 4.1.5 → 4.1.6

package/internal/devenv/syncsql_repair_test.go

@@ -1,150 +0,0 @@
-package devenv
-
-import (
-	"context"
-	"errors"
-	"io"
-	"strings"
-	"testing"
-)
-
-func TestBuildDomainRepairSQLUsesGuardedTransaction(t *testing.T) {
-	script, err := buildDomainRepairSQL([]DomainRepair{
-		{BlogID: 9, SourceDomain: "mapped.example.net", TargetDomain: "mapped-example-net-b9.mysite.vipdev.site"},
-		{BlogID: 0, SourceDomain: "recovery.example.net", TargetDomain: "recovered.mysite.vipdev.site"},
-		{BlogID: 9, SourceDomain: "mapped.example.net", TargetDomain: "mapped-example-net-b9.mysite.vipdev.site"},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	for _, want := range []string{
-		"DROP PROCEDURE IF EXISTS vip_sync_update_blog_domains;",
-		"DECLARE EXIT HANDLER FOR SQLEXCEPTION",
-		"ROLLBACK;",
-		"RESIGNAL;",
-		"information_schema.tables",
-		"table_schema = 'wordpress' AND table_name = 'wp_blogs'",
-		"START TRANSACTION;",
-		"UPDATE wordpress.wp_blogs SET domain = 'mapped-example-net-b9.mysite.vipdev.site' WHERE blog_id = 9 AND domain = 'mapped.example.net';",
-		"UPDATE wordpress.wp_blogs SET domain = 'recovered.mysite.vipdev.site' WHERE domain = 'recovery.example.net';",
-		"COMMIT;",
-		"CALL vip_sync_update_blog_domains();",
-	} {
-		if !strings.Contains(script, want) {
-			t.Errorf("script missing %q:\n%s", want, script)
-		}
-	}
-	if got := strings.Count(script, "mapped-example-net-b9.mysite.vipdev.site"); got != 1 {
-		t.Fatalf("deduplicated target count = %d, want 1:\n%s", got, script)
-	}
-	if strings.Index(script, "START TRANSACTION;") > strings.Index(script, "UPDATE wordpress.wp_blogs") ||
-		strings.Index(script, "UPDATE wordpress.wp_blogs") > strings.Index(script, "COMMIT;") {
-		t.Fatalf("transaction statement order is wrong:\n%s", script)
-	}
-}
-
-func TestBuildDomainRepairSQLRejectsConflictsAndInvalidDomains(t *testing.T) {
-	tests := []struct {
-		name    string
-		repairs []DomainRepair
-	}{
-		{
-			name: "conflicting targets",
-			repairs: []DomainRepair{
-				{BlogID: 1, SourceDomain: "old.example.com", TargetDomain: "one.mysite.vipdev.site"},
-				{BlogID: 2, SourceDomain: "old.example.com", TargetDomain: "two.mysite.vipdev.site"},
-			},
-		},
-		{
-			name: "invalid source",
-			repairs: []DomainRepair{
-				{BlogID: 1, SourceDomain: "old.example.com' OR 1=1 --", TargetDomain: "one.mysite.vipdev.site"},
-			},
-		},
-		{
-			name: "negative blog id",
-			repairs: []DomainRepair{
-				{BlogID: -1, SourceDomain: "old.example.com", TargetDomain: "one.mysite.vipdev.site"},
-			},
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if _, err := buildDomainRepairSQL(tt.repairs); err == nil {
-				t.Fatal("buildDomainRepairSQL accepted unsafe repairs")
-			}
-		})
-	}
-}
-
-type recordingDomainRepairRunner struct {
-	composeCalls      [][]string
-	composeStdinCalls [][]string
-	stdin             string
-	stdinErr          error
-	cleanupErr        error
-}
-
-func (r *recordingDomainRepairRunner) Compose(_ context.Context, _ string, args ...string) error {
-	r.composeCalls = append(r.composeCalls, append([]string(nil), args...))
-	if len(r.composeCalls) > 1 {
-		return r.cleanupErr
-	}
-	return nil
-}
-
-func (r *recordingDomainRepairRunner) ComposeStdin(_ context.Context, _ string, input io.Reader, args ...string) error {
-	r.composeStdinCalls = append(r.composeStdinCalls, append([]string(nil), args...))
-	b, _ := io.ReadAll(input)
-	r.stdin = string(b)
-	return r.stdinErr
-}
-
-func TestRepairBlogDomainsCleansProcedureAfterFailure(t *testing.T) {
-	runner := &recordingDomainRepairRunner{stdinErr: errors.New("local mysql failed")}
-	err := repairBlogDomainsWith(context.Background(), runner, "mysite", []DomainRepair{
-		{BlogID: 9, SourceDomain: "mapped.example.net", TargetDomain: "mapped.mysite.vipdev.site"},
-	})
-	var postImportErr *PostImportRepairError
-	if !errors.As(err, &postImportErr) {
-		t.Fatalf("err = %T %v, want PostImportRepairError", err, err)
-	}
-	if !strings.Contains(err.Error(), "database was imported") || !strings.Contains(err.Error(), "no partial domain repairs were committed") {
-		t.Fatalf("error does not explain post-import state: %v", err)
-	}
-	if len(runner.composeStdinCalls) != 1 || !strings.Contains(runner.stdin, "CREATE PROCEDURE") {
-		t.Fatalf("stdin calls=%#v script=%q", runner.composeStdinCalls, runner.stdin)
-	}
-	if len(runner.composeCalls) != 2 {
-		t.Fatalf("cleanup calls = %#v, want preflight and deferred cleanup", runner.composeCalls)
-	}
-	for _, call := range runner.composeCalls {
-		if strings.Join(call, " ") != "exec -T php wp --allow-root db query DROP PROCEDURE IF EXISTS vip_sync_update_blog_domains" {
-			t.Fatalf("cleanup argv = %#v", call)
-		}
-	}
-}
-
-func TestRepairBlogDomainsNoRepairsIsNoop(t *testing.T) {
-	runner := &recordingDomainRepairRunner{}
-	if err := repairBlogDomainsWith(context.Background(), runner, "mysite", nil); err != nil {
-		t.Fatal(err)
-	}
-	if len(runner.composeCalls) != 0 || len(runner.composeStdinCalls) != 0 {
-		t.Fatalf("runner called for empty repair set: %#v %#v", runner.composeCalls, runner.composeStdinCalls)
-	}
-}
-
-func TestRepairBlogDomainsReportsCleanupFailureAfterCommit(t *testing.T) {
-	runner := &recordingDomainRepairRunner{cleanupErr: errors.New("drop failed")}
-	err := repairBlogDomainsWith(context.Background(), runner, "mysite", []DomainRepair{
-		{BlogID: 9, SourceDomain: "mapped.example.net", TargetDomain: "mapped.mysite.vipdev.site"},
-	})
-	var postImportErr *PostImportRepairError
-	if !errors.As(err, &postImportErr) || !postImportErr.RepairsCommitted {
-		t.Fatalf("err = %#v, want committed cleanup error", err)
-	}
-	if !strings.Contains(err.Error(), "domain repairs committed") {
-		t.Fatalf("cleanup error state is ambiguous: %v", err)
-	}
-}

package/internal/devenv/syncsql_test.go

@@ -1,220 +0,0 @@
-package devenv
-
-import (
-	"context"
-	"errors"
-	"os"
-	"reflect"
-	"strings"
-	"testing"
-)
-
-func TestFindSiteHomeURL(t *testing.T) {
-	line := `('siteurl','https://example.com',`
-	if got := findSiteHomeURL(line); got != "https://example.com" {
-		t.Fatalf("findSiteHomeURL = %q", got)
-	}
-	if got := findSiteHomeURL(`('blogname','My Site',`); got != "" {
-		t.Fatalf("findSiteHomeURL non-url = %q", got)
-	}
-}
-
-func TestExtractSiteURLsSortedByLengthDesc(t *testing.T) {
-	sql := strings.Join([]string{
-		`('home','https://example.com',`,
-		`('siteurl','https://example.com/sub',`,
-		`('home','https://example.com',`, // duplicate
-	}, "\n")
-	got, err := extractSiteURLs(strings.NewReader(sql))
-	if err != nil {
-		t.Fatal(err)
-	}
-	want := []string{"https://example.com/sub", "https://example.com"}
-	if !reflect.DeepEqual(got, want) {
-		t.Fatalf("extractSiteURLs = %v, want %v", got, want)
-	}
-}
-
-func TestSyncSQLOrchestration(t *testing.T) {
-	var events []string
-	var importPairs []string
-	deps := SyncDeps{
-		ExportTo: func(_ context.Context, dest string) error {
-			events = append(events, "export")
-			return os.WriteFile(dest, []byte(`('siteurl','https://mapped.example.com',`), 0o644)
-		},
-		FetchSites: func(context.Context) ([]SyncSite, string) {
-			events = append(events, "fetch")
-			return []SyncSite{
-				{BlogID: 1, HomeURL: "https://primary.example.com"},
-				{BlogID: 2, HomeURL: "https://mapped.example.com"},
-			}, ""
-		},
-		ImportFile: func(_ context.Context, slug, file string, pairs []string) error {
-			events = append(events, "import")
-			importPairs = pairs
-			return nil
-		},
-		RepairDomains: func(_ context.Context, slug string, repairs []DomainRepair) error {
-			events = append(events, "repair")
-			if len(repairs) != 1 || repairs[0].BlogID != 2 {
-				t.Fatalf("repairs = %#v", repairs)
-			}
-			return nil
-		},
-		RefreshHosts: func(context.Context) error {
-			events = append(events, "hosts")
-			return nil
-		},
-	}
-	if err := syncSQLWith(context.Background(), SyncOptions{
-		Slug: "mysite", Domain: "vipdev.site", IsMultisite: true,
-	}, deps); err != nil {
-		t.Fatal(err)
-	}
-	if want := []string{"export", "fetch", "import", "repair", "hosts"}; !reflect.DeepEqual(events, want) {
-		t.Fatalf("events = %#v, want %#v", events, want)
-	}
-	joined := strings.Join(importPairs, " ")
-	if !strings.Contains(joined, "mapped.example.com,mapped-example-com-b2.mysite.vipdev.site") {
-		t.Fatalf("search-replace pair missing/wrong: %v", importPairs)
-	}
-}
-
-func TestSyncSQLRecoveryRebuildsBeforeExactlyOneImport(t *testing.T) {
-	var events []string
-	imports := 0
-	deps := SyncDeps{
-		ExportTo: func(_ context.Context, dest string) error {
-			events = append(events, "export")
-			return os.WriteFile(dest, []byte(`('home','https://missing.example.com',`), 0o644)
-		},
-		FetchSites: func(context.Context) ([]SyncSite, string) {
-			events = append(events, "fetch")
-			return nil, "transport"
-		},
-		ResolveDraft: func(draft PlanDraft) ([]string, error) {
-			events = append(events, "resolve")
-			if len(draft.Unresolved) != 1 || draft.Unresolved[0].Source != "missing.example.com" {
-				t.Fatalf("draft = %#v", draft)
-			}
-			return []string{"missing.example.com,recovered.mysite.vipdev.site"}, nil
-		},
-		ImportFile: func(context.Context, string, string, []string) error {
-			events = append(events, "import")
-			imports++
-			return nil
-		},
-		RepairDomains: func(context.Context, string, []DomainRepair) error {
-			events = append(events, "repair")
-			return nil
-		},
-		RefreshHosts: func(context.Context) error {
-			events = append(events, "hosts")
-			return nil
-		},
-	}
-	if err := syncSQLWith(context.Background(), SyncOptions{
-		Slug: "mysite", Domain: "vipdev.site", IsMultisite: true,
-	}, deps); err != nil {
-		t.Fatal(err)
-	}
-	if imports != 1 {
-		t.Fatalf("imports = %d, want exactly 1", imports)
-	}
-	if want := []string{"export", "fetch", "resolve", "import", "repair", "hosts"}; !reflect.DeepEqual(events, want) {
-		t.Fatalf("events = %#v, want %#v", events, want)
-	}
-}
-
-func TestSyncSQLCancellationAndUnresolvedStopBeforeImport(t *testing.T) {
-	tests := []struct {
-		name       string
-		resolve    func(PlanDraft) ([]string, error)
-		wantErr    bool
-		wantCancel bool
-	}{
-		{name: "cancel", resolve: func(PlanDraft) ([]string, error) { return nil, ErrSyncCancelled }, wantCancel: true},
-		{name: "still unresolved", resolve: func(PlanDraft) ([]string, error) { return nil, nil }, wantErr: true},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			imported := false
-			var logs []string
-			err := syncSQLWith(context.Background(), SyncOptions{
-				Slug: "mysite", Domain: "vipdev.site", IsMultisite: true,
-			}, SyncDeps{
-				ExportTo: func(_ context.Context, dest string) error {
-					return os.WriteFile(dest, []byte(`('home','https://missing.example.com',`), 0o644)
-				},
-				FetchSites:   func(context.Context) ([]SyncSite, string) { return nil, "transport" },
-				ResolveDraft: tt.resolve,
-				ImportFile: func(context.Context, string, string, []string) error {
-					imported = true
-					return nil
-				},
-				RepairDomains: func(context.Context, string, []DomainRepair) error { return nil },
-				RefreshHosts:  func(context.Context) error { return nil },
-				Log:           func(line string) { logs = append(logs, line) },
-			})
-			if tt.wantErr && err == nil {
-				t.Fatal("expected unresolved error")
-			}
-			if tt.wantCancel && (err != nil || !strings.Contains(strings.Join(logs, "\n"), "cancelled")) {
-				t.Fatalf("cancel err=%v logs=%#v", err, logs)
-			}
-			if imported {
-				t.Fatal("import called without a complete final plan")
-			}
-		})
-	}
-}
-
-func TestSyncSQLStopsLaterPhasesAfterFailure(t *testing.T) {
-	importErr := errors.New("import failed")
-	repairErr := errors.New("repair failed")
-	tests := []struct {
-		name       string
-		importErr  error
-		repairErr  error
-		hostErr    error
-		wantEvents []string
-		wantHost   bool
-	}{
-		{name: "import", importErr: importErr, wantEvents: []string{"import"}},
-		{name: "repair", repairErr: repairErr, wantEvents: []string{"import", "repair"}},
-		{name: "hosts", hostErr: errors.New("sudo declined"), wantEvents: []string{"import", "repair", "hosts"}, wantHost: true},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			var events []string
-			err := syncSQLWith(context.Background(), SyncOptions{Slug: "mysite", Domain: "vipdev.site"}, SyncDeps{
-				ExportTo: func(_ context.Context, dest string) error {
-					return os.WriteFile(dest, []byte(`('home','https://single.example.com',`), 0o644)
-				},
-				ImportFile: func(context.Context, string, string, []string) error {
-					events = append(events, "import")
-					return tt.importErr
-				},
-				RepairDomains: func(context.Context, string, []DomainRepair) error {
-					events = append(events, "repair")
-					return tt.repairErr
-				},
-				RefreshHosts: func(context.Context) error {
-					events = append(events, "hosts")
-					return tt.hostErr
-				},
-			})
-			if err == nil {
-				t.Fatal("expected phase error")
-			}
-			if !reflect.DeepEqual(events, tt.wantEvents) {
-				t.Fatalf("events=%#v want=%#v", events, tt.wantEvents)
-			}
-			var hostErr *HostRefreshError
-			if errors.As(err, &hostErr) != tt.wantHost {
-				t.Fatalf("HostRefreshError=%t want=%t; err=%v", errors.As(err, &hostErr), tt.wantHost, err)
-			}
-		})
-	}
-}

package/internal/devenv/update.go

@@ -1,87 +0,0 @@
-package devenv
-
-import (
-	"context"
-
-	"github.com/Automattic/vip/internal/debuglog"
-	"github.com/Automattic/vip/internal/devenv/instancedata"
-)
-
-// UpdateConfig carries only the fields the user chose to change. nil pointers
-// mean "leave as-is" so an `update` with one flag doesn't reset everything.
-type UpdateConfig struct {
-	PHP           *string
-	WordPress     *string
-	MuPluginsDir  *string
-	AppCodeDir    *string
-	Elasticsearch *bool
-	PHPMyAdmin    *bool
-	Mailpit       *bool
-	Xdebug        *bool
-	XdebugConfig  *string
-	Cron          *bool
-	Photon        *bool
-	MediaDomain   *string
-}
-
-// applyUpdate overlays the set fields of c onto d.
-func applyUpdate(d *instancedata.InstanceData, c UpdateConfig) {
-	if c.PHP != nil {
-		d.PHP = *c.PHP
-	}
-	if c.WordPress != nil {
-		d.WordPress.Mode = "image"
-		d.WordPress.Tag = *c.WordPress
-	}
-	if c.MuPluginsDir != nil {
-		d.MuPlugins = componentConfig(*c.MuPluginsDir)
-	}
-	if c.AppCodeDir != nil {
-		d.AppCode = componentConfig(*c.AppCodeDir)
-	}
-	if c.Elasticsearch != nil {
-		if *c.Elasticsearch {
-			d.Elasticsearch = []byte("true")
-		} else {
-			d.Elasticsearch = []byte("false")
-		}
-	}
-	if c.PHPMyAdmin != nil {
-		d.PHPMyAdmin = *c.PHPMyAdmin
-	}
-	if c.Mailpit != nil {
-		d.Mailpit = *c.Mailpit
-	}
-	if c.Xdebug != nil {
-		d.Xdebug = *c.Xdebug
-	}
-	if c.XdebugConfig != nil {
-		d.XdebugConfig = *c.XdebugConfig
-	}
-	if c.Cron != nil {
-		d.Cron = *c.Cron
-	}
-	if c.Photon != nil {
-		d.Photon = *c.Photon
-	}
-	if c.MediaDomain != nil {
-		d.MediaRedirectDomain = *c.MediaDomain
-	}
-}
-
-// Update reads, overlays, re-materializes, and persists an env's instance data.
-// Like Node it does NOT restart — the caller instructs the user to start again.
-func Update(ctx context.Context, slug string, c UpdateConfig) error {
-	debuglog.Printf(ctx, debugNamespace, "Will update an environment %q", slug)
-	d, err := instancedata.Read(slug)
-	if err != nil {
-		return err
-	}
-	applyUpdate(d, c)
-	if err := instancedata.Write(slug, d); err != nil {
-		return err
-	}
-	view := viewForData(d)
-	_, err = Materialize(slug, view)
-	return err
-}

package/internal/devenv/update_test.go

@@ -1,47 +0,0 @@
-package devenv
-
-import (
-	"testing"
-
-	"github.com/Automattic/vip/internal/devenv/instancedata"
-)
-
-func TestApplyUpdateOverlaysProvidedFields(t *testing.T) {
-	d := &instancedata.InstanceData{PHP: "8.1", PHPMyAdmin: false}
-	applyUpdate(d, UpdateConfig{
-		PHP:        strPtr("8.3"),
-		WordPress:  strPtr("6.5"),
-		PHPMyAdmin: boolPtr(true),
-	})
-	if d.PHP != "8.3" {
-		t.Fatalf("PHP = %q, want 8.3", d.PHP)
-	}
-	if d.WordPress.Tag != "6.5" {
-		t.Fatalf("WordPress.Tag = %q, want 6.5", d.WordPress.Tag)
-	}
-	if !d.PHPMyAdmin {
-		t.Fatal("PHPMyAdmin should be true")
-	}
-}
-
-func TestApplyUpdateLeavesUnsetFields(t *testing.T) {
-	d := &instancedata.InstanceData{PHP: "8.1"}
-	applyUpdate(d, UpdateConfig{})
-	if d.PHP != "8.1" {
-		t.Fatalf("PHP changed unexpectedly: %q", d.PHP)
-	}
-}
-
-func strPtr(s string) *string { return &s }
-func boolPtr(b bool) *bool    { return &b }
-
-func TestApplyUpdateCronAndXdebugConfig(t *testing.T) {
-	d := &instancedata.InstanceData{}
-	applyUpdate(d, UpdateConfig{Cron: boolPtr(true), XdebugConfig: strPtr("idekey=VIP")})
-	if !d.Cron {
-		t.Fatal("Cron should be true")
-	}
-	if d.XdebugConfig != "idekey=VIP" {
-		t.Fatalf("XdebugConfig = %q", d.XdebugConfig)
-	}
-}

package/internal/edgeworkers/api.go

@@ -1,173 +0,0 @@
-package edgeworkers
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"strings"
-
-	"github.com/Automattic/vip/internal/gql"
-	"github.com/Automattic/vip/internal/gql/edgeworkerinput"
-	"github.com/Khan/genqlient/graphql"
-	"github.com/vektah/gqlparser/v2/gqlerror"
-)
-
-type APIClient struct{ Client graphql.Client }
-
-// APIError retains the server's messages without gqlparser's source/path
-// prefixes. The command prints the individual diagnostics like Node's error
-// link, then adds its operation-specific context. Rechallenge and 401 handling
-// still run in the configured transport before this conversion.
-type APIError struct {
-	Messages []string
-	Cause    error
-}
-
-func (e *APIError) Error() string { return strings.Join(e.Messages, "\n") }
-func (e *APIError) Unwrap() error { return e.Cause }
-func apiError(err error) error {
-	var list gqlerror.List
-	if !errors.As(err, &list) {
-		return err
-	}
-	messages := make([]string, len(list))
-	for i, item := range list {
-		messages[i] = item.Message
-	}
-	return &APIError{Messages: messages, Cause: err}
-}
-
-var errInvalidRead = errors.New("EdgeWorkers query returned an invalid response.")
-
-func workerFromFields(f gql.EdgeWorkerFields) Worker {
-	w := Worker{ID: f.Id, Name: f.Name, Active: f.Active, Phases: phaseStrings(f.Phases), OnFailure: string(f.OnFailure), CreatedAt: f.CreatedAt, UpdatedAt: f.UpdatedAt}
-	if f.Location != nil {
-		w.Location = &Location{Operator: string(f.Location.Operator), Value: f.Location.Value}
-	}
-	return w
-}
-
-func phaseStrings(phases []gql.EdgeWorkerPhase) []string {
-	out := make([]string, len(phases))
-	for i, p := range phases {
-		out[i] = string(p)
-	}
-	return out
-}
-
-func (a APIClient) List(ctx context.Context, appID, envID int64) ([]Worker, error) {
-	r, err := gql.EdgeWorkers(gql.WithAllowGQLErrors(ctx), a.Client, appID, envID)
-	if err != nil {
-		return nil, apiError(err)
-	}
-	if r == nil || r.App == nil || len(r.App.Environments) == 0 || r.App.Environments[0] == nil || r.App.Environments[0].EdgeWorkers == nil {
-		return nil, errInvalidRead
-	}
-	workers := make([]Worker, 0, len(r.App.Environments[0].EdgeWorkers))
-	for _, w := range r.App.Environments[0].EdgeWorkers {
-		if w == nil {
-			return nil, errInvalidRead
-		}
-		workers = append(workers, workerFromFields(w.EdgeWorkerFields))
-	}
-	return workers, nil
-}
-
-func (a APIClient) Get(ctx context.Context, appID, envID int64, name string, source bool) (*Worker, error) {
-	ctx = gql.WithAllowGQLErrors(ctx)
-	if source {
-		r, err := gql.EdgeWorkerDetailWithSource(ctx, a.Client, appID, envID)
-		if err != nil {
-			return nil, apiError(err)
-		}
-		if r == nil || r.App == nil || len(r.App.Environments) == 0 || r.App.Environments[0] == nil || r.App.Environments[0].EdgeWorkers == nil {
-			return nil, errInvalidRead
-		}
-		for _, f := range r.App.Environments[0].EdgeWorkers {
-			if f == nil {
-				return nil, errInvalidRead
-			}
-			if f.Name == name {
-				w := workerFromFields(f.EdgeWorkerFields)
-				w.Source = f.Source
-				return &w, nil
-			}
-		}
-		return nil, nil
-	}
-	r, err := gql.EdgeWorkerDetail(ctx, a.Client, appID, envID)
-	if err != nil {
-		return nil, apiError(err)
-	}
-	if r == nil || r.App == nil || len(r.App.Environments) == 0 || r.App.Environments[0] == nil || r.App.Environments[0].EdgeWorkers == nil {
-		return nil, errInvalidRead
-	}
-	for _, f := range r.App.Environments[0].EdgeWorkers {
-		if f == nil {
-			return nil, errInvalidRead
-		}
-		if f.Name == name {
-			w := workerFromFields(f.EdgeWorkerFields)
-			return &w, nil
-		}
-	}
-	return nil, nil
-}
-
-func missingResult(operation string) error { return fmt.Errorf("%s returned no result.", operation) }
-
-func (a APIClient) Create(ctx context.Context, envID int64, input WriteInput) (Worker, error) {
-	r, err := gql.CreateEdgeWorker(gql.WithAllowGQLErrors(ctx), a.Client, &edgeworkerinput.Create{EnvironmentID: envID, Fields: input})
-	if err != nil {
-		return Worker{}, apiError(err)
-	}
-	if r == nil || r.CreateEdgeWorker == nil {
-		return Worker{}, missingResult("createEdgeWorker")
-	}
-	return workerFromFields(r.CreateEdgeWorker.EdgeWorkerFields), nil
-}
-
-func (a APIClient) Update(ctx context.Context, envID, workerID int64, input WriteInput) (Worker, error) {
-	r, err := gql.UpdateEdgeWorker(gql.WithAllowGQLErrors(ctx), a.Client, &edgeworkerinput.Update{EnvironmentID: envID, EdgeWorkerID: workerID, Fields: input})
-	if err != nil {
-		return Worker{}, apiError(err)
-	}
-	if r == nil || r.UpdateEdgeWorker == nil {
-		return Worker{}, missingResult("updateEdgeWorker")
-	}
-	return workerFromFields(r.UpdateEdgeWorker.EdgeWorkerFields), nil
-}
-
-func (a APIClient) SetActive(ctx context.Context, envID, workerID int64, active bool) (Worker, error) {
-	r, err := gql.SetEdgeWorkerActive(gql.WithAllowGQLErrors(ctx), a.Client, &gql.SetEdgeWorkerActiveInput{EnvironmentId: envID, EdgeWorkerId: workerID, Active: active})
-	if err != nil {
-		return Worker{}, apiError(err)
-	}
-	if r == nil || r.SetEdgeWorkerActive == nil {
-		return Worker{}, missingResult("setEdgeWorkerActive")
-	}
-	return workerFromFields(r.SetEdgeWorkerActive.EdgeWorkerFields), nil
-}
-
-func (a APIClient) Delete(ctx context.Context, envID, workerID int64) error {
-	r, err := gql.DeleteEdgeWorker(gql.WithAllowGQLErrors(ctx), a.Client, &gql.DeleteEdgeWorkerInput{EnvironmentId: envID, EdgeWorkerId: workerID})
-	if err != nil {
-		return apiError(err)
-	}
-	if r == nil || r.DeleteEdgeWorker == nil || !*r.DeleteEdgeWorker {
-		return errors.New("deleteEdgeWorker did not confirm deletion.")
-	}
-	return nil
-}
-
-func (a APIClient) Validate(ctx context.Context, envID int64, binary string) (ValidationResult, error) {
-	r, err := gql.ValidateEdgeWorker(gql.WithAllowGQLErrors(ctx), a.Client, &gql.ValidateEdgeWorkerInput{EnvironmentId: envID, WasmBinary: binary})
-	if err != nil {
-		return ValidationResult{}, apiError(err)
-	}
-	if r == nil || r.ValidateEdgeWorker == nil {
-		return ValidationResult{}, missingResult("validateEdgeWorker")
-	}
-	v := r.ValidateEdgeWorker
-	return ValidationResult{Valid: v.Valid, Phases: phaseStrings(v.Phases), Errors: v.Errors}, nil
-}