go-duck-cli 1.0.0

package/generators/mqtt.js

@@ -0,0 +1,87 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+
+export const generateMQTTCode = async (config, outputDir) => {
+    const messagingDir = path.join(outputDir, 'messaging');
+    await fs.ensureDir(messagingDir);
+
+    const mqttClientGo = `
+package messaging
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"time"
+
+	"{{app_name}}/config"
+	mq "github.com/eclipse/paho.mqtt.golang"
+)
+
+var MQTTClient mq.Client
+
+type EventMessage struct {
+	Action        string      \`json:"action"\`
+	Entity        string      \`json:"entity"\`
+	EventTime     time.Time   \`json:"event_time"\`
+	Payload       interface{} \`json:"payload"\`
+	PreviousValue interface{} \`json:"previous_value,omitempty"\`
+}
+
+func InitMQTT(cfg *config.Config) {
+	if !cfg.GoDuck.Messaging.MQTT.Enabled {
+		log.Println("MQTT Messaging is disabled.")
+		return
+	}
+
+	opts := mq.NewClientOptions()
+	opts.AddBroker(cfg.GoDuck.Messaging.MQTT.Broker)
+	opts.SetClientID(cfg.GoDuck.Messaging.MQTT.ClientID)
+	
+	if cfg.GoDuck.Messaging.MQTT.Username != "" {
+		opts.SetUsername(cfg.GoDuck.Messaging.MQTT.Username)
+		opts.SetPassword(cfg.GoDuck.Messaging.MQTT.Password)
+	}
+
+	opts.OnConnect = func(c mq.Client) {
+		log.Printf("Connected to MQTT Broker: %s", cfg.GoDuck.Messaging.MQTT.Broker)
+	}
+
+	client := mq.NewClient(opts)
+	if token := client.Connect(); token.Wait() && token.Error() != nil {
+		log.Printf("Failed to connect to MQTT: %v", token.Error())
+		return
+	}
+
+	MQTTClient = client
+}
+
+func PublishEvent(topicPrefix string, action string, entity string, payload interface{}, prev interface{}) {
+	if MQTTClient == nil || !MQTTClient.IsConnected() {
+		return
+	}
+
+	msg := EventMessage{
+		Action:        action,
+		Entity:        entity,
+		EventTime:     time.Now(),
+		Payload:       payload,
+		PreviousValue: prev,
+	}
+
+	data, err := json.Marshal(msg)
+	if err != nil {
+		log.Printf("Error marshaling MQTT message: %v", err)
+		return
+	}
+
+	topic := fmt.Sprintf("%s/%s/%s", topicPrefix, entity, action)
+	token := MQTTClient.Publish(topic, 0, false, data)
+	token.Wait()
+}
+`;
+
+    await fs.writeFile(path.join(messagingDir, 'mqtt.go'), mqttClientGo.replace(/{{app_name}}/g, config.name));
+    console.log(chalk.gray('  Generated MQTT Messaging Package'));
+};

package/generators/multitenancy.js

