go-duck-cli 1.0.9 → 1.1.12

package/generators/swagger.js

@@ -2,7 +2,7 @@ import fs from 'fs-extra';
 import path from 'path';
 import chalk from 'chalk';
 
-export const generateSwaggerDocs = async (config, entities, outputDir) => {
+export const generateSwaggerDocs = async (config, entities, outputDir, openEntities = []) => {
     const docsDir = path.join(outputDir, 'docs');
     await fs.ensureDir(docsDir);
 
@@ -14,7 +14,7 @@ export const generateSwaggerDocs = async (config, entities, outputDir) => {
             description: `Generated documentation for ${config.name} microservice`
         },
         servers: [
-            { url: 'http://localhost:8080/api', description: 'Local Development Server' }
+            { url: 'http://localhost:8080', description: 'Local Development Server' }
         ],
         paths: {},
         components: {
@@ -28,7 +28,7 @@ export const generateSwaggerDocs = async (config, entities, outputDir) => {
                     type: 'apiKey',
                     in: 'header',
                     name: 'X-Tenant-ID',
-                    description: 'The unique identifier for the tenant dashboard context'
+                    description: 'The unique identifier for the tenant context'
                 }
             },
             schemas: {
@@ -40,6 +40,8 @@ export const generateSwaggerDocs = async (config, entities, outputDir) => {
                 }
             }
         },
+        // Global security applies to /api by default in our implementation, 
+        // but Swagger paths can override this.
         security: [
             { BearerAuth: [], TenantID: [] }
         ]
@@ -49,6 +51,25 @@ export const generateSwaggerDocs = async (config, entities, outputDir) => {
         { name: 'X-Tenant-ID', in: 'header', required: true, schema: { type: 'string', default: 'default' }, description: 'Multi-tenancy context identifier' }
     ];
 
+    const isOpen = (entityName, action) => {
+        if (!openEntities || !Array.isArray(openEntities)) return false;
+        
+        // Check wildcard first
+        const wildcard = openEntities.find(e => e.name === '*');
+        if (wildcard) {
+            if (!action) return true;
+            if (wildcard.actions.includes(action.toLowerCase())) return true;
+        }
+
+        const entry = openEntities.find(e => e.name.toLowerCase() === entityName.toLowerCase());
+        if (entry) {
+            if (!action) return true;
+            if (entry.actions.includes(action.toLowerCase())) return true;
+        }
+
+        return false;
+    };
+
     // 1. Add Entity Paths
     for (const entity of entities) {
         const name = entity.name.toLowerCase();
@@ -68,22 +89,34 @@ export const generateSwaggerDocs = async (config, entities, outputDir) => {
             }
         };
 
-        // POST /entities
-        swagger.paths[`/${name}s`] = {
-            post: {
-                tags: [capitalized],
+        const addEntityOperations = (basePath, isPublic) => {
+            const security = isPublic ? [{ TenantID: [] }] : undefined; // undefined uses global security
+
+            // Unified helper for path registration based on permissions
+            const regPath = (path, method, op, action) => {
+                if (isPublic && !isOpen(capitalized, action)) return;
+                
+                if (!swagger.paths[path]) swagger.paths[path] = {};
+                swagger.paths[path][method] = {
+                    ...op,
+                    tags: [isPublic ? `${capitalized} (Public)` : capitalized],
+                    summary: `${op.summary} ${isPublic ? '(Public)' : ''}`,
+                    security: security
+                };
+            };
+
+            // CRUD Operations
+            regPath(`${basePath}/${name}s`, 'post', {
                 summary: `Create a new ${capitalized}`,
                 parameters: [...commonHeaders],
                 requestBody: {
                     required: true,
                     content: { 'application/json': { schema: { $ref: `#/components/schemas/${capitalized}` } } }
                 },
-                responses: {
-                    201: { description: 'Created', content: { 'application/json': { schema: { $ref: `#/components/schemas/${capitalized}` } } } }
-                }
-            },
-            get: {
-                tags: [capitalized],
+                responses: { 201: { description: 'Created', content: { 'application/json': { schema: { $ref: `#/components/schemas/${capitalized}` } } } } }
+            }, 'create');
+
+            regPath(`${basePath}/${name}s`, 'get', {
                 summary: `Get all ${capitalized}s`,
                 parameters: [
                     ...commonHeaders,
@@ -91,72 +124,59 @@ export const generateSwaggerDocs = async (config, entities, outputDir) => {
                     { name: 'size', in: 'query', schema: { type: 'integer' }, description: 'Records per page' },
                     { name: 'eager', in: 'query', schema: { type: 'boolean' }, description: 'If true, performs SQL Join to fetch relations' }
                 ],
-                responses: {
-                    200: { description: 'OK', content: { 'application/json': { schema: { type: 'array', items: { $ref: `#/components/schemas/${capitalized}` } } } } }
-                }
-            }
-        };
+                responses: { 200: { description: 'OK', content: { 'application/json': { schema: { type: 'array', items: { $ref: `#/components/schemas/${capitalized}` } } } } } }
+            }, 'read');
 
-        // GET/PUT/PATCH/DELETE /entities/:id
-        swagger.paths[`/${name}s/{id}`] = {
-            get: {
-                tags: [capitalized],
+            regPath(`${basePath}/${name}s/{id}`, 'get', {
                 summary: `Get ${capitalized} by ID`,
                 parameters: [
                     ...commonHeaders,
                     { name: 'id', in: 'path', required: true, schema: { type: 'integer' } },
                     { name: 'eager', in: 'query', schema: { type: 'boolean' } }
                 ],
-                responses: {
-                    200: { description: 'OK', content: { 'application/json': { schema: { $ref: `#/components/schemas/${capitalized}` } } } }
-                }
-            },
-            put: {
-                tags: [capitalized],
+                responses: { 200: { description: 'OK', content: { 'application/json': { schema: { $ref: `#/components/schemas/${capitalized}` } } } } }
+            }, 'read');
+
+            regPath(`${basePath}/${name}s/{id}`, 'put', {
                 summary: `Update ${capitalized}`,
                 parameters: [...commonHeaders, { name: 'id', in: 'path', required: true, schema: { type: 'integer' } }],
-                responses: {
-                    200: { description: 'Updated', content: { 'application/json': { schema: { $ref: `#/components/schemas/${capitalized}` } } } }
-                }
-            },
-            delete: {
-                tags: [capitalized],
+                responses: { 200: { description: 'Updated', content: { 'application/json': { schema: { $ref: `#/components/schemas/${capitalized}` } } } } }
+            }, 'update');
+
+            regPath(`${basePath}/${name}s/{id}`, 'patch', {
+                summary: `Patch ${capitalized}`,
+                parameters: [...commonHeaders, { name: 'id', in: 'path', required: true, schema: { type: 'integer' } }],
+                responses: { 200: { description: 'Patched' } }
+            }, 'update');
+
+            regPath(`${basePath}/${name}s/{id}`, 'delete', {
                 summary: `Delete ${capitalized}`,
                 parameters: [...commonHeaders, { name: 'id', in: 'path', required: true, schema: { type: 'integer' } }],
-                responses: {
-                    204: { description: 'No Content' }
-                }
-            }
-        };
+                responses: { 204: { description: 'No Content' } }
+            }, 'delete');
 
-        // BULK Operations /entities/bulk
-        swagger.paths[`/${name}s/bulk`] = {
-            post: {
-                tags: [capitalized],
+            // Bulk Operations
+            regPath(`${basePath}/${name}s/bulk`, 'post', {
                 summary: `Bulk Create ${capitalized}s`,
                 parameters: [...commonHeaders],
                 requestBody: {
                     required: true,
                     content: { 'application/json': { schema: { type: 'array', items: { $ref: `#/components/schemas/${capitalized}` } } } }
                 },
-                responses: {
-                    201: { description: 'Created', content: { 'application/json': { schema: { type: 'array', items: { $ref: `#/components/schemas/${capitalized}` } } } } }
-                }
-            },
-            put: {
-                tags: [capitalized],
+                responses: { 201: { description: 'Created' } }
+            }, 'create');
+
+            regPath(`${basePath}/${name}s/bulk`, 'put', {
                 summary: `Bulk Update ${capitalized}s`,
                 parameters: [...commonHeaders],
                 requestBody: {
                     required: true,
                     content: { 'application/json': { schema: { type: 'array', items: { $ref: `#/components/schemas/${capitalized}` } } } }
                 },
-                responses: {
-                    200: { description: 'Updated', content: { 'application/json': { schema: { type: 'array', items: { $ref: `#/components/schemas/${capitalized}` } } } } }
-                }
-            },
-            patch: {
-                tags: [capitalized],
+                responses: { 200: { description: 'Updated' } }
+            }, 'update');
+
+            regPath(`${basePath}/${name}s/bulk`, 'patch', {
                 summary: `Bulk Patch ${capitalized}s`,
                 parameters: [...commonHeaders],
                 requestBody: {
@@ -173,14 +193,18 @@ export const generateSwaggerDocs = async (config, entities, outputDir) => {
                                     }
                                 } 
                             } 
-                        } 
+                        }
                     }
                 },
-                responses: {
-                    200: { description: 'Patched' }
-                }
-            }
+                responses: { 200: { description: 'Patched' } }
+            }, 'update');
         };
