go-duck-cli 1.0.8 → 1.1.1

package/generators/postman.js

@@ -0,0 +1,405 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+
+export const generatePostmanCollection = async (config, entities, outputDir, openEntities = []) => {
+    const docsDir = path.join(outputDir, 'docs');
+    await fs.ensureDir(docsDir);
+
+    const collection = {
+        info: {
+            name: `${config.name} Complete Postman API Suite`,
+            description: `Auto-generated comprehensive testing suite for all REST, GraphQL, WebSocket, RPC, and Management APIs of the ${config.name} microservice.`,
+            schema: "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
+        },
+        item: [],
+        variable: [
+            { key: "host", value: "localhost", type: "string" },
+            { key: "port", value: "8080", type: "string" },
+            { key: "tenant", value: "tenant_1", type: "string" },
+            { key: "token", value: "", type: "string" },
+            { key: "keycloak_url", value: "http://localhost:8180", type: "string" },
+            { key: "realm", value: config.security?.['keycloak-realm'] || 'master', type: "string" },
+            { key: "app_client_id", value: `${config.name}-app`, type: "string" },
+            { key: "service_client_id", value: `${config.name}-service`, type: "string" },
+            { key: "service_secret", value: "service-secret-123", type: "string" },
+            { key: "username", value: "admin", type: "string" },
+            { key: "password", value: "admin", type: "string" }
+        ]
+    };
+
+    // 1. Auth Folder
+    collection.item.push({
+        name: "1. Authentication (Zero-Trust)",
+        description: "Fetch OIDC Tokens from Keycloak",
+        item: [
+            {
+                name: "1. Public App Login (User Login)",
+                event: [
+                    {
+                        listen: "test",
+                        script: {
+                            exec: [
+                                "var jsonData = pm.response.json();",
+                                "if (jsonData.access_token) {",
+                                "    pm.collectionVariables.set(\"token\", jsonData.access_token);",
+                                "}"
+                            ],
+                            type: "text/javascript"
+                        }
+                    }
+                ],
+                request: {
+                    method: "POST",
+                    header: [{ key: "Content-Type", value: "application/x-www-form-urlencoded" }],
+                    body: {
+                        mode: "urlencoded",
+                        urlencoded: [
+                            { key: "client_id", value: "{{app_client_id}}", type: "text" },
+                            { key: "username", value: "{{username}}", type: "text" },
+                            { key: "password", value: "{{password}}", type: "text" },
+                            { key: "grant_type", value: "password", type: "text" }
+                        ]
+                    },
+                    url: {
+                        raw: "{{keycloak_url}}/realms/{{realm}}/protocol/openid-connect/token",
+                        host: ["{{keycloak_url}}"],
+                        path: ["realms", "{{realm}}", "protocol", "openid-connect", "token"]
+                    }
+                }
+            },
+            {
+                name: "2. Confidential Service Login (Service Account)",
+                event: [
+                    {
+                        listen: "test",
+                        script: {
+                            exec: [
+                                "var jsonData = pm.response.json();",
+                                "if (jsonData.access_token) {",
+                                "    pm.collectionVariables.set(\"token\", jsonData.access_token);",
+                                "}"
+                            ],
+                            type: "text/javascript"
+                        }
+                    }
+                ],
+                request: {
+                    method: "POST",
+                    header: [{ key: "Content-Type", value: "application/x-www-form-urlencoded" }],
+                    body: {
+                        mode: "urlencoded",
+                        urlencoded: [
+                            { key: "client_id", value: "{{service_client_id}}", type: "text" },
+                            { key: "client_secret", value: "{{service_secret}}", type: "text" },
+                            { key: "grant_type", value: "client_credentials", type: "text" }
+                        ]
+                    },
+                    url: {
+                        raw: "{{keycloak_url}}/realms/{{realm}}/protocol/openid-connect/token",
+                        host: ["{{keycloak_url}}"],
+                        path: ["realms", "{{realm}}", "protocol", "openid-connect", "token"]
+                    }
+                }
+            }
+        ]
+    });
+
+    // 2. Management & Zero-Trust
+    collection.item.push({
+        name: "2. Architecture Management Metrics",
+        item: [
+            {
+                name: "1. Provision & Assign Tenant DB",
+                request: {
+                    method: "POST",
+                    header: [
+                        { key: "Authorization", value: "Bearer {{token}}" },
+                        { key: "X-Tenant-ID", value: "master_internal" },
+                        { key: "Content-Type", value: "application/json" }
+                    ],
+                    body: {
+                        mode: "raw",
+                        raw: "{\n  \"roleName\": \"tenant_1_admin\",\n  \"dbName\": \"tenant_1\"\n}"
+                    },
+                    url: {
+                        raw: "http://{{host}}:{{port}}/management/tenant/assign",
+                        protocol: "http",
+                        host: ["{{host}}"],
+                        port: "{{port}}",
+                        path: ["management", "tenant", "assign"]
+                    }
+                }
+            },
+            {
+                name: "2. Fetch Central Audit Logs",
+                request: {
+                    method: "GET",
+                    header: [
+                        { key: "Authorization", value: "Bearer {{token}}" },
+                        { key: "X-Tenant-ID", value: "{{tenant}}" }
+                    ],
+                    url: {
+                        raw: "http://{{host}}:{{port}}/api/audit",
+                        protocol: "http",
+                        host: ["{{host}}"],
+                        port: "{{port}}",
+                        path: ["api", "audit"]
+                    }
+                }
+            },
+            {
+                name: "3. Monitor API Quotas",
+                request: {
+                    method: "GET",
+                    header: [
+                        { key: "Authorization", value: "Bearer {{token}}" },
+                        { key: "X-Tenant-ID", value: "{{tenant}}" }
+                    ],
+                    url: {
+                        raw: "http://{{host}}:{{port}}/api/metering/usage",
+                        protocol: "http",
+                        host: ["{{host}}"],
+                        port: "{{port}}",
+                        path: ["api", "metering", "usage"]
+                    }
+                }
+            }
+        ]
+    });
+
+    // 3. GraphQL
+    collection.item.push({
+        name: "3. GraphQL Federation Layer",
+        item: [
+            {
+                name: "1. Unified GraphQL Engine",
+                request: {
+                    method: "POST",
+                    header: [
+                        { key: "Authorization", value: "Bearer {{token}}" },
+                        { key: "X-Tenant-ID", value: "{{tenant}}" },
+                        { key: "Content-Type", value: "application/json" }
+                    ],
+                    body: {
+                        mode: "graphql",
+                        graphql: {
+                            query: `query {\n  ${entities.length > 0 ? 'list' + entities[0].name.charAt(0).toUpperCase() + entities[0].name.slice(1) + 's' : 'test'} {\n    id\n  }\n}`,
+                            variables: ""
+                        }
+                    },
+                    url: {
+                        raw: "http://{{host}}:{{port}}/graphql",
+                        protocol: "http",
+                        host: ["{{host}}"],
+                        port: "{{port}}",
+                        path: ["graphql"]
+                    }
+                }
+            }
+        ]
+    });
+
+    // 4. REST Entities
+    const restFolder = { name: "4. Standard REST & Deep Search", item: [] };
+    
+    const generateDummyJson = (fields) => {
+        const obj = {};
+        for (const f of fields) {
+            if (f.type === 'String' || f.type === 'Text') obj[f.name] = "Sample " + f.name;
+            else if (f.type === 'Integer' || f.type === 'Long') obj[f.name] = 100;
+            else if (f.type === 'Float' || f.type === 'BigDecimal') obj[f.name] = 99.99;
+            else if (f.type === 'Boolean') obj[f.name] = true;
+            else if (f.type === 'LocalDate') obj[f.name] = "2024-01-01";
+            else if (f.type === 'Instant') obj[f.name] = "2024-01-01T12:00:00Z";
+            else if (f.type === 'JSON' || f.type === 'JSONB') obj[f.name] = {"attribute": "example_value"};
+            else obj[f.name] = "test";
+        }
+        return JSON.stringify(obj, null, 2);
+    };
+
+    const isOpen = (entityName, action) => {
+        if (!openEntities || !Array.isArray(openEntities)) return false;
+        const wildcard = openEntities.find(e => e.name === '*');
+        if (wildcard && wildcard.actions.includes(action.toLowerCase())) return true;
+        const entry = openEntities.find(e => e.name.toLowerCase() === entityName.toLowerCase());
+        if (entry && entry.actions.includes(action.toLowerCase())) return true;
+        return false;
+    };
+
+    for (const entity of entities) {
+        const name = entity.name.toLowerCase();
+        const capitalized = entity.name.charAt(0).toUpperCase() + entity.name.slice(1);
+        const folder = { name: `${capitalized} APIs`, item: [] };
+
+        // 1. PUBLIC API Folder (If Open)
+        const publicItems = [];
+        if (isOpen(capitalized, 'read')) {
+            publicItems.push({
+                name: `[PUBLIC] List ${capitalized}s`,
+                request: {
+                    method: "GET",
+                    header: [ { key: "X-Tenant-ID", value: "{{tenant}}" } ],
+                    url: { raw: `http://{{host}}:{{port}}/open/api/${name}s?page=1&size=10&eager=true`, protocol: "http", host: ["{{host}}"], port: "{{port}}", path: ["open", "api", `${name}s`], query: [ { key: "page", value: "1" }, { key: "size", value: "10" }, { key: "eager", value: "true" } ] }
+                }
+            });
+            publicItems.push({
+                name: `[PUBLIC] Get ${capitalized} by ID`,
+                request: {
+                    method: "GET",
+                    header: [ { key: "X-Tenant-ID", value: "{{tenant}}" } ],
+                    url: { raw: `http://{{host}}:{{port}}/open/api/${name}s/1`, protocol: "http", host: ["{{host}}"], port: "{{port}}", path: ["open", "api", `${name}s`, "1"] }
+                }
+            });
+        }
+        if (isOpen(capitalized, 'create')) {
+            publicItems.push({
+                name: `[PUBLIC] Create ${capitalized}`,
+                request: {
+                    method: "POST",
+                    header: [ { key: "X-Tenant-ID", value: "{{tenant}}" }, { key: "Content-Type", value: "application/json" } ],
+                    body: { mode: "raw", raw: generateDummyJson(entity.fields) },
+                    url: { raw: `http://{{host}}:{{port}}/open/api/${name}s`, protocol: "http", host: ["{{host}}"], port: "{{port}}", path: ["open", "api", `${name}s`] }
+                }
+            });
+        }
+
+        if (publicItems.length > 0) {
+            folder.item.push({ name: "Public (Zero-Auth) Access", item: publicItems });
+        }
+
+        // 2. PRIVATE API Folder (Secured)
+        const privateItems = [
+            {
+                name: `List ${capitalized}s (REST)`,
+                request: {
+                    method: "GET",
+                    header: [ { key: "Authorization", value: "Bearer {{token}}" }, { key: "X-Tenant-ID", value: "{{tenant}}" } ],
+                    url: { raw: `http://{{host}}:{{port}}/api/${name}s?page=1&size=10&eager=true`, protocol: "http", host: ["{{host}}"], port: "{{port}}", path: ["api", `${name}s`], query: [ { key: "page", value: "1" }, { key: "size", value: "10" }, { key: "eager", value: "true" } ] }
+                }
+            },
+            {
+                name: `Create ${capitalized} (REST)`,
+                request: {
+                    method: "POST",
+                    header: [ { key: "Authorization", value: "Bearer {{token}}" }, { key: "X-Tenant-ID", value: "{{tenant}}" }, { key: "Content-Type", value: "application/json" } ],
+                    body: { mode: "raw", raw: generateDummyJson(entity.fields) },
+                    url: { raw: `http://{{host}}:{{port}}/api/${name}s`, protocol: "http", host: ["{{host}}"], port: "{{port}}", path: ["api", `${name}s`] }
+                }
+            },
+            {
+                name: `Get ${capitalized} by ID (REST)`,
+                request: {
+                    method: "GET",
+                    header: [ { key: "Authorization", value: "Bearer {{token}}" }, { key: "X-Tenant-ID", value: "{{tenant}}" } ],
+                    url: { raw: `http://{{host}}:{{port}}/api/${name}s/1`, protocol: "http", host: ["{{host}}"], port: "{{port}}", path: ["api", `${name}s`, "1"] }
+                }
+            },
+            {
+                name: `RPC Deep JSON Search (${capitalized})`,
+                request: {
+                    method: "GET",
+                    header: [ { key: "Authorization", value: "Bearer {{token}}" }, { key: "X-Tenant-ID", value: "{{tenant}}" } ],
+                    url: { raw: `http://{{host}}:{{port}}/api/rpc/${name}?id=gt.0`, protocol: "http", host: ["{{host}}"], port: "{{port}}", path: ["api", "rpc", name], query: [ { key: "id", value: "gt.0" } ] }
+                }
+            }
+        ];
+
+        folder.item.push({ name: "Private (Auth Required) CRUD", item: privateItems });
+        restFolder.item.push(folder);
+    }
+    collection.item.push(restFolder);
+
+    // 5. WebSocket
+    collection.item.push({
+        name: "5. Real-Time Distributed WebSockets",
+        item: [
+            {
+                name: "1. REST-over-WS Streaming Link",
+                request: {
+                    method: "GET",
+                    header: [],
+                    url: {
+                        raw: "ws://{{host}}:{{port}}/ws?token={{token}}",
+                        protocol: "ws",
+                        host: ["{{host}}"],
+                        port: "{{port}}",
+                        path: ["ws"],
+                        query: [{ key: "token", value: "{{token}}" }]
+                    }
+                }
+            }
+        ]
+    });
+
+    // 6. Storage Mesh
+    collection.item.push({
+        name: "6. Universal Storage Mesh",
+        item: [
+            {
+                name: "1. Upload File to Active Lake",
+                request: {
+                    method: "POST",
+                    header: [
+                        { key: "Authorization", value: "Bearer {{token}}" },
+                        { key: "X-Tenant-ID", value: "{{tenant}}" }
+                    ],
+                    body: {
+                        mode: "formdata",
+                        formdata: [
+                            { key: "file", type: "file", src: [] },
+                            { key: "folder", value: "farm/animals", type: "text" }
+                        ]
+                    },
+                    url: {
+                        raw: "http://{{host}}:{{port}}/api/storage/upload?provider=sftp",
+                        protocol: "http",
+                        host: ["{{host}}"],
+                        port: "{{port}}",
+                        path: ["api", "storage", "upload"],
+                        query: [{ key: "provider", value: "sftp" }]
+                    }
+                }
+            },
+            {
+                name: "2. Download File (Provider Targeted)",
+                request: {
+                    method: "GET",
+                    header: [
+                        { key: "Authorization", value: "Bearer {{token}}" },
+                        { key: "X-Tenant-ID", value: "{{tenant}}" }
+                    ],
+                    url: {
+                        raw: "http://{{host}}:{{port}}/api/storage/download/farm/animals/photo.jpg?provider=sftp",
+                        protocol: "http",
+                        host: ["{{host}}"],
+                        port: "{{port}}",
+                        path: ["api", "storage", "download", "farm", "animals", "photo.jpg"],
+                        query: [{ key: "provider", value: "sftp" }]
+                    }
+                }
+            },
+            {
+                name: "3. Distributed Cross-Scan Retrieve",
+                request: {
+                    method: "GET",
+                    header: [
+                        { key: "Authorization", value: "Bearer {{token}}" },
+                        { key: "X-Tenant-ID", value: "{{tenant}}" }
+                    ],
+                    url: {
+                        raw: "http://{{host}}:{{port}}/api/storage/scan/farm/animals/photo.jpg",
+                        protocol: "http",
+                        host: ["{{host}}"],
+                        port: "{{port}}",
+                        path: ["api", "storage", "scan", "farm", "animals", "photo.jpg"]
+                    }
+                }
+            }
+        ]
+    });
+
+    const filePath = path.join(docsDir, 'postman_collection.json');
+    await fs.writeJson(filePath, collection, { spaces: 2 });
+    console.log(chalk.gray('  Generated Postman Collection: postman_collection.json'));
+};