@@ -0,0 +1,130 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+
+export const generateMultitenancy = async (config, outputDir) => {
+
+	const multitenancyTemplate = `
+package middleware
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+func TenantMiddleware(db *gorm.DB) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		// 1. Get roles from JWT (previously set by JWTMiddleware)
+		userRolesInterface, exists := c.Get("UserRoles")
+		if !exists {
+			c.JSON(http.StatusUnauthorized, gin.H{"error": "No roles found in token"})
+			c.Abort()
+			return
+		}
+
+		roles, ok := userRolesInterface.([]interface{})
+		if !ok {
+			c.JSON(http.StatusUnauthorized, gin.H{"error": "Invalid roles format"})
+			c.Abort()
+			return
+		}
+
+		// 2. Lookup DB name for the roles in tenant_roles table
+		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 == "" {
+			// Fallback to default DB if no role match (optional behavior)
+			dbName = "go-duck" 
+		}
+
+		// 3. Store tenant info for downstream use
+		c.Set("tenantDB", dbName)
+		c.Next()
+	}
+}
+`;
+
+	const dbApiTemplate = `
+package management
+
+import (
+	"fmt"
+	"net/http"
+	"os/exec"
+	"{{app_name}}/config"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type DatabaseRequest struct {
+	Role   string \`json:"role" binding:"required"\`
+	DBName string \`json:"db_name" binding:"required"\`
+}
+
+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
+		}
+
+		// 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()})
+			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
+		}
+
+		// 3. Start Liquibase Migration for the new tenant
+		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
+		}
+
+		c.JSON(http.StatusOK, gin.H{"message": "Database created, role mapped, and migration completed for " + req.Role})
+	}
+}
+`;
+
+	const middlewarePath = path.join(outputDir, 'middleware/tenant_middleware.go');
+	const dbApiPath = path.join(outputDir, 'management/db_controller.go');
+
+	await fs.ensureDir(path.join(outputDir, 'middleware'));
+	await fs.ensureDir(path.join(outputDir, 'management'));
+
+	await fs.writeFile(middlewarePath, multitenancyTemplate);
+	await fs.writeFile(dbApiPath, dbApiTemplate.replace('{{app_name}}', config.name));
+
+	console.log(chalk.gray('  Generated Multitenancy Middleware & Management API'));
+};

package/generators/postgrest.js

@@ -0,0 +1,115 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+
+export const generatePostgRESTCode = async (config, outputDir) => {
+    const controllersDir = path.join(outputDir, 'controllers');
+    await fs.ensureDir(controllersDir);
+
+    const postgrestController = `
+package controllers
+
+import (
+	"fmt"
+	"net/http"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type SearchController struct {
+	DB *gorm.DB
+}
+
+// GenericSearch handles PostgREST-like queries
+// 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)
+
+	// Apply Filters
+	params := c.Request.URL.Query()
+	for key, values := range params {
+		if key == "order" || key == "limit" || key == "offset" || key == "select" {
+			continue
+		}
+
+		for _, val := range values {
+			parts := strings.SplitN(val, ".", 2)
+			if len(parts) < 2 {
+				// Default to equality
+				query = query.Where(fmt.Sprintf("%s = ?", key), val)
+				continue
+			}
+
+			op := parts[0]
+			target := parts[1]
+
+			switch op {
+			case "eq":
+				query = query.Where(fmt.Sprintf("%s = ?", key), target)
+			case "neq":
+				query = query.Where(fmt.Sprintf("%s <> ?", key), target)
+			case "gt":
+				query = query.Where(fmt.Sprintf("%s > ?", key), target)
+			case "gte":
+				query = query.Where(fmt.Sprintf("%s >= ?", key), target)
+			case "lt":
+				query = query.Where(fmt.Sprintf("%s < ?", key), target)
+			case "lte":
+				query = query.Where(fmt.Sprintf("%s <= ?", key), target)
+			case "like":
+				query = query.Where(fmt.Sprintf("%s LIKE ?", key), "%"+target+"%")
+			case "ilike":
+				query = query.Where(fmt.Sprintf("%s ILIKE ?", key), "%"+target+"%")
+			case "in":
+				list := strings.Split(target, ",")
+				query = query.Where(fmt.Sprintf("%s IN ?", key), list)
+			}
+		}
+	}
+
+	// Apply Sorting
+	if order := c.Query("order"); order != "" {
+		parts := strings.SplitN(order, ".", 2)
+		field := parts[0]
+		direction := "asc"
+		if len(parts) > 1 {
+			direction = parts[1]
+		}
+		query = query.Order(fmt.Sprintf("%s %s", field, direction))
+	}
+
+	// Apply Pagination
+	if limit := c.Query("limit"); limit != "" {
+		query = query.Limit(parseInt(limit, 10))
+	} else {
+		query = query.Limit(100) // Default limit
+	}
+
+	if offset := c.Query("offset"); offset != "" {
+		query = query.Offset(parseInt(offset, 0))
+	}
+
+	var results []map[string]interface{}
+	if err := query.Find(&results).Error; err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Search failed: " + err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, results)
+}
+
+func parseInt(s string, def int) int {
+	var val int
+	if _, err := fmt.Sscanf(s, "%d", &val); err != nil {
+		return def
+	}
+	return val
+}
+`;
+
+    await fs.writeFile(path.join(controllersDir, 'search_controller.go'), postgrestController);
+    console.log(chalk.gray('  Generated PostgREST-like Search Controller'));
+};

