go-duck-cli 1.0.9 → 1.1.12

package/index.js

@@ -11,6 +11,9 @@ import path from 'path';
 import yaml from 'js-yaml';
 import Handlebars from 'handlebars';
 import chalk from 'chalk';
+import { execSync } from 'child_process';
+import express from 'express';
+import open from 'open';
 import { parseGDL } from './parser/gdl.js';
 import { generateMultitenancy } from './generators/multitenancy.js';
 import { generateLiquibaseChangelogs } from './generators/migrations.js';
@@ -18,6 +21,7 @@ import { generateMeteringCode } from './generators/metering.js';
 import { generateGraphQLCode } from './generators/graphql.js';
 import { generatePostgRESTCode } from './generators/postgrest.js';
 import { generateSwaggerDocs } from './generators/swagger.js';
+import { generatePostmanCollection } from './generators/postman.js';
 import { generateSecurityMiddleware } from './generators/security.js';
 import { generateWebSocketCode } from './generators/websocket.js';
 import { generateConfigLoader } from './generators/config.js';
@@ -30,6 +34,14 @@ import { generateDeploymentArtifacts } from './generators/devops.js';
 import { generateKratosCode } from './generators/kratos.js';
 import { generateRepositoryCode } from './generators/repository.js';
 import { generateDocumentation } from './generators/docs.js';
