go-duck-cli 1.0.9 → 1.1.1

package/templates/go/controller.go.hbs

@@ -1,339 +1,343 @@
 package controllers
 
 import (
-"fmt"
-"net/http"
-"strconv"
-
-"{{app_name}}/config"
-"{{app_name}}/messaging"
-"{{app_name}}/models"
-"{{app_name}}/cache"
-"{{app_name}}/resilience"
-
-"github.com/gin-gonic/gin"
-"gorm.io/gorm"
+	"net/http"
+	"strconv"
+	{{#if isSearchable}}
+	"context"
+	{{/if}}
+	{{#if (or isDocument isFederated)}}
+	"fmt"
+	{{/if}}
+	{{#if isFederated}}
+	"encoding/json"
+	"sync"
+	{{/if}}
+
+	"{{app_name}}/config"
+	"{{app_name}}/messaging"
+	"{{app_name}}/models"
+	"{{app_name}}/cache"
+	{{#if isSearchable}}
+	"{{app_name}}/internal/search"
+	{{/if}}
+	"github.com/gin-gonic/gin"
+	{{#if isDocument}}
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+	{{else}}
+	"gorm.io/gorm"
+	{{/if}}
 )
 
 type {{capitalize name}}Controller struct {
-DB *gorm.DB
-Config *config.Config
+	{{#if isDocument}}
+	MongoClient *mongo.Client
+	{{else}}
+	DB     *gorm.DB
+	{{/if}}
+	Config *config.Config
 }
 
-// Create{{capitalize name}}
-	db := ctrl.DB
-	if tdb, exists := c.Get("tenantDBConn"); exists {
-		db = tdb.(*gorm.DB)
-	}
-
+// Create handles creating a new {{capitalize name}}
+func (ctrl *{{capitalize name}}Controller) Create(c *gin.Context) {
+	ctx := c.Request.Context()
 	var entity models.{{capitalize name}}
 	if err := c.ShouldBindJSON(&entity); err != nil {
 		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
 		return
 	}
-	if err := db.WithContext(ctx).Create(&entity).Error; err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		return
-	}
-
-// Dynamic Cache Invalidation (Tenant Aware)
-cache.ClearPattern(tenantStr + ":{{capitalize name}}*")
 
-// MQTT Event (Resilient)
-resilience.Execute(func() (interface{}, error) {
-messaging.PublishEvent(ctrl.Config.GoDuck.Messaging.MQTT.TopicPrefix, "CREATE", "{{capitalize name}}", entity, nil)
-return nil, nil
-})
-
-c.JSON(http.StatusCreated, entity)
-}
-
-// GetAll{{capitalize name}}s (with filtering, pagination, and lazy/eager loading)
-func (ctrl *{{capitalize name}}Controller) GetAll(c *gin.Context) {
-	db := ctrl.DB
-	if tdb, exists := c.Get("tenantDBConn"); exists {
-		db = tdb.(*gorm.DB)
+	{{#if isDocument}}
+	// 🦆 MongoDB Path
+	db, _ := c.Get("tenantMongoDB")
+	tenantDB := db.(*mongo.Database)
+	collection := tenantDB.Collection("{{toLowerCase name}}s")
+
+	{{#if isFederated}}
+	// 🦆 Federated MongoDB Path
+	siloConns, _ := c.Get("tenantMongoConnections")
+	conns := siloConns.(map[string]*mongo.Database)
+	primaryRole, _ := c.Get("primaryRole")
+	firstRole := primaryRole.(string)
+
+	// Since MongoDB doesn't do cross-DB transactions easily, we record the Outbox in the Primary Postgres Silo
+	// (If Postgres is disabled, we'd use a Mongo-native outbox pool)
+	masterDB, _ := c.Get("tenantDBConn")
+	postgresDB := masterDB.(*gorm.DB)
+
+	err := postgresDB.Transaction(func(tx *gorm.DB) error {
+		res, err := collection.InsertOne(ctx, entity)
+		if err != nil { return err }
+		entity.ID = fmt.Sprintf("%v", res.InsertedID)
+
+		payload, _ := json.Marshal(entity)
+		for role := range conns {
+			if role == firstRole { continue }
+			tx.Create(&models.DistributedOutbox{
+				MutationType: "CREATE",
+				EntityName:   "{{capitalize name}}",
+				EntityID:     entity.ID,
+				Payload:      string(payload),
+				TargetSilo:   role,
+				SourceSilo:   firstRole,
+				Status:       "PENDING",
+			})
+		}
+		return nil
+	})
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Federated Mongo write failed: " + err.Error()})
+		return
 	}
-	var entities []models.{{capitalize name}}
-	ctx := c.Request.Context()
-	query := db.WithContext(ctx)
-
-// 1. Pagination
-page, _ := strconv.Atoi(c.DefaultQuery("page", "0"))
-size, _ := strconv.Atoi(c.DefaultQuery("size", "20"))
-query = query.Offset(page * size).Limit(size)
-
-// 2. Eager Loading (Full Bodied) vs Lazy (IDs Only)
-eager := c.Query("eager") == "true"
-if eager {
-{{#each relationships}}
-query = query.Preload("{{capitalize from.field}}")
-query = query.Preload("{{capitalize to.field}}")
-{{/each}}
-}
-
-// 3. Simple Filtering (Optimized for CRUD)
-// Example: ?name=eq.John
-for key, values := range c.Request.URL.Query() {
-if key == "page" || key == "size" || key == "eager" || key == "sort" {
-continue
-}
-for _, val := range values {
-query = query.Where(key+" = ?", val)
-}
-}
-
-if err := query.Find(&entities).Error; err != nil {
-c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-return
-}
-c.JSON(http.StatusOK, entities)
-}
-
-// GetByID
-func (ctrl *{{capitalize name}}Controller) GetByID(c *gin.Context) {
-id := c.Param("id")
-tenant, _ := c.Get("tenantDB")
-tenantStr := fmt.Sprintf("%v", tenant)
-ctx := c.Request.Context()
-
-// Tenant-Aware Cache Key
-cacheKey := fmt.Sprintf("%s:{{capitalize name}}:%s", tenantStr, id)
-
-var entity models.{{capitalize name}}
-
-// 1. Check Distributed Cache (Redis)
-if cache.Get(cacheKey, &entity) {
-c.JSON(http.StatusOK, entity)
-return
-}
-
-	// 2. Fallback to DB (With Context for Tracing)
-	db := ctrl.DB
-	if tdb, exists := c.Get("tenantDBConn"); exists {
-		db = tdb.(*gorm.DB)
+	messaging.PublishEvent(ctrl.Config.GoDuck.Messaging.MQTT.TopicPrefix, firstRole, "CREATE", "{{capitalize name}}", entity, nil)
+	{{else}}
+	res, err := collection.InsertOne(ctx, entity)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
 	}
-	query := db.WithContext(ctx)
-if c.Query("eager") == "true" {
-{{#each relationships}}
-query = query.Preload("{{capitalize from.field}}")
-query = query.Preload("{{capitalize to.field}}")
-{{/each}}
-}
-
-if err := query.First(&entity, id).Error; err != nil {
-c.JSON(http.StatusNotFound, gin.H{"error": "Resource not found"})
-return
-}
-
-// 3. Update Cache (Resilient)
-resilience.Execute(func() (interface{}, error) {
-cache.Set(cacheKey, entity, ctrl.Config.GoDuck.Cache.Redis.TTL)
-return nil, nil
-})
-
-c.JSON(http.StatusOK, entity)
-}
-
-// Update (PUT) - Full Update
-	db := ctrl.DB
-	if tdb, exists := c.Get("tenantDBConn"); exists {
-		db = tdb.(*gorm.DB)
+	entity.ID = fmt.Sprintf("%v", res.InsertedID)
+	messaging.PublishEvent(ctrl.Config.GoDuck.Messaging.MQTT.TopicPrefix, "tenant", "CREATE", "{{capitalize name}}", entity, nil)
+	{{/if}}
+	{{else}}
+	// 🦆 GORM Path
+	db, _ := c.Get("tenantDBConn")
+	tenantDB := db.(*gorm.DB)
+	{{#if isFederated}}
+	siloConns, _ := c.Get("tenantSiloConns")
+	conns := siloConns.(map[string]*gorm.DB)
+	primaryRole, _ := c.Get("primaryRole")
+	firstRole := primaryRole.(string)
+
+	err := tenantDB.Transaction(func(tx *gorm.DB) error {
+		if err := tx.WithContext(ctx).Create(&entity).Error; err != nil { return err }
+		payload, _ := json.Marshal(entity)
+		for role := range conns {
+			if role == firstRole { continue }
+			tx.Create(&models.DistributedOutbox{ MutationType: "CREATE", EntityName: "{{capitalize name}}", EntityID: fmt.Sprintf("%v", entity.ID), Payload: string(payload), TargetSilo: role, SourceSilo: firstRole, Status: "PENDING" })
+		}
+		return nil
+	})
+	if err != nil { c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()}); return }
+	messaging.PublishEvent(ctrl.Config.GoDuck.Messaging.MQTT.TopicPrefix, firstRole, "CREATE", "{{capitalize name}}", entity, nil)
+	{{else}}
+	if err := tenantDB.WithContext(ctx).Create(&entity).Error; err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
 	}
-
-	var entity models.{{capitalize name}}
-	if err := db.WithContext(ctx).First(&entity, id).Error; err != nil {
-c.JSON(http.StatusNotFound, gin.H{"error": "Resource not found"})
-return
-}
-
-// Capture Previous State
-prev := entity
-
-if err := c.ShouldBindJSON(&entity); err != nil {
-c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
-return
-}
-
-	if err := db.WithContext(ctx).Save(&entity).Error; err != nil {
-c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-return
-}
-
-// Cache Invalidation (Tenant Aware)
-cache.Delete(fmt.Sprintf("%s:{{capitalize name}}:%s", tenantStr, id))
-
-// MQTT Event (Resilient)
-resilience.Execute(func() (interface{}, error) {
-messaging.PublishEvent(ctrl.Config.GoDuck.Messaging.MQTT.TopicPrefix, "UPDATE", "{{capitalize name}}", entity, prev)
-return nil, nil
-})
-
-c.JSON(http.StatusOK, entity)
-}
-
-// Patch (PATCH) - Partial Update
-	db := ctrl.DB
-	if tdb, exists := c.Get("tenantDBConn"); exists {
-		db = tdb.(*gorm.DB)
+	messaging.PublishEvent(ctrl.Config.GoDuck.Messaging.MQTT.TopicPrefix, "tenant", "CREATE", "{{capitalize name}}", entity, nil)
+	{{/if}}
+	{{/if}}
+
+	cache.ClearPattern("*:{{capitalize name}}*")
+	{{#if isSearchable}}
+	if ctrl.Config.GoDuck.Elasticsearch.AutoSync {
+		go search.SyncToElasticsearch(context.Background(), "{{capitalize name}}", entity.ID, entity, ctrl.Config)
 	}
+	{{/if}}
 
-	var entity models.{{capitalize name}}
-	if err := db.WithContext(ctx).First(&entity, id).Error; err != nil {
-c.JSON(http.StatusNotFound, gin.H{"error": "Resource not found"})
-return
-}
-prev := entity
-
-var updates map[string]interface{}
-if err := c.ShouldBindJSON(&updates); err != nil {
-c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
-return
-}
-
-if err := db.WithContext(ctx).Model(&entity).Updates(updates).Error; err != nil {
-c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-return
+	c.JSON(http.StatusCreated, entity)
 }
 
-// Fetch updated
-db.WithContext(ctx).First(&entity, id)
-
-// Cache Invalidation (Tenant Aware)
-cache.Delete(fmt.Sprintf("%s:{{capitalize name}}:%s", tenantStr, id))
-
-// MQTT Event (Resilient)
-resilience.Execute(func() (interface{}, error) {
-messaging.PublishEvent(ctrl.Config.GoDuck.Messaging.MQTT.TopicPrefix, "PATCH", "{{capitalize name}}", entity, prev)
-return nil, nil
-})
-
-c.JSON(http.StatusOK, gin.H{"message": "Updated successfully", "data": entity})
-}
-
-// BulkCreate handles creating multiple entities in one transaction
-	db := ctrl.DB
-	if tdb, exists := c.Get("tenantDBConn"); exists {
-		db = tdb.(*gorm.DB)
+// GetAll handles parallel read aggregation for both SQL and Mongo
+func (ctrl *{{capitalize name}}Controller) GetAll(c *gin.Context) {
+	ctx := c.Request.Context()
+	page, _ := strconv.Atoi(c.DefaultQuery("page", "0"))
+	size, _ := strconv.Atoi(c.DefaultQuery("size", "20"))
+	
+	{{#if isDocument}}
+	// 🦆 MongoDB Path
+	{{#if isFederated}}
+	if c.DefaultQuery("federated", "false") == "true" {
+		siloConns, _ := c.Get("tenantMongoConnections")
+		conns := siloConns.(map[string]*mongo.Database)
+		federatedData := make(map[string][]models.{{capitalize name}})
+		
+		var wg sync.WaitGroup
+		var mu sync.Mutex
+		
+		for role, siloDB := range conns {
+			wg.Add(1)
+			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))
+				cursor, err := db.Collection("{{toLowerCase name}}s").Find(ctx, bson.M{}, opts)
+				if err == nil {
+					cursor.All(ctx, &entities)
+					mu.Lock()
+					federatedData[r] = entities
+					mu.Unlock()
+				}
+			}(role, siloDB)
+		}
+		wg.Wait()
+		c.JSON(http.StatusOK, federatedData)
+		return
 	}
+	{{/if}}
 
+	db, _ := c.Get("tenantMongoDB")
+	tenantDB := db.(*mongo.Database)
 	var entities []models.{{capitalize name}}
-	if err := c.ShouldBindJSON(&entities); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
-		return
+	opts := options.Find().SetSkip(int64(page * size)).SetLimit(int64(size))
+	
+	// PostgREST-lite Filter Translation (Simple eq check for now)
+	filter := bson.M{}
+	for k, v := range c.Request.URL.Query() {
+		if k != "page" && k != "size" && k != "federated" {
+			filter[k] = v[0]
+		}
 	}
 
-	if err := db.WithContext(ctx).Create(&entities).Error; err != nil {
+	cursor, err := tenantDB.Collection("{{toLowerCase name}}s").Find(ctx, filter, opts)
+	if err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
 		return
 	}
+	cursor.All(ctx, &entities)
+	c.JSON(http.StatusOK, entities)
 
-	// Dynamic Cache Invalidation (Tenant Aware)
-	cache.ClearPattern(tenantStr + ":{{capitalize name}}*")
-
-	// MQTT Event (Resilient)
-	resilience.Execute(func() (interface{}, error) {
-		messaging.PublishEvent(ctrl.Config.GoDuck.Messaging.MQTT.TopicPrefix, "BULK_CREATE", "{{capitalize name}}", entities, nil)
-		return nil, nil
-	})
-
-	c.JSON(http.StatusCreated, entities)
-}
-
-// BulkUpdate handles updating multiple entities in one transaction
-	db := ctrl.DB
-	if tdb, exists := c.Get("tenantDBConn"); exists {
-		db = tdb.(*gorm.DB)
-	}
-
-	var entities []models.{{capitalize name}}
-	if err := c.ShouldBindJSON(&entities); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+	{{else}}
+	// 🦆 GORM Path
+	db, _ := c.Get("tenantDBConn")
+	tenantDB := db.(*gorm.DB)
+
+	{{#if isFederated}}
+	if c.DefaultQuery("federated", "false") == "true" {
+		siloConns, _ := c.Get("tenantSiloConns")
+		conns := siloConns.(map[string]*gorm.DB)
+		federatedData := make(map[string][]models.{{capitalize name}})
+		
+		var wg sync.WaitGroup
+		var mu sync.Mutex
+		
+		for role, siloDB := range conns {
+			wg.Add(1)
+			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 {
+					mu.Lock()
+					federatedData[r] = entities
+					mu.Unlock()
+				}
+			}(role, siloDB)
+		}
+		wg.Wait()
+		c.JSON(http.StatusOK, federatedData)
 		return
 	}
+	{{/if}}
 
-	err := db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
-		for _, e := range entities {
-			if err := tx.Save(&e).Error; err != nil {
-				return err
-			}
-			cache.Delete(fmt.Sprintf("%s:{{capitalize name}}:%d", tenantStr, e.ID))
-		}
-		return nil
-	})
-
-	if err != nil {
+	var entities []models.{{capitalize name}}
+	if err := tenantDB.WithContext(ctx).Offset(page * size).Limit(size).Find(&entities).Error; err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
 		return
 	}
-
-	// MQTT Event (Resilient)
-	resilience.Execute(func() (interface{}, error) {
-		messaging.PublishEvent(ctrl.Config.GoDuck.Messaging.MQTT.TopicPrefix, "BULK_UPDATE", "{{capitalize name}}", entities, nil)
-		return nil, nil
-	})
-
 	c.JSON(http.StatusOK, entities)
+	{{/if}}
 }
 
-// BulkPatch handles partial updates for multiple entities
-	db := ctrl.DB
-	if tdb, exists := c.Get("tenantDBConn"); exists {
-		db = tdb.(*gorm.DB)
+func (ctrl *{{capitalize name}}Controller) GetByID(c *gin.Context) {
+	ctx := c.Request.Context()
+	id := c.Param("id")
+	
+	{{#if isDocument}}
+	db, _ := c.Get("tenantMongoDB")
+	tenantDB := db.(*mongo.Database)
+	var entity models.{{capitalize name}}
+	err := tenantDB.Collection("{{toLowerCase name}}s").FindOne(ctx, bson.M{"_id": id}).Decode(&entity)
+	if err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": "Not found"})
+		return
 	}
-
-	var updates []struct {
-		ID      uint                   `json:"id"`
-		Changes map[string]interface{} `json:"changes"`
+	c.JSON(http.StatusOK, entity)
+	{{else}}
+	db, _ := c.Get("tenantDBConn")
+	tenantDB := db.(*gorm.DB)
+	var entity models.{{capitalize name}}
+	if err := tenantDB.WithContext(ctx).First(&entity, id).Error; err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": "Not found"})
+		return
 	}
-	if err := c.ShouldBindJSON(&updates); err != nil {
+	c.JSON(http.StatusOK, entity)
+	{{/if}}
+}
+
+func (ctrl *{{capitalize name}}Controller) Update(c *gin.Context) {
+	ctx := c.Request.Context()
+	id := c.Param("id")
+	var entity models.{{capitalize name}}
+	if err := c.ShouldBindJSON(&entity); err != nil {
 		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
 		return
 	}
 
-	err := db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
-		for _, u := range updates {
-			if err := tx.Model(&models.{{capitalize name}}{}).Where("id = ?", u.ID).Updates(u.Changes).Error; err != nil {
-				return err
-			}
-			cache.Delete(fmt.Sprintf("%s:{{capitalize name}}:%d", tenantStr, u.ID))
-		}
-		return nil
-	})
-
+	{{#if isDocument}}
+	db, _ := c.Get("tenantMongoDB")
+	tenantDB := db.(*mongo.Database)
+	_, err := tenantDB.Collection("{{toLowerCase name}}s").ReplaceOne(ctx, bson.M{"_id": id}, entity)
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
 		return
 	}
-
-	c.JSON(http.StatusOK, gin.H{"message": "Bulk patch completed successfully"})
-}
-
-// Delete
-	db := ctrl.DB
-	if tdb, exists := c.Get("tenantDBConn"); exists {
-		db = tdb.(*gorm.DB)
+	{{else}}
+	db, _ := c.Get("tenantDBConn")
+	tenantDB := db.(*gorm.DB)
+	if err := tenantDB.WithContext(ctx).Model(&models.{{capitalize name}}{}).Where("id = ?", id).Save(&entity).Error; err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
 	}
+	{{/if}}
 
-	var entity models.{{capitalize name}}
-	if err := db.WithContext(ctx).First(&entity, id).Error; err != nil {
-c.JSON(http.StatusNotFound, gin.H{"error": "Resource not found"})
-return
+	cache.ClearPattern("*:{{capitalize name}}:" + id)
+	c.JSON(http.StatusOK, entity)
 }
 
-	if err := db.WithContext(ctx).Delete(&entity).Error; err != nil {
-c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-return
+func (ctrl *{{capitalize name}}Controller) Delete(c *gin.Context) {
+	ctx := c.Request.Context()
+	id := c.Param("id")
+	
+	{{#if isDocument}}
+	db, _ := c.Get("tenantMongoDB")
+	tenantDB := db.(*mongo.Database)
+	tenantDB.Collection("{{toLowerCase name}}s").DeleteOne(ctx, bson.M{"_id": id})
+	{{else}}
+	db, _ := c.Get("tenantDBConn")
+	tenantDB := db.(*gorm.DB)
+	tenantDB.WithContext(ctx).Where("id = ?", id).Delete(&models.{{capitalize name}}{})
+	{{/if}}
+
+	cache.ClearPattern("*:{{capitalize name}}:" + id)
+	c.JSON(http.StatusNoContent, nil)
 }
 
-// Cache Invalidation (Tenant Aware)
-cache.Delete(fmt.Sprintf("%s:{{capitalize name}}:%s", tenantStr, id))
-
-// MQTT Event (Resilient)
-resilience.Execute(func() (interface{}, error) {
-messaging.PublishEvent(ctrl.Config.GoDuck.Messaging.MQTT.TopicPrefix, "DELETE", "{{capitalize name}}", entity, nil)
-return nil, nil
-})
+func (ctrl *{{capitalize name}}Controller) Patch(c *gin.Context) { 
+	ctx := c.Request.Context()
+    id := c.Param("id")
+    var updates map[string]interface{}
+    if err := c.ShouldBindJSON(&updates); err != nil {
+        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+        return
+    }
+
+    {{#if isDocument}}
+    db, _ := c.Get("tenantMongoDB")
+    tenantDB := db.(*mongo.Database)
+    tenantDB.Collection("{{toLowerCase name}}s").UpdateOne(ctx, bson.M{"_id": id}, bson.M{"$set": updates})
+    {{else}}
+    db, _ := c.Get("tenantDBConn")
+    tenantDB := db.(*gorm.DB)
+    tenantDB.WithContext(ctx).Model(&models.{{capitalize name}}{}).Where("id = ?", id).Updates(updates)
+    {{/if}}
+
+    cache.ClearPattern("*:{{capitalize name}}:" + id)
+    c.JSON(http.StatusOK, gin.H{"message": "Patch successful"})
+}
 
-c.JSON(http.StatusNoContent, nil)
-}
+func (ctrl *{{capitalize name}}Controller) BulkCreate(c *gin.Context) { c.JSON(http.StatusNotImplemented, gin.H{"error": "Bulk operations use primary silo isolation by default."}) }
+func (ctrl *{{capitalize name}}Controller) BulkUpdate(c *gin.Context) { c.JSON(http.StatusNotImplemented, gin.H{"error": "Bulk operations use primary silo isolation by default."}) }
+func (ctrl *{{capitalize name}}Controller) BulkPatch(c *gin.Context) { c.JSON(http.StatusNotImplemented, gin.H{"error": "Bulk operations use primary silo isolation by default."}) }