go-duck-cli 1.0.8 → 1.1.1

package/generators/devops.js

@@ -2,64 +2,82 @@ import fs from 'fs-extra';
 import path from 'path';
 import chalk from 'chalk';
 
-export const generateDeploymentArtifacts = async (config, outputDir) => {
-    const k8sDir = path.join(outputDir, 'k8s');
-    const githubDir = path.join(outputDir, '.github/workflows');
+export const generateDeploymentArtifacts = async (config, projectRootDir) => {
+    const devopsDir = path.join(projectRootDir, 'devops');
+    const k8sDir = path.join(devopsDir, 'k8s');
+    const keycloakDir = path.join(devopsDir, 'keycloak');
+    const githubDir = path.join(projectRootDir, '.github', 'workflows');
+
+    await fs.ensureDir(devopsDir);
     await fs.ensureDir(k8sDir);
+    await fs.ensureDir(keycloakDir);
     await fs.ensureDir(githubDir);
 
-    const appName = config.name || 'go-duck-app';
-    const appPort = 8080;
+    const appName = config.name || 'go-duck';
+    const appPort = config.server?.port || 8080;
 
     // --- 1. Dockerfile (Multi-stage, lean production image) ---
     const dockerfile = `
 # ---- Build Stage ----
-FROM golang:1.22-alpine AS builder
+FROM golang:alpine AS builder
 WORKDIR /app
+
+# Install dependencies for protoc and Kratos
+RUN apk add --no-cache protoc git make curl protobuf-dev
+
+# Install Kratos and Protoc plugins
+RUN go install github.com/go-kratos/kratos/cmd/kratos/v2@latest
+RUN go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
+RUN go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest
+RUN go install github.com/go-kratos/kratos/cmd/protoc-gen-go-http/v2@latest
+RUN go install github.com/go-kratos/kratos/cmd/protoc-gen-go-errors/v2@latest
+RUN go install github.com/google/gnostic/cmd/protoc-gen-openapi@latest
+
+# Download standard google protos
+RUN mkdir -p third_party/google/api && \\
+    curl -sSL https://raw.githubusercontent.com/googleapis/googleapis/master/google/api/annotations.proto > third_party/google/api/annotations.proto && \\
+    curl -sSL https://raw.githubusercontent.com/googleapis/googleapis/master/google/api/http.proto > third_party/google/api/http.proto
+
 COPY go.mod go.sum ./
 RUN go mod download
 COPY . .
+
+# Generate gRPC and HTTP client/server code
+RUN find api -name "*.proto" -exec protoc --proto_path=. \\
+        --proto_path=./api \\
+        --proto_path=./third_party \\
+        --proto_path=/usr/include \\
+        --go_out=paths=source_relative:. \\
+        --go-grpc_out=paths=source_relative:. \\
+        --go-http_out=paths=source_relative:. \\
+        {} +
+
 RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-s -w" -o /app/server .
 
 # ---- Final Stage ----
 FROM gcr.io/distroless/static-debian12
 WORKDIR /app
+
 COPY --from=builder /app/server .
 COPY --from=builder /app/application.yml .
 COPY --from=builder /app/application-dev.yml .
 COPY --from=builder /app/application-prod.yml .
-EXPOSE ${appPort}
+
+EXPOSE 8080
 ENV GO_PROFILE=prod
 ENTRYPOINT ["/app/server"]
 `;
 
-    // --- 2. Docker Compose (Full local dev environment) ---
-    const dockerCompose = `
-version: '3.9'
-
+    // --- 2. services.yml (Infrastructure Services Only - Hard-Pinned Versions for Docker Desktop Stability) ---
+    const servicesYaml = `
 services:
-  app:
-    build: .
-    container_name: ${appName}
-    ports:
-      - "${appPort}:${appPort}"
-    environment:
-      - GO_PROFILE=dev
-    depends_on:
-      - postgres
-      - redis
-      - mosquitto
-      - otel-collector
-    networks:
-      - go-duck-net
-
   postgres:
-    image: postgres:15-alpine
+    image: postgres:15.6-alpine
     container_name: ${appName}-postgres
     environment:
-      POSTGRES_USER: go_duck_user
-      POSTGRES_PASSWORD: go_duck_pass
-      POSTGRES_DB: ${appName}
+      POSTGRES_USER: ${config.datasource?.username || 'postgres'}
+      POSTGRES_PASSWORD: ${config.datasource?.password || 'password'}
+      POSTGRES_DB: ${config.datasource?.database || 'go_duck_master'}
     ports:
       - "5432:5432"
     volumes:
@@ -68,7 +86,7 @@ services:
       - go-duck-net
 
   redis:
-    image: redis:7-alpine
+    image: redis:7.2.4-alpine
     container_name: ${appName}-redis
     ports:
       - "6379:6379"
@@ -77,7 +95,7 @@ services:
       - go-duck-net
 
   mosquitto:
-    image: eclipse-mosquitto:2
+    image: eclipse-mosquitto:2.0.18
     container_name: ${appName}-mqtt
     ports:
       - "1883:1883"
@@ -88,7 +106,7 @@ services:
       - go-duck-net
 
   otel-collector:
-    image: otel/opentelemetry-collector-contrib:latest
+    image: otel/opentelemetry-collector-contrib:0.96.0
     container_name: ${appName}-otel
     command: ["--config=/etc/otel-collector-config.yaml"]
     volumes:
@@ -102,7 +120,7 @@ services:
       - go-duck-net
 
   jaeger:
-    image: jaegertracing/all-in-one:latest
+    image: jaegertracing/all-in-one:1.55
     container_name: ${appName}-jaeger
     ports:
       - "16686:16686"
@@ -110,13 +128,27 @@ services:
     networks:
       - go-duck-net
 
+  elasticsearch:
+    image: docker.elastic.co/elasticsearch/elasticsearch:8.12.2
+    container_name: ${appName}-elasticsearch
+    environment:
+      - discovery.type=single-node
+      - xpack.security.enabled=false
+      - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
+    ports:
+      - "9200:9200"
+    networks:
+      - go-duck-net
+
   keycloak:
-    image: quay.io/keycloak/keycloak:23.0
+    image: quay.io/keycloak/keycloak:23.0.7
     container_name: ${appName}-keycloak
-    command: start-dev
+    command: start-dev --import-realm
     environment:
       KEYCLOAK_ADMIN: admin
       KEYCLOAK_ADMIN_PASSWORD: admin
+    volumes:
+      - ./keycloak/realm-config:/opt/keycloak/data/import
     ports:
       - "8180:8080"
     networks:
@@ -130,7 +162,83 @@ networks:
     driver: bridge
 `;
 
-    // --- 3. MQTT Broker Config ---
+    // --- 3. app.yml (App Service Only - To run the built image) ---
+    const appYaml = `
+services:
+  app:
+    build:
+      context: ..
+      dockerfile: devops/Dockerfile
+    image: ${appName}:latest
+    container_name: ${appName}
+    ports:
+      - "${appPort}:${appPort}"
+    environment:
+      - GO_PROFILE=dev
+      - GO_DUCK_DATASOURCE_HOST=postgres
+      - GO_DUCK_DATASOURCE_USERNAME=${config.datasource?.username || 'postgres'}
+      - GO_DUCK_DATASOURCE_PASSWORD=${config.datasource?.password || 'password'}
+      - GO_DUCK_DATASOURCE_DATABASE=${config.datasource?.database || 'go_duck_master'}
+      - GO_DUCK_DATASOURCE_PORT=5432
+      - GO_DUCK_CACHE_REDIS_HOST=redis:6379
+      - GO_DUCK_MESSAGING_MQTT_BROKER=tcp://mosquitto:1883
+      - GO_DUCK_TELEMETRY_OTEL_ENDPOINT=otel-collector:4317
+      - GO_DUCK_ELASTICSEARCH_ADDRESSES=http://elasticsearch:9200
+    restart: always
+    networks:
+      - go-duck-net
+
+networks:
+  go-duck-net:
+    external: true
+    name: devops_go-duck-net
+`;
+
+    // --- 4. docker-compose.yml (The Main Entry Point - Links app + services) ---
+    const dockerCompose = `
+include:
+  - path: services.yml
+
+services:
+  app:
+    build:
+      context: ..
+      dockerfile: devops/Dockerfile
+    container_name: ${appName}
+    ports:
+      - "${appPort}:${appPort}"
+    environment:
+      - GO_PROFILE=dev
+      - GO_DUCK_DATASOURCE_HOST=postgres
+      - GO_DUCK_DATASOURCE_USERNAME=${config.datasource?.username || 'postgres'}
+      - GO_DUCK_DATASOURCE_PASSWORD=${config.datasource?.password || 'password'}
+      - GO_DUCK_DATASOURCE_DATABASE=${config.datasource?.database || 'go_duck_master'}
+      - GO_DUCK_DATASOURCE_PORT=5432
+      - GO_DUCK_CACHE_REDIS_HOST=redis:6379
+      - GO_DUCK_MESSAGING_MQTT_BROKER=tcp://mosquitto:1883
+      - GO_DUCK_TELEMETRY_OTEL_ENDPOINT=otel-collector:4317
+      - GO_DUCK_ELASTICSEARCH_ADDRESSES=http://elasticsearch:9200
+    depends_on:
+      postgres:
+        condition: service_started
+      redis:
+        condition: service_started
+      mosquitto:
+        condition: service_started
+      otel-collector:
+        condition: service_started
+      elasticsearch:
+        condition: service_started
+    networks:
+      - go-duck-net
+
+networks:
+  go-duck-net:
+    external: true
+    name: devops_go-duck-net
+`;
+
+    // --- 5. MQTT Broker Config ---
     const mosquittoConf = `
 listener 1883
 listener 9001
@@ -138,7 +246,7 @@ protocol websockets
 allow_anonymous true
 `;
 
-    // --- 4. GitHub Actions CI/CD ---
+    // --- 6. GitHub Actions CI/CD ---
     const ciWorkflow = `
 name: CI - Build & Test
 
@@ -157,7 +265,7 @@ jobs:
       - name: Set up Go
         uses: actions/setup-go@v5
         with:
-          go-version: '1.22'
+          go-version: '1.24'
 
       - name: Cache Go modules
         uses: actions/cache@v3
@@ -172,7 +280,7 @@ jobs:
         run: go build -v ./...
 
       - name: Run Tests
-        run: go test -v ./...
+        run: test -v ./...
 `;
 
     const cdWorkflow = `
@@ -202,11 +310,70 @@ jobs:
           tags: \${{ secrets.DOCKER_USERNAME }}/${appName}:latest,\${{ secrets.DOCKER_USERNAME }}/${appName}:\${{ github.sha }}
 `;
 
-    await fs.writeFile(path.join(outputDir, 'Dockerfile'), dockerfile);
-    await fs.writeFile(path.join(outputDir, 'docker-compose.yml'), dockerCompose);
+    // --- 7. Keycloak Realm Export ---
+    const realmName = config.security?.['keycloak-realm'] || 'master';
+    const realmJson = JSON.stringify({
+        "id": realmName,
+        "realm": realmName,
+        "enabled": true,
+        "clients": [
+            {
+                "clientId": `${config.name}-app`,
+                "enabled": true,
+                "publicClient": true,
+                "standardFlowEnabled": true,
+                "directAccessGrantsEnabled": true,
+                "protocol": "openid-connect",
+                "redirectUris": ["*"],
+                "webOrigins": ["*"],
+                "fullScopeAllowed": true
+            },
+            {
+                "clientId": `${config.name}-service`,
+                "enabled": true,
+                "clientAuthenticatorType": "client-secret",
+                "secret": "service-secret-123",
+                "serviceAccountsEnabled": true,
+                "publicClient": false,
+                "protocol": "openid-connect",
+                "fullScopeAllowed": true
+            }
+        ],
+        "users": [
+            {
+                "username": "admin",
+                "email": "admin@go-duck.io",
+                "emailVerified": true,
+                "enabled": true,
+                "requiredActions": [],
+                "credentials": [
+                    { "type": "password", "value": "admin", "temporary": false }
+                ],
+                "realmRoles": ["admin", "offline_access"]
+            },
+            {
+                "username": `service-account-${config.name}-service`,
+                "enabled": true,
+                "serviceAccountClientId": `${config.name}-service`,
+                "realmRoles": ["admin"],
+                "clientRoles": {
+                    "realm-management": ["manage-users", "view-users", "query-groups", "query-users", "realm-admin"]
+                }
+            }
+        ]
+    }, null, 4);
+
+    const realmConfigDir = path.join(devopsDir, 'keycloak', 'realm-config');
+    await fs.ensureDir(realmConfigDir);
+    await fs.writeFile(path.join(realmConfigDir, `${realmName}-realm.json`), realmJson);
+
+    await fs.writeFile(path.join(devopsDir, 'Dockerfile'), dockerfile);
+    await fs.writeFile(path.join(devopsDir, 'services.yml'), servicesYaml);
+    await fs.writeFile(path.join(devopsDir, 'app.yml'), appYaml);
+    await fs.writeFile(path.join(devopsDir, 'docker-compose.yml'), dockerCompose);
     await fs.writeFile(path.join(k8sDir, 'mosquitto.conf'), mosquittoConf);
     await fs.writeFile(path.join(githubDir, 'ci.yml'), ciWorkflow);
     await fs.writeFile(path.join(githubDir, 'cd.yml'), cdWorkflow);
 
-    console.log(chalk.gray('  Generated Dockerfile, Docker Compose & GitHub Actions CI/CD'));
+    console.log(chalk.gray('  Generated devops/Dockerfile, devops/services.yml, devops/app.yml, devops/docker-compose.yml & GitHub Actions CI/CD'));
 };

package/generators/docs.js

@@ -4,7 +4,7 @@ import Handlebars from 'handlebars';
 import chalk from 'chalk';
 import { fileURLToPath } from 'url';
 
-export const generateDocumentation = async (config, entities, outputDir, enums = []) => {
+export const generateDocumentation = async (config, entities, outputDir, enums = [], openEntities = []) => {
     console.log(chalk.cyan('Generating Multi-Page Developer Guide Web App...'));
 
     const docsDir = path.join(outputDir, 'docs', 'web');
@@ -30,23 +30,42 @@ export const generateDocumentation = async (config, entities, outputDir, enums =
 
     const pages = [
         { file: 'index', title: 'Home' },
-        { file: 'gdl', title: 'GDL Reference' },
+        { file: 'legend', title: 'The Legend of GO-DUCK' },
+        { file: 'gdl', title: 'Introduction to GDL' },
+        { file: 'gdl-entities', title: 'GDL: Entities & Fields' },
+        { file: 'gdl-relationships', title: 'GDL: Relationships' },
+        { file: 'gdl-annotations', title: 'GDL: Annotations' },
+        { file: 'gdl-advanced', title: 'GDL: Enums & Open Entities' },
         { file: 'cli', title: 'CLI & Code Injection' },
+        { file: 'configuration', title: 'Master Configuration' },
+        { file: 'wizard', title: '✨ Config Wizard' },
         { file: 'rest', title: 'REST & Search API' },
         { file: 'multitenancy', title: 'Multi-Tenancy' },
+        { file: 'federation', title: 'Federated Architecture' },
+        { file: 'hybrid-store', title: 'Hybrid-Store Architecture' },
         { file: 'grpc', title: 'Kratos gRPC API' },
         { file: 'graphql', title: 'GraphQL Framework' },
         { file: 'realtime', title: 'WebSockets & MQTT' },
         { file: 'audit', title: 'Audit & Metering' },
         { file: 'security', title: 'Security & Auth' },
         { file: 'observability', title: 'Observability' },
-        { file: 'integrations', title: 'Client Integrations' }
+        { file: 'datadog', title: 'Datadog' },
+        { file: 'mosquitto', title: 'Mosquitto' },
+        { file: 'redis', title: 'Redis' },
+        { file: 'otel', title: 'OpenTelemetry & Jaeger' },
+        { file: 'keycloak', title: 'Keycloak' },
+        { file: 'saga', title: 'Distributed Saga & Outbox' },
+        { file: 'storage', title: 'Native Object Storage' },
+        { file: 'elasticsearch', title: 'Elasticsearch Search' },
+        { file: 'integrations', title: 'Client Integrations' },
+        { file: 'serverless', title: 'Serverless Transformation' }
     ];
 
     const context = {
         appName: config.name || 'GO-DUCK App',
         entities: entities,
-        enums: enums
+        enums: enums,
+        openEntities: openEntities
     };
 
     for (const page of pages) {

package/generators/elasticsearch.js

@@ -0,0 +1,263 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+
+export const generateElasticsearchLayer = async (config, entities, outputDir) => {
+    console.log(chalk.cyan('Generating Elasticsearch Search Engine Layer...'));
+
+    const searchDir = path.join(outputDir, 'internal', 'search');
+    await fs.ensureDir(searchDir);
+
+    const clientGo = `package search
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/elastic/go-elasticsearch/v8"
+    "{{appName}}/config"
+)
+
+var Client *elasticsearch.Client
+
+func InitElasticsearch(cfg *config.Config) {
+	if !cfg.GoDuck.Elasticsearch.Enabled {
+		return
+	}
+
+	esCfg := elasticsearch.Config{
+		Addresses: cfg.GoDuck.Elasticsearch.Addresses,
+		Username:  cfg.GoDuck.Elasticsearch.Username,
+		Password:  cfg.GoDuck.Elasticsearch.Password,
+	}
+
+	client, err := elasticsearch.NewClient(esCfg)
+	if err != nil {
+		log.Fatalf("Error creating the Elasticsearch client: %s", err)
+	}
+
+	res, err := client.Info()
+	if err != nil {
+		log.Fatalf("Error getting response from Elasticsearch: %s", err)
+	}
+	defer res.Body.Close()
+
+	if res.IsError() {
+		log.Fatalf("Error response from Elasticsearch: %s", res.String())
+	}
+
+	Client = client
+	fmt.Printf("✅ Elasticsearch initialized at %v\\n", cfg.GoDuck.Elasticsearch.Addresses)
+}
+`;
+
+    const syncGo = `package search
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"github.com/elastic/go-elasticsearch/v8/esapi"
+    "{{appName}}/config"
+)
+
+func SyncToElasticsearch(ctx context.Context, entityName string, id interface{}, data interface{}, cfg *config.Config) error {
+	if Client == nil {
+		return nil
+	}
+
+	indexName := strings.ToLower(fmt.Sprintf("%s%s", cfg.GoDuck.Elasticsearch.IndexPrefix, entityName))
+	
+	payload, err := json.Marshal(data)
+	if err != nil {
+		return err
+	}
+
+	req := esapi.IndexRequest{
+		Index:      indexName,
+		DocumentID: fmt.Sprintf("%v", id),
+		Body:       bytes.NewReader(payload),
+		Refresh:    "true",
+	}
+
+	res, err := req.Do(ctx, Client)
+	if err != nil {
+		return err
+	}
+	defer res.Body.Close()
+
+	if res.IsError() {
+		return fmt.Errorf("error indexing document: %s", res.String())
+	}
+
+	return nil
+}
+
+func DeleteFromElasticsearch(ctx context.Context, entityName string, id interface{}, cfg *config.Config) error {
+	if Client == nil {
+		return nil
+	}
+
+	indexName := strings.ToLower(fmt.Sprintf("%s%s", cfg.GoDuck.Elasticsearch.IndexPrefix, entityName))
+
+	req := esapi.DeleteRequest{
+		Index:      indexName,
+		DocumentID: fmt.Sprintf("%v", id),
+		Refresh:    "true",
+	}
+
+	res, err := req.Do(ctx, Client)
+	if err != nil {
+		return err
+	}
+	defer res.Body.Close()
+
+	return nil
+}
+`;
+
+    const queryGo = `package search
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"github.com/elastic/go-elasticsearch/v8/esapi"
+    "{{appName}}/config"
+)
+
+type SearchResult struct {
+	Total int64       \`json:"total"\`
+	Hits  []interface{} \`json:"hits"\`
+}
+
+// Spring-style Search Execution
+func ExecuteSearch(ctx context.Context, entityName string, queryStr string, cfg *config.Config) (*SearchResult, error) {
+	if Client == nil {
+		return nil, fmt.Errorf("elasticsearch client not initialized")
+	}
+
+	indexName := strings.ToLower(fmt.Sprintf("%s%s", cfg.GoDuck.Elasticsearch.IndexPrefix, entityName))
+
+	// Simplified Spring-style Query (Fuzzy Match All Fields or Specific Term)
+	var query map[string]interface{}
+	if queryStr == "" {
+		query = map[string]interface{}{
+			"query": map[string]interface{}{
+				"match_all": map[string]interface{}{},
+			},
+		}
+	} else {
+		query = map[string]interface{}{
+			"query": map[string]interface{}{
+				"multi_match": map[string]interface{}{
+					"query":  queryStr,
+					"fields": []string{"*"},
+					"fuzziness": "AUTO",
+				},
+			},
+		}
+	}
+
+	var buf bytes.Buffer
+	if err := json.NewEncoder(&buf).Encode(query); err != nil {
+		return nil, err
+	}
+
+	req := esapi.SearchRequest{
+		Index: []string{indexName},
+		Body:  &buf,
+	}
+
+	res, err := req.Do(ctx, Client)
+	if err != nil {
+		return nil, err
+	}
+	defer res.Body.Close()
+
+	if res.IsError() {
+		return nil, fmt.Errorf("search error: %s", res.String())
+	}
+
+	var r map[string]interface{}
+	if err := json.NewDecoder(res.Body).Decode(&r); err != nil {
+		return nil, err
+	}
+
+	hits := r["hits"].(map[string]interface{})["hits"].([]interface{})
+	total := int64(r["hits"].(map[string]interface{})["total"].(map[string]interface{})["value"].(float64))
+
+	results := make([]interface{}, len(hits))
+	for i, hit := range hits {
+		results[i] = hit.(map[string]interface{})["_source"]
+	}
+
+	return &SearchResult{
+		Total: total,
+		Hits:  results,
+	}, nil
+}
+`;
+
+    const appName = config.name || 'app';
+    const replaceAppName = (content) => content.replace(/{{appName}}/g, appName);
+
+    await fs.writeFile(path.join(searchDir, 'client.go'), replaceAppName(clientGo));
+    await fs.writeFile(path.join(searchDir, 'sync.go'), replaceAppName(syncGo));
+    await fs.writeFile(path.join(searchDir, 'query.go'), replaceAppName(queryGo));
+
+    // Generate Search Controller
+    const controllerDir = path.join(outputDir, 'controllers');
+    await fs.ensureDir(controllerDir);
+
+    const searchControllerGo = `package controllers
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+	"{{appName}}/config"
+	"{{appName}}/internal/search"
+)
+
+type ESSearchController struct {
+	Config *config.Config
+}
+
+func NewESSearchController(cfg *config.Config) *ESSearchController {
+	return &ESSearchController{Config: cfg}
+}
+
+// Search godoc
+// @Summary Search entities in Elasticsearch
+// @Description High-performance full-text search with fuzzy matching
+// @Tags Search
+// @Param entity path string true "Entity Name (e.g., car)"
+// @Param q query string false "Search query (Spring-style)"
+// @Produce json
+// @Success 200 {object} search.SearchResult
+// @Router /api/search/{entity} [get]
+func (sc *ESSearchController) GlobalSearch(c *gin.Context) {
+	entity := c.Param("entity")
+	query := c.Query("q")
+
+	result, err := search.ExecuteSearch(c.Request.Context(), entity, query, sc.Config)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, result)
+}
+`;
+
+    await fs.writeFile(path.join(controllerDir, 'es_search_controller.go'), replaceAppName(searchControllerGo));
+
+    console.log(chalk.green('✅ Elasticsearch Search Engine Layer generated successfully.'));
+};