go-duck-cli 1.1.27 → 1.1.30

package/generators/devops.js

@@ -96,6 +96,7 @@ services:
       - "${dbPort}:5432"
     volumes:
       - postgres_data:/var/lib/postgresql/data
+      - ./postgres-init:/docker-entrypoint-initdb.d
     healthcheck:
       test: ["CMD-SHELL", "pg_isready -U ${config.datasource?.username || 'postgres'} -d ${config.datasource?.database || 'go_duck_master'}"]
       interval: 5s
@@ -167,7 +168,7 @@ services:
       KEYCLOAK_ADMIN: admin
       KEYCLOAK_ADMIN_PASSWORD: admin
       KC_DB: postgres
-      KC_DB_URL: jdbc:postgresql://postgres:5432/${config.datasource?.database || 'go_duck_master'}
+      KC_DB_URL: jdbc:postgresql://postgres:5432/keycloak
       KC_DB_USERNAME: ${config.datasource?.username || 'postgres'}
       KC_DB_PASSWORD: ${config.datasource?.password || 'password'}
     depends_on:
@@ -392,6 +393,10 @@ jobs:
     await fs.ensureDir(realmConfigDir);
     await fs.writeFile(path.join(realmConfigDir, `${realmName}-realm.json`), realmJson);
 
+    const postgresInitDir = path.join(devopsDir, 'postgres-init');
+    await fs.ensureDir(postgresInitDir);
+    await fs.writeFile(path.join(postgresInitDir, 'init.sql'), 'CREATE DATABASE keycloak;\n');
+
     await fs.writeFile(path.join(devopsDir, 'Dockerfile'), dockerfile);
     await fs.writeFile(path.join(devopsDir, 'services.yml'), servicesYaml);
     await fs.writeFile(path.join(devopsDir, 'app.yml'), appYaml);

package/generators/kratos.js

@@ -260,13 +260,15 @@ import (
     "{{projectName}}/models"
     my_middleware "{{projectName}}/middleware"
 	"gorm.io/gorm"
+	"go.mongodb.org/mongo-driver/mongo"
 	"strings"
 	"fmt"
+	"sort"
 )
 
 func TenantServerInterceptor(conf *config.Config, db *gorm.DB) middleware.Middleware {
     mgr := my_middleware.GetTenantManager(db, conf)
-    fallbackDB := "go_duck_fallback" // Standard fallback
+    fallbackDB := strings.ToLower(conf.GoDuck.Name) + "_fallback"
 
     return func(handler middleware.Handler) middleware.Handler {
         return func(ctx context.Context, req interface{}) (interface{}, error) {
@@ -296,36 +298,76 @@ func TenantServerInterceptor(conf *config.Config, db *gorm.DB) middleware.Middle
                 requestedTenant = strings.ToLower(md.Get("x-tenant-id"))
             }
 
-            siloConnections := make(map[string]*gorm.DB)
+            var mappings []models.TenantRole
             if requestedTenant != "" {
-                var mapping models.TenantRole
-                if err := db.Raw("SELECT role_name, db_name FROM tenant_roles WHERE role_name IN ? AND tenant_id = ? LIMIT 1", lowerRoles, requestedTenant).Scan(&mapping).Error; err == nil && mapping.DBName != "" {
-                     if mapping.DBName == "admin_db" && !isAdmin {
-                         conn, _ := mgr.GetDB(fallbackDB)
-                         siloConnections["fallback"] = conn
-                     } else {
-                         conn, _ := mgr.GetDB(mapping.DBName)
-                         siloConnections[mapping.RoleName] = conn
-                     }
+                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)
+            }
+
+            siloConnections := make(map[string]*gorm.DB)
+            mongoConnections := make(map[string]*mongo.Database)
+
+            if len(mappings) == 0 {
+                conn, _ := mgr.GetDB(fallbackDB)
+                siloConnections["fallback"] = conn
+                ctx = context.WithValue(ctx, "tenantDBConn", conn)
+
+                if conf.GoDuck.Datasource.MongoDB.Enabled {
+                    mClient, err := mgr.GetMongoClient(fallbackDB)
+                    if err == nil && mClient != nil {
+                        mDB := mClient.Database(fallbackDB)
+                        mongoConnections["fallback"] = mDB
+                        ctx = context.WithValue(ctx, "tenantMongoDB", mDB)
+                    }
                 }
             } else {
-                var mappings []models.TenantRole
-                db.Raw("SELECT role_name, db_name FROM tenant_roles WHERE role_name IN ?", lowerRoles).Scan(&mappings)
+                isGenericRole := func(role string) bool {
+                    r := strings.ToLower(role)
+                    return r == "offline_access" || r == "uma_authorization" || strings.HasPrefix(r, "default-roles-")
+                }
+
+                // Sort mappings
+                sort.Slice(mappings, func(i, j int) bool {
+                    if mappings[i].IsPrimary != mappings[j].IsPrimary {
+                        return mappings[i].IsPrimary
+                    }
+                    gI := isGenericRole(mappings[i].RoleName)
+                    gJ := isGenericRole(mappings[j].RoleName)
+                    if gI != gJ {
+                        return !gI
+                    }
+                    return false
+                })
+
                 for _, m := range mappings {
                     if m.DBName == "admin_db" && !isAdmin { continue }
                     if conn, err := mgr.GetDB(m.DBName); err == nil {
                         siloConnections[m.RoleName] = conn
                     }
+                    if conf.GoDuck.Datasource.MongoDB.Enabled {
+                        mClient, err := mgr.GetMongoClient(m.DBName)
+                        if err == nil && mClient != nil {
+                            mongoConnections[m.RoleName] = mClient.Database(m.DBName)
+                        }
+                    }
                 }
-            }
 
-            if len(siloConnections) == 0 {
-                conn, _ := mgr.GetDB(fallbackDB)
-                siloConnections["fallback"] = conn
+                // Lead/Primary Silo DB
+                primaryConn, err := mgr.GetDB(mappings[0].DBName)
+                if err == nil && primaryConn != nil {
+                    ctx = context.WithValue(ctx, "tenantDBConn", primaryConn)
+                }
+                if conf.GoDuck.Datasource.MongoDB.Enabled {
+                    mClient, err := mgr.GetMongoClient(mappings[0].DBName)
+                    if err == nil && mClient != nil {
+                        ctx = context.WithValue(ctx, "tenantMongoDB", mClient.Database(mappings[0].DBName))
+                    }
+                }
             }
 
-            // Inject Federated Bundle
             ctx = context.WithValue(ctx, "tenantSiloConns", siloConnections)
+            ctx = context.WithValue(ctx, "tenantMongoConnections", mongoConnections)
             return handler(ctx, req)
         }
     }

