@automattic/vip 4.1.4 → 4.1.6

package/internal/siteimport/status.go

@@ -1,282 +0,0 @@
-package siteimport
-
-import (
-	"context"
-	"errors"
-	"strings"
-	"time"
-
-	"github.com/fatih/color"
-
-	"github.com/Automattic/vip/internal/debuglog"
-	"github.com/Automattic/vip/internal/tui"
-)
-
-// DefaultPollInterval — IMPORT_SQL_PROGRESS_POLL_INTERVAL (status.ts:25).
-const DefaultPollInterval = 5 * time.Second
-
-// JobStep is one step of the import job as reported by the server
-// (jobs[].progress.steps or synthesized from importStatus.progress).
-type JobStep struct {
-	ID     string
-	Name   string
-	Status tui.StepState
-}
-
-// ImportJob mirrors the slice of Job the poller consumes (real k8s job or
-// the pseudo-job Node synthesizes from importStatus.progress —
-// status.ts:288-328; the synthesis lives in the command's fetch closure).
-type ImportJob struct {
-	CreatedAt   string
-	CompletedAt string
-	Status      string // progress.status; "" treated as "unknown" (status.ts:333)
-	Steps       []JobStep
-}
-
-// FailedStep is a failed entry from importStatus.progress.steps
-// (status.ts:361 failedImportStep).
-type FailedStep struct {
-	Name      string
-	Output    []string
-	StartedAt int64 // unix seconds
-}
-
-// ProgressSnapshot flattens one ImportSQLProgress response. Job == nil
-// means "no job data available yet" — the poller waits (or fast-returns
-// under ReturnMissingJobImmediately).
-type ProgressSnapshot struct {
-	Job                     *ImportJob
-	StatusProgressStartedAt int64 // importStatus.progress.started_at (unix seconds)
-	FailedStep              *FailedStep
-	Launched                bool
-}
-
-// ProgressFetch retrieves the current snapshot (the command wraps
-// gql.ImportSQLProgress).
-type ProgressFetch func(ctx context.Context) (*ProgressSnapshot, error)
-
-// CheckStatusOpts configures CheckStatus.
-type CheckStatusOpts struct {
-	Fetch    ProgressFetch
-	Tracker  *tui.ProgressTracker
-	Interval time.Duration
-	// ReturnMissingJobImmediately — true for `vip import sql status`
-	// (status.ts:198).
-	ReturnMissingJobImmediately bool
-	// OnPoll fires after each snapshot is applied to the tracker, before
-	// terminal-state checks — the command renders its suffix block here.
-	OnPoll func(createdAt, completedAt, overallStatus string)
-}
-
-// StatusResult is the terminal outcome of a finished (non-failed) poll.
-type StatusResult struct {
-	Status      string
-	Message     string // e.g. "No import job found"
-	CreatedAt   string
-	CompletedAt string
-}
-
-// ImportFailedError ports ImportFailedError (status.ts:107).
-type ImportFailedError struct {
-	InImportProgress bool
-	CommandOutput    []string
-	ErrorText        string
-	StepName         string
-	Launched         bool
-}
-
-func (e *ImportFailedError) Error() string { return e.ErrorText }
-
-// parseFlexibleTime mimics JS `new Date(s).getTime()`: accept the formats
-// the API and the synthesis path produce. Returns ok=false for NaN cases.
-func parseFlexibleTime(s string) (time.Time, bool) {
-	for _, layout := range []string{
-		time.RFC3339, time.RFC1123, time.RFC1123Z, time.RFC822, time.RFC850,
-		"2006-01-02 15:04:05", "2006-01-02T15:04:05.000Z",
-	} {
-		if t, err := time.Parse(layout, s); err == nil {
-			return t, true
-		}
-	}
-	return time.Time{}, false
-}
-
-// CheckStatus ports importSqlCheckStatus's getResults loop
-// (status.ts:267-417). The command owns rendering and exit codes; this
-// owns the poll-state machine.
-func CheckStatus(ctx context.Context, opts CheckStatusOpts) (*StatusResult, error) {
-	interval := opts.Interval
-	if interval == 0 {
-		interval = DefaultPollInterval
-	}
-	overall := "Checking..." // status.ts:213
-
-	for {
-		snap, err := opts.Fetch(ctx)
-		if err != nil {
-			return nil, err
-		}
-
-		if snap.Job == nil {
-			debuglog.Printf(ctx, "vip:lib/site-import/status", "No import job data available")
-			if opts.ReturnMissingJobImmediately {
-				// status.ts:329 — resolve('No import job found')
-				return &StatusResult{Message: "No import job found"}, nil
-			}
-			// status.ts:294 — progress meta not filled out yet; wait.
-			select {
-			case <-ctx.Done():
-				return nil, ctx.Err()
-			case <-time.After(interval):
-			}
-			continue
-		}
-
-		job := snap.Job
-		jobStatus := job.Status
-		if jobStatus == "" {
-			jobStatus = "unknown" // status.ts:333
-		}
-		createdAt := job.CreatedAt
-		completedAt := job.CompletedAt
-		// Server strings and command output can contain sensitive data. Only
-		// allow known status values into the diagnostic summary.
-		diagnosticStatus := "unknown"
-		switch jobStatus {
-		case "running", "success", "error", "failed", "completed":
-			diagnosticStatus = jobStatus
-		}
-		debuglog.Printf(ctx, "vip:lib/site-import/status", "Import job: status=%s steps=%d completed=%t", diagnosticStatus, len(job.Steps), completedAt != "")
-
-		// failedImportStep gate (status.ts:353-366): the import_progress
-		// meta is only pertinent when it started at/after job creation.
-		var failed *FailedStep
-		if jobCreation, ok := parseFlexibleTime(createdAt); ok &&
-			snap.StatusProgressStartedAt*1000 >= jobCreation.UnixMilli() {
-			if fs := snap.FailedStep; fs != nil && fs.StartedAt*1000 > jobCreation.UnixMilli() {
-				failed = fs
-			}
-		}
-
-		if len(job.Steps) == 0 {
-			// status.ts:368 — reject({error: 'Could not enumerate the
-			// import job steps'})
-			return nil, errors.New("Could not enumerate the import job steps")
-		}
-
-		if failed != nil {
-			debuglog.Printf(ctx, "vip:lib/site-import/status", "Import step failed: launched=%t", snap.Launched)
-			// status.ts:373 — demote the 'import' step to failed, render,
-			// then reject with the structured error.
-			steps := make([]JobStep, len(job.Steps))
-			copy(steps, job.Steps)
-			for i := range steps {
-				if steps[i].ID == "import" {
-					steps[i].Status = tui.StepFailed
-				}
-			}
-			opts.Tracker.SetStepsFromServer(toServerSteps(steps))
-			if opts.OnPoll != nil {
-				opts.OnPoll(createdAt, completedAt, "failed")
-			}
-			return nil, &ImportFailedError{
-				InImportProgress: true,
-				CommandOutput:    failed.Output,
-				ErrorText:        "Import step failed",
-				StepName:         failed.Name,
-				Launched:         snap.Launched,
-			}
-		}
-
-		opts.Tracker.SetStepsFromServer(toServerSteps(job.Steps))
-		if opts.OnPoll != nil {
-			opts.OnPoll(createdAt, completedAt, overall)
-		}
-
-		if jobStatus == "error" {
-			// status.ts:399 — reject({error: 'Import job failed', ...})
-			return nil, errors.New("Import job failed")
-		}
-
-		if jobStatus != "running" && completedAt != "" {
-			// status.ts:404 — resolve(importJob)
-			return &StatusResult{
-				Status: jobStatus, CreatedAt: createdAt, CompletedAt: completedAt,
-			}, nil
-		}
-
-		overall = "running" // status.ts:408
-
-		select {
-		case <-ctx.Done():
-			return nil, ctx.Err()
-		case <-time.After(interval):
-		}
-	}
-}
-
-func toServerSteps(steps []JobStep) []tui.ServerStep {
-	out := make([]tui.ServerStep, len(steps))
-	for i, s := range steps {
-		out[i] = tui.ServerStep{Name: s.Name, Status: s.Status}
-	}
-	return out
-}
-
-// GetErrorMessage ports getErrorMessage (status.ts:116). Message blocks
-// are copied verbatim, including blank lines and the conditional
-// rollback notice (suppressed for launched environments).
-func GetErrorMessage(fe *ImportFailedError) string {
-	rollbackMessage := ""
-	if !fe.Launched {
-		rollbackMessage = "Your site is " + color.BlueString("automatically being rolled back") +
-			" to the last backup prior to your import job.\n"
-	}
-
-	message := fe.ErrorText
-	if !fe.InImportProgress {
-		return message
-	}
-
-	commandOutputBlock := func() string {
-		if fe.CommandOutput != nil {
-			joined := strings.Join(fe.CommandOutput, ";")
-			return "\nPlease inspect your input file and make the appropriate corrections before trying again.\nThe server said:\n> " +
-				color.RedString(joined) + "\n"
-		}
-		return ""
-	}
-
-	switch fe.StepName {
-	case "import_preflights":
-		message += "\nThis error occurred prior to the mysql batch script processing of your SQL file.\n\nYour site content was not altered.\n\nIf this error persists, please contact support.\n"
-	case "importing_db":
-		message += "\nThis error occurred during the mysql batch script processing of your SQL file.\n\n" + rollbackMessage
-		if fe.CommandOutput != nil {
-			message += commandOutputBlock()
-		} else {
-			message += "Please contact support and include this message along with your sql file."
-		}
-	case "validating_db":
-		message += "\nThis error occurred during the post-import validation of the imported data.\n\n" + rollbackMessage + "\n"
-		if fe.CommandOutput != nil {
-			message += commandOutputBlock()
-		} else {
-			message += "Please contact support and include this message along with your sql file."
-		}
-	case "update_primary_domain":
-		message += "\nThis error occurred during the update of the primary domain.\n\n" + rollbackMessage + "\n"
-		if fe.CommandOutput != nil {
-			message += commandOutputBlock()
-		}
-	}
-	return message
-}
-
-// Capitalize ports format.ts capitalize (format.ts:139).
-func Capitalize(s string) string {
-	if s == "" {
-		return ""
-	}
-	return strings.ToUpper(s[:1]) + s[1:]
-}

