Use dedicated read replica names in the Go client

internal/cmd/dedicatedreadreplica/create.go

@@ -37,7 +37,7 @@ defaults to the primary cluster size when those flags are omitted.`,
 				return err
 			}
 
-			req := &ps.CreatePostgresReadOnlyReplicaRequest{
+			req := &ps.CreatePostgresDedicatedReadReplicaRequest{
 				Organization: ch.Config.Organization,
 				Database:     database,
 				Branch:       branch,
@@ -52,7 +52,7 @@ defaults to the primary cluster size when those flags are omitted.`,
 			end := ch.Printer.PrintProgress(fmt.Sprintf("Creating dedicated read replica %s for %s/%s", printer.BoldBlue(name), printer.BoldBlue(database), printer.BoldBlue(branch)))
 			defer end()
 
-			replica, err := client.PostgresReadOnlyReplicas.Create(ctx, req)
+			replica, err := client.PostgresDedicatedReadReplicas.Create(ctx, req)
 			if err != nil {
 				switch cmdutil.ErrCode(err) {
 				case ps.ErrNotFound:
@@ -69,7 +69,7 @@ defaults to the primary cluster size when those flags are omitted.`,
 					printer.BoldBlue(replica.Name), printer.BoldBlue(database), printer.BoldBlue(branch), printer.BoldBlue(replica.State))
 				return nil
 			}
-			return ch.Printer.PrintResource(toReadOnlyReplica(replica))
+			return ch.Printer.PrintResource(toDedicatedReadReplica(replica))
 		},
 	}
 

internal/cmd/dedicatedreadreplica/dedicatedreadreplica.go

@@ -55,8 +55,8 @@ This command is only available for PostgreSQL databases.`,
 	return cmd
 }
 
-// ReadOnlyReplica is the human/JSON/CSV view of a Postgres dedicated read replica.
-type ReadOnlyReplica struct {
+// DedicatedReadReplica is the human/JSON/CSV view of a Postgres dedicated read replica.
+type DedicatedReadReplica struct {
 	ID        string `header:"id" json:"id"`
 	Name      string `header:"name" json:"name"`
 	State     string `header:"state" json:"state"`
@@ -66,18 +66,18 @@ type ReadOnlyReplica struct {
 	Ready     bool   `header:"ready" json:"ready"`
 	CreatedAt int64  `header:"created_at,timestamp(ms|utc|human)" json:"created_at"`
 
-	orig *ps.PostgresReadOnlyReplica
+	orig *ps.PostgresDedicatedReadReplica
 }
 
-func (r *ReadOnlyReplica) MarshalJSON() ([]byte, error) {
+func (r *DedicatedReadReplica) MarshalJSON() ([]byte, error) {
 	return json.MarshalIndent(r.orig, "", "  ")
 }
 
-func (r *ReadOnlyReplica) MarshalCSVValue() interface{} {
-	return []*ReadOnlyReplica{r}
+func (r *DedicatedReadReplica) MarshalCSVValue() interface{} {
+	return []*DedicatedReadReplica{r}
 }
 
-func toReadOnlyReplica(replica *ps.PostgresReadOnlyReplica) *ReadOnlyReplica {
+func toDedicatedReadReplica(replica *ps.PostgresDedicatedReadReplica) *DedicatedReadReplica {
 	size := replica.ClusterDisplayName
 	if size == "" {
 		size = replica.ClusterName
@@ -94,7 +94,7 @@ func toReadOnlyReplica(replica *ps.PostgresReadOnlyReplica) *ReadOnlyReplica {
 		region = "-"
 	}
 
-	return &ReadOnlyReplica{
+	return &DedicatedReadReplica{
 		ID:        replica.ID,
 		Name:      replica.Name,
 		State:     replica.State,
@@ -107,10 +107,10 @@ func toReadOnlyReplica(replica *ps.PostgresReadOnlyReplica) *ReadOnlyReplica {
 	}
 }
 
-func toReadOnlyReplicas(replicas []*ps.PostgresReadOnlyReplica) []*ReadOnlyReplica {
-	out := make([]*ReadOnlyReplica, 0, len(replicas))
+func toDedicatedReadReplicas(replicas []*ps.PostgresDedicatedReadReplica) []*DedicatedReadReplica {
+	out := make([]*DedicatedReadReplica, 0, len(replicas))
 	for _, replica := range replicas {
-		out = append(out, toReadOnlyReplica(replica))
+		out = append(out, toDedicatedReadReplica(replica))
 	}
 	return out
 }

internal/cmd/dedicatedreadreplica/dedicatedreadreplica_test.go

@@ -15,9 +15,9 @@ import (
 	"github.com/planetscale/cli/internal/printer"
 )
 
-func testReplica() *ps.PostgresReadOnlyReplica {
+func testDedicatedReadReplica() *ps.PostgresDedicatedReadReplica {
 	readyAt := time.Date(2026, 8, 28, 10, 20, 23, 0, time.UTC)
-	return &ps.PostgresReadOnlyReplica{
+	return &ps.PostgresDedicatedReadReplica{
 		ID:                 "replica-1",
 		Name:               "analytics",
 		State:              "ready",
@@ -34,16 +34,16 @@ func testReplica() *ps.PostgresReadOnlyReplica {
 	}
 }
 
-func testHelper(org string, dbSvc *mock.DatabaseService, replicaSvc *mock.PostgresReadOnlyReplicasService, format printer.Format, buf *bytes.Buffer) *cmdutil.Helper {
+func testHelper(org string, dbSvc *mock.DatabaseService, replicaSvc *mock.PostgresDedicatedReadReplicasService, format printer.Format, buf *bytes.Buffer) *cmdutil.Helper {
 	p := printer.NewPrinter(&format)
 	p.SetResourceOutput(buf)
 	return &cmdutil.Helper{
 		Printer: p,
 		Config:  &config.Config{Organization: org},
 		Client: func() (*ps.Client, error) {
 			return &ps.Client{
-				Databases:                dbSvc,
-				PostgresReadOnlyReplicas: replicaSvc,
+				Databases:                     dbSvc,
+				PostgresDedicatedReadReplicas: replicaSvc,
 			}, nil
 		},
 	}
@@ -86,9 +86,9 @@ func TestDeprecatedCmdWarnsOnSubcommand(t *testing.T) {
 	c := qt.New(t)
 	var stdout, stderr bytes.Buffer
 	org, database, branch := "planetscale", "mydb", "main"
-	svc := &mock.PostgresReadOnlyReplicasService{
-		ListFn: func(ctx context.Context, req *ps.ListPostgresReadOnlyReplicasRequest) ([]*ps.PostgresReadOnlyReplica, error) {
-			return []*ps.PostgresReadOnlyReplica{testReplica()}, nil
+	svc := &mock.PostgresDedicatedReadReplicasService{
+		ListFn: func(ctx context.Context, req *ps.ListPostgresDedicatedReadReplicasRequest) ([]*ps.PostgresDedicatedReadReplica, error) {
+			return []*ps.PostgresDedicatedReadReplica{testDedicatedReadReplica()}, nil
 		},
 	}
 
@@ -112,30 +112,30 @@ func TestListCmd(t *testing.T) {
 	c := qt.New(t)
 	var buf bytes.Buffer
 	org, database, branch := "planetscale", "mydb", "main"
-	replica := testReplica()
-	svc := &mock.PostgresReadOnlyReplicasService{
-		ListFn: func(ctx context.Context, req *ps.ListPostgresReadOnlyReplicasRequest) ([]*ps.PostgresReadOnlyReplica, error) {
+	replica := testDedicatedReadReplica()
+	svc := &mock.PostgresDedicatedReadReplicasService{
+		ListFn: func(ctx context.Context, req *ps.ListPostgresDedicatedReadReplicasRequest) ([]*ps.PostgresDedicatedReadReplica, error) {
 			c.Assert(req.Organization, qt.Equals, org)
 			c.Assert(req.Database, qt.Equals, database)
 			c.Assert(req.Branch, qt.Equals, branch)
-			return []*ps.PostgresReadOnlyReplica{replica}, nil
+			return []*ps.PostgresDedicatedReadReplica{replica}, nil
 		},
 	}
 
 	cmd := ListCmd(testHelper(org, databaseService(c, org, database), svc, printer.JSON, &buf))
 	cmd.SetArgs([]string{database, branch})
 	c.Assert(cmd.Execute(), qt.IsNil)
 	c.Assert(svc.ListFnInvoked, qt.IsTrue)
-	c.Assert(buf.String(), qt.JSONEquals, []*ReadOnlyReplica{{orig: replica}})
+	c.Assert(buf.String(), qt.JSONEquals, []*DedicatedReadReplica{{orig: replica}})
 }
 
 func TestShowCmd(t *testing.T) {
 	c := qt.New(t)
 	var buf bytes.Buffer
 	org, database, branch := "planetscale", "mydb", "main"
-	replica := testReplica()
-	svc := &mock.PostgresReadOnlyReplicasService{
-		GetFn: func(ctx context.Context, req *ps.GetPostgresReadOnlyReplicaRequest) (*ps.PostgresReadOnlyReplica, error) {
+	replica := testDedicatedReadReplica()
+	svc := &mock.PostgresDedicatedReadReplicasService{
+		GetFn: func(ctx context.Context, req *ps.GetPostgresDedicatedReadReplicaRequest) (*ps.PostgresDedicatedReadReplica, error) {
 			c.Assert(req.Organization, qt.Equals, org)
 			c.Assert(req.Database, qt.Equals, database)
 			c.Assert(req.Branch, qt.Equals, branch)
@@ -148,16 +148,16 @@ func TestShowCmd(t *testing.T) {
 	cmd.SetArgs([]string{database, branch, "analytics"})
 	c.Assert(cmd.Execute(), qt.IsNil)
 	c.Assert(svc.GetFnInvoked, qt.IsTrue)
-	c.Assert(buf.String(), qt.JSONEquals, &ReadOnlyReplica{orig: replica})
+	c.Assert(buf.String(), qt.JSONEquals, &DedicatedReadReplica{orig: replica})
 }
 
 func TestCreateCmd(t *testing.T) {
 	c := qt.New(t)
 	var buf bytes.Buffer
 	org, database, branch := "planetscale", "mydb", "main"
-	replica := testReplica()
-	svc := &mock.PostgresReadOnlyReplicasService{
-		CreateFn: func(ctx context.Context, req *ps.CreatePostgresReadOnlyReplicaRequest) (*ps.PostgresReadOnlyReplica, error) {
+	replica := testDedicatedReadReplica()
+	svc := &mock.PostgresDedicatedReadReplicasService{
+		CreateFn: func(ctx context.Context, req *ps.CreatePostgresDedicatedReadReplicaRequest) (*ps.PostgresDedicatedReadReplica, error) {
 			c.Assert(req.Organization, qt.Equals, org)
 			c.Assert(req.Database, qt.Equals, database)
 			c.Assert(req.Branch, qt.Equals, branch)
@@ -174,16 +174,16 @@ func TestCreateCmd(t *testing.T) {
 	cmd.SetArgs([]string{database, branch, "analytics", "--region", "us-east", "--replicas", "2", "--cluster-size", "PS_10_GCP_X86"})
 	c.Assert(cmd.Execute(), qt.IsNil)
 	c.Assert(svc.CreateFnInvoked, qt.IsTrue)
-	c.Assert(buf.String(), qt.JSONEquals, &ReadOnlyReplica{orig: replica})
+	c.Assert(buf.String(), qt.JSONEquals, &DedicatedReadReplica{orig: replica})
 }
 
 func TestUpdateCmd(t *testing.T) {
 	c := qt.New(t)
 	var buf bytes.Buffer
 	org, database, branch := "planetscale", "mydb", "main"
-	replica := testReplica()
-	svc := &mock.PostgresReadOnlyReplicasService{
-		UpdateFn: func(ctx context.Context, req *ps.UpdatePostgresReadOnlyReplicaRequest) (*ps.PostgresReadOnlyReplica, error) {
+	replica := testDedicatedReadReplica()
+	svc := &mock.PostgresDedicatedReadReplicasService{
+		UpdateFn: func(ctx context.Context, req *ps.UpdatePostgresDedicatedReadReplicaRequest) (*ps.PostgresDedicatedReadReplica, error) {
 			c.Assert(req.Organization, qt.Equals, org)
 			c.Assert(req.Database, qt.Equals, database)
 			c.Assert(req.Branch, qt.Equals, branch)
@@ -207,12 +207,12 @@ func TestUpdateCmd(t *testing.T) {
 	})
 	c.Assert(cmd.Execute(), qt.IsNil)
 	c.Assert(svc.UpdateFnInvoked, qt.IsTrue)
-	c.Assert(buf.String(), qt.JSONEquals, &ReadOnlyReplica{orig: replica})
+	c.Assert(buf.String(), qt.JSONEquals, &DedicatedReadReplica{orig: replica})
 }
 
 func TestUpdateCmdRequiresChange(t *testing.T) {
 	c := qt.New(t)
-	svc := &mock.PostgresReadOnlyReplicasService{}
+	svc := &mock.PostgresDedicatedReadReplicasService{}
 	cmd := UpdateCmd(testHelper("planetscale", &mock.DatabaseService{}, svc, printer.JSON, &bytes.Buffer{}))
 	cmd.SetArgs([]string{"mydb", "main", "analytics"})
 	c.Assert(cmd.Execute(), qt.ErrorMatches, `nothing to change:.*`)
@@ -223,8 +223,8 @@ func TestDeleteCmd(t *testing.T) {
 	c := qt.New(t)
 	var buf bytes.Buffer
 	org, database, branch := "planetscale", "mydb", "main"
-	svc := &mock.PostgresReadOnlyReplicasService{
-		DeleteFn: func(ctx context.Context, req *ps.DeletePostgresReadOnlyReplicaRequest) error {
+	svc := &mock.PostgresDedicatedReadReplicasService{
+		DeleteFn: func(ctx context.Context, req *ps.DeletePostgresDedicatedReadReplicaRequest) error {
 			c.Assert(req.Organization, qt.Equals, org)
 			c.Assert(req.Database, qt.Equals, database)
 			c.Assert(req.Branch, qt.Equals, branch)
@@ -248,7 +248,7 @@ func TestDeleteCmd(t *testing.T) {
 func TestDeleteCmdRequiresForceInJSON(t *testing.T) {
 	c := qt.New(t)
 	org, database := "planetscale", "mydb"
-	svc := &mock.PostgresReadOnlyReplicasService{}
+	svc := &mock.PostgresDedicatedReadReplicasService{}
 	cmd := DeleteCmd(testHelper(org, databaseService(c, org, database), svc, printer.JSON, &bytes.Buffer{}))
 	cmd.SetArgs([]string{database, "main", "analytics"})
 	c.Assert(cmd.Execute(), qt.ErrorMatches, `(?s).*run with --force.*`)
@@ -263,7 +263,7 @@ func TestListCmdRejectsMySQL(t *testing.T) {
 			return &ps.Database{Name: database, Kind: ps.DatabaseEngineMySQL}, nil
 		},
 	}
-	svc := &mock.PostgresReadOnlyReplicasService{}
+	svc := &mock.PostgresDedicatedReadReplicasService{}
 	cmd := ListCmd(testHelper(org, dbSvc, svc, printer.JSON, &bytes.Buffer{}))
 	cmd.SetArgs([]string{database, "main"})
 	c.Assert(cmd.Execute(), qt.ErrorMatches, `(?s).*only available for PostgreSQL.*mysql.*`)

internal/cmd/dedicatedreadreplica/delete.go

@@ -40,7 +40,7 @@ func DeleteCmd(ch *cmdutil.Helper) *cobra.Command {
 			end := ch.Printer.PrintProgress(fmt.Sprintf("Deleting dedicated read replica %s from %s/%s", printer.BoldBlue(name), printer.BoldBlue(database), printer.BoldBlue(branch)))
 			defer end()
 
-			err = client.PostgresReadOnlyReplicas.Delete(ctx, &ps.DeletePostgresReadOnlyReplicaRequest{
+			err = client.PostgresDedicatedReadReplicas.Delete(ctx, &ps.DeletePostgresDedicatedReadReplicaRequest{
 				Organization: ch.Config.Organization,
 				Database:     database,
 				Branch:       branch,

internal/cmd/dedicatedreadreplica/list.go

@@ -31,7 +31,7 @@ func ListCmd(ch *cmdutil.Helper) *cobra.Command {
 			end := ch.Printer.PrintProgress(fmt.Sprintf("Fetching dedicated read replicas for %s/%s", printer.BoldBlue(database), printer.BoldBlue(branch)))
 			defer end()
 
-			replicas, err := client.PostgresReadOnlyReplicas.List(ctx, &ps.ListPostgresReadOnlyReplicasRequest{
+			replicas, err := client.PostgresDedicatedReadReplicas.List(ctx, &ps.ListPostgresDedicatedReadReplicasRequest{
 				Organization: ch.Config.Organization,
 				Database:     database,
 				Branch:       branch,
@@ -52,7 +52,7 @@ func ListCmd(ch *cmdutil.Helper) *cobra.Command {
 				return nil
 			}
 
-			return ch.Printer.PrintResource(toReadOnlyReplicas(replicas))
+			return ch.Printer.PrintResource(toDedicatedReadReplicas(replicas))
 		},
 	}
 

internal/cmd/dedicatedreadreplica/show.go

@@ -30,7 +30,7 @@ func ShowCmd(ch *cmdutil.Helper) *cobra.Command {
 			end := ch.Printer.PrintProgress(fmt.Sprintf("Fetching dedicated read replica %s for %s/%s", printer.BoldBlue(name), printer.BoldBlue(database), printer.BoldBlue(branch)))
 			defer end()
 
-			replica, err := client.PostgresReadOnlyReplicas.Get(ctx, &ps.GetPostgresReadOnlyReplicaRequest{
+			replica, err := client.PostgresDedicatedReadReplicas.Get(ctx, &ps.GetPostgresDedicatedReadReplicaRequest{
 				Organization: ch.Config.Organization,
 				Database:     database,
 				Branch:       branch,
@@ -47,7 +47,7 @@ func ShowCmd(ch *cmdutil.Helper) *cobra.Command {
 			}
 			end()
 
-			return ch.Printer.PrintResource(toReadOnlyReplica(replica))
+			return ch.Printer.PrintResource(toDedicatedReadReplica(replica))
 		},
 	}
 

internal/cmd/dedicatedreadreplica/update.go

@@ -50,7 +50,7 @@ equal to the primary branch's corresponding values.`,
 				return err
 			}
 
-			req := &ps.UpdatePostgresReadOnlyReplicaRequest{
+			req := &ps.UpdatePostgresDedicatedReadReplicaRequest{
 				Organization: ch.Config.Organization,
 				Database:     database,
 				Branch:       branch,
@@ -65,7 +65,7 @@ equal to the primary branch's corresponding values.`,
 			end := ch.Printer.PrintProgress(fmt.Sprintf("Updating dedicated read replica %s on %s/%s", printer.BoldBlue(name), printer.BoldBlue(database), printer.BoldBlue(branch)))
 			defer end()
 
-			replica, err := client.PostgresReadOnlyReplicas.Update(ctx, req)
+			replica, err := client.PostgresDedicatedReadReplicas.Update(ctx, req)
 			if err != nil {
 				switch cmdutil.ErrCode(err) {
 				case ps.ErrNotFound:
@@ -82,7 +82,7 @@ equal to the primary branch's corresponding values.`,
 					printer.BoldBlue(name), printer.BoldBlue(database), printer.BoldBlue(branch), printer.BoldBlue(replica.State))
 				return nil
 			}
-			return ch.Printer.PrintResource(toReadOnlyReplica(replica))
+			return ch.Printer.PrintResource(toDedicatedReadReplica(replica))
 		},
 	}
 

internal/cmd/role/get.go

@@ -39,15 +39,15 @@ func GetCmd(ch *cmdutil.Helper) *cobra.Command {
 			defer end()
 
 			role, err := client.PostgresRoles.Get(ctx, &ps.GetPostgresRoleRequest{
-				Organization:    ch.Config.Organization,
-				Database:        database,
-				Branch:          branch,
-				RoleId:          roleID,
-				Replica:         flags.replica,
-				ReadOnlyReplica: flags.dedicatedReadReplica,
-				Bouncer:         flags.bouncer,
-				Router:          flags.router,
-				Shard:           flags.shard,
+				Organization:         ch.Config.Organization,
+				Database:             database,
+				Branch:               branch,
+				RoleId:               roleID,
+				Replica:              flags.replica,
+				DedicatedReadReplica: flags.dedicatedReadReplica,
+				Bouncer:              flags.bouncer,
+				Router:               flags.router,
+				Shard:                flags.shard,
 			})
 			if err != nil {
 				switch cmdutil.ErrCode(err) {

internal/cmd/role/get_test.go

@@ -90,7 +90,7 @@ func TestRole_GetCmdConnectionTargets(t *testing.T) {
 			name: "dedicated read replica",
 			args: []string{"mydb", "main", "role-id", "--dedicated-read-replica", "analytics"},
 			request: ps.GetPostgresRoleRequest{
-				ReadOnlyReplica: "analytics",
+				DedicatedReadReplica: "analytics",
 			},
 			username:      "app.read-only|replica",
 			accessHostURL: "analytics.pg.psdb.cloud",
@@ -100,7 +100,7 @@ func TestRole_GetCmdConnectionTargets(t *testing.T) {
 			name: "deprecated read-only replica alias",
 			args: []string{"mydb", "main", "role-id", "--read-only-replica", "analytics"},
 			request: ps.GetPostgresRoleRequest{
-				ReadOnlyReplica: "analytics",
+				DedicatedReadReplica: "analytics",
 			},
 			username:      "app.read-only|replica",
 			accessHostURL: "analytics.pg.psdb.cloud",