refactor: derive MongoDB database name from URI appName parameter

- Remove hardcoded mongoDBName constant
- Parse appName query parameter from MONGODB_URI as the database name
- NewMongoDB now returns (client, dbName, error)
- Repository constructors accept dbName parameter
- DI container caches and passes the DB name to repositories
- Update test .env to include appName=httpsms in URI

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: AchoArnold

api/pkg/di/container.go

@@ -84,6 +84,7 @@ type Container struct {
 	db                   *gorm.DB
 	dedicatedDB          *gorm.DB
 	mongoClient          *mongoDriver.Client
+	mongoDBName          string
 	version              string
 	app                  *fiber.App
 	eventDispatcher      *services.EventDispatcher
@@ -301,15 +302,24 @@ func (container *Container) MongoDB() *mongoDriver.Client {
 
 	container.logger.Debug("creating MongoDB *mongo.Client connection")
 
-	client, err := repositories.NewMongoDB(os.Getenv("MONGODB_URI"))
+	client, dbName, err := repositories.NewMongoDB(os.Getenv("MONGODB_URI"))
 	if err != nil {
 		container.logger.Fatal(err)
 	}
 
 	container.mongoClient = client
+	container.mongoDBName = dbName
 	return container.mongoClient
 }
 
+// MongoDBName returns the MongoDB database name derived from the connection URI appName
+func (container *Container) MongoDBName() string {
+	if container.mongoClient == nil {
+		container.MongoDB()
+	}
+	return container.mongoDBName
+}
+
 // HedgingFailureCounter creates an OTel counter for hedging secondary write failures
 func (container *Container) HedgingFailureCounter() otelMetric.Int64Counter {
 	meter := otel.GetMeterProvider().Meter(
@@ -928,14 +938,15 @@ func (container *Container) HeartbeatMonitorRepository() (repository repositorie
 			container.Logger(),
 			container.Tracer(),
 			container.MongoDB(),
+			container.MongoDBName(),
 		)
 	case "hedging":
 		container.logger.Debug("creating hedging repositories.HeartbeatMonitorRepository")
 		return repositories.NewHedgingHeartbeatMonitorRepository(
 			container.Logger(),
 			container.Tracer(),
 			repositories.NewGormHeartbeatMonitorRepository(container.Logger(), container.Tracer(), container.DedicatedDB()),
-			repositories.NewMongoHeartbeatMonitorRepository(container.Logger(), container.Tracer(), container.MongoDB()),
+			repositories.NewMongoHeartbeatMonitorRepository(container.Logger(), container.Tracer(), container.MongoDB(), container.MongoDBName()),
 			container.HedgingFailureCounter(),
 		)
 	default:
@@ -1766,14 +1777,15 @@ func (container *Container) HeartbeatRepository() repositories.HeartbeatReposito
 			container.Logger(),
 			container.Tracer(),
 			container.MongoDB(),
+			container.MongoDBName(),
 		)
 	case "hedging":
 		container.logger.Debug("creating hedging repositories.HeartbeatRepository")
 		return repositories.NewHedgingHeartbeatRepository(
 			container.Logger(),
 			container.Tracer(),
 			repositories.NewGormHeartbeatRepository(container.Logger(), container.Tracer(), container.DedicatedDB()),
-			repositories.NewMongoHeartbeatRepository(container.Logger(), container.Tracer(), container.MongoDB()),
+			repositories.NewMongoHeartbeatRepository(container.Logger(), container.Tracer(), container.MongoDB(), container.MongoDBName()),
 			container.HedgingFailureCounter(),
 		)
 	default:

api/pkg/repositories/mongo_heartbeat_monitor_repository.go

@@ -26,11 +26,12 @@ func NewMongoHeartbeatMonitorRepository(
 	logger telemetry.Logger,
 	tracer telemetry.Tracer,
 	client *mongo.Client,
+	dbName string,
 ) HeartbeatMonitorRepository {
 	return &mongoHeartbeatMonitorRepository{
 		logger:     logger.WithService(fmt.Sprintf("%T", &mongoHeartbeatMonitorRepository{})),
 		tracer:     tracer,
-		collection: client.Database(mongoDBName).Collection(collectionHeartbeatMonitors),
+		collection: client.Database(dbName).Collection(collectionHeartbeatMonitors),
 	}
 }
 

api/pkg/repositories/mongo_heartbeat_repository.go

@@ -25,11 +25,12 @@ func NewMongoHeartbeatRepository(
 	logger telemetry.Logger,
 	tracer telemetry.Tracer,
 	client *mongo.Client,
+	dbName string,
 ) HeartbeatRepository {
 	return &mongoHeartbeatRepository{
 		logger:     logger.WithService(fmt.Sprintf("%T", &mongoHeartbeatRepository{})),
 		tracer:     tracer,
-		collection: client.Database(mongoDBName).Collection(collectionHeartbeats),
+		collection: client.Database(dbName).Collection(collectionHeartbeats),
 	}
 }
 

api/pkg/repositories/mongodb.go

@@ -3,6 +3,7 @@ package repositories
 import (
 	"context"
 	"fmt"
+	"net/url"
 	"reflect"
 	"time"
 
@@ -15,7 +16,6 @@ import (
 )
 
 const (
-	mongoDBName                 = "httpsms"
 	collectionHeartbeats        = "heartbeats"
 	collectionHeartbeatMonitors = "heartbeat_monitors"
 )
@@ -48,8 +48,14 @@ func newMongoRegistry() *bson.Registry {
 	return rb
 }
 
-// NewMongoDB creates a new *mongo.Client connection to MongoDB Atlas and ensures indexes
-func NewMongoDB(uri string) (*mongo.Client, error) {
+// NewMongoDB creates a new *mongo.Client connection to MongoDB Atlas and ensures indexes.
+// The database name is derived from the appName query parameter in the URI.
+func NewMongoDB(uri string) (*mongo.Client, string, error) {
+	dbName, err := parseMongoDBName(uri)
+	if err != nil {
+		return nil, "", stacktrace.Propagate(err, "cannot parse database name from MongoDB URI")
+	}
+
 	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 	defer cancel()
 
@@ -59,22 +65,37 @@ func NewMongoDB(uri string) (*mongo.Client, error) {
 
 	client, err := mongo.Connect(opts)
 	if err != nil {
-		return nil, stacktrace.Propagate(err, "cannot connect to MongoDB Atlas")
+		return nil, "", stacktrace.Propagate(err, "cannot connect to MongoDB Atlas")
 	}
 
 	if err = client.Ping(ctx, nil); err != nil {
-		return nil, stacktrace.Propagate(err, fmt.Sprintf("cannot ping MongoDB with URI [%s]", uri))
+		return nil, "", stacktrace.Propagate(err, fmt.Sprintf("cannot ping MongoDB with URI [%s]", uri))
+	}
+
+	if err = createMongoIndexes(ctx, client, dbName); err != nil {
+		return nil, "", stacktrace.Propagate(err, "cannot create MongoDB indexes")
+	}
+
+	return client, dbName, nil
+}
+
+// parseMongoDBName extracts the appName query parameter from the MongoDB URI to use as the database name
+func parseMongoDBName(uri string) (string, error) {
+	parsed, err := url.Parse(uri)
+	if err != nil {
+		return "", stacktrace.Propagate(err, fmt.Sprintf("cannot parse MongoDB URI [%s]", uri))
 	}
 
-	if err = createMongoIndexes(ctx, client); err != nil {
-		return nil, stacktrace.Propagate(err, "cannot create MongoDB indexes")
+	appName := parsed.Query().Get("appName")
+	if appName == "" {
+		return "", stacktrace.NewError("MongoDB URI is missing the 'appName' query parameter which is used as the database name")
 	}
 
-	return client, nil
+	return appName, nil
 }
 
-func createMongoIndexes(ctx context.Context, client *mongo.Client) error {
-	db := client.Database(mongoDBName)
+func createMongoIndexes(ctx context.Context, client *mongo.Client, dbName string) error {
+	db := client.Database(dbName)
 
 	// Heartbeats indexes
 	heartbeatsCol := db.Collection(collectionHeartbeats)

tests/.env.test

@@ -29,4 +29,4 @@ GCS_BUCKET_NAME=
 UPTRACE_DSN=
 CLOUDFLARE_TURNSTILE_SECRET_KEY=
 HEARTBEAT_DB_BACKEND=hedging
-MONGODB_URI=mongodb://httpsms:testpassword@mongodb:27017/?authSource=admin
+MONGODB_URI=mongodb://httpsms:testpassword@mongodb:27017/?authSource=admin&appName=httpsms