go-duck-cli 1.0.8 → 1.1.1

package/generators/metering.js

@@ -19,63 +19,228 @@ import (
 )
 
 type APIUsage struct {
-	ID          uint      \`gorm:"primaryKey" json:"id"\`
-	UserID      string    \`json:"userId" gorm:"index:idx_user_api,unique"\`
-	APIPath     string    \`json:"apiPath" gorm:"index:idx_user_api,unique"\`
-	UsageCount  int64     \`json:"usageCount"\`
-	MaxLimit    int64     \`json:"maxLimit" gorm:"default:1000"\`
+	ID           uint      \`gorm:"primaryKey" json:"id"\`
+	TargetType   string    \`json:"targetType" gorm:"index:idx_target_api,unique"\` // "user" or "role"
+	TargetID     string    \`json:"targetId" gorm:"index:idx_target_api,unique"\` // KeycloakID or Role Name
+	APIPath      string    \`json:"apiPath" gorm:"index:idx_target_api,unique"\`
+	TenantDB     string    \`json:"tenantDb" gorm:"index:idx_target_api,unique"\`
+	UsageCount   int64     \`json:"usageCount"\`
+	MaxLimit     int64     \`json:"maxLimit" gorm:"default:1000"\`
+	DurationDays int       \`json:"durationDays" gorm:"default:30"\` // Duration in Days
+	AutoReset    bool      \`json:"autoReset" gorm:"default:true"\` // Lock them until they pay if false!
+	WindowStart  time.Time \`json:"windowStart"\` // When did the current quota period start?
 	LastAccessed time.Time \`json:"lastAccessed"\`
 }
+
+type APIUsageHistory struct {
+	ID           uint      \`gorm:"primaryKey" json:"id"\`
+	TargetType   string    \`json:"targetType" gorm:"index:idx_hist_target_api"\`
+	TargetID     string    \`json:"targetId" gorm:"index:idx_hist_target_api"\`
+	APIPath      string    \`json:"apiPath" gorm:"index:idx_hist_target_api"\`
+	TenantDB     string    \`json:"tenantDb" gorm:"index:idx_hist_target_api"\`
+	FinalUsage   int64     \`json:"finalUsage"\`
+	MaxLimit     int64     \`json:"maxLimit"\`
+	DurationDays int       \`json:"durationDays"\`
+	WindowStart  time.Time \`json:"windowStart"\`
+	WindowEnd    time.Time \`json:"windowEnd"\`
+}
 `;
 
     const meteringMiddleware = `
 package middleware
 
 import (
+	"context"
+	"fmt"
 	"net/http"
+	"strconv"
+	"strings"
 	"time"
 
 	"github.com/gin-gonic/gin"
 	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"{{app_name}}/cache"
 	"{{app_name}}/models"
 )
 
+var meterCtx = context.Background()
+
 func MeteringMiddleware(db *gorm.DB) gin.HandlerFunc {
 	return func(c *gin.Context) {
-		userID := c.GetHeader("X-Keycloak-Id")
-		if userID == "" {
+		keycloakId, exists := c.Get("KeycloakID")
+		if !exists {
 			c.Next()
 			return
 		}
+		userID := keycloakId.(string)
 
+		rolesList := []string{}
+		if roles, exists := c.Get("UserRoles"); exists {
+			for _, r := range roles.([]interface{}) {
+				rolesList = append(rolesList, r.(string))
+			}
+		}
+
+		tenant, _ := c.Get("tenantDB")
+		tenantStr := fmt.Sprintf("%v", tenant)
 		path := c.Request.URL.Path
-		var usage models.APIUsage
-
-		// Get usage and limit
-		result := db.Where("user_id = ? AND api_path = ?", userID, path).First(&usage)
-		if result.Error == gorm.ErrRecordNotFound {
-			usage = models.APIUsage{
-				UserID:     userID,
-				APIPath:    path,
-				UsageCount: 1,
-				MaxLimit:   1000, // Default limit
-				LastAccessed: time.Now(),
+
+		if cache.RedisClient != nil {
+			var targetType, targetID, limitStr string
+			
+			// 1. Try Specific User Limit
+			userLimitKey := fmt.Sprintf("metering_limit:user:%s:%s:%s", userID, tenantStr, path)
+			limitStr, _ = cache.RedisClient.Get(meterCtx, userLimitKey).Result()
+			if limitStr != "" {
+				targetType = "user"
+				targetID = userID
 			}
-			db.Create(&usage)
-		} else {
-			if usage.UsageCount >= usage.MaxLimit {
-				c.JSON(http.StatusTooManyRequests, gin.H{
-					"error": "Usage limit exceeded",
-					"limit": usage.MaxLimit,
-					"usage": usage.UsageCount,
+
+			// 2. Try Role Limit (First match wins)
+			if targetType == "" {
+				for _, role := range rolesList {
+					roleLimitKey := fmt.Sprintf("metering_limit:role:%s:%s:%s", role, tenantStr, path)
+					limitStr, _ = cache.RedisClient.Get(meterCtx, roleLimitKey).Result()
+					if limitStr != "" {
+						targetType = "role"
+						targetID = role
+						break
+					}
+				}
+			}
+
+			restoredActiveWindow := false
+			
+			// 3. Fallback: Parse from Database
+			if db != nil && targetType == "" {
+				var usage models.APIUsage
+				result := db.Where("target_type = 'user' AND target_id = ? AND api_path = ? AND tenant_db = ?", userID, path, tenantStr).First(&usage)
+				if result.Error == nil {
+					targetType = "user"
+					targetID = userID
+				} else {
+					for _, role := range rolesList {
+						result = db.Where("target_type = 'role' AND target_id = ? AND api_path = ? AND tenant_db = ?", role, path, tenantStr).First(&usage)
+						if result.Error == nil {
+							targetType = "role"
+							targetID = role
+							break
+						}
+					}
+				}
+
+				if targetType != "" {
+					autoResetStr := "true"
+					if !usage.AutoReset {
+						autoResetStr = "false"
+					}
+					limitStr = fmt.Sprintf("%d:%d:%s", usage.MaxLimit, usage.DurationDays, autoResetStr)
+					cache.RedisClient.Set(meterCtx, fmt.Sprintf("metering_limit:%s:%s:%s:%s", targetType, targetID, tenantStr, path), limitStr, 0)
+
+					// Safely Restore Usage from DB considering AutoReset
+					duration := time.Duration(usage.DurationDays) * 24 * time.Hour
+					usageKey := fmt.Sprintf("metering_usage:%s:%s:%s:%s", targetType, targetID, tenantStr, path)
+
+					// Only restore if AutoReset is disabled OR the Window is still mathematically Active!
+					if !usage.AutoReset || usage.DurationDays <= 0 || !time.Now().After(usage.WindowStart.Add(duration)) {
+						restoredActiveWindow = true
+						if usage.AutoReset && usage.DurationDays > 0 {
+							remainingTTL := time.Until(usage.WindowStart.Add(duration))
+							cache.RedisClient.Set(meterCtx, usageKey, usage.UsageCount, remainingTTL)
+						} else {
+							cache.RedisClient.Set(meterCtx, usageKey, usage.UsageCount, 0) // No Expiry (Locked!)
+						}
+					}
+				}
+			}
+
+			// 4. Default Limits (Per User, 1000 requests per 30 Days, Auto Resets)
+			if targetType == "" {
+				targetType = "user"
+				targetID = userID
+				limitStr = "1000:30:true"
+				cache.RedisClient.Set(meterCtx, userLimitKey, limitStr, 0)
+			}
+
+			parts := strings.Split(limitStr, ":")
+			maxLimit, _ := strconv.ParseInt(parts[0], 10, 64)
+			durationDays, _ := strconv.Atoi(parts[1])
+			autoReset := parts[2] == "true"
+
+			usageKey := fmt.Sprintf("metering_usage:%s:%s:%s:%s", targetType, targetID, tenantStr, path)
+			currentUsage, _ := cache.RedisClient.Incr(meterCtx, usageKey).Result()
+
+			var windowStart time.Time
+
+			// Explicit Window tracking for absolute fresh usages in Redis
+			isNewWindow := currentUsage == 1 && !restoredActiveWindow
+			if isNewWindow {
+				windowStart = time.Now()
+				// Only set TTL if AutoReset is enabled!
+				if autoReset && durationDays > 0 {
+					cache.RedisClient.Expire(meterCtx, usageKey, time.Duration(durationDays)*24*time.Hour)
+				}
+			}
+
+			if currentUsage > maxLimit {
+				c.JSON(http.StatusPaymentRequired, gin.H{
+					"error":       fmt.Sprintf("SaaS Quota Exceeded for %s", targetType),
+					"target":      targetID,
+					"limit":       maxLimit,
+					"auto_reset":  autoReset,
+					"current_use": currentUsage,
 				})
 				c.Abort()
 				return
 			}
-			db.Model(&usage).Updates(map[string]interface{}{
-				"usage_count":   usage.UsageCount + 1,
-				"last_accessed": time.Now(),
-			})
+
+			if db != nil {
+				go func(tt string, tid string, p string, t string, count int64, lim int64, dur int, ar bool, isNew bool, ws time.Time) {
+					if count%10 == 0 || isNew {
+						if isNew {
+							var old models.APIUsage
+							res := db.Where("target_type = ? AND target_id = ? AND api_path = ? AND tenant_db = ?", tt, tid, p, t).First(&old)
+							if res.Error == nil && old.UsageCount > 0 {
+								db.Create(&models.APIUsageHistory{
+									TargetType:   tt,
+									TargetID:     tid,
+									APIPath:      p,
+									TenantDB:     t,
+									FinalUsage:   old.UsageCount,
+									MaxLimit:     old.MaxLimit,
+									DurationDays: old.DurationDays,
+									WindowStart:  old.WindowStart,
+									WindowEnd:    time.Now(),
+								})
+							}
+						}
+
+						updateCols := []string{"usage_count", "last_accessed"}
+						if isNew {
+							updateCols = append(updateCols, "window_start")
+						}
+						db.Clauses(clause.OnConflict{
+							Columns:   []clause.Column{{Name: "target_type"}, {Name: "target_id"}, {Name: "api_path"}, {Name: "tenant_db"}},
+							DoUpdates: clause.AssignmentColumns(updateCols),
+						}).Create(&models.APIUsage{
+							TargetType:   tt,
+							TargetID:     tid,
+							APIPath:      p,
+							TenantDB:     t,
+							UsageCount:   count,
+							MaxLimit:     lim,
+							DurationDays: dur,
+							AutoReset:    ar,
+							WindowStart:  ws,
+							LastAccessed: time.Now(),
+						})
+					}
+				}(targetType, targetID, path, tenantStr, currentUsage, maxLimit, durationDays, autoReset, isNewWindow, windowStart)
+			}
+
+			c.Next()
+			return
 		}
 
 		c.Next()
@@ -83,15 +248,21 @@ func MeteringMiddleware(db *gorm.DB) gin.HandlerFunc {
 }
 `;
 
-    const meteringController = `
+    	const meteringController = `
 package controllers
 
 import (
+	"context"
+	"fmt"
 	"net/http"
+	"time"
+	
+	"{{app_name}}/cache"
 	"{{app_name}}/models"
 
 	"github.com/gin-gonic/gin"
 	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
 )
 
 type MeteringController struct {
@@ -99,10 +270,18 @@ type MeteringController struct {
 }
 
 func (mc *MeteringController) SetLimit(c *gin.Context) {
+	if mc.DB == nil {
+		c.JSON(http.StatusServiceUnavailable, gin.H{"error": "Infrastructure DB not initialized. SaaS Metering persistence requires a SQL database."})
+		return
+	}
 	var req struct {
-		UserID   string \`json:"userId" binding:"required"\`
-		APIPath  string \`json:"apiPath" binding:"required"\`
-		MaxLimit int64  \`json:"maxLimit" binding:"required"\`
+		TargetType   string \`json:"targetType" binding:"required"\` // "user" or "role"
+		TargetID     string \`json:"targetId" binding:"required"\`   // The UUID or the Realm Role
+		APIPath      string \`json:"apiPath" binding:"required"\`
+		TenantDB     string \`json:"tenantDb" binding:"required"\`
+		MaxLimit     int64  \`json:"maxLimit" binding:"required"\`
+		DurationDays int    \`json:"durationDays" binding:"required"\` // Duration Reset
+		AutoReset    *bool  \`json:"autoReset" binding:"required"\`  // Paywall Lock!
 	}
 
 	if err := c.ShouldBindJSON(&req); err != nil {
@@ -110,34 +289,87 @@ func (mc *MeteringController) SetLimit(c *gin.Context) {
 		return
 	}
 
-	var usage models.APIUsage
-	result := mc.DB.Where("user_id = ? AND api_path = ?", req.UserID, req.APIPath).First(&usage)
-	
-	if result.Error == gorm.ErrRecordNotFound {
-		usage = models.APIUsage{
-			UserID:     req.UserID,
-			APIPath:    req.APIPath,
-			MaxLimit:   req.MaxLimit,
-			UsageCount: 0,
+	if req.TargetType != "user" && req.TargetType != "role" {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "targetType must be 'user' or 'role'"})
+		return
+	}
+
+	var old models.APIUsage
+	res := mc.DB.Where("target_type = ? AND target_id = ? AND api_path = ? AND tenant_db = ?", req.TargetType, req.TargetID, req.APIPath, req.TenantDB).First(&old)
+	if res.Error == nil {
+		mc.DB.Create(&models.APIUsageHistory{
+			TargetType:   old.TargetType,
+			TargetID:     old.TargetID,
+			APIPath:      old.APIPath,
+			TenantDB:     old.TenantDB,
+			FinalUsage:   old.UsageCount,
+			MaxLimit:     old.MaxLimit,
+			DurationDays: old.DurationDays,
+			WindowStart:  old.WindowStart,
+			WindowEnd:    time.Now(),
+		})
+	}
+
+	mc.DB.Clauses(clause.OnConflict{
+		Columns:   []clause.Column{{Name: "target_type"}, {Name: "target_id"}, {Name: "api_path"}, {Name: "tenant_db"}},
+		DoUpdates: clause.AssignmentColumns([]string{"max_limit", "duration_days", "auto_reset", "usage_count", "window_start"}),
+	}).Create(&models.APIUsage{
+		TargetType:   req.TargetType,
+		TargetID:     req.TargetID,
+		APIPath:      req.APIPath,
+		TenantDB:     req.TenantDB,
+		MaxLimit:     req.MaxLimit,
+		DurationDays: req.DurationDays,
+		AutoReset:    *req.AutoReset,
+		UsageCount:   0,
+		WindowStart:  time.Now(), // Reset the usage window explicit start date!
+	})
+
+	if cache.RedisClient != nil {
+		autoResetStr := "true"
+		if !*req.AutoReset {
+			autoResetStr = "false"
 		}
-		mc.DB.Create(&usage)
-	} else {
-		mc.DB.Model(&usage).Update("max_limit", req.MaxLimit)
+
+		limitKey := fmt.Sprintf("metering_limit:%s:%s:%s:%s", req.TargetType, req.TargetID, req.TenantDB, req.APIPath)
+		usageKey := fmt.Sprintf("metering_usage:%s:%s:%s:%s", req.TargetType, req.TargetID, req.TenantDB, req.APIPath)
+		cache.RedisClient.Set(context.Background(), limitKey, fmt.Sprintf("%d:%d:%s", req.MaxLimit, req.DurationDays, autoResetStr), 0)
+		cache.RedisClient.Del(context.Background(), usageKey)
 	}
 
-	c.JSON(http.StatusOK, gin.H{"message": "Limit updated successfully"})
+	c.JSON(http.StatusOK, gin.H{"message": "Quota, Duration & Paywall Lock updated globally."})
 }
 
 func (mc *MeteringController) GetUsage(c *gin.Context) {
+	if mc.DB == nil {
+		c.JSON(http.StatusServiceUnavailable, gin.H{"error": "Infrastructure DB not initialized."})
+		return
+	}
 	var usages []models.APIUsage
 	mc.DB.Find(&usages)
 	c.JSON(http.StatusOK, usages)
 }
+
+func (mc *MeteringController) GetHistory(c *gin.Context) {
+	if mc.DB == nil {
+		c.JSON(http.StatusServiceUnavailable, gin.H{"error": "Infrastructure DB not initialized."})
+		return
+	}
+	targetID := c.Query("targetId")
+	if targetID == "" {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "targetId query parameter is required"})
+		return
+	}
+
+	var history []models.APIUsageHistory
+	mc.DB.Where("target_id = ?", targetID).Order("window_end desc").Find(&history)
+	c.JSON(http.StatusOK, history)
+}
 `;
 
     await fs.writeFile(path.join(modelsDir, 'api_usage.go'), meteringModel);
-    await fs.writeFile(path.join(middlewareDir, 'metering_middleware.go'), meteringMiddleware.replace('{{app_name}}', config.name));
-    await fs.writeFile(path.join(controllersDir, 'metering_controller.go'), meteringController.replace('{{app_name}}', config.name));
+    await fs.writeFile(path.join(middlewareDir, 'metering_middleware.go'), meteringMiddleware.replace(/{{app_name}}/g, config.name));
+    await fs.writeFile(path.join(controllersDir, 'metering_controller.go'), meteringController.replace(/{{app_name}}/g, config.name));
 
     console.log(chalk.gray('  Generated Metering Model, Middleware & Controller'));
 };