package/internal/siteimport/status_test.go

@@ -1,234 +0,0 @@
-package siteimport
-
-import (
-	"context"
-	"errors"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/Automattic/vip/internal/tui"
-)
-
-// scriptedFetch returns each snapshot in order, repeating the last.
-func scriptedFetch(snaps []ProgressSnapshot) ProgressFetch {
-	i := 0
-	return func(ctx context.Context) (*ProgressSnapshot, error) {
-		s := snaps[i]
-		if i < len(snaps)-1 {
-			i++
-		}
-		return &s, nil
-	}
-}
-
-func TestCheckStatusSuccessFromJob(t *testing.T) {
-	created := "Mon, 01 Jun 2026 00:00:00 UTC"
-	completed := "Mon, 01 Jun 2026 00:05:00 UTC"
-	snaps := []ProgressSnapshot{
-		{Job: &ImportJob{CreatedAt: created, Status: "running", Steps: []JobStep{
-			{ID: "preflights", Name: "Import preflights", Status: tui.StepSuccess},
-			{ID: "import", Name: "Importing db", Status: tui.StepRunning},
-		}}},
-		{Job: &ImportJob{CreatedAt: created, CompletedAt: completed, Status: "success", Steps: []JobStep{
-			{ID: "preflights", Name: "Import preflights", Status: tui.StepSuccess},
-			{ID: "import", Name: "Importing db", Status: tui.StepSuccess},
-		}}},
-	}
-	pt := tui.NewProgressTracker(nil)
-	var polls int
-	res, err := CheckStatus(context.Background(), CheckStatusOpts{
-		Fetch: scriptedFetch(snaps), Tracker: pt, Interval: time.Millisecond,
-		OnPoll: func(_, _, _ string) { polls++ },
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if res.Status != "success" || res.CompletedAt != completed {
-		t.Errorf("res = %+v", res)
-	}
-	if polls < 2 {
-		t.Errorf("OnPoll fired %d times, want >= 2", polls)
-	}
-	if !pt.AllStepsSucceeded() {
-		t.Error("tracker should reflect all-success server steps")
-	}
-}
-
-func TestCheckStatusJobErrorRejects(t *testing.T) {
-	snaps := []ProgressSnapshot{
-		{Job: &ImportJob{CreatedAt: "Mon, 01 Jun 2026 00:00:00 UTC", Status: "error", Steps: []JobStep{
-			{ID: "import", Name: "Importing db", Status: tui.StepFailed},
-		}}},
-	}
-	pt := tui.NewProgressTracker(nil)
-	_, err := CheckStatus(context.Background(), CheckStatusOpts{
-		Fetch: scriptedFetch(snaps), Tracker: pt, Interval: time.Millisecond,
-	})
-	if err == nil || !strings.Contains(err.Error(), "Import job failed") {
-		t.Errorf("err = %v", err)
-	}
-}
-
-func TestCheckStatusMissingJobReturnsFast(t *testing.T) {
-	snaps := []ProgressSnapshot{{Job: nil}}
-	pt := tui.NewProgressTracker(nil)
-	res, err := CheckStatus(context.Background(), CheckStatusOpts{
-		Fetch: scriptedFetch(snaps), Tracker: pt, Interval: time.Millisecond,
-		ReturnMissingJobImmediately: true,
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if res.Message != "No import job found" {
-		t.Errorf("message = %q", res.Message)
-	}
-}
-
-func TestCheckStatusWaitsForProgressMeta(t *testing.T) {
-	created := "Mon, 01 Jun 2026 00:00:00 UTC"
-	snaps := []ProgressSnapshot{
-		{Job: nil}, // meta not ready yet — must wait, not error
-		{Job: &ImportJob{CreatedAt: created, CompletedAt: created, Status: "success", Steps: []JobStep{
-			{ID: "import", Name: "Importing db", Status: tui.StepSuccess},
-		}}},
-	}
-	pt := tui.NewProgressTracker(nil)
-	res, err := CheckStatus(context.Background(), CheckStatusOpts{
-		Fetch: scriptedFetch(snaps), Tracker: pt, Interval: time.Millisecond,
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if res.Status != "success" {
-		t.Errorf("res = %+v", res)
-	}
-}
-
-func TestCheckStatusEmptyStepsErrors(t *testing.T) {
-	snaps := []ProgressSnapshot{
-		{Job: &ImportJob{CreatedAt: "Mon, 01 Jun 2026 00:00:00 UTC", Status: "running"}},
-	}
-	pt := tui.NewProgressTracker(nil)
-	_, err := CheckStatus(context.Background(), CheckStatusOpts{
-		Fetch: scriptedFetch(snaps), Tracker: pt, Interval: time.Millisecond,
-	})
-	if err == nil || err.Error() != "Could not enumerate the import job steps" {
-		t.Errorf("err = %v", err)
-	}
-}
-
-func TestCheckStatusFailedImportStepProducesStepError(t *testing.T) {
-	now := time.Now()
-	snaps := []ProgressSnapshot{{
-		Job: &ImportJob{
-			CreatedAt: now.Add(-time.Hour).UTC().Format(time.RFC1123),
-			Status:    "running",
-			Steps: []JobStep{
-				{ID: "import", Name: "Import", Status: tui.StepRunning},
-			},
-		},
-		StatusProgressStartedAt: now.Unix(),
-		FailedStep: &FailedStep{
-			Name: "importing_db", Output: []string{"ERROR 1064 (42000) at line 9"},
-			StartedAt: now.Unix(),
-		},
-		Launched: false,
-	}}
-	pt := tui.NewProgressTracker(nil)
-	_, err := CheckStatus(context.Background(), CheckStatusOpts{
-		Fetch: scriptedFetch(snaps), Tracker: pt, Interval: time.Millisecond,
-	})
-	var fe *ImportFailedError
-	if !errors.As(err, &fe) {
-		t.Fatalf("err = %v (type %T)", err, err)
-	}
-	if fe.StepName != "importing_db" || len(fe.CommandOutput) != 1 || !fe.InImportProgress {
-		t.Errorf("fe = %+v", fe)
-	}
-	// The demoted server step renders the failed glyph (Node sets
-	// hasFailure only for caller steps; server-step failure shows via the
-	// glyph — progress.ts:264).
-	if frame := pt.Frame(); !strings.Contains(frame, "✕") {
-		t.Errorf("frame missing failed glyph: %q", frame)
-	}
-}
-
-func TestCheckStatusOldFailedStepIgnored(t *testing.T) {
-	// A failed step from BEFORE the job was created is stale and must be
-	// ignored (status.ts:353-366 timestamp gate).
-	now := time.Now()
-	created := now.UTC().Format(time.RFC1123)
-	snaps := []ProgressSnapshot{{
-		Job: &ImportJob{
-			CreatedAt: created, CompletedAt: created, Status: "success",
-			Steps: []JobStep{{ID: "import", Name: "Import", Status: tui.StepSuccess}},
-		},
-		StatusProgressStartedAt: now.Add(-2 * time.Hour).Unix(),
-		FailedStep: &FailedStep{
-			Name: "importing_db", StartedAt: now.Add(-2 * time.Hour).Unix(),
-		},
-	}}
-	pt := tui.NewProgressTracker(nil)
-	res, err := CheckStatus(context.Background(), CheckStatusOpts{
-		Fetch: scriptedFetch(snaps), Tracker: pt, Interval: time.Millisecond,
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if res.Status != "success" {
-		t.Errorf("res = %+v", res)
-	}
-}
-
-func TestGetErrorMessageBlocks(t *testing.T) {
-	fe := &ImportFailedError{
-		InImportProgress: true, ErrorText: "Import step failed",
-		StepName: "importing_db", CommandOutput: []string{"line1", "line2"},
-		Launched: false,
-	}
-	msg := GetErrorMessage(fe)
-	for _, want := range []string{
-		"Import step failed",
-		"This error occurred during the mysql batch script processing of your SQL file.",
-		"automatically being rolled back",
-		"The server said:",
-		"line1;line2",
-	} {
-		if !strings.Contains(msg, want) {
-			t.Errorf("message missing %q:\n%s", want, msg)
-		}
-	}
-
-	// launched suppresses the rollback notice
-	fe.Launched = true
-	if msg := GetErrorMessage(fe); strings.Contains(msg, "rolled back") {
-		t.Errorf("launched env must not mention rollback:\n%s", msg)
-	}
-
-	// no command output → contact-support line
-	fe.CommandOutput = nil
-	if msg := GetErrorMessage(fe); !strings.Contains(msg, "Please contact support and include this message along with your sql file.") {
-		t.Errorf("missing contact-support fallback:\n%s", msg)
-	}
-
-	// preflights block
-	fe2 := &ImportFailedError{InImportProgress: true, ErrorText: "Import step failed", StepName: "import_preflights"}
-	if msg := GetErrorMessage(fe2); !strings.Contains(msg, "Your site content was not altered.") {
-		t.Errorf("preflights block missing:\n%s", msg)
-	}
-
-	// non-import-progress error returns the bare text
-	fe3 := &ImportFailedError{ErrorText: "Could not enumerate the import job steps"}
-	if msg := GetErrorMessage(fe3); msg != "Could not enumerate the import job steps" {
-		t.Errorf("msg = %q", msg)
-	}
-}
-
-func TestCapitalize(t *testing.T) {
-	for in, want := range map[string]string{"": "", "import preflights": "Import preflights", "a": "A"} {
-		if got := Capitalize(in); got != want {
-			t.Errorf("Capitalize(%q) = %q", in, got)
-		}
-	}
-}

package/internal/slowlogsapi/slowlogsapi.go

@@ -1,176 +0,0 @@
-// Package slowlogsapi wraps the GetAppSlowlogs genqlient operation behind
-// a flat Go-friendly surface. The schema field is
-// `AppEnvironment.slowlogs(limit, after)` and returns
-// `AppEnvironmentSlowlogsList` (`nodes`, `nextCursor`,
-// `pollingDelaySeconds`).
-//
-// Node parity: src/lib/app-slowlogs/app-slowlogs.ts (getRecentSlowlogs).
-// The reflection walker matches internal/logsapi but yields a richer row
-// shape: timestamp, rowsSent, rowsExamined, queryTime, requestUri, query.
-package slowlogsapi
-
-import (
-	"context"
-	"reflect"
-
-	"github.com/Khan/genqlient/graphql"
-
-	"github.com/Automattic/vip/internal/gql"
-)
-
-// LIMIT_MAX is the server-side ceiling for the `limit` argument on the
-// slowlogs query. Node's vip-slowlogs.ts uses 500 as the validation cap
-// (vs 5000 for runtime logs); slowlogs are intentionally smaller-batched
-// to keep the MySQL slow-query window manageable.
-const LIMIT_MAX = 500
-
-// SlowlogNode is one slow-query log line. All fields are strings on the
-// wire (the schema exposes them as String, including rowsSent/rowsExamined
-// which are numeric in MySQL but serialized as text to preserve bigint
-// precision).
-type SlowlogNode struct {
-	Timestamp    string
-	RowsSent     string
-	RowsExamined string
-	QueryTime    string
-	RequestUri   string
-	Query        string
-}
-
-// Page is a single response page from the slowlogs endpoint.
-type Page struct {
-	Nodes               []SlowlogNode
-	NextCursor          *string
-	PollingDelaySeconds int
-}
-
-// RecentSlowlogs runs GetAppSlowlogs and flattens the response. Validation
-// (limit bounds, format allow-list) lives at the command-line layer to
-// match Node's exact error wording.
-func RecentSlowlogs(ctx context.Context, c graphql.Client, appID, envID int64, limit int, after *string) (*Page, error) {
-	resp, err := gql.GetAppSlowlogs(ctx, c, appID, envID, int64(limit), after)
-	if err != nil {
-		return nil, err
-	}
-	return reflectSlowlogsResponse(resp), nil
-}
-
-// reflectSlowlogsResponse mirrors logsapi.reflectLogsResponse but pulls
-// the six slowlog-specific fields from each node. Same defensive shape:
-// returns an empty Page on any missing parent field.
-func reflectSlowlogsResponse(v any) *Page {
-	p := &Page{Nodes: []SlowlogNode{}}
-	rv := reflect.ValueOf(v)
-	for rv.Kind() == reflect.Ptr {
-		if rv.IsNil() {
-			return p
-		}
-		rv = rv.Elem()
-	}
-	if rv.Kind() != reflect.Struct {
-		return p
-	}
-	app := rv.FieldByName("App")
-	for app.Kind() == reflect.Ptr {
-		if app.IsNil() {
-			return p
-		}
-		app = app.Elem()
-	}
-	if !app.IsValid() || app.Kind() != reflect.Struct {
-		return p
-	}
-	envs := app.FieldByName("Environments")
-	if !envs.IsValid() || envs.Kind() != reflect.Slice || envs.Len() == 0 {
-		return p
-	}
-	env := envs.Index(0)
-	for env.Kind() == reflect.Ptr {
-		if env.IsNil() {
-			return p
-		}
-		env = env.Elem()
-	}
-	if env.Kind() != reflect.Struct {
-		return p
-	}
-	sl := env.FieldByName("Slowlogs")
-	for sl.Kind() == reflect.Ptr {
-		if sl.IsNil() {
-			return p
-		}
-		sl = sl.Elem()
-	}
-	if !sl.IsValid() || sl.Kind() != reflect.Struct {
-		return p
-	}
-	if nc := sl.FieldByName("NextCursor"); nc.IsValid() {
-		switch nc.Kind() {
-		case reflect.Ptr:
-			if !nc.IsNil() {
-				s := nc.Elem().String()
-				p.NextCursor = &s
-			}
-		case reflect.String:
-			s := nc.String()
-			p.NextCursor = &s
-		}
-	}
-	if pd := sl.FieldByName("PollingDelaySeconds"); pd.IsValid() {
-		switch pd.Kind() {
-		case reflect.Ptr:
-			if !pd.IsNil() {
-				p.PollingDelaySeconds = int(pd.Elem().Int())
-			}
-		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-			p.PollingDelaySeconds = int(pd.Int())
-		}
-	}
-	nodes := sl.FieldByName("Nodes")
-	if !nodes.IsValid() || nodes.Kind() != reflect.Slice {
-		return p
-	}
-	for i := 0; i < nodes.Len(); i++ {
-		n := nodes.Index(i)
-		for n.Kind() == reflect.Ptr {
-			if n.IsNil() {
-				n = reflect.Value{}
-				break
-			}
-			n = n.Elem()
-		}
-		if !n.IsValid() || n.Kind() != reflect.Struct {
-			continue
-		}
-		var item SlowlogNode
-		item.Timestamp = readStringField(n, "Timestamp")
-		item.RowsSent = readStringField(n, "RowsSent")
-		item.RowsExamined = readStringField(n, "RowsExamined")
-		item.QueryTime = readStringField(n, "QueryTime")
-		item.RequestUri = readStringField(n, "RequestUri")
-		item.Query = readStringField(n, "Query")
-		p.Nodes = append(p.Nodes, item)
-	}
-	return p
-}
-
-// readStringField yields the string value of a struct field that may be
-// either `string` or `*string` (genqlient emits either depending on
-// nullability + use_struct_references). Missing or nil pointer fields
-// return "".
-func readStringField(rv reflect.Value, name string) string {
-	f := rv.FieldByName(name)
-	if !f.IsValid() {
-		return ""
-	}
-	switch f.Kind() {
-	case reflect.Ptr:
-		if f.IsNil() {
-			return ""
-		}
-		return f.Elem().String()
-	case reflect.String:
-		return f.String()
-	}
-	return ""
-}