go-duck-cli 1.1.37 → 1.1.42

package/generators/kratos.js

@@ -147,6 +147,8 @@ export const generateKratosCode = async (entities, projectRootDir, projectName,
             annotation: entity.annotation, 
             isDocument: entity.isDocument || false,
             isAudited: entity.isAudited || false,
+            isFederated: entity.isFederated || false,
+            needFmt: (entity.isDocument || false) || !(entity.isFederated || false),
             projectName,
             enums
         };
@@ -278,7 +280,8 @@ import (
 
 func TenantServerInterceptor(conf *config.Config, db *gorm.DB) middleware.Middleware {
     mgr := my_middleware.GetTenantManager(db, conf)
-    fallbackDB := strings.ToLower(conf.GoDuck.Name) + "_fallback"
+    fallbackDB := conf.GoDuck.Datasource.Database
+    fallbackMongoDB := conf.GoDuck.Datasource.MongoDB.Database
 
     return func(handler middleware.Handler) middleware.Handler {
         return func(ctx context.Context, req interface{}) (interface{}, error) {
@@ -342,9 +345,9 @@ func TenantServerInterceptor(conf *config.Config, db *gorm.DB) middleware.Middle
                 ctx = context.WithValue(ctx, "tenantDBConn", conn)
 
                 if conf.GoDuck.Datasource.MongoDB.Enabled {
-                    mClient, err := mgr.GetMongoClient(fallbackDB)
+                    mClient, err := mgr.GetMongoClient(fallbackMongoDB)
                     if err == nil && mClient != nil {
-                        mDB := mClient.Database(fallbackDB)
+                        mDB := mClient.Database(fallbackMongoDB)
                         mongoConnections["fallback"] = mDB
                         ctx = context.WithValue(ctx, "tenantMongoDB", mDB)
                     }

package/generators/multitenancy.js

@@ -129,7 +129,8 @@ func (m *TenantDBManager) GetMongoClient(dbName string) (*mongo.Client, error) {
 
 func TenantMiddleware(db *gorm.DB, cfg *config.Config) gin.HandlerFunc {
 	mgr := GetTenantManager(db, cfg)
-	fallbackDB := strings.ToLower(cfg.GoDuck.Name) + "_fallback"
+	fallbackDB := cfg.GoDuck.Datasource.Database
+	fallbackMongoDB := cfg.GoDuck.Datasource.MongoDB.Database
 
 	return func(c *gin.Context) {
 		userRolesInterface, exists := c.Get("UserRoles")
@@ -207,13 +208,13 @@ func TenantMiddleware(db *gorm.DB, cfg *config.Config) gin.HandlerFunc {
              c.Set("tenantDBConn", conn)
 
 			 if cfg.GoDuck.Datasource.MongoDB.Enabled {
-				mClient, err := mgr.GetMongoClient(fallbackDB)
+				mClient, err := mgr.GetMongoClient(fallbackMongoDB)
 				if err != nil || mClient == nil {
 					c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to resolve tenant fallback MongoDB connection"})
 					c.Abort()
 					return
 				}
-				mDB := mClient.Database(fallbackDB)
+				mDB := mClient.Database(fallbackMongoDB)
 				mongoConnections["fallback"] = mDB
 				c.Set("tenantMongoDB", mDB)
 			 }
@@ -285,7 +286,8 @@ func TenantMiddleware(db *gorm.DB, cfg *config.Config) gin.HandlerFunc {
 
 func PublicTenantMiddleware(db *gorm.DB, cfg *config.Config) gin.HandlerFunc {
 	mgr := GetTenantManager(db, cfg)
-	fallbackDB := strings.ToLower(cfg.GoDuck.Name) + "_fallback"
+	fallbackDB := cfg.GoDuck.Datasource.Database
+	fallbackMongoDB := cfg.GoDuck.Datasource.MongoDB.Database
 
 	return func(c *gin.Context) {
         requestedTenantRaw := strings.ToLower(c.GetHeader("X-Tenant-ID"))
@@ -308,8 +310,10 @@ func PublicTenantMiddleware(db *gorm.DB, cfg *config.Config) gin.HandlerFunc {
         }
 
         dbName := fallbackDB
+        mongoDbName := fallbackMongoDB
         if len(mappings) > 0 {
              dbName = mappings[0].DBName
+             mongoDbName = mappings[0].DBName
         }
 
 		tenantConn, err := mgr.GetDB(dbName)
@@ -322,9 +326,9 @@ func PublicTenantMiddleware(db *gorm.DB, cfg *config.Config) gin.HandlerFunc {
 		c.Set("tenantDBConn", tenantConn)
 
 		if cfg.GoDuck.Datasource.MongoDB.Enabled {
-			mClient, err := mgr.GetMongoClient(dbName)
+			mClient, err := mgr.GetMongoClient(mongoDbName)
 			if err == nil && mClient != nil {
-				c.Set("tenantMongoDB", mClient.Database(dbName))
+				c.Set("tenantMongoDB", mClient.Database(mongoDbName))
 			}
 		}
 

package/generators/postman.js

@@ -140,11 +140,11 @@ export const generatePostmanCollection = async (config, entities, outputDir, ope
                         { key: "X-Tenant-ID", value: "{{tenant}}" }
                     ],
                     url: {
-                        raw: "http://{{host}}:{{port}}/api/audit",
+                        raw: "http://{{host}}:{{port}}/api/admin/audit",
                         protocol: "http",
                         host: ["{{host}}"],
                         port: "{{port}}",
-                        path: ["api", "audit"]
+                        path: ["api", "admin", "audit"]
                     }
                 }
             },
@@ -305,6 +305,17 @@ export const generatePostmanCollection = async (config, entities, outputDir, ope
             }
         ];
 
+        if (entity.isSearchable && config.elasticsearch?.enabled) {
+            privateItems.push({
+                name: `Elasticsearch Search (${capitalized})`,
+                request: {
+                    method: "GET",
+                    header: [ { key: "Authorization", value: "Bearer {{token}}" }, { key: "X-Tenant-ID", value: "{{tenant}}" } ],
+                    url: { raw: `http://{{host}}:{{port}}/api/search/${name}?q=Sample`, protocol: "http", host: ["{{host}}"], port: "{{port}}", path: ["api", "search", name], query: [ { key: "q", value: "Sample" } ] }
+                }
+            });
+        }
+
         folder.item.push({ name: "Private (Auth Required) CRUD", item: privateItems });
         restFolder.item.push(folder);
     }

package/generators/swagger.js

@@ -208,7 +208,7 @@ export const generateSwaggerDocs = async (config, entities, outputDir, openEntit
     }
 
     // 2. Add System Paths
-    swagger.paths['/rpc/{table}'] = {
+    swagger.paths['/api/rpc/{table}'] = {
         get: {
             tags: ['Search Engine'],
             summary: 'Generic PostgREST RPC Engine',
@@ -240,7 +240,7 @@ export const generateSwaggerDocs = async (config, entities, outputDir, openEntit
         }
     };
 
-    swagger.paths['/audit'] = {
+    swagger.paths['/api/admin/audit'] = {
         get: {
             tags: ['Observability'],
             summary: 'Fetch Audit Trail',
@@ -249,6 +249,68 @@ export const generateSwaggerDocs = async (config, entities, outputDir, openEntit
         }
     };
 
+    swagger.paths['/management/tenant/assign'] = {
+        post: {
+            tags: ['Management'],
+            summary: 'Provision and Assign Tenant Database',
+            description: 'Creates a dedicated database for the specified tenant and runs all migrations.',
+            requestBody: {
+                required: true,
+                content: {
+                    'application/json': {
+                        schema: {
+                            type: 'object',
+                            properties: {
+                                roleName: { type: 'string', example: 'tenant_1_admin', description: 'The realm role name mapped to this database context' },
+                                dbName: { type: 'string', example: 'tenant_1', description: 'The physical name of the database to create and provision' }
+                            },
+                            required: ['roleName', 'dbName']
+                        }
+                    }
+                }
+            },
+            parameters: [
+                { name: 'X-Tenant-ID', in: 'header', required: true, schema: { type: 'string', default: 'master_internal' }, description: 'SuperAdmin internal master bypass token' }
+            ],
+            responses: {
+                200: { description: 'Success' },
+                401: { description: 'Unauthorized' },
+                403: { description: 'Forbidden (Requires SuperAdmin role)' }
+            }
+        }
+    };
+
+    if (config.elasticsearch?.enabled) {
+        swagger.paths['/api/search/{entity}'] = {
+            get: {
+                tags: ['Search Engine'],
+                summary: 'Elasticsearch Global Search',
+                description: 'High-performance full-text search with fuzzy matching across federated silos using Elasticsearch.',
+                parameters: [
+                    ...commonHeaders,
+                    { name: 'entity', in: 'path', required: true, schema: { type: 'string' }, description: 'The entity name to search (e.g., institute)' },
+                    { name: 'q', in: 'query', schema: { type: 'string' }, description: 'The search query (Spring-style fuzzy match)' }
+                ],
+                responses: {
+                    200: {
+                        description: 'OK',
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    type: 'object',
+                                    properties: {
+                                        total: { type: 'integer', description: 'Total search hits matching query' },
+                                        hits: { type: 'array', items: { type: 'object' }, description: 'Search hits (matching source documents)' }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        };
+    }
+
     await fs.writeJson(path.join(docsDir, 'swagger.json'), swagger, { spaces: 2 });
     console.log(chalk.gray('  Generated Swagger Documentation: swagger.json'));
 };

package/index.js

@@ -642,6 +642,47 @@ program
             if (await fs.pathExists(p)) await fs.remove(p);
         }
 
+        const goModPath = path.join(absoluteOutputDir, 'go.mod');
+        if (!await fs.pathExists(goModPath)) {
+            const goModContent = `module ${config.name}
+
+go 1.24
+
+require (
+	github.com/gin-gonic/gin v1.10.0
+	github.com/go-kratos/kratos/v2 v2.8.2
+	github.com/google/uuid v1.6.0
+	github.com/spf13/viper v1.19.0
+	go.opentelemetry.io/otel v1.26.0
+	go.opentelemetry.io/otel/trace v1.26.0
+	go.opentelemetry.io/otel/sdk v1.26.0
+	go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin v0.51.0
+	google.golang.org/grpc v1.64.0
+	gorm.io/datatypes v1.2.0
+	gorm.io/driver/postgres v1.5.7
+	gorm.io/gorm v1.25.10
+	gorm.io/plugin/opentelemetry v0.1.5
+	github.com/golang-jwt/jwt/v5 v5.2.1
+	github.com/eclipse/paho.mqtt.golang v1.4.3
+	github.com/sony/gobreaker v0.5.0
+	github.com/redis/go-redis/v9 v9.5.1
+	github.com/gorilla/websocket v1.5.1
+	github.com/99designs/gqlgen v0.17.44
+	github.com/vektah/gqlparser/v2 v2.5.11
+    github.com/aws/aws-lambda-go v1.47.0
+    github.com/awslabs/aws-lambda-go-api-proxy v0.16.1
+    github.com/GoogleCloudPlatform/functions-framework-go v1.8.1
+    go.mongodb.org/mongo-driver v1.17.1
+    github.com/gin-contrib/cors v1.7.1
+    github.com/go-resty/resty/v2 v2.16.0
+    github.com/olivere/elastic/v7 v7.0.32
+    github.com/nats-io/nats.go v1.38.0
+)
+`;
+            await fs.writeFile(goModPath, goModContent);
+            console.log(chalk.green('✅ go.mod file created!'));
+        }
+
         await generateConfigLoader(absoluteOutputDir);
         await generateLoggerCode(config, absoluteOutputDir);
         await generateMQTTCode(config, absoluteOutputDir);
@@ -657,6 +698,13 @@ program
         await generateGraphQLCode(config, entities, relationships, absoluteOutputDir, enums);
         await generatePostgRESTCode(config, absoluteOutputDir);
 
+        if (config.multitenancy?.enabled) await generateMultitenancy(config, absoluteOutputDir, entities);
+        await generateAuditCode(config, absoluteOutputDir);
+        await generateMeteringCode(config, absoluteOutputDir);
+        await generateOutbox(absoluteOutputDir, config);
+        await generateNATSCode(config, absoluteOutputDir);
+        await generateBrokerCode(config, absoluteOutputDir);
+
         // Sync Search & Security
         await generateElasticsearchLayer(config, entities, absoluteOutputDir);
         await generateSecurityMiddleware(config, absoluteOutputDir);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "go-duck-cli",
-  "version": "1.1.37",
+  "version": "1.1.42",
   "description": "The Ultimate Evolutionary Go Microservice Scaffolder.",
   "main": "index.js",
   "type": "module",

package/templates/go/controller.go.hbs

@@ -147,6 +147,11 @@ func (ctrl *{{capitalize name}}Controller) GetAll(c *gin.Context) {
 	page, _ := strconv.Atoi(c.DefaultQuery("page", "0"))
 	size, _ := strconv.Atoi(c.DefaultQuery("size", "20"))
 	
+	offset := 0
+	if page > 0 {
+		offset = (page - 1) * size
+	}
+	
 	{{#if isDocument}}
 	// 🦆 MongoDB Path
 	{{#if isFederated}}
@@ -163,7 +168,7 @@ func (ctrl *{{capitalize name}}Controller) GetAll(c *gin.Context) {
 			go func(r string, db *mongo.Database) {
 				defer wg.Done()
 				var entities []models.{{capitalize name}}
-				opts := options.Find().SetSkip(int64(page * size)).SetLimit(int64(size))
+				opts := options.Find().SetSkip(int64(offset)).SetLimit(int64(size))
 				cursor, err := db.Collection("{{toLowerCase name}}s").Find(ctx, bson.M{}, opts)
 				if err == nil {
 					cursor.All(ctx, &entities)
@@ -194,7 +199,7 @@ func (ctrl *{{capitalize name}}Controller) GetAll(c *gin.Context) {
 	c.Header("X-Total-Count", strconv.FormatInt(totalCount, 10))
 
 	var entities []models.{{capitalize name}}
-	opts := options.Find().SetSkip(int64(page * size)).SetLimit(int64(size))
+	opts := options.Find().SetSkip(int64(offset)).SetLimit(int64(size))
 	cursor, err := tenantDB.Collection("{{toLowerCase name}}s").Find(ctx, filter, opts)
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
@@ -222,7 +227,7 @@ func (ctrl *{{capitalize name}}Controller) GetAll(c *gin.Context) {
 			go func(r string, db *gorm.DB) {
 				defer wg.Done()
 				var entities []models.{{capitalize name}}
-				if err := db.WithContext(ctx).Offset(page * size).Limit(size).Find(&entities).Error; err == nil {
+				if err := db.WithContext(ctx).Offset(offset).Limit(size).Find(&entities).Error; err == nil {
 					mu.Lock()
 					federatedData[r] = entities
 					mu.Unlock()
@@ -243,7 +248,7 @@ func (ctrl *{{capitalize name}}Controller) GetAll(c *gin.Context) {
 	c.Header("X-Total-Count", strconv.FormatInt(totalCount, 10))
 
 	var entities []models.{{capitalize name}}
-	if err := tenantDB.WithContext(ctx).Offset(page * size).Limit(size).Find(&entities).Error; err != nil {
+	if err := tenantDB.WithContext(ctx).Offset(offset).Limit(size).Find(&entities).Error; err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
 		return
 	}

package/templates/go/router.go.hbs

@@ -5,7 +5,6 @@ import (
     "fmt"
     "log"
     "net/http"
-    "strings"
     "time"
 
     "github.com/gin-gonic/gin"
@@ -87,29 +86,32 @@ func SetupRouter(appConfig *config.Config) *gin.Engine {
             logger.Error("Goose Migration failed: %v", err)
         }
 
-        // 10b. Initialize and Migrate Fallback DB if multi-tenancy is enabled
+        // 10b. Initialize and Migrate Fallback DB if multi-tenancy is enabled and different from master DB
         if appConfig.GoDuck.Multitenancy.Enabled {
-            fallbackDB := strings.ToLower(appConfig.GoDuck.Name) + "_fallback"
-            var exists int
-            masterDB.Raw("SELECT 1 FROM pg_database WHERE datname = ?", fallbackDB).Scan(&exists)
-            if exists == 0 {
-                if err := masterDB.Exec(fmt.Sprintf("CREATE DATABASE \"%s\"", fallbackDB)).Error; err != nil {
-                    log.Printf("Warning: Failed to create fallback database %s: %v", fallbackDB, err)
-                } else {
-                    log.Printf("✅ Created fallback database: %s", fallbackDB)
+            fallbackDB := appConfig.GoDuck.Datasource.Database
+            masterDBName := appConfig.GoDuck.Datasource.Database
+            if fallbackDB != masterDBName {
+                var exists int
+                masterDB.Raw("SELECT 1 FROM pg_database WHERE datname = ?", fallbackDB).Scan(&exists)
+                if exists == 0 {
+                    if err := masterDB.Exec(fmt.Sprintf("CREATE DATABASE \"%s\"", fallbackDB)).Error; err != nil {
+                        log.Printf("Warning: Failed to create fallback database %s: %v", fallbackDB, err)
+                    } else {
+                        log.Printf("✅ Created fallback database: %s", fallbackDB)
+                    }
                 }
-            }
 
-            // Run tenant migrations on the fallback database
-            mgr := middleware.GetTenantManager(masterDB, appConfig)
-            if fDB, err := mgr.GetDB(fallbackDB); err == nil {
-                if err := migrations.RunGoNativeMigrationsForTenant(fDB); err != nil {
-                    log.Printf("Warning: Failed to run migrations on fallback database: %v", err)
+                // Run tenant migrations on the fallback database
+                mgr := middleware.GetTenantManager(masterDB, appConfig)
+                if fDB, err := mgr.GetDB(fallbackDB); err == nil {
+                    if err := migrations.RunGoNativeMigrationsForTenant(fDB); err != nil {
+                        log.Printf("Warning: Failed to run migrations on fallback database: %v", err)
+                    } else {
+                        log.Printf("✅ Migrated fallback database: %s", fallbackDB)
+                    }
                 } else {
-                    log.Printf("✅ Migrated fallback database: %s", fallbackDB)
+                    log.Printf("Warning: Failed to connect to fallback database for migration: %v", err)
                 }
-            } else {
-                log.Printf("Warning: Failed to connect to fallback database for migration: %v", err)
             }
         }
     }

package/templates/kratos/service.go.hbs

@@ -2,7 +2,7 @@ package service
 
 import (
 	"context"
-	{{#if isDocument}}
+	{{#if needFmt}}
 	"fmt"
 	{{/if}}
 	{{#if (hasNested fields)}}
@@ -38,10 +38,19 @@ func New{{capitalize name}}Service(repo *repository.Repository) *{{capitalize na
 
 func (s *{{capitalize name}}Service) Create{{capitalize name}}(ctx context.Context, req *pb.Create{{capitalize name}}Request) (*pb.{{capitalize name}}Reply, error) {
 	{{#if isDocument}}
+	{{#if isFederated}}
+	siloConns, _ := ctx.Value("tenantMongoConnections").(map[string]*mongo.Database)
+	{{else}}
 	db, ok := ctx.Value("tenantMongoDB").(*mongo.Database)
 	if !ok { return nil, fmt.Errorf("mongo database not found in context") }
+	{{/if}}
 	{{else}}
+	{{#if isFederated}}
 	siloConns, _ := ctx.Value("tenantSiloConns").(map[string]*gorm.DB)
+	{{else}}
+	db, ok := ctx.Value("tenantDBConn").(*gorm.DB)
+	if !ok { return nil, fmt.Errorf("database not found in context") }
+	{{/if}}
 	{{/if}}
 	federatedData := make(map[string]*pb.{{capitalize name}})
 
@@ -67,17 +76,33 @@ func (s *{{capitalize name}}Service) Create{{capitalize name}}(ctx context.Conte
 	{{#each fields}}{{#if isNested}}
 	json.Unmarshal([]byte(req.{{toProtoFieldName name}}), &entity.{{capitalize name}})
 	{{/if}}{{/each}}
+	{{#if isFederated}}
+	for role, dbCon := range siloConns {
+		res, err := dbCon.Collection("{{toLowerCase name}}s").InsertOne(ctx, entity)
+		if err == nil {
+			entity.ID = fmt.Sprintf("%v", res.InsertedID)
+			federatedData[role] = map{{capitalize name}}ToPb(entity)
+		}
+	}
+	{{else}}
 	res, err := db.Collection("{{toLowerCase name}}s").InsertOne(ctx, entity)
 	if err == nil {
 		entity.ID = fmt.Sprintf("%v", res.InsertedID)
 		federatedData["tenant"] = map{{capitalize name}}ToPb(entity)
 	}
+	{{/if}}
 	{{else}}
-	for role, db := range siloConns {
-		if err := db.WithContext(ctx).Create(entity).Error; err == nil {
+	{{#if isFederated}}
+	for role, dbCon := range siloConns {
+		if err := dbCon.WithContext(ctx).Create(entity).Error; err == nil {
 			federatedData[role] = map{{capitalize name}}ToPb(entity)
 		}
 	}
+	{{else}}
+	if err := db.WithContext(ctx).Create(entity).Error; err == nil {
+		federatedData["tenant"] = map{{capitalize name}}ToPb(entity)
+	}
+	{{/if}}
 	{{/if}}
 
 	return &pb.{{capitalize name}}Reply{
@@ -89,12 +114,25 @@ func (s *{{capitalize name}}Service) Get{{capitalize name}}(ctx context.Context,
 	federatedData := make(map[string]*pb.{{capitalize name}})
 
 	{{#if isDocument}}
-	db, _ := ctx.Value("tenantMongoDB").(*mongo.Database)
-	var entity models.{{capitalize name}}
-	if err := db.Collection("{{toLowerCase name}}s").FindOne(ctx, bson.M{"_id": req.Id}).Decode(&entity); err == nil {
-		federatedData["tenant"] = map{{capitalize name}}ToPb(&entity)
+	{{#if isFederated}}
+	siloConns, _ := ctx.Value("tenantMongoConnections").(map[string]*mongo.Database)
+	for role, db := range siloConns {
+		var entity models.{{capitalize name}}
+		if err := db.Collection("{{toLowerCase name}}s").FindOne(ctx, bson.M{"_id": req.Id}).Decode(&entity); err == nil {
+			federatedData[role] = map{{capitalize name}}ToPb(&entity)
+		}
+	}
+	{{else}}
+	db, ok := ctx.Value("tenantMongoDB").(*mongo.Database)
+	if ok {
+		var entity models.{{capitalize name}}
+		if err := db.Collection("{{toLowerCase name}}s").FindOne(ctx, bson.M{"_id": req.Id}).Decode(&entity); err == nil {
+			federatedData["tenant"] = map{{capitalize name}}ToPb(&entity)
+		}
 	}
+	{{/if}}
 	{{else}}
+	{{#if isFederated}}
 	siloConns, _ := ctx.Value("tenantSiloConns").(map[string]*gorm.DB)
 	for role, db := range siloConns {
 		var entity models.{{capitalize name}}
@@ -102,6 +140,15 @@ func (s *{{capitalize name}}Service) Get{{capitalize name}}(ctx context.Context,
 			federatedData[role] = map{{capitalize name}}ToPb(&entity)
 		}
 	}
+	{{else}}
+	db, ok := ctx.Value("tenantDBConn").(*gorm.DB)
+	if ok {
+		var entity models.{{capitalize name}}
+		if err := db.WithContext(ctx).First(&entity, req.Id).Error; err == nil {
+			federatedData["tenant"] = map{{capitalize name}}ToPb(&entity)
+		}
+	}
+	{{/if}}
 	{{/if}}
 
 	return &pb.{{capitalize name}}Reply{
@@ -133,17 +180,37 @@ func (s *{{capitalize name}}Service) Update{{capitalize name}}(ctx context.Conte
 	{{/each}}
 
 	{{#if isDocument}}
-	db, _ := ctx.Value("tenantMongoDB").(*mongo.Database)
-	if _, err := db.Collection("{{toLowerCase name}}s").ReplaceOne(ctx, bson.M{"_id": req.Id}, entity); err == nil {
-		federatedData["tenant"] = map{{capitalize name}}ToPb(&entity)
+	{{#if isFederated}}
+	siloConns, _ := ctx.Value("tenantMongoConnections").(map[string]*mongo.Database)
+	for role, db := range siloConns {
+		if _, err := db.Collection("{{toLowerCase name}}s").ReplaceOne(ctx, bson.M{"_id": req.Id}, entity); err == nil {
+			federatedData[role] = map{{capitalize name}}ToPb(&entity)
+		}
 	}
 	{{else}}
+	db, ok := ctx.Value("tenantMongoDB").(*mongo.Database)
+	if ok {
+		if _, err := db.Collection("{{toLowerCase name}}s").ReplaceOne(ctx, bson.M{"_id": req.Id}, entity); err == nil {
+			federatedData["tenant"] = map{{capitalize name}}ToPb(&entity)
+		}
+	}
+	{{/if}}
+	{{else}}
+	{{#if isFederated}}
 	siloConns, _ := ctx.Value("tenantSiloConns").(map[string]*gorm.DB)
 	for role, db := range siloConns {
 		if err := db.WithContext(ctx).Model(&models.{{capitalize name}}{}).Where("id = ?", req.Id).Save(&entity).Error; err == nil {
 			federatedData[role] = map{{capitalize name}}ToPb(&entity)
 		}
 	}
+	{{else}}
+	db, ok := ctx.Value("tenantDBConn").(*gorm.DB)
+	if ok {
+		if err := db.WithContext(ctx).Model(&models.{{capitalize name}}{}).Where("id = ?", req.Id).Save(&entity).Error; err == nil {
+			federatedData["tenant"] = map{{capitalize name}}ToPb(&entity)
+		}
+	}
+	{{/if}}
 	{{/if}}
 
 	return &pb.{{capitalize name}}Reply{
@@ -153,13 +220,29 @@ func (s *{{capitalize name}}Service) Update{{capitalize name}}(ctx context.Conte
 
 func (s *{{capitalize name}}Service) Delete{{capitalize name}}(ctx context.Context, req *pb.Delete{{capitalize name}}Request) (*pb.Delete{{capitalize name}}Reply, error) {
 	{{#if isDocument}}
-	db, _ := ctx.Value("tenantMongoDB").(*mongo.Database)
-	db.Collection("{{toLowerCase name}}s").DeleteOne(ctx, bson.M{"_id": req.Id})
+	{{#if isFederated}}
+	siloConns, _ := ctx.Value("tenantMongoConnections").(map[string]*mongo.Database)
+	for _, db := range siloConns {
+		db.Collection("{{toLowerCase name}}s").DeleteOne(ctx, bson.M{"_id": req.Id})
+	}
+	{{else}}
+	db, ok := ctx.Value("tenantMongoDB").(*mongo.Database)
+	if ok {
+		db.Collection("{{toLowerCase name}}s").DeleteOne(ctx, bson.M{"_id": req.Id})
+	}
+	{{/if}}
 	{{else}}
+	{{#if isFederated}}
 	siloConns, _ := ctx.Value("tenantSiloConns").(map[string]*gorm.DB)
 	for _, db := range siloConns {
 		db.WithContext(ctx).Where("id = ?", req.Id).Delete(&models.{{capitalize name}}{})
 	}
+	{{else}}
+	db, ok := ctx.Value("tenantDBConn").(*gorm.DB)
+	if ok {
+		db.WithContext(ctx).Where("id = ?", req.Id).Delete(&models.{{capitalize name}}{})
+	}
+	{{/if}}
 	{{/if}}
 	return &pb.Delete{{capitalize name}}Reply{Message: "Delete completed"}, nil
 }
@@ -169,21 +252,43 @@ func (s *{{capitalize name}}Service) List{{capitalize name}}(ctx context.Context
 	var total int64
 
 	{{#if isDocument}}
-	db, _ := ctx.Value("tenantMongoDB").(*mongo.Database)
-	var results []models.{{capitalize name}}
-	opts := options.Find().SetSkip(int64((req.Page - 1) * req.PageSize)).SetLimit(int64(req.PageSize))
-	cursor, err := db.Collection("{{toLowerCase name}}s").Find(ctx, bson.M{}, opts)
-	if err == nil {
-		cursor.All(ctx, &results)
-		items := make([]*pb.{{capitalize name}}, len(results))
-		for i, r := range results {
-			items[i] = map{{capitalize name}}ToPb(&r)
+	{{#if isFederated}}
+	siloConns, _ := ctx.Value("tenantMongoConnections").(map[string]*mongo.Database)
+	for role, db := range siloConns {
+		var results []models.{{capitalize name}}
+		opts := options.Find().SetSkip(int64((req.Page - 1) * req.PageSize)).SetLimit(int64(req.PageSize))
+		cursor, err := db.Collection("{{toLowerCase name}}s").Find(ctx, bson.M{}, opts)
+		if err == nil {
+			cursor.All(ctx, &results)
+			items := make([]*pb.{{capitalize name}}, len(results))
+			for i, r := range results {
+				items[i] = map{{capitalize name}}ToPb(&r)
+			}
+			federatedResults[role] = &pb.{{capitalize name}}List{Items: items}
+			count, _ := db.Collection("{{toLowerCase name}}s").CountDocuments(ctx, bson.M{})
+			total += count
 		}
-		federatedResults["tenant"] = &pb.{{capitalize name}}List{Items: items}
-		count, _ := db.Collection("{{toLowerCase name}}s").CountDocuments(ctx, bson.M{})
-		total = count
 	}
 	{{else}}
+	db, ok := ctx.Value("tenantMongoDB").(*mongo.Database)
+	if ok {
+		var results []models.{{capitalize name}}
+		opts := options.Find().SetSkip(int64((req.Page - 1) * req.PageSize)).SetLimit(int64(req.PageSize))
+		cursor, err := db.Collection("{{toLowerCase name}}s").Find(ctx, bson.M{}, opts)
+		if err == nil {
+			cursor.All(ctx, &results)
+			items := make([]*pb.{{capitalize name}}, len(results))
+			for i, r := range results {
+				items[i] = map{{capitalize name}}ToPb(&r)
+			}
+			federatedResults["tenant"] = &pb.{{capitalize name}}List{Items: items}
+			count, _ := db.Collection("{{toLowerCase name}}s").CountDocuments(ctx, bson.M{})
+			total = count
+		}
+	}
+	{{/if}}
+	{{else}}
+	{{#if isFederated}}
 	siloConns, _ := ctx.Value("tenantSiloConns").(map[string]*gorm.DB)
 	for role, db := range siloConns {
 		var results []models.{{capitalize name}}
@@ -202,6 +307,26 @@ func (s *{{capitalize name}}Service) List{{capitalize name}}(ctx context.Context
 			federatedResults[role] = &pb.{{capitalize name}}List{Items: items}
 		}
 	}
+	{{else}}
+	db, ok := ctx.Value("tenantDBConn").(*gorm.DB)
+	if ok {
+		var results []models.{{capitalize name}}
+		query := db.WithContext(ctx).Model(&models.{{capitalize name}}{})
+		
+		var count int64
+		query.Count(&count)
+		total = count
+
+		offset := (req.Page - 1) * req.PageSize
+		if err := query.Limit(int(req.PageSize)).Offset(int(offset)).Find(&results).Error; err == nil {
+			items := make([]*pb.{{capitalize name}}, len(results))
+			for i, r := range results {
+				items[i] = map{{capitalize name}}ToPb(&r)
+			}
+			federatedResults["tenant"] = &pb.{{capitalize name}}List{Items: items}
+		}
+	}
+	{{/if}}
 	{{/if}}
 	
 	return &pb.List{{capitalize name}}Reply{