go-duck-cli 1.0.8 → 1.1.1

package/generators/multitenancy.js

@@ -1,29 +1,43 @@
 import fs from 'fs-extra';
 import path from 'path';
 import chalk from 'chalk';
+import Handlebars from 'handlebars';
 
-export const generateMultitenancy = async (config, outputDir) => {
+Handlebars.registerHelper('capitalize', (str) => {
+    if (!str) return '';
+    return str.charAt(0).toUpperCase() + str.slice(1);
+});
+
+export const generateMultitenancy = async (config, outputDir, entities = []) => {
 
 	const multitenancyTemplate = `
 package middleware
 
 import (
+	"context"
 	"fmt"
 	"net/http"
+	"strings"
 	"sync"
+    "sort"
+	"time"
 
 	"github.com/gin-gonic/gin"
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
 	"gorm.io/driver/postgres"
 	"gorm.io/gorm"
 	"{{app_name}}/config"
+	"{{app_name}}/models"
 )
 
 // TenantDBManager handles dynamic connection pooling for all tenants
 type TenantDBManager struct {
-	masterDB *gorm.DB
-	configs  *config.Config
-	conns    map[string]*gorm.DB
-	mu       sync.RWMutex
+	masterDB   *gorm.DB
+	configs    *config.Config
+	conns      map[string]*gorm.DB
+	mongoConns map[string]*mongo.Client
+	mu         sync.RWMutex
 }
 
 var (
@@ -34,9 +48,10 @@ var (
 func GetTenantManager(db *gorm.DB, cfg *config.Config) *TenantDBManager {
 	once.Do(func() {
 		manager = &TenantDBManager{
-			masterDB: db,
-			configs:  cfg,
-			conns:    make(map[string]*gorm.DB),
+			masterDB:   db,
+			configs:    cfg,
+			conns:      make(map[string]*gorm.DB),
+			mongoConns: make(map[string]*mongo.Client),
 		}
 	})
 	return manager
@@ -68,18 +83,55 @@ func (m *TenantDBManager) GetDB(dbName string) (*gorm.DB, error) {
 		return nil, err
 	}
 
+	sqlDB, err := newDB.DB()
+	if err == nil {
+		sqlDB.SetMaxOpenConns(5)
+		sqlDB.SetMaxIdleConns(2)
+		sqlDB.SetConnMaxLifetime(m.configs.GoDuck.Datasource.ConnMaxLifetime)
+	}
+
+	// Ensure Silo supports Distributed Outbox (Saga Consistency)
+	newDB.AutoMigrate(&models.DistributedOutbox{})
+
 	m.conns[dbName] = newDB
 	return newDB, nil
 }
 
+func (m *TenantDBManager) GetMongoClient(dbName string) (*mongo.Client, error) {
+	m.mu.RLock()
+	if client, ok := m.mongoConns[dbName]; ok {
+		m.mu.RUnlock()
+		return client, nil
+	}
+	m.mu.RUnlock()
+
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if client, ok := m.mongoConns[dbName]; ok {
+		return client, nil
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	// For multi-tenancy in MongoDB, we either use one client and switch DBs, 
+	// or create a client per DB if they are on different hosts.
+	// Here we assume same host, different DBs for performance.
+	client, err := mongo.Connect(ctx, options.Client().ApplyURI(m.configs.GetMongoURI()))
+	if err != nil {
+		return nil, err
+	}
+
+	m.mongoConns[dbName] = client
+	return client, nil
+}
+
 func TenantMiddleware(db *gorm.DB, cfg *config.Config) gin.HandlerFunc {
 	mgr := GetTenantManager(db, cfg)
+	fallbackDB := strings.ToLower(cfg.GoDuck.Name) + "_fallback"
 
 	return func(c *gin.Context) {
-		// 1. Identification (Hint from Header)
-		requestedTenant := c.GetHeader("X-Tenant-ID")
-
-		// 2. Authorization (Extracted from JWT by JWTMiddleware)
 		userRolesInterface, exists := c.Get("UserRoles")
 		if !exists {
 			c.JSON(http.StatusUnauthorized, gin.H{"error": "No roles found in token"})
@@ -94,24 +146,110 @@ func TenantMiddleware(db *gorm.DB, cfg *config.Config) gin.HandlerFunc {
 			return
 		}
 
-		// 3. Resolution (Which DB is this role authorized to access?)
-		var dbName string
-		err := db.Raw("SELECT db_name FROM tenant_roles WHERE role_name IN ? LIMIT 1", roles).Scan(&dbName).Error
-		
-		if err != nil || dbName == "" {
-			c.JSON(http.StatusForbidden, gin.H{"error": "Security: No tenant context mapped to user roles"})
-			c.Abort()
-			return
+		var lowerRoles []string
+		isAdmin := false
+		for _, r := range roles {
+			roleStr := strings.ToLower(fmt.Sprintf("%v", r))
+			lowerRoles = append(lowerRoles, roleStr)
+			if roleStr == "admin" || roleStr == "role_admin" {
+				isAdmin = true
+			}
 		}
 
-		// 4. Security Check (Prevent Cross-Tenant Spoofing)
-		if requestedTenant != "" && requestedTenant != dbName {
-			c.JSON(http.StatusForbidden, gin.H{"error": "Security Breach: Header/Token tenant mismatch"})
-			c.Abort()
-			return
+		siloConnections := make(map[string]*gorm.DB)
+		mongoConnections := make(map[string]*mongo.Database)
+        var mappings []models.TenantRole
+        
+		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)
+				}
+			}
+		}
+
+		if len(requestedTenants) > 0 {
+			db.Raw("SELECT role_name, db_name, is_primary FROM tenant_roles WHERE 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 role_name IN ?", lowerRoles).Scan(&mappings)
 		}
 
-		// 5. Dynamic Switching (Get or Create the DB Connection)
+        if len(mappings) == 0 {
+             conn, _ := mgr.GetDB(fallbackDB)
+             siloConnections["fallback"] = conn
+             c.Set("tenantDBConn", conn)
+
+			 if cfg.GoDuck.Datasource.MongoDB.Enabled {
+				mClient, _ := mgr.GetMongoClient(fallbackDB)
+				mDB := mClient.Database(fallbackDB)
+				mongoConnections["fallback"] = mDB
+				c.Set("tenantMongoDB", mDB)
+			 }
+
+             c.Set("primaryRole", "fallback")
+        } else {
+            // Sort by is_primary to ensure primary silo is selected as the default connection
+            sort.Slice(mappings, func(i, j int) bool {
+                return mappings[i].IsPrimary && !mappings[j].IsPrimary
+            })
+
+            for _, m := range mappings {
+                if m.DBName == "admin_db" && !isAdmin { continue }
+                conn, err := mgr.GetDB(m.DBName)
+                if err == nil {
+                    siloConnections[m.RoleName] = conn
+                }
+
+				if cfg.GoDuck.Datasource.MongoDB.Enabled {
+					mClient, err := mgr.GetMongoClient(m.DBName)
+					if err == nil {
+						mongoConnections[m.RoleName] = mClient.Database(m.DBName)
+					}
+				}
+            }
+
+            // The FIRST one in our sorted list is the primary/lead silo for this request
+            if len(mappings) > 0 {
+                primaryConn, _ := mgr.GetDB(mappings[0].DBName)
+                c.Set("tenantDBConn", primaryConn)
+
+				if cfg.GoDuck.Datasource.MongoDB.Enabled {
+					mClient, _ := mgr.GetMongoClient(mappings[0].DBName)
+					c.Set("tenantMongoDB", mClient.Database(mappings[0].DBName))
+				}
+
+                c.Set("primaryRole", mappings[0].RoleName)
+            }
+        }
+
+		c.Set("tenantSiloConns", siloConnections)
+		c.Set("tenantMongoConnections", mongoConnections)
+		c.Set("isAdmin", isAdmin)
+		c.Next()
+	}
+}
+
+func PublicTenantMiddleware(db *gorm.DB, cfg *config.Config) gin.HandlerFunc {
+	mgr := GetTenantManager(db, cfg)
+	fallbackDB := strings.ToLower(cfg.GoDuck.Name) + "_fallback"
+
+	return func(c *gin.Context) {
+		requestedTenant := strings.ToLower(c.GetHeader("X-Tenant-ID"))
+        
+        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)
+        }
+
+        dbName := fallbackDB
+        if len(mappings) > 0 {
+             dbName = mappings[0].DBName
+        }
+
 		tenantConn, err := mgr.GetDB(dbName)
 		if err != nil {
 			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to resolve tenant database connection"})
@@ -119,9 +257,15 @@ func TenantMiddleware(db *gorm.DB, cfg *config.Config) gin.HandlerFunc {
 			return
 		}
 
-		// 6. Inject Live Connection into Context
-		c.Set("tenantDB", dbName)
 		c.Set("tenantDBConn", tenantConn)
+
+		if cfg.GoDuck.Datasource.MongoDB.Enabled {
+			mClient, err := mgr.GetMongoClient(dbName)
+			if err == nil {
+				c.Set("tenantMongoDB", mClient.Database(dbName))
+			}
+		}
+
 		c.Next()
 	}
 }
@@ -133,77 +277,136 @@ package management
 import (
 	"fmt"
 	"net/http"
-	"os/exec"
+	"strings"
 	"{{app_name}}/config"
+	"{{app_name}}/middleware"
+	"{{app_name}}/migrations"
+    "{{app_name}}/models"
 
 	"github.com/gin-gonic/gin"
+    "github.com/google/uuid"
 	"gorm.io/gorm"
 )
 
 type DatabaseRequest struct {
-	Role   string \`json:"role" binding:"required"\`
-	DBName string \`json:"db_name" binding:"required"\`
+	RoleName  string \`json:"roleName" form:"roleName" binding:"required"\`
+	DBName    string \`json:"dbName" form:"dbName" binding:"required"\`
+    IsPrimary bool   \`json:"isPrimary" form:"isPrimary"\`
 }
 
 func CreateDatabaseAndMigrate(masterDB *gorm.DB) gin.HandlerFunc {
 	return func(c *gin.Context) {
 		var req DatabaseRequest
 		if err := c.ShouldBindJSON(&req); err != nil {
-			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
-			return
+			    c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			    return
 		}
 
-		// 1. CREATE DATABASE
-		// Note: CREATE DATABASE cannot be run in a transaction.
-		// We use the masterDB connection.
-		if err := masterDB.Exec(fmt.Sprintf("CREATE DATABASE %s", req.DBName)).Error; err != nil {
-			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to create database: " + err.Error()})
+		req.DBName = strings.ToLower(req.DBName)
+        req.RoleName = strings.ToLower(req.RoleName)
+
+		// 1. Ensure DB exists
+        var exists int
+        masterDB.Raw("SELECT 1 FROM pg_database WHERE datname = ?", req.DBName).Scan(&exists)
+        if exists == 0 {
+		    masterDB.Exec(fmt.Sprintf("CREATE DATABASE %s", req.DBName))
+        }
+
+		// 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)
+        }
+
+		// 3. Upsert mapping
+        var existing models.TenantRole
+        if err := masterDB.Where("role_name = ? AND db_name = ?", req.RoleName, req.DBName).First(&existing).Error; err == nil {
+            existing.IsPrimary = req.IsPrimary
+            masterDB.Save(&existing)
+        } else {
+            masterDB.Create(&models.TenantRole{
+                TenantID:  uuid.New().String(),
+                RoleName:  req.RoleName,
+                DBName:    req.DBName,
+                IsPrimary: req.IsPrimary,
+            })
+        }
+
+		// 4. Migrate
+		appConfig, _ := config.LoadConfig()
+		mgr := middleware.GetTenantManager(masterDB, appConfig)
+        
+        tenantDB, err := mgr.GetDB(req.DBName)
+        if err == nil {
+            migrations.RunGoNativeMigrationsForTenant(tenantDB)
+        }
+
+		c.JSON(http.StatusOK, gin.H{"message": "Role silo assigned successfully", "role": req.RoleName, "primary": req.IsPrimary})
+	}
+}
+
+func GetMySilos(masterDB *gorm.DB) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		userRoles, _ := c.Get("UserRoles")
+		roles, ok := userRoles.([]interface{})
+		if !ok {
+			c.JSON(http.StatusUnauthorized, gin.H{"error": "Unauthorized"})
 			return
 		}
 
-		// 2. Insert into roles mapping table
-		if err := masterDB.Exec("INSERT INTO tenant_roles (role_name, db_name) VALUES (?, ?)", req.Role, req.DBName).Error; err != nil {
-			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to map role: " + err.Error()})
-			return
+		var lowerRoles []string
+		for _, r := range roles {
+			lowerRoles = append(lowerRoles, strings.ToLower(fmt.Sprintf("%v", r)))
 		}
 
-		// 3. Start Liquibase Migration for the new tenant
+		var mappings []models.TenantRole
+		masterDB.Where("role_name IN ?", lowerRoles).Find(&mappings)
+
 		appConfig, _ := config.LoadConfig()
-		ds := appConfig.GoDuck.Datasource
-		
-		// Construct JDBC URL for the new database
-		jdbcUrl := fmt.Sprintf("jdbc:postgresql://%s:%d/%s", ds.Host, ds.Port, req.DBName)
-		
-		fmt.Printf("Migrating new tenant DB: %s\\n", req.DBName)
-		
-		cmd := exec.Command("liquibase", 
-			"--url=" + jdbcUrl, 
-			"--username=" + ds.Username, 
-			"--password=" + ds.Password, 
-			"--changeLogFile=migrations/master.xml", 
-			"update")
-		
-		if err := cmd.Run(); err != nil {
-			fmt.Printf("Liquibase Error: %v\\n", err)
-			// We don't fail the whole request because the DB is created, 
-			// but we warn the admin.
-			c.JSON(http.StatusOK, gin.H{"message": "Database created but migration failed to auto-start. Please run manually.", "error": err.Error()})
-			return
+		hideDBNames := appConfig.GoDuck.Multitenancy.HideSiloNames
+
+		type SiloInfo struct {
+			TenantID  string \`json:"tenantId"\`
+			RoleName  string \`json:"roleName"\`
+			DBName    string \`json:"dbName,omitempty"\`
+			IsPrimary bool   \`json:"isPrimary"\`
+		}
+
+		var result []SiloInfo
+		for _, m := range mappings {
+			info := SiloInfo{
+				TenantID:  m.TenantID,
+				RoleName:  m.RoleName,
+				IsPrimary: m.IsPrimary,
+			}
+			if !hideDBNames {
+				info.DBName = m.DBName
+			}
+			result = append(result, info)
 		}
 
-		c.JSON(http.StatusOK, gin.H{"message": "Database created, role mapped, and migration completed for " + req.Role})
+		c.JSON(http.StatusOK, result)
 	}
 }
 `;
 
-	const middlewarePath = path.join(outputDir, 'middleware/tenant_middleware.go');
-	const dbApiPath = path.join(outputDir, 'management/db_controller.go');
+	const tenantRoleModel = `
+package models
 
-	await fs.ensureDir(path.join(outputDir, 'middleware'));
-	await fs.ensureDir(path.join(outputDir, 'management'));
+type TenantRole struct {
+	ID          uint    \`gorm:"primaryKey" json:"id"\`
+	TenantID    string  \`json:"tenantId" gorm:"unique;not null;index"\`
+	RoleName    string  \`json:"roleName" gorm:"unique;not null"\`
+	DBName      string  \`json:"dbName" gorm:"not null"\`
+	MongoDBName string  \`json:"mongoDbName"\`
+    IsPrimary   bool    \`json:"isPrimary" gorm:"default:false"\`
+}
+`;
 
-	await fs.writeFile(middlewarePath, multitenancyTemplate);
-	await fs.writeFile(dbApiPath, dbApiTemplate.replace('{{app_name}}', config.name));
+    await fs.ensureDir(path.join(outputDir, 'middleware'));
+    await fs.ensureDir(path.join(outputDir, 'management'));
+    await fs.ensureDir(path.join(outputDir, 'models'));
 
-	console.log(chalk.gray('  Generated Multitenancy Middleware & Management API'));
+	await fs.writeFile(path.join(outputDir, 'middleware/tenant_middleware.go'), Handlebars.compile(multitenancyTemplate)({ app_name: config.name, entities }));
+	await fs.writeFile(path.join(outputDir, 'management/db_controller.go'), Handlebars.compile(dbApiTemplate)({ app_name: config.name, entities }));
+    await fs.writeFile(path.join(outputDir, 'models/tenant_role.go'), tenantRoleModel);
 };

package/generators/nats.js

@@ -0,0 +1,39 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+
+export const generateNATSCode = async (config, outputDir) => {
+    const messagingDir = path.join(outputDir, 'messaging');
+    await fs.ensureDir(messagingDir);
+
+    const natsClientGo = `package messaging
+
+import (
+	"log"
+
+	"{{app_name}}/config"
+	"github.com/nats-io/nats.go"
+)
+
+var NATSConn *nats.Conn
+
+func InitNATS(cfg *config.Config) {
+	if !cfg.GoDuck.Messaging.NATS.Enabled {
+		log.Println("NATS Messaging is disabled.")
+		return
+	}
+
+	nc, err := nats.Connect(cfg.GoDuck.Messaging.NATS.URL)
+	if err != nil {
+		log.Printf("Failed to connect to NATS: %v", err)
+		return
+	}
+
+	log.Printf("Connected to NATS Server: %s", cfg.GoDuck.Messaging.NATS.URL)
+	NATSConn = nc
+}
+`;
+
+    await fs.writeFile(path.join(messagingDir, 'nats.go'), natsClientGo.replace(/{{app_name}}/g, config.name));
+    console.log(chalk.gray('  Generated NATS Messaging Package'));
+};

package/generators/outbox.js

@@ -0,0 +1,171 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+
+export const generateOutbox = async (outputDir, config) => {
+    const modelsDir = path.join(outputDir, 'models');
+    const workerDir = path.join(outputDir, 'internal/worker');
+    await fs.ensureDir(modelsDir);
+    await fs.ensureDir(workerDir);
+
+    const outboxModel = `package models
+
+import (
+	"time"
+)
+
+type DistributedOutbox struct {
+	ID           uint      \`gorm:"primaryKey" json:"id"\`
+	MutationType string    \`json:"mutationType"\` // CREATE, UPDATE, PATCH, DELETE, BULK_CREATE, etc.
+	EntityName   string    \`json:"entityName"\`
+	EntityID     string    \`json:"entityId"\`
+	Payload      string    \`json:"payload" gorm:"type:text"\`
+	TargetSilo   string    \`json:"targetSilo"\`     // Which role/silo to sync to
+	SourceSilo   string    \`json:"sourceSilo"\`     // Which role/silo originated this
+	Status       string    \`json:"status" gorm:"default:'PENDING'"\` // PENDING, COMPLETED, FAILED
+	RetryCount   int       \`json:"retryCount" gorm:"default:0"\`
+	LastError    string    \`json:"lastError"\`
+	CreatedAt    time.Time \`json:"createdAt"\`
+	UpdatedAt    time.Time \`json:"updatedAt"\`
+}
+`;
+
+    const outboxWorker = `package worker
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"strings"
+	"time"
+	"{{app_name}}/logger"
+	"{{app_name}}/models"
+	"{{app_name}}/config"
+	"{{app_name}}/middleware"
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+)
+
+type OutboxWorker struct {
+	MasterDB *gorm.DB
+	Config   *config.Config
+}
+
+func NewOutboxWorker(db *gorm.DB, cfg *config.Config) *OutboxWorker {
+	return &OutboxWorker{MasterDB: db, Config: cfg}
+}
+
+func (w *OutboxWorker) Start(ctx context.Context) {
+	ticker := time.NewTicker(10 * time.Second) // Poll every 10 seconds
+	logger.Info("Distributed Outbox (Saga Consistency) Worker started")
+
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-ticker.C:
+			w.processOutbox()
+		}
+	}
+}
+
+func (w *OutboxWorker) processOutbox() {
+	// 1. Identify all managed silos
+	var siloMappings []models.TenantRole
+	if err := w.MasterDB.Find(&siloMappings).Error; err != nil {
+		return
+	}
+
+	mgr := middleware.GetTenantManager(w.MasterDB, w.Config)
+
+	// 2. Poll each silo for pending outbox items originated there
+	for _, mapping := range siloMappings {
+		srcDB, err := mgr.GetDB(mapping.DBName)
+		if err != nil {
+			continue
+		}
+
+		var pending []models.DistributedOutbox
+		if err := srcDB.Limit(50).Where("status = ? AND retry_count < 5", "PENDING").Find(&pending).Error; err != nil {
+			continue
+		}
+
+		for _, item := range pending {
+			// Resolve Target DB Name
+			var targetMapping models.TenantRole
+			if err := w.MasterDB.Where("role_name = ?", item.TargetSilo).First(&targetMapping).Error; err != nil {
+				w.markFailed(srcDB, &item, "Silo resolution failed: "+err.Error())
+				continue
+			}
+
+			targetDB, err := mgr.GetDB(targetMapping.DBName)
+			if err != nil {
+				w.markFailed(srcDB, &item, "Target DB connect failed: "+err.Error())
+				continue
+			}
+
+			if err := w.relayMutation(targetDB, item); err != nil {
+				w.markFailed(srcDB, &item, "Relay failed: "+err.Error())
+			} else {
+				srcDB.Model(&item).Update("status", "COMPLETED")
+			}
+		}
+	}
+}
+
+func (w *OutboxWorker) markFailed(db *gorm.DB, item *models.DistributedOutbox, reason string) {
+	db.Model(item).Updates(map[string]interface{}{
+		"status":      "PENDING", // Keep pending so we can retry
+		"retry_count": item.RetryCount + 1,
+		"last_error":  reason,
+	})
+}
+
+func (w *OutboxWorker) relayMutation(targetDB *gorm.DB, item models.DistributedOutbox) error {
+	var data map[string]interface{}
+	if item.Payload != "" && item.MutationType != "DELETE" {
+		if err := json.Unmarshal([]byte(item.Payload), &data); err != nil {
+			return fmt.Errorf("payload unmarshal failed: %v", err)
+		}
+	}
+
+	table := strings.ToLower(item.EntityName)
+
+	switch item.MutationType {
+	case "CREATE":
+		return targetDB.Table(table).Clauses(clause.OnConflict{DoNothing: true}).Create(data).Error
+	case "UPDATE", "PATCH":
+		return targetDB.Table(table).Where("id = ?", item.EntityID).Updates(data).Error
+	case "DELETE":
+		return targetDB.Table(table).Where("id = ?", item.EntityID).Delete(nil).Error
+	case "BULK_CREATE":
+		var list []map[string]interface{}
+		json.Unmarshal([]byte(item.Payload), &list)
+		return targetDB.Table(table).Clauses(clause.OnConflict{DoNothing: true}).Create(list).Error
+	case "BULK_UPDATE", "BULK_PATCH":
+		var list []map[string]interface{}
+		json.Unmarshal([]byte(item.Payload), &list)
+		err := targetDB.Transaction(func(tx *gorm.DB) error {
+			for _, row := range list {
+				// Identify ID for updates in bulk
+				id := row["id"]
+				if id == nil {
+					id = row["ID"]
+				}
+				if err := tx.Table(table).Where("id = ?", id).Updates(row).Error; err != nil {
+					return err
+				}
+			}
+			return nil
+		})
+		return err
+	}
+	return fmt.Errorf("unknown mutation type: %s", item.MutationType)
+}
+`;
+
+    await fs.writeFile(path.join(modelsDir, 'outbox.go'), outboxModel);
+    await fs.writeFile(path.join(workerDir, 'outbox_worker.go'), outboxWorker.replace(/{{app_name}}/g, config.name));
+
+    console.log(chalk.gray('  Generated Distributed Outbox Model & Worker Skeleton'));
+};

package/generators/postgrest.js

@@ -26,7 +26,11 @@ type SearchController struct {
 // Syntax: /api/search/:table?age=gt.20&order=id.desc&limit=10&offset=0
 func (sc *SearchController) GenericSearch(c *gin.Context) {
 	tableName := c.Param("table")
-	query := sc.DB.Table(tableName)
+	db := sc.DB
+	if tdb, exists := c.Get("tenantDBConn"); exists {
+		db = tdb.(*gorm.DB)
+	}
+	query := db.Table(tableName)
 
 	// Apply Filters
 	params := c.Request.URL.Query()
@@ -48,10 +52,10 @@ func (sc *SearchController) GenericSearch(c *gin.Context) {
 				path = path[1:]
 			}
 			// Wrap column in quotes and path in single quotes for Postgres JSONB safety
-			processedKey = fmt.Sprintf("\"%s\"%s'%s'", column, operator, path)
+			processedKey = fmt.Sprintf("\\"%s\\"%s'%s'", column, operator, path)
 		} else {
 			// Standard column: Wrap in quotes for safety
-			processedKey = fmt.Sprintf("\"%s\"", key)
+			processedKey = fmt.Sprintf("\\"%s\\"", key)
 		}
 
 		for _, val := range values {