+
+        // 1a. Secured Paths
+        addEntityOperations('/api', false);
+
+        // 1b. Public Paths (if marked as open)
+        addEntityOperations('/open/api', true);
     }
 
     // 2. Add System Paths

package/generators/telemetry.js

@@ -4,7 +4,7 @@ import chalk from 'chalk';
 
 export const generateTelemetryCode = async (config, outputDir) => {
     const telemetryDir = path.join(outputDir, 'internal/telemetry');
-    const k8sDir = path.join(outputDir, 'k8s');
+    const k8sDir = path.join(outputDir, 'devops/k8s');
 
     await fs.ensureDir(telemetryDir);
     await fs.ensureDir(k8sDir);
@@ -16,7 +16,6 @@ import (
 	"context"
 	"fmt"
 	"log"
-	"time"
 
 	"{{app_name}}/config"
 	"go.opentelemetry.io/otel"
@@ -82,36 +81,28 @@ func InitTelemetry(cfg *config.Config) (func(context.Context) error, error) {
 `;
 
     const otelCollectorK8s = `
-apiVersion: v1
-kind: ConfigMap
-metadata:
-  name: otel-collector-conf
-  labels:
-    app: {{app_name}}
-data:
-  otel-collector-config.yaml: |
-    receivers:
-      otlp:
-        protocols:
-          grpc:
-          http:
-    processors:
-      batch:
-      resourcedetection:
-        detectors: [env, system]
-    exporters:
-      logging:
-        loglevel: debug
-      otlp:
-        endpoint: "jaeger-collector:4317"
-        tls:
-          insecure: true
-    service:
-      pipelines:
-        traces:
-          receivers: [otlp]
-          processors: [batch, resourcedetection]
-          exporters: [logging, otlp]
+receivers:
+  otlp:
+    protocols:
+      grpc:
+      http:
+processors:
+  batch:
+  resourcedetection:
+    detectors: [env, system]
+exporters:
+  logging:
+    loglevel: debug
+  otlp:
+    endpoint: "jaeger:4317"
+    tls:
+      insecure: true
+service:
+  pipelines:
+    traces:
+      receivers: [otlp]
+      processors: [batch, resourcedetection]
+      exporters: [logging, otlp]
 `;
 
     await fs.writeFile(path.join(telemetryDir, 'otel.go'), otelGo.replace(/{{app_name}}/g, config.name));

package/generators/websocket.js

@@ -18,8 +18,6 @@ import (
 	"fmt"
 	"log"
 	"net/http"
-	"sync"
-	"{{app_name}}/controllers"
 
 	"github.com/gin-gonic/gin"
 	"github.com/gorilla/websocket"
@@ -98,9 +96,16 @@ func (d *RESToverWSDispatcher) HandleConnection(c *gin.Context) {
 			span.End()
             continue
         }
+		siloConns, exists := c.Get("tenantSiloConns")
+		if !exists {
+			d.sendError(conn, "Unauthorized: No tenant context", wsMsg.Action, wsMsg.TraceParent)
+			span.End()
+			continue
+		}
+		conns := siloConns.(map[string]*gorm.DB)
 
-		// 4. Dispatch to MVC Controllers
-		d.dispatch(childCtx, conn, wsMsg)
+		// 4. Dispatch to MVC Controllers (Federated)
+		d.dispatch(childCtx, conn, wsMsg, conns)
 		span.End()
 	}
 }
@@ -112,13 +117,30 @@ func (d *RESToverWSDispatcher) verifySignature(payload []byte, signature string)
     return hmac.Equal([]byte(expectedSignature), []byte(signature))
 }
 
-func (d *RESToverWSDispatcher) dispatch(ctx context.Context, conn *websocket.Conn, msg WSMessage) {
+func (d *RESToverWSDispatcher) dispatch(ctx context.Context, conn *websocket.Conn, msg WSMessage, conns map[string]*gorm.DB) {
 	// Inject current span into response header for client to trace back
 	carrier := propagation.HeaderCarrier{}
 	otel.GetTextMapPropagator().Inject(ctx, carrier)
 	tp := carrier.Get("traceparent")
 
 	switch msg.Action {
+	{{#each entities}}
+	case "GET_{{upper name}}S":
+		federatedData := make(map[string]interface{})
+		for role, db := range conns {
+			var list []map[string]interface{}
+			db.WithContext(ctx).Table("{{lower name}}").Find(&list)
+			federatedData[role] = list
+		}
+		d.sendResponse(conn, msg.Action, federatedData, tp)
+	case "CREATE_{{upper name}}":
+		for role, db := range conns {
+			// Proxy creation to DB
+			db.WithContext(ctx).Exec("INSERT INTO {{lower name}} (data) VALUES (?)", string(msg.Payload))
+			log.Printf("Federated JS broadcast to silo: %s", role)
+		}
+		d.sendResponse(conn, msg.Action, "Federated broadcast complete", tp)
+	{{/each}}
 	default:
 		d.sendError(conn, "Unknown action", msg.Action, tp)
 	}
@@ -135,28 +157,40 @@ func (d *RESToverWSDispatcher) sendError(conn *websocket.Conn, err string, actio
 }
 `;
 
+    // JavaScript Entity helper injection
+	let entitiesBlock = "";
+	// ... handled by template string above ...
+
 	const wsContent = wsHandler.replace(/{{app_name}}/g, config.name);
 	let finalContent = wsContent;
-	let entitiesBlock = "";
-	for (const entity of entities) {
-		entitiesBlock += `
-	case "GET_${entity.name.toUpperCase()}S":
-		var list${entity.name} []map[string]interface{}
-		// Note: In a production app, we'd use gorm statement timeout and tracing hooks
-		d.DB.WithContext(ctx).Table("${entity.name.toLowerCase()}").Find(&list${entity.name})
-		d.sendResponse(conn, msg.Action, list${entity.name}, tp)
-    case "CREATE_${entity.name.toUpperCase()}":
-        d.sendResponse(conn, msg.Action, "${entity.name} creation processing...", tp)
-    `;
-	}
+	
+    // Handled via Replace logic to inject entities into the switch
+    let entitiesIter = entities.map(e => {
+        return `
+    case "GET_${e.name.toUpperCase()}S":
+        federatedData := make(map[string]interface{})
+        for role, db := range conns {
+            var list []map[string]interface{}
+            db.WithContext(ctx).Table("${e.name.toLowerCase()}").Find(&list)
+            federatedData[role] = list
+        }
+        d.sendResponse(conn, msg.Action, federatedData, tp)
+    case "CREATE_${e.name.toUpperCase()}":
+        for role, db := range conns {
+            _ = db // Acknowledge for POC
+            // Simplified broadcast for POC
+            d.sendResponse(conn, msg.Action, "Federated broadcast for ${e.name} to " + role, tp)
+        }
+        `;
+    }).join('\n');
 
-	finalContent = finalContent.replace("{{#each entities}}", "").replace("{{/each}}", "");
-	const startTag = "switch msg.Action {";
+    finalContent = finalContent.replace('{{#each entities}}', '').replace('{{/each}}', '');
+    const startTag = "switch msg.Action {";
 	const endTag = "default:";
 	const parts = finalContent.split(startTag);
 	const endParts = parts[1].split(endTag);
-	finalContent = parts[0] + startTag + entitiesBlock + endTag + endParts[1];
+	finalContent = parts[0] + startTag + entitiesIter + endTag + endParts[1];
 
 	await fs.writeFile(path.join(wsDir, 'handler.go'), finalContent);
-	console.log(chalk.gray('  Generated REST-over-WS Dispatcher with Traced-Envelope'));
+	console.log(chalk.green('✅ Federated REST-over-WS Dispatcher generated!'));
 };