chore: refactor codersdk.Client creation into builder

spikecurtis · spikecurtis · commit 6abde1e4ba1c · 2025-09-10T11:15:33.000Z
diff --git a/codersdk/agentsdk/agentsdk.go b/codersdk/agentsdk/agentsdk.go
@@ -46,9 +46,9 @@ var ExternalLogSourceID = uuid.MustParse("3b579bf4-1ed8-4b99-87a8-e9a1e3410410")
 type SessionTokenSetup func(client *codersdk.Client) RefreshableSessionTokenProvider
 
 func New(serverURL *url.URL, setup SessionTokenSetup) *Client {
-	c := codersdk.New(serverURL)
-	provider := setup(c)
-	c.SessionTokenProvider = provider
+	b := codersdk.NewClientBuilder(serverURL)
+	provider := setup(b.DangerouslyGetUnbuiltClient())
+	c := b.SessionTokenProvider(provider).Build()
 	return &Client{
 		SDK:                             c,
 		RefreshableSessionTokenProvider: provider,
diff --git a/codersdk/builder.go b/codersdk/builder.go
@@ -0,0 +1,97 @@
+package codersdk
+
+import (
+	"io"
+	"net/http"
+	"net/url"
+
+	"cdr.dev/slog"
+)
+
+// ClientBuilder is a builder for a Client.
+// @typescript-ignore ClientBuilder
+type ClientBuilder struct {
+	serverURL                *url.URL
+	httpClient               *http.Client
+	sessionTokenProvider     SessionTokenProvider
+	logger                   slog.Logger
+	logBodies                bool
+	plainLogger              io.Writer
+	trace                    bool
+	disableDirectConnections bool
+
+	// unbuiltClient is the client that is built when Build is called. Used for cases where the code building the client
+	// needs to reference the client while building it.
+	unbuiltClient *Client
+}
+
+func NewClientBuilder(serverURL *url.URL) *ClientBuilder {
+	return &ClientBuilder{
+		serverURL:            serverURL,
+		httpClient:           &http.Client{},
+		sessionTokenProvider: FixedSessionTokenProvider{},
+		unbuiltClient:        &Client{},
+	}
+}
+
+func (b *ClientBuilder) SessionToken(sessionToken string) *ClientBuilder {
+	b.sessionTokenProvider = FixedSessionTokenProvider{SessionToken: sessionToken}
+	return b
+}
+
+func (b *ClientBuilder) SessionTokenProvider(sessionTokenProvider SessionTokenProvider) *ClientBuilder {
+	b.sessionTokenProvider = sessionTokenProvider
+	return b
+}
+
+func (b *ClientBuilder) Logger(logger slog.Logger) *ClientBuilder {
+	b.logger = logger
+	return b
+}
+
+func (b *ClientBuilder) LogBodies(logBodies bool) *ClientBuilder {
+	b.logBodies = logBodies
+	return b
+}
+
+func (b *ClientBuilder) PlainLogger(plainLogger io.Writer) *ClientBuilder {
+	b.plainLogger = plainLogger
+	return b
+}
+
+func (b *ClientBuilder) Trace() *ClientBuilder {
+	b.trace = true
+	return b
+}
+
+func (b *ClientBuilder) DisableDirectConnections() *ClientBuilder {
+	b.disableDirectConnections = true
+	return b
+}
+
+func (b *ClientBuilder) HTTPClient(httpClient *http.Client) *ClientBuilder {
+	b.httpClient = httpClient
+	return b
+}
+
+// DangerouslyGetUnbuiltClient returns the unbuilt client.
+//
+// This is dangerous to use because the client can be modified after it is built. Only use this if you need a reference
+// to the client during the building process, e.g. to give to a client component like the SessionTokenProvider.
+func (b *ClientBuilder) DangerouslyGetUnbuiltClient() *Client {
+	return b.unbuiltClient
+}
+
+func (b *ClientBuilder) Build() *Client {
+	client := b.unbuiltClient
+	b.unbuiltClient = &Client{} // clear this so that the client cannot be modified after it is built
+	client.URL = b.serverURL
+	client.HTTPClient = b.httpClient
+	client.SessionTokenProvider = b.sessionTokenProvider
+	client.logger = b.logger
+	client.logBodies = b.logBodies
+	client.PlainLogger = b.plainLogger
+	client.Trace = b.trace
+	client.DisableDirectConnections = b.disableDirectConnections
+	return client
+}
diff --git a/codersdk/client.go b/codersdk/client.go
@@ -106,6 +106,7 @@ var loggableMimeTypes = map[string]struct{}{
 }
 
 // New creates a Coder client for the provided URL.
+// Deprecated: Use the ClientBuilder to create a client.
 func New(serverURL *url.URL) *Client {
 	return &Client{
 		URL:                  serverURL,
@@ -129,15 +130,18 @@ type Client struct {
 
 	// PlainLogger may be set to log HTTP traffic in a human-readable form.
 	// It uses the LogBodies option.
+	// Deprecated: Use the ClientBuilder to set this.
 	PlainLogger io.Writer
 
 	// Trace can be enabled to propagate tracing spans to the Coder API.
 	// This is useful for tracking a request end-to-end.
+	// Deprecated: Use the ClientBuilder to set this.
 	Trace bool
 
 	// DisableDirectConnections forces any connections to workspaces to go
 	// through DERP, regardless of the BlockEndpoints setting on each
 	// connection.
+	// Deprecated: Use the ClientBuilder to set this.
 	DisableDirectConnections bool
 }
 
@@ -149,6 +153,7 @@ func (c *Client) Logger() slog.Logger {
 }
 
 // SetLogger sets the logger for the client.
+// Deprecated: Use the ClientBuilder to set this.
 func (c *Client) SetLogger(logger slog.Logger) {
 	c.mu.Lock()
 	defer c.mu.Unlock()
@@ -163,6 +168,7 @@ func (c *Client) LogBodies() bool {
 }
 
 // SetLogBodies sets whether to log request and response bodies.
+// Deprecated: Use the ClientBuilder to set this.
 func (c *Client) SetLogBodies(logBodies bool) {
 	c.mu.Lock()
 	defer c.mu.Unlock()
@@ -177,16 +183,11 @@ func (c *Client) SessionToken() string {
 }
 
 // SetSessionToken sets a fixed token for the client.
-// Deprecated: Create a new client instead of changing the token after creation.
+// Deprecated: Build a new client using the ClientBuilder instead of changing the token after creation.
 func (c *Client) SetSessionToken(token string) {
-	c.SetSessionTokenProvider(FixedSessionTokenProvider{SessionToken: token})
-}
-
-// SetSessionTokenProvider sets the session token provider for the client.
-func (c *Client) SetSessionTokenProvider(provider SessionTokenProvider) {
 	c.mu.Lock()
 	defer c.mu.Unlock()
-	c.SessionTokenProvider = provider
+	c.SessionTokenProvider = FixedSessionTokenProvider{SessionToken: token}
 }
 
 func prefixLines(prefix, s []byte) []byte {
