GODRIVER-3434 Revert lister-builder pattern for client suboptions

Author: prestonvasquez

internal/integration/client_side_encryption_prose_test.go

@@ -527,7 +527,7 @@ func TestClientSideEncryptionProse(t *testing.T) {
 			tlsConfig["kmip"] = kmipConfig
 		}
 
-		getBaseAutoEncryptionOpts := func() *options.AutoEncryptionOptionsBuilder {
+		getBaseAutoEncryptionOpts := func() *options.AutoEncryptionOptions {
 			return options.AutoEncryption().
 				SetKmsProviders(fullKmsProvidersMap).
 				SetKeyVaultNamespace(kvNamespace).
@@ -537,7 +537,7 @@ func TestClientSideEncryptionProse(t *testing.T) {
 
 		testCases := []struct {
 			name   string
-			aeo    *options.AutoEncryptionOptionsBuilder
+			aeo    *options.AutoEncryptionOptions
 			schema bson.Raw // the schema to create the collection. if nil, the collection won't be explicitly created
 		}{
 			{"remote schema", getBaseAutoEncryptionOpts(), corpusSchema},
@@ -3014,7 +3014,7 @@ type cseProseTest struct {
 	cseStarted   []*event.CommandStartedEvent
 }
 
-func setup(mt *mtest.T, aeo *options.AutoEncryptionOptionsBuilder, kvClientOpts *options.ClientOptions,
+func setup(mt *mtest.T, aeo *options.AutoEncryptionOptions, kvClientOpts *options.ClientOptions,
 	ceo options.Lister[options.ClientEncryptionOptions]) *cseProseTest {
 	mt.Helper()
 	var cpt cseProseTest

internal/integration/json_helpers_test.go

@@ -125,7 +125,7 @@ func createClientOptions(t testing.TB, opts bson.Raw) *options.ClientOptions {
 	return clientOpts
 }
 
-func createAutoEncryptionOptions(t testing.TB, opts bson.Raw) *options.AutoEncryptionOptionsBuilder {
+func createAutoEncryptionOptions(t testing.TB, opts bson.Raw) *options.AutoEncryptionOptions {
 	t.Helper()
 
 	aeo := options.AutoEncryption()

internal/integration/unified/client_entity.go

@@ -20,7 +20,6 @@ import (
 	"go.mongodb.org/mongo-driver/v2/internal/integration/mtest"
 	"go.mongodb.org/mongo-driver/v2/internal/integtest"
 	"go.mongodb.org/mongo-driver/v2/internal/logger"
-	"go.mongodb.org/mongo-driver/v2/internal/mongoutil"
 	"go.mongodb.org/mongo-driver/v2/mongo"
 	"go.mongodb.org/mongo-driver/v2/mongo/options"
 	"go.mongodb.org/mongo-driver/v2/mongo/readconcern"
@@ -184,15 +183,10 @@ func newClientEntity(ctx context.Context, em *EntityMap, entityOptions *entityOp
 		}
 	}
 	if entityOptions.ServerAPIOptions != nil {
-		args, err := mongoutil.NewOptions[options.ServerAPIOptions](entityOptions.ServerAPIOptions)
-		if err != nil {
-			return nil, fmt.Errorf("failed to construct options from builder: %w", err)
-		}
-
-		if err := args.ServerAPIVersion.Validate(); err != nil {
+		if err := entityOptions.ServerAPIOptions.ServerAPIVersion.Validate(); err != nil {
 			return nil, err
 		}
-		clientOpts.SetServerAPIOptions(entityOptions.ServerAPIOptions.ServerAPIOptionsBuilder)
+		clientOpts.SetServerAPIOptions(entityOptions.ServerAPIOptions.ServerAPIOptions)
 	} else {
 		integtest.AddTestServerAPIVersion(clientOpts)
 	}

internal/integration/unified/server_api_options.go

@@ -16,7 +16,7 @@ import (
 // serverAPIOptions is a wrapper for *options.ServerAPIOptions. This type implements the bson.Unmarshaler interface
 // to convert BSON documents to a serverAPIOptions instance.
 type serverAPIOptions struct {
-	*options.ServerAPIOptionsBuilder
+	*options.ServerAPIOptions
 }
 
 type serverAPIVersion = options.ServerAPIVersion
@@ -37,7 +37,7 @@ func (s *serverAPIOptions) UnmarshalBSON(data []byte) error {
 		return fmt.Errorf("unrecognized fields for serverAPIOptions: %v", mapKeys(temp.Extra))
 	}
 
-	s.ServerAPIOptionsBuilder = options.ServerAPI(temp.ServerAPIVersion)
+	s.ServerAPIOptions = options.ServerAPI(temp.ServerAPIVersion)
 	if temp.DeprecationErrors != nil {
 		s.SetDeprecationErrors(*temp.DeprecationErrors)
 	}

internal/integration/unified_spec_test.go

@@ -27,8 +27,6 @@ import (
 	"go.mongodb.org/mongo-driver/v2/internal/failpoint"
 	"go.mongodb.org/mongo-driver/v2/internal/integration/mtest"
 	"go.mongodb.org/mongo-driver/v2/internal/integtest"
-	"go.mongodb.org/mongo-driver/v2/internal/mongoutil"
-	"go.mongodb.org/mongo-driver/v2/internal/require"
 	"go.mongodb.org/mongo-driver/v2/mongo"
 	"go.mongodb.org/mongo-driver/v2/mongo/address"
 	"go.mongodb.org/mongo-driver/v2/mongo/options"
@@ -291,31 +289,20 @@ func runSpecTestCase(mt *mtest.T, test *testCase, testFile testFile) {
 		// bypassAutoEncryption nor bypassQueryAnalysis are true), then add extra options to load
 		// the crypt_shared library.
 		if testClientOpts.AutoEncryptionOptions != nil {
-			aeArgs, err := mongoutil.NewOptions[options.AutoEncryptionOptions](testClientOpts.AutoEncryptionOptions)
-			require.NoError(mt, err, "failed to construct options from builder")
+			aeOpts := testClientOpts.AutoEncryptionOptions
 
-			bypassAutoEncryption := aeArgs.BypassAutoEncryption != nil && *aeArgs.BypassAutoEncryption
-			bypassQueryAnalysis := aeArgs.BypassQueryAnalysis != nil && *aeArgs.BypassQueryAnalysis
+			bypassAutoEncryption := aeOpts.BypassAutoEncryption != nil && *aeOpts.BypassAutoEncryption
+			bypassQueryAnalysis := aeOpts.BypassQueryAnalysis != nil && *aeOpts.BypassQueryAnalysis
 
 			if !bypassAutoEncryption && !bypassQueryAnalysis {
-				if aeArgs.ExtraOptions == nil {
-					aeArgs.ExtraOptions = make(map[string]interface{})
+				if aeOpts.ExtraOptions == nil {
+					aeOpts.ExtraOptions = make(map[string]interface{})
 				}
 
 				for k, v := range getCryptSharedLibExtraOptions() {
-					aeArgs.ExtraOptions[k] = v
+					aeOpts.ExtraOptions[k] = v
 				}
 			}
-
-			testClientOpts.AutoEncryptionOptions = &options.AutoEncryptionOptionsBuilder{
-				Opts: []func(*options.AutoEncryptionOptions) error{
-					func(args *options.AutoEncryptionOptions) error {
-						*args = *aeArgs
-
-						return nil
-					},
-				},
-			}
 		}
 
 		test.monitor = newUnifiedRunnerEventMonitor()

internal/mongoutil/mongoutil_test.go

@@ -31,18 +31,4 @@ func BenchmarkNewOptions(b *testing.B) {
 			_, _ = NewOptions[options.FindOptions](opts...)
 		}
 	})
-
-	b.Run("reflect.ValuOf is never called", func(b *testing.B) {
-		opts := make([]options.Lister[options.LoggerOptions], b.N)
-
-		for i := 0; i < b.N; i++ {
-			var lo *options.LoggerOptionsBuilder
-			opts[i] = lo
-		}
-
-		b.ReportAllocs()
-		for i := 0; i < b.N; i++ {
-			_, _ = NewOptions[options.LoggerOptions](opts...)
-		}
-	})
 }

mongo/client.go

@@ -1,5 +1,5 @@
-// Copyright (C) MongoDB, Inc. 2017-present.
 //
+// Copyright (C) MongoDB, Inc. 2017-present.
 // Licensed under the Apache License, Version 2.0 (the "License"); you may
 // not use this file except in compliance with the License. You may obtain
 // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
@@ -471,12 +471,7 @@ func (c *Client) endSessions(ctx context.Context) {
 }
 
 func (c *Client) configureAutoEncryption(args *options.ClientOptions) error {
-	aeArgs, err := mongoutil.NewOptions[options.AutoEncryptionOptions](args.AutoEncryptionOptions)
-	if err != nil {
-		return fmt.Errorf("failed to construct options from builder: %w", err)
-	}
-
-	c.encryptedFieldsMap = aeArgs.EncryptedFieldsMap
+	c.encryptedFieldsMap = args.AutoEncryptionOptions.EncryptedFieldsMap
 	if err := c.configureKeyVaultClientFLE(args); err != nil {
 		return err
 	}
@@ -519,60 +514,51 @@ func (c *Client) getOrCreateInternalClient(args *options.ClientOptions) (*Client
 	return c.internalClientFLE, err
 }
 
-func (c *Client) configureKeyVaultClientFLE(clientArgs *options.ClientOptions) error {
-	// parse key vault options and create new key vault client
-	aeArgs, err := mongoutil.NewOptions[options.AutoEncryptionOptions](clientArgs.AutoEncryptionOptions)
-	if err != nil {
-		return fmt.Errorf("failed to construct options from builder: %w", err)
-	}
+func (c *Client) configureKeyVaultClientFLE(clientOpts *options.ClientOptions) error {
+	aeOpts := clientOpts.AutoEncryptionOptions
+
+	var err error
 
 	switch {
-	case aeArgs.KeyVaultClientOptions != nil:
-		c.keyVaultClientFLE, err = newClient(aeArgs.KeyVaultClientOptions)
-	case clientArgs.MaxPoolSize != nil && *clientArgs.MaxPoolSize == 0:
+	case aeOpts.KeyVaultClientOptions != nil:
+		c.keyVaultClientFLE, err = newClient(aeOpts.KeyVaultClientOptions)
+	case clientOpts.MaxPoolSize != nil && *clientOpts.MaxPoolSize == 0:
 		c.keyVaultClientFLE = c
 	default:
-		c.keyVaultClientFLE, err = c.getOrCreateInternalClient(clientArgs)
+		c.keyVaultClientFLE, err = c.getOrCreateInternalClient(clientOpts)
 	}
 
 	if err != nil {
 		return err
 	}
 
-	dbName, collName := splitNamespace(aeArgs.KeyVaultNamespace)
+	dbName, collName := splitNamespace(aeOpts.KeyVaultNamespace)
 	c.keyVaultCollFLE = c.keyVaultClientFLE.Database(dbName).Collection(collName, keyVaultCollOpts)
 	return nil
 }
 
-func (c *Client) configureMetadataClientFLE(clientArgs *options.ClientOptions) error {
-	// parse key vault options and create new key vault client
-	aeArgs, err := mongoutil.NewOptions[options.AutoEncryptionOptions](clientArgs.AutoEncryptionOptions)
-	if err != nil {
-		return fmt.Errorf("failed to construct options from builder: %w", err)
-	}
+func (c *Client) configureMetadataClientFLE(clientOpts *options.ClientOptions) error {
+	aeOpts := clientOpts.AutoEncryptionOptions
 
-	if aeArgs.BypassAutoEncryption != nil && *aeArgs.BypassAutoEncryption {
+	if aeOpts.BypassAutoEncryption != nil && *aeOpts.BypassAutoEncryption {
 		// no need for a metadata client.
 		return nil
 	}
-	if clientArgs.MaxPoolSize != nil && *clientArgs.MaxPoolSize == 0 {
+	if clientOpts.MaxPoolSize != nil && *clientOpts.MaxPoolSize == 0 {
 		c.metadataClientFLE = c
 		return nil
 	}
 
-	c.metadataClientFLE, err = c.getOrCreateInternalClient(clientArgs)
+	var err error
+	c.metadataClientFLE, err = c.getOrCreateInternalClient(clientOpts)
+
 	return err
 }
 
-func (c *Client) newMongoCrypt(opts options.Lister[options.AutoEncryptionOptions]) (*mongocrypt.MongoCrypt, error) {
-	args, err := mongoutil.NewOptions[options.AutoEncryptionOptions](opts)
-	if err != nil {
-		return nil, fmt.Errorf("failed to construct options from builder: %w", err)
-	}
-
+func (c *Client) newMongoCrypt(opts *options.AutoEncryptionOptions) (*mongocrypt.MongoCrypt, error) {
 	// convert schemas in SchemaMap to bsoncore documents
 	cryptSchemaMap := make(map[string]bsoncore.Document)
-	for k, v := range args.SchemaMap {
+	for k, v := range opts.SchemaMap {
 		schema, err := marshal(v, c.bsonOpts, c.registry)
 		if err != nil {
 			return nil, err
@@ -582,23 +568,23 @@ func (c *Client) newMongoCrypt(opts options.Lister[options.AutoEncryptionOptions
 
 	// convert schemas in EncryptedFieldsMap to bsoncore documents
 	cryptEncryptedFieldsMap := make(map[string]bsoncore.Document)
-	for k, v := range args.EncryptedFieldsMap {
+	for k, v := range opts.EncryptedFieldsMap {
 		encryptedFields, err := marshal(v, c.bsonOpts, c.registry)
 		if err != nil {
 			return nil, err
 		}
 		cryptEncryptedFieldsMap[k] = encryptedFields
 	}
 
-	kmsProviders, err := marshal(args.KmsProviders, c.bsonOpts, c.registry)
+	kmsProviders, err := marshal(opts.KmsProviders, c.bsonOpts, c.registry)
 	if err != nil {
 		return nil, fmt.Errorf("error creating KMS providers document: %w", err)
 	}
 
 	// Set the crypt_shared library override path from the "cryptSharedLibPath" extra option if one
 	// was set.
 	cryptSharedLibPath := ""
-	if val, ok := args.ExtraOptions["cryptSharedLibPath"]; ok {
+	if val, ok := opts.ExtraOptions["cryptSharedLibPath"]; ok {
 		str, ok := val.(string)
 		if !ok {
 			return nil, fmt.Errorf(
@@ -611,12 +597,12 @@ func (c *Client) newMongoCrypt(opts options.Lister[options.AutoEncryptionOptions
 	// intended for use from tests; there is no supported public API for explicitly disabling
 	// loading the crypt_shared library.
 	cryptSharedLibDisabled := false
-	if v, ok := args.ExtraOptions["__cryptSharedLibDisabledForTestOnly"]; ok {
+	if v, ok := opts.ExtraOptions["__cryptSharedLibDisabledForTestOnly"]; ok {
 		cryptSharedLibDisabled = v.(bool)
 	}
 
-	bypassAutoEncryption := args.BypassAutoEncryption != nil && *args.BypassAutoEncryption
-	bypassQueryAnalysis := args.BypassQueryAnalysis != nil && *args.BypassQueryAnalysis
+	bypassAutoEncryption := opts.BypassAutoEncryption != nil && *opts.BypassAutoEncryption
+	bypassQueryAnalysis := opts.BypassQueryAnalysis != nil && *opts.BypassQueryAnalysis
 
 	mc, err := mongocrypt.NewMongoCrypt(mcopts.MongoCrypt().
 		SetKmsProviders(kmsProviders).
@@ -625,13 +611,13 @@ func (c *Client) newMongoCrypt(opts options.Lister[options.AutoEncryptionOptions
 		SetEncryptedFieldsMap(cryptEncryptedFieldsMap).
 		SetCryptSharedLibDisabled(cryptSharedLibDisabled || bypassAutoEncryption).
 		SetCryptSharedLibOverridePath(cryptSharedLibPath).
-		SetHTTPClient(args.HTTPClient))
+		SetHTTPClient(opts.HTTPClient))
 	if err != nil {
 		return nil, err
 	}
 
 	var cryptSharedLibRequired bool
-	if val, ok := args.ExtraOptions["cryptSharedLibRequired"]; ok {
+	if val, ok := opts.ExtraOptions["cryptSharedLibRequired"]; ok {
 		b, ok := val.(bool)
 		if !ok {
 			return nil, fmt.Errorf(
@@ -652,10 +638,8 @@ func (c *Client) newMongoCrypt(opts options.Lister[options.AutoEncryptionOptions
 }
 
 //nolint:unused // the unused linter thinks that this function is unreachable because "c.newMongoCrypt" always panics without the "cse" build tag set.
-func (c *Client) configureCryptFLE(mc *mongocrypt.MongoCrypt, opts options.Lister[options.AutoEncryptionOptions]) {
-	args, _ := mongoutil.NewOptions[options.AutoEncryptionOptions](opts)
-
-	bypass := args.BypassAutoEncryption != nil && *args.BypassAutoEncryption
+func (c *Client) configureCryptFLE(mc *mongocrypt.MongoCrypt, opts *options.AutoEncryptionOptions) {
+	bypass := opts.BypassAutoEncryption != nil && *opts.BypassAutoEncryption
 	kr := keyRetriever{coll: c.keyVaultCollFLE}
 	var cir collInfoRetriever
 	// If bypass is true, c.metadataClientFLE is nil and the collInfoRetriever
@@ -670,7 +654,7 @@ func (c *Client) configureCryptFLE(mc *mongocrypt.MongoCrypt, opts options.Liste
 		CollInfoFn:           cir.cryptCollInfo,
 		KeyFn:                kr.cryptKeys,
 		MarkFn:               c.mongocryptdFLE.markCommand,
-		TLSConfig:            args.TLSConfig,
+		TLSConfig:            opts.TLSConfig,
 		BypassAutoEncryption: bypass,
 	})
 }
@@ -892,28 +876,23 @@ func (c *Client) createBaseCursorOptions() driver.CursorOptions {
 
 // newLogger will use the LoggerOptions to create an internal logger and publish
 // messages using a LogSink.
-func newLogger(opts options.Lister[options.LoggerOptions]) (*logger.Logger, error) {
+func newLogger(opts *options.LoggerOptions) (*logger.Logger, error) {
 	// If there are no logger options, then create a default logger.
 	if opts == nil {
 		opts = options.Logger()
 	}
 
-	args, err := mongoutil.NewOptions[options.LoggerOptions](opts)
-	if err != nil {
-		return nil, fmt.Errorf("failed to construct options from builder: %w", err)
-	}
-
 	// If there are no component-level options and the environment does not
 	// contain component variables, then do nothing.
-	if len(args.ComponentLevels) == 0 && !logger.EnvHasComponentVariables() {
+	if len(opts.ComponentLevels) == 0 && !logger.EnvHasComponentVariables() {
 		return nil, nil
 	}
 
 	// Otherwise, collect the component-level options and create a logger.
 	componentLevels := make(map[logger.Component]logger.Level)
-	for component, level := range args.ComponentLevels {
+	for component, level := range opts.ComponentLevels {
 		componentLevels[logger.Component(component)] = logger.Level(level)
 	}
 
-	return logger.New(args.Sink, args.MaxDocumentLength, componentLevels)
+	return logger.New(opts.Sink, opts.MaxDocumentLength, componentLevels)
 }

mongo/client_test.go

@@ -413,7 +413,7 @@ func TestClient(t *testing.T) {
 		}
 	})
 	t.Run("serverAPI version", func(t *testing.T) {
-		getServerAPIOptions := func() *options.ServerAPIOptionsBuilder {
+		getServerAPIOptions := func() *options.ServerAPIOptions {
 			return options.ServerAPI(options.ServerAPIVersion1).
 				SetStrict(false).SetDeprecationErrors(false)
 		}