package/generators/repository.js

@@ -9,6 +9,8 @@ export const generateRepositoryCode = async (outputDir) => {
     const repoGo = `package repository
 
 import (
+	"context"
+	"go.mongodb.org/mongo-driver/mongo"
 	"gorm.io/gorm"
 )
 
@@ -21,6 +23,31 @@ func NewRepository(db *gorm.DB) *Repository {
 		DB: db,
 	}
 }
+
+func (r *Repository) GetDB(ctx context.Context) *gorm.DB {
+	// Kratos/Gin shared context value
+	if tdb, ok := ctx.Value("tenantDBConn").(*gorm.DB); ok {
+		return tdb
+	}
+	return r.DB
+}
+
+type MongoRepository struct {
+	Client *mongo.Client
+}
+
+func NewMongoRepository(client *mongo.Client) *MongoRepository {
+	return &MongoRepository{
+		Client: client,
+	}
+}
+
+func (r *MongoRepository) GetMongoDB(ctx context.Context) *mongo.Database {
+	if mdb, ok := ctx.Value("tenantMongoDB").(*mongo.Database); ok {
+		return mdb
+	}
+	return nil
+}
 `;
 
     await fs.writeFile(path.join(repoDir, 'repository.go'), repoGo);

package/generators/router.js

@@ -0,0 +1,27 @@
+import fs from 'fs-extra';
+import path from 'path';
+import Handlebars from 'handlebars';
+import chalk from 'chalk';
+
+export const generateRouterCode = async (outputDir, config, entities, openEntities) => {
+    const routerDir = path.join(outputDir, 'router');
+    await fs.ensureDir(routerDir);
+
+    const templatePath = path.resolve(path.dirname(import.meta.url.replace('file://', '')), '../templates/go/router.go.hbs');
+    if (!await fs.pathExists(templatePath)) {
+        console.error(chalk.red(`❌ Router template not found: ${templatePath}`));
+        return;
+    }
+
+    const templateSource = await fs.readFile(templatePath, 'utf8');
+    const template = Handlebars.compile(templateSource);
+
+    const content = template({
+        app_name: config.name,
+        entities,
+        openEntities
+    });
+
+    await fs.writeFile(path.join(routerDir, 'router.go'), content);
+    console.log(chalk.gray('  Generated Reusable Router Package: router/router.go'));
+};

package/generators/security.js

@@ -10,11 +10,13 @@ export const generateSecurityMiddleware = async (config, outputDir) => {
 package middleware
 
 import (
+	"fmt"
 	"net/http"
 	"strings"
 
 	"github.com/gin-gonic/gin"
 	"github.com/golang-jwt/jwt/v4"
+	"{{app_name}}/config"
 )
 
 // JWTMiddleware validates Keycloak JWTs
@@ -34,9 +36,15 @@ func JWTMiddleware() gin.HandlerFunc {
 
 		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"})
+		token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
+			if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
+				return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
+			}
+			return []byte(config.GetConfig().GoDuck.Security.KeycloakAppClientSecret), nil
+		})
+
+		if err != nil || !token.Valid {
+			c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "Invalid or expired token"})
 			return
 		}
 
