go-duck-cli 1.0.0

package/generators/swagger.js

@@ -0,0 +1,145 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+
+export const generateSwaggerDocs = async (config, entities, outputDir) => {
+    const docsDir = path.join(outputDir, 'docs');
+    await fs.ensureDir(docsDir);
+
+    const swagger = {
+        openapi: '3.0.0',
+        info: {
+            title: `${config.name} API`,
+            version: '1.0.0',
+            description: `Generated documentation for ${config.name} microservice`
+        },
+        servers: [
+            { url: 'http://localhost:8080/api', description: 'Local Development Server' }
+        ],
+        paths: {},
+        components: {
+            schemas: {
+                Error: {
+                    type: 'object',
+                    properties: {
+                        error: { type: 'string' }
+                    }
+                }
+            }
+        }
+    };
+
+    // 1. Add Entity Paths
+    for (const entity of entities) {
+        const name = entity.name.toLowerCase();
+        const capitalized = entity.name;
+
+        // Add Schema for Entity
+        swagger.components.schemas[capitalized] = {
+            type: 'object',
+            properties: {
+                id: { type: 'integer' },
+                ...entity.fields.reduce((acc, field) => {
+                    acc[field.name] = { type: mapToSwaggerType(field.type) };
+                    return acc;
+                }, {}),
+                createdAt: { type: 'string', format: 'date-time' },
+                updatedAt: { type: 'string', format: 'date-time' }
+            }
+        };
+
+        // POST /entities
+        swagger.paths[`/${name}s`] = {
+            post: {
+                tags: [capitalized],
+                summary: `Create a new ${capitalized}`,
+                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],
+                summary: `Get all ${capitalized}s`,
+                parameters: [
+                    { name: 'page', in: 'query', schema: { type: 'integer' } },
+                    { name: 'size', in: 'query', schema: { type: 'integer' } },
+                    { name: 'eager', in: 'query', schema: { type: 'boolean' } }
+                ],
+                responses: {
+                    200: { description: 'OK', content: { 'application/json': { schema: { type: 'array', items: { $ref: `#/components/schemas/${capitalized}` } } } } }
+                }
+            }
+        };
+
+        // GET/PUT/PATCH/DELETE /entities/:id
+        swagger.paths[`/${name}s/{id}`] = {
+            get: {
+                tags: [capitalized],
+                summary: `Get ${capitalized} by ID`,
+                parameters: [{ name: 'id', in: 'path', required: true, schema: { type: 'integer' } }],
+                responses: {
+                    200: { description: 'OK', content: { 'application/json': { schema: { $ref: `#/components/schemas/${capitalized}` } } } }
+                }
+            },
+            put: {
+                tags: [capitalized],
+                summary: `Update ${capitalized}`,
+                parameters: [{ name: 'id', in: 'path', required: true, schema: { type: 'integer' } }],
+                responses: {
+                    200: { description: 'Updated', content: { 'application/json': { schema: { $ref: `#/components/schemas/${capitalized}` } } } }
+                }
+            },
+            delete: {
+                tags: [capitalized],
+                summary: `Delete ${capitalized}`,
+                parameters: [{ name: 'id', in: 'path', required: true, schema: { type: 'integer' } }],
+                responses: {
+                    204: { description: 'No Content' }
+                }
+            }
+        };
+    }
+
+    // 2. Add System Paths
+    swagger.paths['/rpc/{table}'] = {
+        get: {
+            tags: ['Search'],
+            summary: 'Generic PostgREST-like Search',
+            parameters: [
+                { name: 'table', in: 'path', required: true, schema: { type: 'string' } },
+                { name: 'order', in: 'query', schema: { type: 'string' } },
+                { name: 'limit', in: 'query', schema: { type: 'integer' } }
+            ],
+            responses: { 200: { description: 'OK' } }
+        }
+    };
+
+    swagger.paths['/audit'] = {
+        get: {
+            tags: ['Audit'],
+            summary: 'View Audit Logs',
+            responses: { 200: { description: 'OK' } }
+        }
+    };
+
+    await fs.writeJson(path.join(docsDir, 'swagger.json'), swagger, { spaces: 2 });
+    console.log(chalk.gray('  Generated Swagger Documentation: swagger.json'));
+};
+
+const mapToSwaggerType = (type) => {
+    const types = {
+        'String': 'string',
+        'Integer': 'integer',
+        'Float': 'number',
+        'Boolean': 'boolean',
+        'Long': 'integer',
+        'BigDecimal': 'number',
+        'LocalDate': 'string',
+        'Instant': 'string'
+    };
+    return types[type] || 'string';
+};