package/generators/multitenancy.js

@@ -271,11 +271,21 @@ func PublicTenantMiddleware(db *gorm.DB, cfg *config.Config) gin.HandlerFunc {
 	fallbackDB := strings.ToLower(cfg.GoDuck.Name) + "_fallback"
 
 	return func(c *gin.Context) {
-		requestedTenant := strings.ToLower(c.GetHeader("X-Tenant-ID"))
+        requestedTenantRaw := strings.ToLower(c.GetHeader("X-Tenant-ID"))
+        var requestedTenants []string
+        if requestedTenantRaw != "" {
+            parts := strings.Split(requestedTenantRaw, ",")
+            for _, p := range parts {
+                trimmed := strings.TrimSpace(p)
+                if trimmed != "" {
+                    requestedTenants = append(requestedTenants, trimmed)
+                }
+            }
+        }
         
         var mappings []models.TenantRole
-        if requestedTenant != "" {
-            db.Raw("SELECT db_name, is_primary FROM tenant_roles WHERE tenant_id = ? ORDER BY is_primary DESC LIMIT 1", requestedTenant).Scan(&mappings)
+        if len(requestedTenants) > 0 {
+            db.Raw("SELECT db_name, is_primary FROM tenant_roles WHERE tenant_id IN ?", requestedTenants).Scan(&mappings)
         }
 
         dbName := fallbackDB
@@ -294,7 +304,7 @@ func PublicTenantMiddleware(db *gorm.DB, cfg *config.Config) gin.HandlerFunc {
 
 		if cfg.GoDuck.Datasource.MongoDB.Enabled {
 			mClient, err := mgr.GetMongoClient(dbName)
-			if err == nil {
+			if err == nil && mClient != nil {
 				c.Set("tenantMongoDB", mClient.Database(dbName))
 			}
 		}
@@ -336,7 +346,6 @@ func CreateDatabaseAndMigrate(masterDB *gorm.DB) gin.HandlerFunc {
 		}
 
 		req.DBName = strings.ToLower(req.DBName)
-        req.RoleName = strings.ToLower(req.RoleName)
 
 		// 1. Ensure DB exists
         var exists int
@@ -347,18 +356,18 @@ func CreateDatabaseAndMigrate(masterDB *gorm.DB) gin.HandlerFunc {
 
 		// 2. Clear other primary flags for this role if setting new primary
         if req.IsPrimary {
-            masterDB.Model(&models.TenantRole{}).Where("role_name = ?", req.RoleName).Update("is_primary", false)
+            masterDB.Model(&models.TenantRole{}).Where("LOWER(role_name) = LOWER(?)", req.RoleName).Update("is_primary", false)
         }
 
 		// 3. Upsert mapping
         var existing models.TenantRole
         isPrimary := req.IsPrimary
         var count int64
-        masterDB.Model(&models.TenantRole{}).Where("role_name = ?", req.RoleName).Count(&count)
+        masterDB.Model(&models.TenantRole{}).Where("LOWER(role_name) = LOWER(?)", req.RoleName).Count(&count)
         if count == 0 {
             isPrimary = true
         }
-        if err := masterDB.Where("role_name = ? AND db_name = ?", req.RoleName, req.DBName).First(&existing).Error; err == nil {
+        if err := masterDB.Where("LOWER(role_name) = LOWER(?) AND db_name = ?", req.RoleName, req.DBName).First(&existing).Error; err == nil {
             if count <= 1 {
                 isPrimary = true
             }
@@ -401,7 +410,7 @@ func GetMySilos(masterDB *gorm.DB) gin.HandlerFunc {
 		}
 
 		var mappings []models.TenantRole
-		masterDB.Where("role_name IN ?", lowerRoles).Find(&mappings)
+		masterDB.Where("LOWER(role_name) IN ?", lowerRoles).Find(&mappings)
 
 		appConfig, _ := config.LoadConfig()
 		hideDBNames := appConfig.GoDuck.Multitenancy.HideSiloNames

package/package.json

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