go-duck-cli 1.1.36 → 1.1.40

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) {
@@ -316,7 +319,11 @@ func TenantServerInterceptor(conf *config.Config, db *gorm.DB) middleware.Middle
                     db.Raw("SELECT role_name, db_name, is_primary FROM tenant_roles WHERE LOWER(role_name) IN ? AND tenant_id = ?", lowerRoles, requestedTenant).Scan(&mappings)
                 }
             } else {
-                db.Raw("SELECT role_name, db_name, is_primary FROM tenant_roles WHERE LOWER(role_name) IN ?", lowerRoles).Scan(&mappings)
+                if isAdmin {
+                    db.Raw("SELECT role_name, db_name, is_primary FROM tenant_roles").Scan(&mappings)
+                } else {
+                    db.Raw("SELECT role_name, db_name, is_primary FROM tenant_roles WHERE LOWER(role_name) IN ?", lowerRoles).Scan(&mappings)
+                }
             }
 
             siloConnections := make(map[string]*gorm.DB)
@@ -338,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")
@@ -179,7 +180,11 @@ func TenantMiddleware(db *gorm.DB, cfg *config.Config) gin.HandlerFunc {
 				db.Raw("SELECT role_name, db_name, is_primary FROM tenant_roles WHERE LOWER(role_name) IN ? AND tenant_id IN ?", lowerRoles, requestedTenants).Scan(&mappings)
 			}
 		} else {
-			db.Raw("SELECT role_name, db_name, is_primary FROM tenant_roles WHERE LOWER(role_name) IN ?", lowerRoles).Scan(&mappings)
+			if isAdmin {
+				db.Raw("SELECT role_name, db_name, is_primary FROM tenant_roles").Scan(&mappings)
+			} else {
+				db.Raw("SELECT role_name, db_name, is_primary FROM tenant_roles WHERE LOWER(role_name) IN ?", lowerRoles).Scan(&mappings)
+			}
 		}
 
 		// Filter out unauthorized mappings (e.g. admin_db for non-admins)
@@ -203,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)
 			 }
@@ -281,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"))
@@ -299,11 +305,15 @@ func PublicTenantMiddleware(db *gorm.DB, cfg *config.Config) gin.HandlerFunc {
         var mappings []models.TenantRole
         if len(requestedTenants) > 0 {
             db.Raw("SELECT db_name, is_primary FROM tenant_roles WHERE tenant_id IN ?", requestedTenants).Scan(&mappings)
+        } else {
+            db.Raw("SELECT db_name, is_primary FROM tenant_roles ORDER BY is_primary DESC, id ASC LIMIT 1").Scan(&mappings)
         }
 
         dbName := fallbackDB
+        mongoDbName := fallbackMongoDB
         if len(mappings) > 0 {
              dbName = mappings[0].DBName
+             mongoDbName = mappings[0].DBName
         }
 
 		tenantConn, err := mgr.GetDB(dbName)
@@ -316,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/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.36",
+  "version": "1.1.40",
   "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{