package/generators/repository.js

@@ -0,0 +1,28 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+
+export const generateRepositoryCode = async (outputDir) => {
+    const repoDir = path.join(outputDir, 'internal', 'repository');
+    await fs.ensureDir(repoDir);
+
+    const repoGo = `package repository
+
+import (
+	"gorm.io/gorm"
+)
+
+type Repository struct {
+	DB *gorm.DB
+}
+
+func NewRepository(db *gorm.DB) *Repository {
+	return &Repository{
+		DB: db,
+	}
+}
+`;
+
+    await fs.writeFile(path.join(repoDir, 'repository.go'), repoGo);
+    console.log(chalk.gray('  Generated Internal Repository Layer'));
+};

package/generators/resilience.js

@@ -0,0 +1,69 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+
+export const generateResilienceCode = async (config, outputDir) => {
+    const resilienceDir = path.join(outputDir, 'resilience');
+    await fs.ensureDir(resilienceDir);
+
+    const circuitBreakerGo = `
+package resilience
+
+import (
+	"fmt"
+	"log"
+	"time"
+
+	"{{app_name}}/config"
+	"github.com/sony/gobreaker"
+)
+
+var (
+	CB *gobreaker.CircuitBreaker
+)
+
+// InitResilience initializes circuit breaker settings
+func InitResilience(cfg *config.Config) {
+	if !cfg.GoDuck.Resilience.CircuitBreaker.Enabled {
+		log.Println("Circuit Breaker is disabled.")
+		return
+	}
+
+	st := gobreaker.Settings{
+		Name:        "Global Breaker",
+		Interval:    time.Minute,
+		Timeout:     cfg.GoDuck.Resilience.CircuitBreaker.Timeout,
+		MaxRequests: cfg.GoDuck.Resilience.CircuitBreaker.SuccessThreshold,
+		ReadyToTrip: func(counts gobreaker.Counts) bool {
+			return counts.ConsecutiveFailures >= cfg.GoDuck.Resilience.CircuitBreaker.FailureThreshold
+		},
+		OnStateChange: func(name string, from gobreaker.State, to gobreaker.State) {
+			log.Printf("Circuit Breaker %s: State Changed from %s to %s", name, from.String(), to.String())
+		},
+	}
+
+	CB = gobreaker.NewCircuitBreaker(st)
+	log.Println("Circuit Breaker initialized.")
+}
+
+// Execute wraps any function call in a circuit breaker
+func Execute(f func() (interface{}, error)) (interface{}, error) {
+	if CB == nil {
+		return f()
+	}
+
+	result, err := CB.Execute(f)
+	if err != nil {
+		if err == gobreaker.ErrOpenState {
+			return nil, fmt.Errorf("circuit breaker is OPEN")
+		}
+		return nil, err
+	}
+
+	return result, nil
+}
+`;
+
+    await fs.writeFile(path.join(resilienceDir, 'circuit_breaker.go'), circuitBreakerGo.replace(/{{app_name}}/g, config.name));
+    console.log(chalk.gray('  Generated Circuit Breaker Resilience Package'));
+};

package/generators/security.js