+import { generateOutbox } from './generators/outbox.js';
+import { generateNATSCode } from './generators/nats.js';
+import { generateBrokerCode } from './generators/broker.js';
+import { generateStorageCode } from './generators/storage.js';
+import { generateElasticsearchLayer } from './generators/elasticsearch.js';
+import { generateServerlessHandler } from './generators/serverless.js';
+import { generateRouterCode } from './generators/router.js';
+import { generateAIDocs } from './generators/ai_docs.js';
 
 export const generateAuditCode = async (config, outputDir) => {
     const middlewareDir = path.join(outputDir, 'middleware');
@@ -50,6 +62,7 @@ import (
 type AuditLog struct {
     ID             uint      \`gorm:"primaryKey" json:"id"\`
     EntityName     string    \`json:"entityName"\`
+    TenantDB       string    \`json:"tenantDb"\`
     EntityID       string    \`json:"entityId"\`
     Action         string    \`json:"action"\` // CREATE, UPDATE, DELETE
     PreviousValue  string    \`json:"previousValue" gorm:"type:text"\`
@@ -65,8 +78,7 @@ type AuditLog struct {
 package middleware
 
 import (
-	"bytes"
-	"io/ioutil"
+	"fmt"
 	"net/http"
 	"time"
 
@@ -77,7 +89,7 @@ import (
 
 func AuditMiddleware(db *gorm.DB) gin.HandlerFunc {
 	return func(c *gin.Context) {
-		if c.Request.Method == http.MethodGet {
+		if db == nil || c.Request.Method == http.MethodGet {
 			c.Next()
 			return
 		}
@@ -91,23 +103,30 @@ func AuditMiddleware(db *gorm.DB) gin.HandlerFunc {
 		if method == http.MethodPost { action = "CREATE" }
 		if method == http.MethodDelete { action = "DELETE" }
 
-		// Mock user and IP
-		userEmail := c.GetHeader("User-Email")
-		if userEmail == "" { userEmail = "anonymous" }
+		// Extract Identity from context
+		userEmail, _ := c.Get("UserEmail")
+		emailStr := "anonymous"
+		if email, ok := userEmail.(string); ok { emailStr = email }
+		
+		keycloakId, _ := c.Get("KeycloakID")
+		kidStr := ""
+		if kid, ok := keycloakId.(string); ok { kidStr = kid }
 		
-		keycloakId := c.GetHeader("X-Keycloak-Id")
 		clientIP := c.ClientIP()
 
+		tenant, _ := c.Get("tenantDB")
+		tenantStr := fmt.Sprintf("%v", tenant)
+
 		// Call next handlers
 		c.Next()
 
 		// Logic to capture entity ID and snapshot values would go here...
-		// For now, track the action
 		auditEntry := models.AuditLog{
 			EntityName: path,
+			TenantDB:   tenantStr,
 			Action:     action,
-			ModifiedBy: userEmail,
-			KeycloakID: keycloakId,
+			ModifiedBy: emailStr,
+			KeycloakID: kidStr,
 			ModifiedAt: time.Now(),
 			ClientIP:   clientIP,
 		}
@@ -148,15 +167,26 @@ const program = new Command();
 // Handlebars Helpers
 Handlebars.registerHelper('capitalize', (str) => {
     if (typeof str !== 'string') return '';
-    return str.charAt(0).toUpperCase() + str.slice(1);
+    // Handle snake_case by splitting and joining title-cased parts
+    return str.replace(/(?:^|_| )(\w)/g, (match, p1) => p1.toUpperCase());
+});
+
+Handlebars.registerHelper('toProtoFieldName', (str) => {
+    if (typeof str !== 'string') return '';
+    // Protoc-gen-go converts snake_case to TitleCase (e.g. site_id -> SiteId)
+    // But it ALSO removes underscores. So we split and capitalize.
+    return str.split('_').map(s => s.charAt(0).toUpperCase() + s.slice(1)).join('');
 });
 
 Handlebars.registerHelper('hasJson', (fields) => {
     if (!fields || !Array.isArray(fields)) return false;
-    return fields.some(f => f.type === 'JSON' || f.type === 'JSONB');
+    return fields.some(f => (f.type || '').toLowerCase() === 'json' || (f.type || '').toLowerCase() === 'jsonb');
 });
 
-Handlebars.registerHelper('isJson', (type) => type === 'JSON' || type === 'JSONB');
+Handlebars.registerHelper('isJson', (type) => {
+    const t = (type || '').toLowerCase();
+    return t === 'json' || t === 'jsonb';
+});
 
 Handlebars.registerHelper('toLowerCase', (str) => {
     if (typeof str !== 'string') return '';
@@ -165,23 +195,30 @@ Handlebars.registerHelper('toLowerCase', (str) => {
 
 Handlebars.registerHelper('toGoType', (type, options) => {
     const enums = options.data.root.enums || [];
-    const isEnum = enums.some(e => e.name === type);
-    if (isEnum) return type;
+    const isEnum = enums.some(e => e.name.toLowerCase() === type.toLowerCase());
+    if (isEnum) {
+        const en = enums.find(e => e.name.toLowerCase() === type.toLowerCase());
+        return en.name;
+    }
 
+    const t = type.toLowerCase();
     const types = {
-        'String': 'string',
-        'Text': 'string',
-        'Integer': 'int',
-        'Float': 'float64',
-        'Boolean': 'bool',
-        'Long': 'int64',
-        'BigDecimal': 'float64',
-        'LocalDate': 'time.Time',
-        'Instant': 'time.Time',
-        'JSON': 'datatypes.JSON',
-        'JSONB': 'datatypes.JSON'
+        'string': 'string',
+        'text': 'string',
+        'integer': 'int',
+        'int': 'int',
+        'float': 'float64',
+        'boolean': 'bool',
+        'bool': 'bool',
+        'long': 'int64',
+        'bigdecimal': 'float64',
+        'localdate': 'time.Time',
+        'instant': 'time.Time',
+        'datetime': 'time.Time',
+        'json': 'datatypes.JSON',
+        'jsonb': 'datatypes.JSON'
     };
-    return types[type] || 'interface{}';
+    return types[t] || 'interface{}';
 });
 
 Handlebars.registerHelper('gql_type', (type, options) => {
@@ -204,8 +241,53 @@ Handlebars.registerHelper('gql_type', (type, options) => {
     return types[type] || 'String';
 });
 
+Handlebars.registerHelper('isAnyOperationOpen', (entityName, openEntities) => {
+    if (!openEntities || !Array.isArray(openEntities)) return false;
+    const wildcard = openEntities.find(e => e.name === '*');
+    if (wildcard && wildcard.actions && wildcard.actions.some(a => a !== 'none' && a !== '')) return true;
+    const entry = openEntities.find(e => e.name.toLowerCase() === entityName.toLowerCase());
+    return !!(entry && entry.actions && entry.actions.some(a => a !== 'none' && a !== ''));
+});
+
+Handlebars.registerHelper('isOpen', (entityName, openEntities, action) => {
+    if (!openEntities || !Array.isArray(openEntities)) return false;
+    
+    // Check wildcard first
+    const wildcard = openEntities.find(e => e.name === '*');
+    if (wildcard) {
+        if (typeof action !== 'string') return true; 
+        if (wildcard.actions.includes(action.toLowerCase())) return true;
+    }
+
+    const entry = openEntities.find(e => e.name.toLowerCase() === entityName.toLowerCase());
+    if (entry) {
+        if (typeof action !== 'string') return true;
+        if (entry.actions.includes(action.toLowerCase())) return true;
+    }
+
+    return false;
+});
+
 Handlebars.registerHelper('eq', (a, b) => a === b);
 
+Handlebars.registerHelper('or', function() {
+    const args = Array.prototype.slice.call(arguments, 0, -1);
+    return args.some(Boolean);
+});
+
+// Recursive field rendering for multi-level JSON
+Handlebars.registerPartial('renderFields', `
+{{#each fields}}
+{{#if isNested}}
+  {{capitalize name}} struct {
+    {{> renderFields fields=children isDocument=../isDocument}}
+  } \`json:"{{name}}"{{#if ../isDocument}} bson:"{{name}}"{{/if}}\`
+{{else}}
+  {{capitalize name}} {{toGoType type}} \`{{#if ../isDocument}}bson:"{{#if (eq name "id")}}_id{{else}}{{name}}{{/if}}{{#if (eq name "id")}},omitempty{{/if}}"{{else}}{{#if (eq name "id")}}gorm:"primaryKey"{{else}}{{#if unique}}gorm:"uniqueIndex"{{/if}}{{/if}}{{/if}} {{#if (isJson type)}}gorm:"type:{{toLowerCase type}};serializer:json"{{/if}} json:"{{name}}"{{#if required}} binding:"required"{{/if}}\`
+{{/if}}
+{{/each}}
+`);
+
 program
     .name('go-duck-cli')
     .description('A powerful Go code generator for microservices')
@@ -216,7 +298,7 @@ const loadConfig = async (configPath) => {
     try {
         const fileContents = await fs.readFile(configPath, 'utf8');
         const config = yaml.load(fileContents);
-        const appConfig = config.app || {};
+        const appConfig = config['go-duck'] || config.app || config || {};
         return appConfig;
     } catch (error) {
         console.error(chalk.red(`Error loading config from ${configPath}:`), error.message);
@@ -245,14 +327,46 @@ const getPreviousEntities = async (outputDir) => {
     return entities;
 };
 
-const generateEntities = async (gdlFilePath, outputDir, config) => {
-    if (!await fs.pathExists(gdlFilePath)) {
-        console.error(chalk.red(`❌ GDL file not found: ${gdlFilePath}`));
-        return null;
+const generateEntities = async (gdlPath, outputDir, config) => {
+    let entities = [];
+    let relationships = [];
+    let enums = [];
+    let openEntities = [];
+
+    if (!await fs.pathExists(gdlPath)) {
+        console.log(chalk.yellow(`⚠️  GDL path not found: ${gdlPath} - Executing Zero-Entity Infrastructure Scaffold.`));
+        const delta = { newEntities: [], newFields: {}, newRelationships: [] };
+        await generateLiquibaseChangelogs(entities, relationships, outputDir, delta, enums);
+        return { entities, relationships, enums, openEntities };
+    }
+
+    const stats = await fs.stat(gdlPath);
+    const files = stats.isDirectory() 
+        ? (await fs.readdir(gdlPath)).filter(f => f.endsWith('.gdl')).map(f => path.join(gdlPath, f))
+        : [gdlPath];
+
+    if (files.length === 0) {
+        console.log(chalk.yellow(`⚠️  No .gdl files found in: ${gdlPath} - Executing Zero-Entity Infrastructure Scaffold.`));
+        const delta = { newEntities: [], newFields: {}, newRelationships: [] };
+        await generateLiquibaseChangelogs(entities, relationships, outputDir, delta, enums);
+        return { entities, relationships, enums, openEntities };
+    }
+
+    console.log(chalk.blue(`📂 Loading ${files.length} GDL file(s)...`));
+
+    for (const file of files) {
+        const result = await parseGDL(file);
+        entities = [...entities, ...result.entities];
+        relationships = [...relationships, ...result.relationships];
+        enums = [...enums, ...result.enums];
+        openEntities = [...openEntities, ...result.openEntities];
     }
 
-    const { entities, relationships, enums } = await parseGDL(gdlFilePath);
-    console.log(chalk.green(`✅ Parsed ${entities.length} entities, ${relationships.length} relationships, and ${enums.length} enums`));
+    // Deduplicate entities and enums by name
+    entities = Array.from(new Map(entities.map(e => [e.name, e])).values());
+    enums = Array.from(new Map(enums.map(e => [e.name, e])).values());
+
+    console.log(chalk.green(`✅ Parsed ${entities.length} entities, ${relationships.length} relationships, ${enums.length} enums, and detected ${openEntities.length} open rules`));
 
     const previousEntities = await getPreviousEntities(outputDir);
     const delta = {
@@ -308,9 +422,20 @@ const generateEntities = async (gdlFilePath, outputDir, config) => {
     }
 
     for (const entity of entities) {
-        entity.relationships = relationships.filter(r => r.from.entity === entity.name || r.to.entity === entity.name);
+        entity.relationships = relationships.filter(r => r.from.entity === entity.name || r.to.entity === entity.name).map(r => {
+            const fromEnt = entities.find(e => e.name === r.from.entity);
+            const toEnt = entities.find(e => e.name === r.to.entity);
+            return {
+                ...r,
+                fromIsDocument: fromEnt ? fromEnt.isDocument : false,
+                toIsDocument: toEnt ? toEnt.isDocument : false
+            };
+        });
         entity.app_name = config.name;
-        entity.enums = enums; // Pass enums context for helpers
+        entity.enums = enums;
+        entity.openEntities = openEntities; // Pass open entities to template
+        // Use already parsed flags from gdl.js
+        // entity.isSearchable, entity.isFederated, entity.isAudited, entity.isDocument are already set correctly.
 
         // Generate Model
         const entityContent = entityTemplate(entity);
@@ -320,7 +445,7 @@ const generateEntities = async (gdlFilePath, outputDir, config) => {
         const controllerContent = controllerTemplate(entity);
         await fs.writeFile(path.join(outputDir, 'controllers', `${entity.name.toLowerCase()}_controller.go`), controllerContent);
 
-        console.log(chalk.gray(`   - Updated Entity & Controller: ${entity.name}`));
+        console.log(chalk.gray(`   - Updated Entity & Controller: ${entity.name} (Mongo: ${entity.isDocument || false})`));
 
         // Save Snapshot for next comparison
         await saveEntitySnapshot(outputDir, entity);
@@ -328,9 +453,9 @@ const generateEntities = async (gdlFilePath, outputDir, config) => {
 
     // Generate Incremental Changelogs!
     await generateLiquibaseChangelogs(entities, relationships, outputDir, delta, enums);
-    console.log(chalk.green('✅ Liquibase incremental migrations updated!'));
+    console.log(chalk.green('✅ Goose SQL incremental migrations updated!'));
 
-    return { entities, relationships, enums };
+    return { entities, relationships, enums, openEntities };
 };
 
 program
@@ -349,6 +474,27 @@ program
         const config = await loadConfig(path.resolve(process.cwd(), configPath));
         console.log(chalk.green(`✅ Config loaded for app: ${config.name}`));
 
+        // Copy configuration file to the generated project .go-duck folder
+        const sourceConfigResolved = path.resolve(process.cwd(), configPath);
+        const targetConfigResolved = path.resolve(absoluteOutputDir, '.go-duck/config.yaml');
+        if (sourceConfigResolved !== targetConfigResolved) {
+            await fs.ensureDir(path.dirname(targetConfigResolved));
+            await fs.copy(sourceConfigResolved, targetConfigResolved);
+            console.log(chalk.green(`📝 Config file copied to: ${path.relative(process.cwd(), targetConfigResolved)}`));
+        }
+
+        // Cleanup legacy files if they exist in the root
+        const legacyFiles = ['Dockerfile', 'docker-compose.yml'];
+        const legacyDirs = ['k8s', 'realm-config'];
+        for (const f of legacyFiles) {
+            const p = path.join(absoluteOutputDir, f);
+            if (await fs.pathExists(p)) await fs.remove(p);
+        }
+        for (const d of legacyDirs) {
+            const p = path.join(absoluteOutputDir, d);
+            if (await fs.pathExists(p)) await fs.remove(p);
+        }
+
         await generateConfigLoader(absoluteOutputDir);
         await generateLoggerCode(config, absoluteOutputDir);
         await generateMQTTCode(config, absoluteOutputDir);
@@ -357,48 +503,138 @@ program
         await generateTelemetryCode(config, absoluteOutputDir);
         await generateDeploymentArtifacts(config, absoluteOutputDir);
         await generateYAMLConfigs(config, absoluteOutputDir);
-        const { entities, relationships, enums } = await generateEntities(path.join(path.resolve(process.cwd(), gdlDir), 'app.gdl'), absoluteOutputDir, config);
+        const { entities, relationships, enums, openEntities } = await generateEntities(path.resolve(process.cwd(), gdlDir), absoluteOutputDir, config);
         await generateKratosCode(entities, absoluteOutputDir, config.name, enums);
 
         await generateRepositoryCode(absoluteOutputDir);
+        
+        {
+            const migratorTemplatePath = path.resolve(path.dirname(import.meta.url.replace('file://', '')), 'templates/go/migrator.go.hbs');
+            if (await fs.pathExists(migratorTemplatePath)) {
+                const migratorTemplate = Handlebars.compile(await fs.readFile(migratorTemplatePath, 'utf8'));
+                await fs.writeFile(path.join(absoluteOutputDir, 'migrations/migrations.go'), migratorTemplate({ app_name: config.name }));
+            }
+        }
 
         await generateGraphQLCode(config, entities, relationships, absoluteOutputDir, enums);
-        if (config.multitenancy?.enabled) await generateMultitenancy(config, absoluteOutputDir);
+        await generatePostgRESTCode(config, absoluteOutputDir);
+        if (config.multitenancy?.enabled) await generateMultitenancy(config, absoluteOutputDir, entities);
         await generateAuditCode(config, absoluteOutputDir);
         await generateMeteringCode(config, absoluteOutputDir);
         await generateSecurityMiddleware(config, absoluteOutputDir);
         await generateWebSocketCode(config, entities, absoluteOutputDir);
-        await generatePostgRESTCode(config, absoluteOutputDir);
-        console.log(chalk.green('✅ PostgREST-like search layer created!'));
+        await generateOutbox(absoluteOutputDir, config);
+        await generateNATSCode(config, absoluteOutputDir);
+        await generateBrokerCode(config, absoluteOutputDir);
+        await generateStorageCode(config, absoluteOutputDir, path.dirname(path.resolve(process.cwd(), configPath)));
+        await generateRouterCode(absoluteOutputDir, config, entities, openEntities);
+        await generateElasticsearchLayer(config, entities, absoluteOutputDir);
+        await generateServerlessHandler(absoluteOutputDir, config);
+        
+        console.log(chalk.green('\n🎉 Go-Duck project generated successfully!'));
 
         // 8. Generate Swagger Docs
-        await generateSwaggerDocs(config, entities, absoluteOutputDir);
-        console.log(chalk.green('✅ Swagger API documentation generated!'));
+        await generateSwaggerDocs(config, entities, absoluteOutputDir, openEntities);
+        await generatePostmanCollection(config, entities, absoluteOutputDir, openEntities);
+        console.log(chalk.green('✅ Swagger API and Postman Collection generated!'));
 
         // 8.5 Generate Web Docs App
-        await generateDocumentation(config, entities, absoluteOutputDir, enums);
+        await generateDocumentation(config, entities, absoluteOutputDir, enums, openEntities);
         console.log(chalk.green('✅ Web Documentation App generated!'));
 
+        // 8.6 Generate AI/LLM Blueprint Documentation
+        await generateAIDocs(config, entities, absoluteOutputDir, enums, openEntities);
+        console.log(chalk.green('🤖 System-level AI Blueprint Documentation generated!'));
+
         // 9. Generate main.go
         const mainTemplatePath = path.resolve(path.dirname(import.meta.url.replace('file://', '')), 'templates/go/main.go.hbs');
         if (await fs.pathExists(mainTemplatePath)) {
             const mainTemplateSource = await fs.readFile(mainTemplatePath, 'utf8');
             const mainTemplate = Handlebars.compile(mainTemplateSource);
-            await fs.writeFile(path.join(absoluteOutputDir, 'main.go'), mainTemplate({ app_name: config.name, entities }));
+            await fs.writeFile(path.join(absoluteOutputDir, 'main.go'), mainTemplate({ app_name: config.name, entities, openEntities }));
             console.log(chalk.green('✅ main.go entry point created!'));
         }
+
+        // 10. Generate go.mod
+        const goModContent = `module ${config.name}
+
+go 1.24
+
+require (
+	github.com/gin-gonic/gin v1.10.0
+	github.com/go-kratos/kratos/v2 v2.8.2
+	github.com/google/uuid v1.6.0
+	github.com/spf13/viper v1.19.0
+	go.opentelemetry.io/otel v1.26.0
+	go.opentelemetry.io/otel/trace v1.26.0
+	go.opentelemetry.io/otel/sdk v1.26.0
+	go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin v0.51.0
+	google.golang.org/grpc v1.64.0
+	gorm.io/datatypes v1.2.0
+	gorm.io/driver/postgres v1.5.7
+	gorm.io/gorm v1.25.10
+	gorm.io/plugin/opentelemetry v0.1.5
+	github.com/golang-jwt/jwt/v5 v5.2.1
+	github.com/eclipse/paho.mqtt.golang v1.4.3
+	github.com/sony/gobreaker v0.5.0
+	github.com/redis/go-redis/v9 v9.5.1
+	github.com/gorilla/websocket v1.5.1
+	github.com/99designs/gqlgen v0.17.44
+	github.com/vektah/gqlparser/v2 v2.5.11
+    github.com/aws/aws-lambda-go v1.47.0
+    github.com/awslabs/aws-lambda-go-api-proxy v0.16.1
+    github.com/GoogleCloudPlatform/functions-framework-go v1.8.1
+    go.mongodb.org/mongo-driver v1.17.1
+    github.com/gin-contrib/cors v1.7.1
+    github.com/go-resty/resty/v2 v2.16.0
+    github.com/olivere/elastic/v7 v7.0.32
+    github.com/nats-io/nats.go v1.38.0
+)
+`;
+        await fs.writeFile(path.join(absoluteOutputDir, 'go.mod'), goModContent);
+        console.log(chalk.green('✅ go.mod file created!'));
+
+        // Post-generation: Run go mod tidy
+        try {
+            console.log(chalk.blue('Cleaning up Go modules (go mod tidy)...'));
+            execSync('go mod tidy', { cwd: absoluteOutputDir, stdio: 'inherit' });
+            console.log(chalk.green('✅ Go modules tidied!'));
+        } catch (error) {
+            console.warn(chalk.yellow('⚠️ Could not run go mod tidy. Please run it manually.'));
+        }
+
         console.log(chalk.bold.magenta('\n✨ Project created successfully!'));
     });
 
 program
-    .command('import-gdl <file>')
-    .description('Import entities from a GDL file into an existing app')
+    .command('import-gdl <path>')
+    .description('Import entities from a GDL file or directory into an existing app')
     .option('-o, --output <path>', 'Path to the existing app root', '.')
-    .action(async (file, options) => {
+    .action(async (gdlPath, options) => {
         const absoluteOutputDir = path.resolve(process.cwd(), options.output);
-        console.log(chalk.blue(`📥 Importing GDL from ${file}...`));
+        console.log(chalk.blue(`📥 Importing GDL from ${gdlPath}...`));
+
+        let configPath = path.resolve(process.cwd(), './.go-duck/config.yaml');
+        if (!await fs.pathExists(configPath)) {
+            configPath = path.resolve(process.cwd(), './CONFIG/config.yaml');
+        }
+        if (!await fs.pathExists(configPath)) {
+            configPath = path.resolve(process.cwd(), '../CONFIG/config.yaml');
+        }
+        const config = await loadConfig(configPath);
+
+        // Cleanup legacy files if they exist in the root
+        const legacyFiles = ['Dockerfile', 'docker-compose.yml'];
+        const legacyDirs = ['k8s', 'realm-config'];
+        for (const f of legacyFiles) {
+            const p = path.join(absoluteOutputDir, f);
+            if (await fs.pathExists(p)) await fs.remove(p);
+        }
+        for (const d of legacyDirs) {
+            const p = path.join(absoluteOutputDir, d);
+            if (await fs.pathExists(p)) await fs.remove(p);
+        }
 
-        const config = await loadConfig(path.resolve(process.cwd(), '../CONFIG/config.yaml'));
         await generateConfigLoader(absoluteOutputDir);
         await generateLoggerCode(config, absoluteOutputDir);
         await generateMQTTCode(config, absoluteOutputDir);
@@ -406,34 +642,52 @@ program
         await generateResilienceCode(config, absoluteOutputDir);
         await generateTelemetryCode(config, absoluteOutputDir);
         await generateDeploymentArtifacts(config, absoluteOutputDir);
-        const { entities, relationships, enums } = await generateEntities(path.resolve(process.cwd(), file), absoluteOutputDir, config);
+        const { entities, relationships, enums, openEntities } = await generateEntities(gdlPath, absoluteOutputDir, config);
         await generateKratosCode(entities, absoluteOutputDir, config.name, enums);
 
         await generateRepositoryCode(absoluteOutputDir);
 
         await generateGraphQLCode(config, entities, relationships, absoluteOutputDir, enums);
-        // Sync PostgREST search as well
         await generatePostgRESTCode(config, absoluteOutputDir);
 
-        // Sync Security
+        // Sync Search & Security
+        await generateElasticsearchLayer(config, entities, absoluteOutputDir);
         await generateSecurityMiddleware(config, absoluteOutputDir);
 
         // Sync WebSocket
         await generateWebSocketCode(config, entities, absoluteOutputDir);
 
         // Sync Swagger Docs
-        await generateSwaggerDocs(config, entities, absoluteOutputDir);
+        await generateSwaggerDocs(config, entities, absoluteOutputDir, openEntities);
+        await generatePostmanCollection(config, entities, absoluteOutputDir, openEntities);
 
         // Sync Web Docs App
-        await generateDocumentation(config, entities, absoluteOutputDir, enums);
+        await generateDocumentation(config, entities, absoluteOutputDir, enums, openEntities);
+        
+        // Sync AI Blueprints
+        await generateAIDocs(config, entities, absoluteOutputDir, enums, openEntities);
+        // Sync Serverless & Router
+        await generateRouterCode(absoluteOutputDir, config, entities, openEntities);
+        await generateServerlessHandler(absoluteOutputDir, config);
 
         // Regenerate main.go to include new routes if any (or just entities)
+        const timestamp = new Date().toISOString().replace(/[-:T]/g, '').split('.')[0];
         const mainTemplatePath = path.resolve(path.dirname(import.meta.url.replace('file://', '')), 'templates/go/main.go.hbs');
         if (await fs.pathExists(mainTemplatePath)) {
             const mainTemplate = Handlebars.compile(await fs.readFile(mainTemplatePath, 'utf8'));
-            await fs.writeFile(path.join(absoluteOutputDir, 'main.go'), mainTemplate({ app_name: config.name, entities }));
+            await fs.writeFile(path.join(absoluteOutputDir, 'main.go'), mainTemplate({ app_name: config.name, entities, openEntities, timestamp }));
             console.log(chalk.green('✅ Updated main.go to register new entity routes.'));
         }
+
+        // Run go mod tidy after import as well
+        try {
+            console.log(chalk.blue('Cleaning up Go modules (go mod tidy)...'));
+            execSync('go mod tidy', { cwd: absoluteOutputDir, stdio: 'inherit' });
+            console.log(chalk.green('✅ Go modules tidied!'));
+        } catch (error) {
+            console.warn(chalk.yellow('⚠️ Could not run go mod tidy. Please run it manually.'));
+        }
+
         console.log(chalk.bold.magenta('\n✨ GDL Import Completed with Incremental Migrations! ✨'));
     });
 
@@ -447,74 +701,159 @@ const generateYAMLConfigs = async (config, outputDir) => {
     const extendedConfig = {
         ...cleanConfig,
         server: {
-            port: 8080,
-            'read-timeout': '30s',
-            'write-timeout': '30s',
+            port: cleanConfig.server?.port || 8080,
+            'read-timeout': cleanConfig.server?.['read-timeout'] || '30s',
+            'write-timeout': cleanConfig.server?.['write-timeout'] || '30s',
             grpc: {
-                addr: ':9000',
-                network: 'tcp',
-                timeout: '1s'
+                addr: cleanConfig.server?.grpc?.addr || ':9000',
+                network: cleanConfig.server?.grpc?.network || 'tcp',
+                timeout: cleanConfig.server?.grpc?.timeout || '1s'
             },
             cors: {
-                'allow-origins': ['*'],
-                'allow-methods': ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'],
-                'allow-headers': ['Origin', 'Content-Type', 'Accept', 'Authorization']
+                'allow-origins': cleanConfig.server?.cors?.['allow-origins'] || ['*'],
+                'allow-methods': cleanConfig.server?.cors?.['allow-methods'] || ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'],
+                'allow-headers': cleanConfig.server?.cors?.['allow-headers'] || ['Origin', 'Content-Type', 'Accept', 'Authorization', 'X-Tenant-ID']
             }
         },
         datasource: {
             ...cleanConfig.datasource,
-            'max-open-conns': 25,
-            'max-idle-conns': 10,
-            'conn-max-lifetime': '5m'
+            'ssl-mode': cleanConfig.datasource?.['ssl-mode'] || 'disable',
+            'max-open-conns': cleanConfig.datasource?.['max-open-conns'] || 25,
+            'max-idle-conns': cleanConfig.datasource?.['max-idle-conns'] || 10,
+            'conn-max-lifetime': cleanConfig.datasource?.['conn-max-lifetime'] || '5m',
+            mongodb: {
+                enabled: cleanConfig.datasource?.mongodb?.enabled || false,
+                uri: cleanConfig.datasource?.mongodb?.uri || 'mongodb://localhost:27017',
+                database: cleanConfig.datasource?.mongodb?.database || cleanConfig.name || 'go_duck_mongo'
+            }
         },
         security: {
             ...cleanConfig.security,
+            'keycloak-app-client-id': cleanConfig.security?.['keycloak-app-client-id'] || `${cleanConfig.name || 'go-duck'}-app`,
+            'keycloak-app-client-secret': cleanConfig.security?.['keycloak-app-client-secret'] || 'app-secret-123',
+            'keycloak-service-client-id': cleanConfig.security?.['keycloak-service-client-id'] || `${cleanConfig.name || 'go-duck'}-service`,
+            'keycloak-service-secret': cleanConfig.security?.['keycloak-service-secret'] || 'service-secret-123',
+            'keycloak-admin-client-id': cleanConfig.security?.['keycloak-admin-client-id'] || 'admin-cli',
+            'keycloak-admin-secret': cleanConfig.security?.['keycloak-admin-secret'] || 'admin-secret-123',
+            'super-admin-role': cleanConfig.security?.['super-admin-role'] || 'admin',
+            'confidential-mode': cleanConfig.security?.['confidential-mode'] ?? true,
             'rate-limit': {
-                rps: 100,
-                burst: 200
+                rps: cleanConfig.security?.['rate-limit']?.rps || 100,
+                burst: cleanConfig.security?.['rate-limit']?.burst || 200
             }
         },
         logging: {
             datadog: {
-                enabled: false,
-                'api-key': 'YOUR_DATADOG_API_KEY',
-                site: 'datadoghq.com',
-                service: cleanConfig.name || 'go-duck-service'
+                enabled: cleanConfig.logging?.datadog?.enabled || false,
+                'api-key': cleanConfig.logging?.datadog?.['api-key'] || 'YOUR_DATADOG_API_KEY',
+                site: cleanConfig.logging?.datadog?.site || 'datadoghq.com',
+                service: cleanConfig.logging?.datadog?.service || cleanConfig.name || 'go-duck-service'
             }
         },
         messaging: {
             mqtt: {
-                enabled: false,
-                broker: 'tcp://localhost:1883',
-                'client-id': (cleanConfig.name || 'go-duck') + '-dev',
-                username: 'dev_user',
-                password: 'dev_password',
-                'topic-prefix': 'go-duck/events'
+                enabled: cleanConfig.messaging?.mqtt?.enabled || false,
+                broker: cleanConfig.messaging?.mqtt?.broker || 'tcp://localhost:1883',
+                'client-id': cleanConfig.messaging?.mqtt?.['client-id'] || (cleanConfig.name || 'go-duck') + '-dev',
+                username: cleanConfig.messaging?.mqtt?.username || 'dev_user',
+                password: cleanConfig.messaging?.mqtt?.password || 'dev_password',
+                'topic-prefix': cleanConfig.messaging?.mqtt?.['topic-prefix'] || 'go-duck/events'
             }
         },
         cache: {
             redis: {
-                enabled: false,
-                host: 'localhost:6379',
-                password: '',
-                db: 0,
-                ttl: '10m'
+                enabled: cleanConfig.cache?.redis?.enabled || false,
+                host: cleanConfig.cache?.redis?.host || 'localhost:6379',
+                password: cleanConfig.cache?.redis?.password || '',
+                db: cleanConfig.cache?.redis?.db || 0,
+                ttl: cleanConfig.cache?.redis?.ttl || '10m'
             }
         },
         resilience: {
             'circuit-breaker': {
-                enabled: true,
-                'failure-threshold': 5,
-                'success-threshold': 2,
-                timeout: '60s'
+                enabled: cleanConfig.resilience?.['circuit-breaker']?.enabled ?? true,
+                'failure-threshold': cleanConfig.resilience?.['circuit-breaker']?.['failure-threshold'] || 5,
+                'success-threshold': cleanConfig.resilience?.['circuit-breaker']?.['success-threshold'] || 2,
+                timeout: cleanConfig.resilience?.['circuit-breaker']?.timeout || '60s'
             }
         },
         telemetry: {
             otel: {
-                enabled: false,
-                endpoint: 'localhost:4317',
-                'sampler-ratio': 1.0
+                enabled: cleanConfig.telemetry?.otel?.enabled || false,
+                endpoint: cleanConfig.telemetry?.otel?.endpoint || 'localhost:4317',
+                'sampler-ratio': cleanConfig.telemetry?.otel?.['sampler-ratio'] || 1.0
+            }
+        },
+        storage: {
+            s3: {
+                enabled: cleanConfig.storage?.s3?.enabled || false,
+                bucket: cleanConfig.storage?.s3?.bucket || 'YOUR_S3_BUCKET',
+                region: cleanConfig.storage?.s3?.region || 'us-east-1',
+                'access-key': cleanConfig.storage?.s3?.['access-key'] || 'YOUR_S3_ACCESS_KEY',
+                'secret-key': cleanConfig.storage?.s3?.['secret-key'] || 'YOUR_S3_SECRET_KEY',
+                endpoint: cleanConfig.storage?.s3?.endpoint || ''
+            },
+            gcs: {
+                enabled: cleanConfig.storage?.gcs?.enabled || false,
+                bucket: cleanConfig.storage?.gcs?.bucket || 'YOUR_GCS_BUCKET',
+                'credentials-file': cleanConfig.storage?.gcs?.['credentials-file'] || 'gcs-service-account.json'
+            },
+            minio: {
+                enabled: cleanConfig.storage?.minio?.enabled || false,
+                bucket: cleanConfig.storage?.minio?.bucket || 'YOUR_MINIO_BUCKET',
+                endpoint: cleanConfig.storage?.minio?.endpoint || 'http://localhost:9000',
+                'access-key': cleanConfig.storage?.minio?.['access-key'] || 'YOUR_MINIO_ACCESS_KEY',
+                'secret-key': cleanConfig.storage?.minio?.['secret-key'] || 'YOUR_MINIO_SECRET_KEY',
+                'use-ssl': cleanConfig.storage?.minio?.['use-ssl'] || false
+            },
+            r2: {
+                enabled: cleanConfig.storage?.r2?.enabled || false,
+                bucket: cleanConfig.storage?.r2?.bucket || 'YOUR_R2_BUCKET',
+                'account-id': cleanConfig.storage?.r2?.['account-id'] || 'YOUR_R2_ACCOUNT_ID',
+                'access-key': cleanConfig.storage?.r2?.['access-key'] || 'YOUR_R2_ACCESS_KEY',
+                'secret-key': cleanConfig.storage?.r2?.['secret-key'] || 'YOUR_R2_SECRET_KEY'
+            },
+            generic: {
+                enabled: cleanConfig.storage?.generic?.enabled || false,
+                provider: cleanConfig.storage?.generic?.provider || 'S3',
+                'access-key': cleanConfig.storage?.generic?.['access-key'] || 'YOUR_ACCESS_KEY',
+                'secret-key': cleanConfig.storage?.generic?.['secret-key'] || 'YOUR_SECRET_KEY'
+            },
+            sftp: {
+                enabled: cleanConfig.storage?.sftp?.enabled || false,
+                host: cleanConfig.storage?.sftp?.host || 'sftp.example.com',
+                port: cleanConfig.storage?.sftp?.port || 22,
+                username: cleanConfig.storage?.sftp?.username || 'sftp_user',
+                password: cleanConfig.storage?.sftp?.password || 'sftp_password',
+                'key-file': cleanConfig.storage?.sftp?.['key-file'] || 'id_rsa',
+                'remote-path': cleanConfig.storage?.sftp?.['remote-path'] || '/uploads'
+            },
+            github: {
+                enabled: cleanConfig.storage?.github?.enabled || false,
+                owner: cleanConfig.storage?.github?.owner || 'YOUR_ORG',
+                repo: cleanConfig.storage?.github?.repo || 'YOUR_REPO',
+                branch: cleanConfig.storage?.github?.branch || 'main',
+                path: cleanConfig.storage?.github?.path || '/',
+                token: cleanConfig.storage?.github?.token || 'YOUR_GITHUB_TOKEN',
+                username: cleanConfig.storage?.github?.username || '',
+                password: cleanConfig.storage?.github?.password || ''
             }
+        },
+        serverless: {
+            enabled: cleanConfig.serverless?.enabled || false,
+            provider: cleanConfig.serverless?.provider || 'aws'
+        },
+        multitenancy: {
+            enabled: cleanConfig.multitenancy?.enabled || false,
+            'hide-silo-names': cleanConfig.multitenancy?.['hide-silo-names'] || false
+        },
+        elasticsearch: {
+            enabled: cleanConfig.elasticsearch?.enabled || false,
+            addresses: cleanConfig.elasticsearch?.addresses || ['http://localhost:9200'],
+            username: cleanConfig.elasticsearch?.username || '',
+            password: cleanConfig.elasticsearch?.password || '',
+            auto_sync: cleanConfig.elasticsearch?.auto_sync ?? true,
+            index_prefix: cleanConfig.elasticsearch?.index_prefix || 'go_duck_'
         }
     };
 
@@ -534,54 +873,55 @@ const generateYAMLConfigs = async (config, outputDir) => {
                 ...extendedConfig.server,
                 cors: {
                     ...extendedConfig.server.cors,
-                    'allow-origins': ['https://your-domain.com']
+                    'allow-origins': cleanConfig.server?.cors?.['allow-origins'] || ['https://your-domain.com']
                 }
             },
             logging: {
                 ...extendedConfig.logging,
                 datadog: {
                     ...extendedConfig.logging.datadog,
-                    enabled: true
+                    enabled: cleanConfig.logging?.datadog?.enabled ?? true
                 }
             },
             messaging: {
                 mqtt: {
-                    enabled: true,
-                    broker: 'tcp://mqtt.production.svc:1883',
-                    'client-id': cleanConfig.name + '-prod',
-                    username: 'prod_user',
-                    password: 'prod_password',
-                    'topic-prefix': 'go-duck/events'
+                    ...extendedConfig.messaging.mqtt,
+                    enabled: cleanConfig.messaging?.mqtt?.enabled ?? true,
+                    broker: cleanConfig.messaging?.mqtt?.broker || 'tcp://mqtt.production.svc:1883',
+                    'client-id': cleanConfig.messaging?.mqtt?.['client-id'] || cleanConfig.name + '-prod'
                 }
             },
             cache: {
                 redis: {
-                    enabled: true,
-                    host: 'redis.production.svc:6379',
-                    password: 'prod_redis_password',
-                    db: 0,
-                    ttl: '1h'
+                    ...extendedConfig.cache.redis,
+                    enabled: cleanConfig.cache?.redis?.enabled ?? true,
+                    host: cleanConfig.cache?.redis?.host || 'redis.production.svc:6379',
+                    ttl: cleanConfig.cache?.redis?.ttl || '1h'
                 }
             },
             resilience: {
                 'circuit-breaker': {
-                    enabled: true,
-                    'failure-threshold': 3,
-                    'success-threshold': 5,
-                    timeout: '30s'
+                    ...extendedConfig.resilience['circuit-breaker'],
+                    enabled: cleanConfig.resilience?.['circuit-breaker']?.enabled ?? true,
+                    'failure-threshold': cleanConfig.resilience?.['circuit-breaker']?.['failure-threshold'] || 3,
+                    'success-threshold': cleanConfig.resilience?.['circuit-breaker']?.['success-threshold'] || 5
                 }
             },
             telemetry: {
                 otel: {
-                    enabled: true,
-                    endpoint: 'otel-collector.monitoring.svc:4317',
-                    'sampler-ratio': 0.1
+                    ...extendedConfig.telemetry.otel,
+                    enabled: cleanConfig.telemetry?.otel?.enabled ?? true,
+                    endpoint: cleanConfig.telemetry?.otel?.endpoint || 'otel-collector.monitoring.svc:4317',
+                    'sampler-ratio': cleanConfig.telemetry?.otel?.['sampler-ratio'] || 0.1
                 }
             },
             datasource: {
                 ...extendedConfig.datasource,
-                'max-open-conns': 100,
-                'max-idle-conns': 50
+                host: cleanConfig.datasource?.host || 'db.production.svc',
+                username: cleanConfig.datasource?.username || 'go_duck_user',
+                password: cleanConfig.datasource?.password || 'go_duck_pass',
+                'max-open-conns': cleanConfig.datasource?.['max-open-conns'] || 100,
+                'max-idle-conns': cleanConfig.datasource?.['max-idle-conns'] || 50
             }
         },
         environment: { active_profile: 'prod' }
@@ -589,4 +929,41 @@ const generateYAMLConfigs = async (config, outputDir) => {
     await fs.writeFile(path.join(outputDir, 'application-prod.yml'), yaml.dump(prodConfig));
 };
 
+program
+    .command('serve')
+    .description('Birth of GO-DUCK: Start the interactive GUI and Documentation server on Port 2026')
+    .action(async () => {
+        const port = 2026;
+        const app = express();
+        const tempDir = path.join(process.cwd(), '.go_duck_birth');
+        
+        console.log(chalk.blue('🦆 Initializing Birth of GO-DUCK (Industrial GUI)...'));
+
+        // Load default config and dummy data for documentation preview
+        const config = { name: 'go-duck-preview' };
+        const entities = []; 
+        const enums = [];
+        const openEntities = [];
+
+        await fs.ensureDir(tempDir);
+        await generateDocumentation(config, entities, tempDir, enums, openEntities);
+
+        const docsPath = path.join(tempDir, 'docs', 'web');
+        app.use(express.static(docsPath));
+
+        app.listen(port, async () => {
+            console.log(chalk.bold.green(`\n🚀 Birth of GO-DUCK Server is ALIVE!`));
+            console.log(chalk.cyan(`🌐 Documentation & Config Wizard: http://localhost:${port}`));
+            console.log(chalk.gray(`Press Ctrl+C to terminate the server.\n`));
+            
+            await open(`http://localhost:${port}/wizard.html`);
+        });
+
+        // Cleanup temp files on exit
+        process.on('SIGINT', async () => {
+            await fs.remove(tempDir);
+            process.exit();
+        });
+    });
+
 program.parse(process.argv);