@automattic/vip 4.1.5 → 4.1.6

package/internal/devenv/syncplan_test.go

@@ -1,256 +0,0 @@
-package devenv
-
-import (
-	"strings"
-	"testing"
-)
-
-func mappingsBySource(t *testing.T, draft PlanDraft) map[string]URLMapping {
-	t.Helper()
-	out := make(map[string]URLMapping, len(draft.Plan.SearchReplace))
-	for _, mapping := range draft.Plan.SearchReplace {
-		out[mapping.Source] = mapping
-	}
-	return out
-}
-
-func TestBuildSyncPlanAutomaticTargets(t *testing.T) {
-	input := PlanInput{
-		IsMultisite: true,
-		BaseHost:    "mysite.vipdev.site",
-		ActiveURLs: []string{
-			"https://domain.com/",
-			"https://domain.com/subsite/",
-			"https://subsite.domain.com",
-			"https://sub.subsite.domain.com",
-			"https://mapped.example.net",
-		},
-		Sites: []SyncSite{
-			{BlogID: 1, HomeURL: "https://domain.com", SiteURL: "https://domain.com/wp"},
-			{BlogID: 2, HomeURL: "https://domain.com/subsite/", SiteURL: "https://domain.com/subsite/wp"},
-			{BlogID: 3, HomeURL: "https://subsite.domain.com", SiteURL: "https://subsite.domain.com/wp"},
-			{BlogID: 7, HomeURL: "https://sub.subsite.domain.com", SiteURL: "https://sub.subsite.domain.com/wp"},
-			{BlogID: 9, HomeURL: "https://mapped.example.net", SiteURL: "https://mapped.example.net/wp"},
-		},
-	}
-
-	draft, err := BuildSyncPlan(input)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(draft.Unresolved) != 0 {
-		t.Fatalf("unresolved = %#v", draft.Unresolved)
-	}
-	got := mappingsBySource(t, draft)
-	want := map[string]string{
-		"domain.com":             "mysite.vipdev.site",
-		"domain.com/subsite":     "mysite.vipdev.site/subsite",
-		"subsite.domain.com":     "subsite.mysite.vipdev.site",
-		"sub.subsite.domain.com": "sub-subsite-b7.mysite.vipdev.site",
-		"mapped.example.net":     "mapped-example-net-b9.mysite.vipdev.site",
-	}
-	for source, target := range want {
-		mapping, ok := got[source]
-		if !ok {
-			t.Errorf("missing mapping for %q in %#v", source, got)
-			continue
-		}
-		if mapping.Target != target || mapping.Origin != MappingSDS {
-			t.Errorf("mapping[%q] = %#v, want target=%q origin=%q", source, mapping, target, MappingSDS)
-		}
-	}
-	if len(got) != len(want) {
-		t.Fatalf("mapping count = %d, want %d: %#v", len(got), len(want), got)
-	}
-}
-
-func TestBuildSyncPlanExplicitPrecedenceAndRecovery(t *testing.T) {
-	input := PlanInput{
-		IsMultisite: true,
-		BaseHost:    "mysite.vipdev.site",
-		ActiveURLs: []string{
-			"https://mapped.example.net",
-			"https://mapped.example.net/shop",
-			"https://missing.example.org/path",
-		},
-		Sites: []SyncSite{
-			{BlogID: 1, HomeURL: "https://primary.example.com"},
-			{BlogID: 9, HomeURL: "https://mapped.example.net"},
-		},
-		Overrides: []string{
-			"mapped.example.net,custom.mysite.vipdev.site",
-			"mapped.example.net/shop,custom.mysite.vipdev.site/special",
-		},
-		Recoveries: []string{
-			"missing.example.org,recovered.mysite.vipdev.site",
-		},
-	}
-
-	draft, err := BuildSyncPlan(input)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(draft.Unresolved) != 0 {
-		t.Fatalf("unresolved = %#v", draft.Unresolved)
-	}
-	got := mappingsBySource(t, draft)
-	if mapping := got["mapped.example.net"]; mapping.Target != "custom.mysite.vipdev.site" || mapping.Origin != MappingOverride {
-		t.Errorf("host override = %#v", mapping)
-	}
-	if mapping := got["mapped.example.net/shop"]; mapping.Target != "custom.mysite.vipdev.site/special" || mapping.Origin != MappingOverride {
-		t.Errorf("path override = %#v", mapping)
-	}
-	if mapping := got["missing.example.org/path"]; mapping.Target != "recovered.mysite.vipdev.site/path" || mapping.Origin != MappingRecovery {
-		t.Errorf("host recovery = %#v", mapping)
-	}
-}
-
-func TestBuildSyncPlanSDSOutageCanBeRecovered(t *testing.T) {
-	input := PlanInput{
-		IsMultisite:  true,
-		BaseHost:     "mysite.vipdev.site",
-		ActiveURLs:   []string{"https://mapped.example.net"},
-		CatalogIssue: "transport",
-	}
-
-	draft, err := BuildSyncPlan(input)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(draft.Unresolved) != 1 || draft.Unresolved[0].Source != "mapped.example.net" {
-		t.Fatalf("unresolved = %#v", draft.Unresolved)
-	}
-
-	input.Recoveries = []string{"mapped.example.net,mapped.mysite.vipdev.site"}
-	draft, err = BuildSyncPlan(input)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(draft.Unresolved) != 0 {
-		t.Fatalf("recovered draft unresolved = %#v", draft.Unresolved)
-	}
-	if got := mappingsBySource(t, draft)["mapped.example.net"]; got.Target != "mapped.mysite.vipdev.site" || got.BlogID != 0 {
-		t.Fatalf("recovery mapping = %#v", got)
-	}
-}
-
-func TestBuildSyncPlanPartialExportOnlyRepairsActiveSites(t *testing.T) {
-	draft, err := BuildSyncPlan(PlanInput{
-		IsMultisite: true,
-		BaseHost:    "mysite.vipdev.site",
-		ActiveURLs:  []string{"https://second.primary.example.com"},
-		Sites: []SyncSite{
-			{BlogID: 1, HomeURL: "https://primary.example.com"},
-			{BlogID: 2, HomeURL: "https://second.primary.example.com"},
-			{BlogID: 3, HomeURL: "https://third.primary.example.com"},
-		},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(draft.Plan.DomainRepairs) != 1 || draft.Plan.DomainRepairs[0].BlogID != 2 {
-		t.Fatalf("domain repairs = %#v, want only blog 2", draft.Plan.DomainRepairs)
-	}
-}
-
-func TestBuildSyncPlanNormalizesIDNAAndSourcePorts(t *testing.T) {
-	draft, err := BuildSyncPlan(PlanInput{
-		IsMultisite: true,
-		BaseHost:    "mysite.vipdev.site",
-		ActiveURLs:  []string{"HTTPS://BÜCHER.example:8080/"},
-		Sites: []SyncSite{
-			{BlogID: 1, HomeURL: "https://primary.example.com"},
-			{BlogID: 4, HomeURL: "https://xn--bcher-kva.example:8080"},
-		},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	got := mappingsBySource(t, draft)["xn--bcher-kva.example:8080"]
-	if got.Target != "xn-bcher-kva-example-b4.mysite.vipdev.site" {
-		t.Fatalf("IDNA mapping = %#v", got)
-	}
-	if len(draft.Plan.DomainRepairs) != 1 || draft.Plan.DomainRepairs[0].SourceDomain != "xn--bcher-kva.example" {
-		t.Fatalf("IDNA repair = %#v", draft.Plan.DomainRepairs)
-	}
-}
-
-func TestBuildSyncPlanRejectsUnroutableExplicitTargets(t *testing.T) {
-	for _, pair := range []string{
-		"source.example.com,foreign.example.com",
-		"source.example.com,deep.label.mysite.vipdev.site",
-		"source.example.com,mapped.mysite.vipdev.site:8443",
-	} {
-		t.Run(pair, func(t *testing.T) {
-			_, err := BuildSyncPlan(PlanInput{
-				BaseHost:   "mysite.vipdev.site",
-				ActiveURLs: []string{"https://source.example.com"},
-				Overrides:  []string{pair},
-			})
-			if err == nil {
-				t.Fatalf("BuildSyncPlan accepted %q", pair)
-			}
-		})
-	}
-}
-
-func TestBuildSyncPlanRejectsConflictingDomainRepairs(t *testing.T) {
-	_, err := BuildSyncPlan(PlanInput{
-		IsMultisite:  true,
-		BaseHost:     "mysite.vipdev.site",
-		ActiveURLs:   []string{"https://source.example.com/a", "https://source.example.com/b"},
-		CatalogIssue: "transport",
-		Overrides: []string{
-			"source.example.com/a,a.mysite.vipdev.site",
-			"source.example.com/b,b.mysite.vipdev.site",
-		},
-	})
-	if err == nil || !strings.Contains(err.Error(), "conflicting domain repair") {
-		t.Fatalf("err = %v, want conflicting domain repair", err)
-	}
-}
-
-func TestBuildSyncPlanTruncatesFlattenedLabelsAndSortsLongestFirst(t *testing.T) {
-	longLabel := strings.Repeat("a", 50) + "." + strings.Repeat("b", 40) + ".example.net"
-	draft, err := BuildSyncPlan(PlanInput{
-		IsMultisite: true,
-		BaseHost:    "mysite.vipdev.site",
-		ActiveURLs:  []string{"https://primary.example.com", "https://primary.example.com/a/long/path", "https://" + longLabel},
-		Sites: []SyncSite{
-			{BlogID: 1, HomeURL: "https://primary.example.com"},
-			{BlogID: 2, HomeURL: "https://primary.example.com/a/long/path"},
-			{BlogID: 123, HomeURL: "https://" + longLabel},
-		},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if got := draft.Plan.SearchReplace; len(got) != 3 || got[1].Source != "primary.example.com/a/long/path" || got[2].Source != "primary.example.com" {
-		t.Fatalf("search-replace order = %#v", got)
-	}
-	for i := 1; i < len(draft.Plan.SearchReplace); i++ {
-		if len(draft.Plan.SearchReplace[i-1].Source) < len(draft.Plan.SearchReplace[i].Source) {
-			t.Fatalf("search-replace is not longest-first: %#v", draft.Plan.SearchReplace)
-		}
-	}
-	for _, host := range draft.Plan.RequiredHosts {
-		label := strings.Split(host, ".")[0]
-		if len(label) > 63 {
-			t.Fatalf("generated label %q is %d bytes", label, len(label))
-		}
-	}
-}
-
-func TestBuildSyncPlanSingleSitePreservesPaths(t *testing.T) {
-	draft, err := BuildSyncPlan(PlanInput{
-		BaseHost:   "mysite.vipdev.site",
-		ActiveURLs: []string{"https://single.example.com", "https://single.example.com/wp"},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	got := mappingsBySource(t, draft)
-	if got["single.example.com"].Target != "mysite.vipdev.site" || got["single.example.com/wp"].Target != "mysite.vipdev.site/wp" {
-		t.Fatalf("single-site mappings = %#v", got)
-	}
-}

package/internal/devenv/syncsql.go

@@ -1,247 +0,0 @@
-package devenv
-
-import (
-	"bufio"
-	"context"
-	"errors"
-	"fmt"
-	"io"
-	"net/url"
-	"os"
-	"path/filepath"
-	"regexp"
-	"sort"
-	"strings"
-)
-
-// findSiteHomeURL extracts a siteurl/home URL from a SQL line, or "".
-// Ports findSiteHomeUrl (dev-env-sync-sql.ts).
-//
-// Note: Go's regexp/RE2 does not support backreferences (\1), so we enumerate
-// both quote flavours explicitly with two alternation branches.
-var siteHomeRe = regexp.MustCompile(
-	`(?:'(?:siteurl|home)',\s*'([Hh][Tt][Tt][Pp][Ss]?://[^']+)'` +
-		`|"(?:siteurl|home)",\s*"([Hh][Tt][Tt][Pp][Ss]?://[^"]+)")`,
-)
-
-func findSiteHomeURL(sql string) string {
-	m := siteHomeRe.FindStringSubmatch(sql)
-	if m == nil {
-		return ""
-	}
-	// m[1] is the single-quote capture, m[2] is the double-quote capture.
-	raw := m[1]
-	if raw == "" {
-		raw = m[2]
-	}
-	if raw == "" {
-		return ""
-	}
-	parsed, err := url.Parse(raw)
-	if err != nil || parsed.Hostname() == "" {
-		return ""
-	}
-	return raw
-}
-
-// extractSiteURLs scans a SQL stream for siteurl/home URLs, dedupes, strips a
-// trailing slash, and sorts longest-first (so longest URLs replace first).
-// Ports extractSiteUrls (dev-env-sync-sql.ts).
-func extractSiteURLs(r io.Reader) ([]string, error) {
-	set := map[string]struct{}{}
-	sc := bufio.NewScanner(r)
-	sc.Buffer(make([]byte, 0, 1024*1024), 16*1024*1024) // SQL lines can be long
-	for sc.Scan() {
-		u := findSiteHomeURL(sc.Text())
-		if u == "" {
-			continue
-		}
-		u = strings.TrimRight(u, "/")
-		set[u] = struct{}{}
-	}
-	if err := sc.Err(); err != nil {
-		return nil, err
-	}
-	out := make([]string, 0, len(set))
-	for u := range set {
-		out = append(out, u)
-	}
-	sort.Slice(out, func(i, j int) bool { return len(out[i]) > len(out[j]) })
-	return out, nil
-}
-
-// landoDomainFor returns "<slug>.<domain>" for the search-replace target.
-func landoDomainFor(slug, domain string) string { return slug + "." + domain }
-
-type SyncOptions struct {
-	Slug        string
-	Domain      string
-	IsMultisite bool
-	Overrides   []string
-}
-
-var ErrSyncCancelled = errors.New("SQL sync cancelled")
-
-type UnresolvedMappingsError struct {
-	Mappings []UnresolvedMapping
-}
-
-func (e *UnresolvedMappingsError) Error() string {
-	if e == nil || len(e.Mappings) == 0 {
-		return "multisite sync has unresolved URL mappings"
-	}
-	values := make([]string, 0, len(e.Mappings))
-	for _, mapping := range e.Mappings {
-		values = append(values, mapping.Source)
-	}
-	return "multisite sync has unresolved URL mappings: " + strings.Join(values, ", ")
-}
-
-type HostRefreshError struct {
-	Slug string
-	Err  error
-}
-
-func (e *HostRefreshError) Error() string {
-	return fmt.Sprintf(
-		"SQL sync completed, but offline hostname setup is incomplete.\nRun `vip dev-env start --slug %s` to retry host configuration: %v",
-		e.Slug,
-		e.Err,
-	)
-}
-
-func (e *HostRefreshError) Unwrap() error { return e.Err }
-
-// SyncDeps injects every I/O boundary so planning and exactly-once import
-// behavior can be verified without Docker or a remote API.
-type SyncDeps struct {
-	// ExportTo exports the production DB to a local SQL file at dest.
-	ExportTo func(ctx context.Context, dest string) error
-	// FetchSites reads the complete SDS catalog. A non-empty issue means the
-	// catalog is unsafe for automatic mapping and explicit recovery is required.
-	FetchSites func(ctx context.Context) (sites []SyncSite, issue string)
-	// ResolveDraft supplies explicit recovery pairs for an unresolved plan.
-	ResolveDraft func(draft PlanDraft) ([]string, error)
-	// ImportFile imports file into the local env, applying "from,to" pairs.
-	ImportFile func(ctx context.Context, slug, file string, pairs []string) error
-	// RepairDomains applies guarded wp_blogs updates after a successful import.
-	RepairDomains func(ctx context.Context, slug string, repairs []DomainRepair) error
-	// RefreshHosts rebuilds the globally owned offline hosts snapshot.
-	RefreshHosts func(ctx context.Context) error
-	// Log, when set, receives progress messages (Node parity console.log lines).
-	Log func(msg string)
-}
-
-// syncSQLWith runs export -> inspect -> SDS -> plan/recovery -> import ->
-// guarded repair -> offline host refresh. Planning and prompting finish before
-// ImportFile is called, and ImportFile is called at most once.
-func syncSQLWith(ctx context.Context, options SyncOptions, deps SyncDeps) error {
-	logf := func(msg string) {
-		if deps.Log != nil {
-			deps.Log(msg)
-		}
-	}
-	if options.Slug == "" || options.Domain == "" {
-		return errors.New("devenv: sync slug and domain are required")
-	}
-	if deps.ExportTo == nil || deps.ImportFile == nil || deps.RepairDomains == nil || deps.RefreshHosts == nil {
-		return errors.New("devenv: incomplete SQL sync dependencies")
-	}
-	if options.IsMultisite && deps.FetchSites == nil {
-		return errors.New("devenv: multisite SQL sync requires an SDS catalog adapter")
-	}
-
-	tmp, err := os.MkdirTemp("", "vip-dev-env-sync-*")
-	if err != nil {
-		return err
-	}
-	defer os.RemoveAll(tmp)
-
-	sqlFile := filepath.Join(tmp, "sql-export.sql")
-	if err := deps.ExportTo(ctx, sqlFile); err != nil {
-		return err
-	}
-
-	logf("Extracting site urls from the SQL file...")
-	f, err := os.Open(sqlFile)
-	if err != nil {
-		return err
-	}
-	urls, err := extractSiteURLs(f)
-	_ = f.Close()
-	if err != nil {
-		return err
-	}
-
-	var sites []SyncSite
-	catalogIssue := ""
-	if options.IsMultisite {
-		logf("Fetching list of sites for database sync...")
-		sites, catalogIssue = deps.FetchSites(ctx)
-	}
-
-	logf("Generating search-replace configuration...")
-	planInput := PlanInput{
-		IsMultisite:  options.IsMultisite,
-		BaseHost:     landoDomainFor(options.Slug, options.Domain),
-		ActiveURLs:   urls,
-		Sites:        sites,
-		Overrides:    options.Overrides,
-		CatalogIssue: catalogIssue,
-	}
-	draft, err := BuildSyncPlan(planInput)
-	if err != nil {
-		return err
-	}
-	if len(draft.Unresolved) > 0 {
-		if deps.ResolveDraft == nil {
-			return &UnresolvedMappingsError{Mappings: draft.Unresolved}
-		}
-		recoveries, resolveErr := deps.ResolveDraft(draft)
-		if errors.Is(resolveErr, ErrSyncCancelled) {
-			logf("SQL sync cancelled; local database was not modified.")
-			return nil
-		}
-		if resolveErr != nil {
-			return resolveErr
-		}
-		planInput.Recoveries = recoveries
-		draft, err = BuildSyncPlan(planInput)
-		if err != nil {
-			return err
-		}
-		if len(draft.Unresolved) > 0 {
-			return &UnresolvedMappingsError{Mappings: draft.Unresolved}
-		}
-	}
-
-	pairs := make([]string, 0, len(draft.Plan.SearchReplace))
-	for _, mapping := range draft.Plan.SearchReplace {
-		pairs = append(pairs, mapping.Source+","+mapping.Target)
-	}
-
-	logf("Running the following search-replace operations on the SQL file:")
-	for _, mapping := range draft.Plan.SearchReplace {
-		logf(fmt.Sprintf("  [%s] %s -> %s", mapping.Origin, mapping.Source, mapping.Target))
-	}
-
-	logf("Importing the SQL file...")
-	if err := deps.ImportFile(ctx, options.Slug, sqlFile, pairs); err != nil {
-		return err
-	}
-	logf("✓ SQL file imported")
-	if err := deps.RepairDomains(ctx, options.Slug, draft.Plan.DomainRepairs); err != nil {
-		return err
-	}
-	if err := deps.RefreshHosts(ctx); err != nil {
-		return &HostRefreshError{Slug: options.Slug, Err: err}
-	}
-	return nil
-}
-
-// SyncSQL executes a fully-adapted SQL sync. The command layer supplies the
-// platform and interactive boundaries; internal/devenv owns local import,
-// repair, and host behavior through those injected functions.
-func SyncSQL(ctx context.Context, options SyncOptions, deps SyncDeps) error {
-	return syncSQLWith(ctx, options, deps)
-}

package/internal/devenv/syncsql_repair.go

@@ -1,169 +0,0 @@
-package devenv
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"io"
-	"sort"
-	"strings"
-)
-
-const syncDomainRepairProcedure = "vip_sync_update_blog_domains"
-
-type PostImportRepairError struct {
-	Err              error
-	RepairsCommitted bool
-}
-
-func (e *PostImportRepairError) Error() string {
-	if e == nil {
-		return ""
-	}
-	if e.RepairsCommitted {
-		return fmt.Sprintf("the database was imported and domain repairs committed, but temporary repair cleanup failed: %v", e.Err)
-	}
-	return fmt.Sprintf("the database was imported, but multisite domain repair failed; no partial domain repairs were committed: %v", e.Err)
-}
-
-func (e *PostImportRepairError) Unwrap() error {
-	if e == nil {
-		return nil
-	}
-	return e.Err
-}
-
-func quoteSQLString(value string) string {
-	return "'" + strings.ReplaceAll(value, "'", "''") + "'"
-}
-
-func normalizedDomainRepairs(repairs []DomainRepair) ([]DomainRepair, error) {
-	targetsBySource := map[string]string{}
-	seen := map[string]bool{}
-	out := make([]DomainRepair, 0, len(repairs))
-	for _, repair := range repairs {
-		if repair.BlogID < 0 {
-			return nil, fmt.Errorf("invalid negative blog ID %d", repair.BlogID)
-		}
-		if !validDNSHost(repair.SourceDomain) || !validDNSHost(repair.TargetDomain) {
-			return nil, fmt.Errorf("invalid domain repair %q -> %q", repair.SourceDomain, repair.TargetDomain)
-		}
-		if target, exists := targetsBySource[repair.SourceDomain]; exists && target != repair.TargetDomain {
-			return nil, fmt.Errorf("conflicting domain repair for %q", repair.SourceDomain)
-		}
-		targetsBySource[repair.SourceDomain] = repair.TargetDomain
-		key := fmt.Sprintf("%d\x00%s\x00%s", repair.BlogID, repair.SourceDomain, repair.TargetDomain)
-		if seen[key] {
-			continue
-		}
-		seen[key] = true
-		out = append(out, repair)
-	}
-	sort.Slice(out, func(i, j int) bool {
-		if out[i].BlogID != out[j].BlogID {
-			return out[i].BlogID < out[j].BlogID
-		}
-		if out[i].SourceDomain != out[j].SourceDomain {
-			return out[i].SourceDomain < out[j].SourceDomain
-		}
-		return out[i].TargetDomain < out[j].TargetDomain
-	})
-	return out, nil
-}
-
-func buildDomainRepairSQL(repairs []DomainRepair) (string, error) {
-	repairs, err := normalizedDomainRepairs(repairs)
-	if err != nil {
-		return "", err
-	}
-	if len(repairs) == 0 {
-		return "", nil
-	}
-
-	var b strings.Builder
-	fmt.Fprintf(&b, "DROP PROCEDURE IF EXISTS %s;\n", syncDomainRepairProcedure)
-	b.WriteString("DELIMITER $$\n")
-	fmt.Fprintf(&b, "CREATE PROCEDURE %s()\n", syncDomainRepairProcedure)
-	b.WriteString("BEGIN\n")
-	b.WriteString("    DECLARE EXIT HANDLER FOR SQLEXCEPTION\n")
-	b.WriteString("    BEGIN\n")
-	b.WriteString("        ROLLBACK;\n")
-	b.WriteString("        RESIGNAL;\n")
-	b.WriteString("    END;\n")
-	b.WriteString("    IF EXISTS (SELECT 1 FROM information_schema.tables WHERE table_schema = 'wordpress' AND table_name = 'wp_blogs') THEN\n")
-	b.WriteString("        START TRANSACTION;\n")
-	for _, repair := range repairs {
-		fmt.Fprintf(&b, "        UPDATE wordpress.wp_blogs SET domain = %s WHERE ", quoteSQLString(repair.TargetDomain))
-		if repair.BlogID > 0 {
-			fmt.Fprintf(&b, "blog_id = %d AND ", repair.BlogID)
-		}
-		fmt.Fprintf(&b, "domain = %s;\n", quoteSQLString(repair.SourceDomain))
-	}
-	b.WriteString("        COMMIT;\n")
-	b.WriteString("    END IF;\n")
-	b.WriteString("END$$\n")
-	b.WriteString("DELIMITER ;\n")
-	fmt.Fprintf(&b, "CALL %s();\n", syncDomainRepairProcedure)
-	return b.String(), nil
-}
-
-type domainRepairRunner interface {
-	Compose(context.Context, string, ...string) error
-	ComposeStdin(context.Context, string, io.Reader, ...string) error
-}
-
-func domainRepairCleanupArgs() []string {
-	return []string{
-		"exec", "-T", phpService,
-		"wp", "--allow-root", "db", "query",
-		"DROP PROCEDURE IF EXISTS " + syncDomainRepairProcedure,
-	}
-}
-
-func domainRepairQueryArgs() []string {
-	return []string{"exec", "-T", phpService, "wp", "--allow-root", "db", "query"}
-}
-
-func repairBlogDomainsWith(ctx context.Context, runner domainRepairRunner, slug string, repairs []DomainRepair) (resultErr error) {
-	if len(repairs) == 0 {
-		return nil
-	}
-	script, err := buildDomainRepairSQL(repairs)
-	if err != nil {
-		return &PostImportRepairError{Err: err}
-	}
-	cleanupArgs := domainRepairCleanupArgs()
-	if err := runner.Compose(ctx, slug, cleanupArgs...); err != nil {
-		return &PostImportRepairError{Err: fmt.Errorf("prepare repair procedure: %w", err)}
-	}
-	defer func() {
-		if cleanupErr := runner.Compose(ctx, slug, cleanupArgs...); cleanupErr != nil {
-			if resultErr != nil {
-				resultErr = errors.Join(resultErr, fmt.Errorf("cleanup repair procedure: %w", cleanupErr))
-				return
-			}
-			resultErr = &PostImportRepairError{
-				Err:              fmt.Errorf("cleanup repair procedure: %w", cleanupErr),
-				RepairsCommitted: true,
-			}
-		}
-	}()
-	if err := runner.ComposeStdin(ctx, slug, strings.NewReader(script), domainRepairQueryArgs()...); err != nil {
-		return &PostImportRepairError{Err: fmt.Errorf("execute repair transaction: %w", err)}
-	}
-	return nil
-}
-
-// RepairBlogDomains applies the final plan's typed domain repairs to the local
-// database. The procedure handler rolls back every repair if any update fails;
-// cleanup is attempted independently before and after execution.
-func RepairBlogDomains(ctx context.Context, slug string, repairs []DomainRepair) error {
-	if len(repairs) == 0 {
-		return nil
-	}
-	runner, err := newRunner(ctx)
-	if err != nil {
-		return &PostImportRepairError{Err: err}
-	}
-	return repairBlogDomainsWith(ctx, runner, slug, repairs)
-}