@@ -59,14 +67,58 @@ func GetUserID(c *gin.Context) string {
 	}
 	return "anonymous"
 }
+
+// SuperAdminRoleMiddleware restricts access to endpoints to only users with the SuperAdminRole
+func SuperAdminRoleMiddleware(cfg *config.Config) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		superRole := cfg.GoDuck.Security.SuperAdminRole
+		if superRole == "" {
+			c.Next()
+			return
+		}
+
+		userRolesInterface, exists := c.Get("UserRoles")
+		if !exists {
+			c.AbortWithStatusJSON(http.StatusForbidden, gin.H{"error": "No roles found in security context"})
+			return
+		}
+
+		roles, ok := userRolesInterface.([]interface{})
+		if !ok {
+			c.AbortWithStatusJSON(http.StatusForbidden, gin.H{"error": "Invalid roles format"})
+			return
+		}
+
+		hasRole := false
+		for _, r := range roles {
+			if strings.ToLower(fmt.Sprintf("%v", r)) == strings.ToLower(superRole) {
+				hasRole = true
+				break
+			}
+		}
+
+		if !hasRole {
+			c.AbortWithStatusJSON(http.StatusForbidden, gin.H{
+				"error": "Insufficient permissions. This endpoint is restricted to " + superRole,
+			})
+			return
+		}
+
+		c.Next()
+	}
+}
 `;
 
 	const rateLimitMiddleware = `
 package middleware
 
 import (
+	"context"
+	"fmt"
 	"net/http"
 	"sync"
+	"time"
+	"{{app_name}}/cache"
 	"{{app_name}}/config"
 
 	"github.com/gin-gonic/gin"
@@ -76,26 +128,55 @@ import (
 var (
 	limiters = make(map[string]*rate.Limiter)
 	mu       sync.Mutex
+	ctx      = context.Background()
 )
 
-// RateLimitMiddleware provides burst protection based on configuration
+// RateLimitMiddleware provides distributed burst protection using Redis (Zero-Trust fallback to local)
 func RateLimitMiddleware(cfg *config.Config) gin.HandlerFunc {
 	return func(c *gin.Context) {
-		ip := c.ClientIP()
-		
+		rps := cfg.GoDuck.Security.RateLimit.RPS
+		burst := cfg.GoDuck.Security.RateLimit.Burst
+
+		// Try to identify by User (KeycloakID) instead of IP for Zero-Trust accuracy
+		identifier := c.ClientIP()
+		if uid, exists := c.Get("KeycloakID"); exists {
+			identifier = uid.(string)
+		}
+
+		// 1. Distributed Redis Architecture (Enterprise Grade)
+		if cache.RedisClient != nil {
+			// Fixed Window Counter per second
+			key := fmt.Sprintf("rate_limit:%s:%d", identifier, time.Now().Unix())
+			count, err := cache.RedisClient.Incr(ctx, key).Result()
+			
+			if err == nil {
+				if count == 1 {
+					cache.RedisClient.Expire(ctx, key, 2*time.Second) // Small TTL for Sliding RPS
+				}
+				if count > int64(rps)+int64(burst) { // Allow burst
+					c.AbortWithStatusJSON(http.StatusTooManyRequests, gin.H{
+						"error": "Distributed Rate limit exceeded. Please try again later.",
+					})
+					return
+				}
+				c.Next()
+				return
+			}
+			// If Redis fails, gracefully degrade to fallback
+		}
+
+		// 2. Local Fallback Architecture
 		mu.Lock()
-		limiter, exists := limiters[ip]
+		limiter, exists := limiters[identifier]
 		if !exists {
-			rps := cfg.GoDuck.Security.RateLimit.RPS
-			burst := cfg.GoDuck.Security.RateLimit.Burst
 			limiter = rate.NewLimiter(rate.Limit(rps), burst)
-			limiters[ip] = limiter
+			limiters[identifier] = limiter
 		}
 		mu.Unlock()
 
 		if !limiter.Allow() {
 			c.AbortWithStatusJSON(http.StatusTooManyRequests, gin.H{
-				"error": "Rate limit exceeded. Please try again later.",
+				"error": "Internal Rate limit exceeded. Please try again later.",
 			})
 			return
 		}
@@ -104,8 +185,8 @@ func RateLimitMiddleware(cfg *config.Config) gin.HandlerFunc {
 }
 `;
 
-	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));
+	await fs.writeFile(path.join(middlewareDir, 'jwt_middleware.go'), jwtMiddleware.replace(/{{app_name}}/g, config.name));
+	await fs.writeFile(path.join(middlewareDir, 'rate_limit_middleware.go'), rateLimitMiddleware.replace(/{{app_name}}/g, config.name));
 
 	const corsMiddleware = `
 package middleware
@@ -163,6 +244,6 @@ func CORSMiddleware(cfg *config.Config) gin.HandlerFunc {
 }
 `;
 
-	await fs.writeFile(path.join(middlewareDir, 'cors_middleware.go'), corsMiddleware.replace('{{app_name}}', config.name));
+	await fs.writeFile(path.join(middlewareDir, 'cors_middleware.go'), corsMiddleware.replace(/{{app_name}}/g, config.name));
 	console.log(chalk.gray('  Generated Advanced Security & CORS Middleware'));
 };