@@ -0,0 +1,168 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+
+export const generateSecurityMiddleware = async (config, outputDir) => {
+	const middlewareDir = path.join(outputDir, 'middleware');
+	await fs.ensureDir(middlewareDir);
+
+	const jwtMiddleware = `
+package middleware
+
+import (
+	"net/http"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+	"github.com/golang-jwt/jwt/v4"
+)
+
+// JWTMiddleware validates Keycloak JWTs
+func JWTMiddleware() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		authHeader := c.GetHeader("Authorization")
+		if authHeader == "" {
+			c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "Authorization header required"})
+			return
+		}
+
+		parts := strings.Split(authHeader, " ")
+		if len(parts) != 2 || parts[0] != "Bearer" {
+			c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "Invalid token format"})
+			return
+		}
+
+		tokenString := parts[1]
+		
+		token, _, err := new(jwt.Parser).ParseUnverified(tokenString, jwt.MapClaims{})
+		if err != nil {
+			c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "Could not parse token"})
+			return
+		}
+
+		if claims, ok := token.Claims.(jwt.MapClaims); ok {
+			c.Set("KeycloakID", claims["sub"])
+			c.Set("UserEmail", claims["email"])
+			if ra, ok := claims["realm_access"].(map[string]interface{}); ok {
+				c.Set("UserRoles", ra["roles"])
+			}
+		}
+
+		c.Next()
+	}
+}
+
+func GetUserID(c *gin.Context) string {
+	val, _ := c.Get("KeycloakID")
+	if str, ok := val.(string); ok {
+		return str
+	}
+	return "anonymous"
+}
+`;
+
+	const rateLimitMiddleware = `
+package middleware
+
+import (
+	"net/http"
+	"sync"
+	"{{app_name}}/config"
+
+	"github.com/gin-gonic/gin"
+	"golang.org/x/time/rate"
+)
+
+var (
+	limiters = make(map[string]*rate.Limiter)
+	mu       sync.Mutex
+)
+
+// RateLimitMiddleware provides burst protection based on configuration
+func RateLimitMiddleware(cfg *config.Config) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		ip := c.ClientIP()
+		
+		mu.Lock()
+		limiter, exists := limiters[ip]
+		if !exists {
+			rps := cfg.GoDuck.Security.RateLimit.RPS
+			burst := cfg.GoDuck.Security.RateLimit.Burst
+			limiter = rate.NewLimiter(rate.Limit(rps), burst)
+			limiters[ip] = limiter
+		}
+		mu.Unlock()
+
+		if !limiter.Allow() {
+			c.AbortWithStatusJSON(http.StatusTooManyRequests, gin.H{
+				"error": "Rate limit exceeded. Please try again later.",
+			})
+			return
+		}
+		c.Next()
+	}
+}
+`;
+
+	await fs.writeFile(path.join(middlewareDir, 'jwt_middleware.go'), jwtMiddleware);
+	await fs.writeFile(path.join(middlewareDir, 'rate_limit_middleware.go'), rateLimitMiddleware.replace('{{app_name}}', config.name));
+
+	const corsMiddleware = `
+package middleware
+
+import (
+	"{{app_name}}/config"
+	"github.com/gin-gonic/gin"
+)
+
+func CORSMiddleware(cfg *config.Config) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		origins := cfg.GoDuck.Server.CORS.AllowOrigins
+		methods := cfg.GoDuck.Server.CORS.AllowMethods
+		headers := cfg.GoDuck.Server.CORS.AllowHeaders
+
+		origin := c.Request.Header.Get("Origin")
+		allowOrigin := ""
+		for _, o := range origins {
+			if o == "*" || o == origin {
+				allowOrigin = origin
+				if o == "*" {
+					allowOrigin = "*"
+				}
+				break
+			}
+		}
+
+		if allowOrigin != "" {
+			c.Writer.Header().Set("Access-Control-Allow-Origin", allowOrigin)
+		}
+		
+		c.Writer.Header().Set("Access-Control-Allow-Credentials", "true")
+		
+		headerString := ""
+		for i, h := range headers {
+			if i > 0 { headerString += ", " }
+			headerString += h
+		}
+		c.Writer.Header().Set("Access-Control-Allow-Headers", headerString)
+
+		methodString := ""
+		for i, m := range methods {
+			if i > 0 { methodString += ", " }
+			methodString += m
+		}
+		c.Writer.Header().Set("Access-Control-Allow-Methods", methodString)
+
+		if c.Request.Method == "OPTIONS" {
+			c.AbortWithStatus(204)
+			return
+		}
+
+		c.Next()
+	}
+}
+`;
+
+	await fs.writeFile(path.join(middlewareDir, 'cors_middleware.go'), corsMiddleware.replace('{{app_name}}', config.name));
+	console.log(chalk.gray('  Generated Advanced Security & CORS Middleware'));
+};