package/generators/telemetry.js

@@ -0,0 +1,121 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+
+export const generateTelemetryCode = async (config, outputDir) => {
+    const telemetryDir = path.join(outputDir, 'internal/telemetry');
+    const k8sDir = path.join(outputDir, 'k8s');
+
+    await fs.ensureDir(telemetryDir);
+    await fs.ensureDir(k8sDir);
+
+    const otelGo = `
+package telemetry
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"time"
+
+	"{{app_name}}/config"
+	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
+	"go.opentelemetry.io/otel/propagation"
+	"go.opentelemetry.io/otel/sdk/resource"
+	sdktrace "go.opentelemetry.io/otel/sdk/trace"
+	semconv "go.opentelemetry.io/otel/semconv/v1.12.0"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/insecure"
+)
+
+// InitTelemetry initializes OpenTelemetry SDK
+func InitTelemetry(cfg *config.Config) (func(context.Context) error, error) {
+	if !cfg.GoDuck.Telemetry.OTel.Enabled {
+		log.Println("OpenTelemetry is disabled.")
+		return func(context.Context) error { return nil }, nil
+	}
+
+	ctx := context.Background()
+
+	// 1. Setup Resource
+	res, err := resource.New(ctx,
+		resource.WithAttributes(
+			semconv.ServiceNameKey.String(cfg.GoDuck.Name),
+			semconv.ServiceVersionKey.String(cfg.GoDuck.Version),
+		),
+	)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create resource: %w", err)
+	}
+
+	// 2. Setup OTLP Exporter (gRPC)
+	conn, err := grpc.DialContext(ctx, cfg.GoDuck.Telemetry.OTel.Endpoint,
+		grpc.WithTransportCredentials(insecure.NewCredentials()),
+		grpc.WithBlock(),
+	)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create gRPC connection to OTel collector: %w", err)
+	}
+
+	traceExporter, err := otlptracegrpc.New(ctx, otlptracegrpc.WithGRPCConn(conn))
+	if err != nil {
+		return nil, fmt.Errorf("failed to create trace exporter: %w", err)
+	}
+
+	// 3. Setup Tracer Provider
+	bsp := sdktrace.NewBatchSpanProcessor(traceExporter)
+	tp := sdktrace.NewTracerProvider(
+		sdktrace.WithSampler(sdktrace.TraceIDRatioBased(cfg.GoDuck.Telemetry.OTel.SamplerRatio)),
+		sdktrace.WithResource(res),
+		sdktrace.WithSpanProcessor(bsp),
+	)
+	otel.SetTracerProvider(tp)
+
+	// 4. Setup Text Map Propagator
+	otel.SetTextMapPropagator(propagation.NewCompositeTextMapPropagator(propagation.TraceContext{}, propagation.Baggage{}))
+
+	log.Printf("OpenTelemetry initialized with endpoint: %s", cfg.GoDuck.Telemetry.OTel.Endpoint)
+
+	return tp.Shutdown, nil
+}
+`;
+
+    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]
+`;
+
+    await fs.writeFile(path.join(telemetryDir, 'otel.go'), otelGo.replace(/{{app_name}}/g, config.name));
+    await fs.writeFile(path.join(k8sDir, 'otel-collector.yml'), otelCollectorK8s.replace(/{{app_name}}/g, config.name));
+
+    console.log(chalk.gray('  Generated OpenTelemetry Telemetry Package & K8s Config'));
+};

package/generators/websocket.js

@@ -0,0 +1,162 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+
+export const generateWebSocketCode = async (config, entities, outputDir) => {
+	const wsDir = path.join(outputDir, 'ws');
+	await fs.ensureDir(wsDir);
+
+	const wsHandler = `
+package ws
+
+import (
+	"context"
+	"crypto/hmac"
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"log"
+	"net/http"
+	"sync"
+	"{{app_name}}/controllers"
+
+	"github.com/gin-gonic/gin"
+	"github.com/gorilla/websocket"
+	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/propagation"
+	"go.opentelemetry.io/otel/trace"
+	"gorm.io/gorm"
+)
+
+var upgrader = websocket.Upgrader{
+	CheckOrigin: func(r *http.Request) bool { return true },
+}
+
+type WSMessage struct {
+	Action      string          \`json:"action"\`
+	Payload     json.RawMessage \`json:"payload"\`
+	Signature   string          \`json:"signature"\`
+	TraceParent string          \`json:"traceparent,omitempty"\` // W3C TraceParent
+}
+
+type WSResponse struct {
+	Action      string      \`json:"action"\`
+	Data        interface{} \`json:"data"\`
+	Error       string      \`json:"error,omitempty"\`
+	TraceParent string      \`json:"traceparent,omitempty"\`
+}
+
+// RESToverWSDispatcher handles the mapping from WS actions to Controller logic
+type RESToverWSDispatcher struct {
+	DB *gorm.DB
+    SecretKey []byte
+	Tracer    trace.Tracer
+}
+
+func NewDispatcher(db *gorm.DB) *RESToverWSDispatcher {
+	return &RESToverWSDispatcher{
+		DB: db,
+        SecretKey: []byte("go-duck-super-secret-key"),
+		Tracer:    otel.Tracer("ws-dispatcher"),
+	}
+}
+
+func (d *RESToverWSDispatcher) HandleConnection(c *gin.Context) {
+	conn, err := upgrader.Upgrade(c.Writer, c.Request, nil)
+	if err != nil {
+		log.Printf("WS Upgrade error: %v", err)
+		return
+	}
+	defer conn.Close()
+
+	for {
+		_, message, err := conn.ReadMessage()
+		if err != nil {
+			break
+		}
+
+		var wsMsg WSMessage
+		if err := json.Unmarshal(message, &wsMsg); err != nil {
+			d.sendError(conn, "Invalid JSON format", wsMsg.Action, "")
+			continue
+		}
+
+		// 1. Extract Parent Trace Context
+		ctx := context.Background()
+		if wsMsg.TraceParent != "" {
+			propagator := otel.GetTextMapPropagator()
+			ctx = propagator.Extract(ctx, propagation.HeaderCarrier{"traceparent": []string{wsMsg.TraceParent}})
+		}
+
+		// 2. Start WS-Action Span
+		childCtx, span := d.Tracer.Start(ctx, fmt.Sprintf("WS Action: %s", wsMsg.Action))
+		
+        // 3. Verify Message Signature (Payload Integrity)
+        if !d.verifySignature(wsMsg.Payload, wsMsg.Signature) {
+            d.sendError(conn, "Invalid signature: Payload compromised", wsMsg.Action, wsMsg.TraceParent)
+			span.End()
+            continue
+        }
+
+		// 4. Dispatch to MVC Controllers
+		d.dispatch(childCtx, conn, wsMsg)
+		span.End()
+	}
+}
+
+func (d *RESToverWSDispatcher) verifySignature(payload []byte, signature string) bool {
+    h := hmac.New(sha256.New, d.SecretKey)
+    h.Write(payload)
+    expectedSignature := hex.EncodeToString(h.Sum(nil))
+    return hmac.Equal([]byte(expectedSignature), []byte(signature))
+}
+
+func (d *RESToverWSDispatcher) dispatch(ctx context.Context, conn *websocket.Conn, msg WSMessage) {
+	// 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 {
+	default:
+		d.sendError(conn, "Unknown action", msg.Action, tp)
+	}
+}
+
+func (d *RESToverWSDispatcher) sendResponse(conn *websocket.Conn, action string, data interface{}, tp string) {
+	resp := WSResponse{Action: action, Data: data, TraceParent: tp}
+	conn.WriteJSON(resp)
+}
+
+func (d *RESToverWSDispatcher) sendError(conn *websocket.Conn, err string, action string, tp string) {
+	resp := WSResponse{Action: action, Error: err, TraceParent: tp}
+	conn.WriteJSON(resp)
+}
+`;
+
+	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)
+    `;
+	}
+
+	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];
+
+	await fs.writeFile(path.join(wsDir, 'handler.go'), finalContent);
+	console.log(chalk.gray('  Generated REST-over-WS Dispatcher with Traced-Envelope'));
+};