go-duck-cli 1.0.9 → 1.1.1

package/generators/kratos.js

@@ -14,63 +14,87 @@ export const generateKratosCode = async (entities, projectRootDir, projectName,
     await fs.ensureDir(serviceDir);
     await fs.ensureDir(serverDir);
 
-    const protoTemplateSource = await fs.readFile(path.join(process.cwd(), 'templates', 'proto', 'entity.proto.hbs'), 'utf8');
+    const __dirname = path.dirname(import.meta.url.replace('file://', ''));
+    const templateBase = path.resolve(__dirname, '..', 'templates');
+
+    const protoTemplateSource = await fs.readFile(path.join(templateBase, 'proto', 'entity.proto.hbs'), 'utf8');
     const protoTemplate = Handlebars.compile(protoTemplateSource);
 
-    const serviceTemplateSource = await fs.readFile(path.join(process.cwd(), 'templates', 'kratos', 'service.go.hbs'), 'utf8');
+    const serviceTemplateSource = await fs.readFile(path.join(templateBase, 'kratos', 'service.go.hbs'), 'utf8');
     const serviceTemplate = Handlebars.compile(serviceTemplateSource);
 
     // Helpers for Proto types
     Handlebars.registerHelper('toProtoType', (type) => {
-        const isEnum = enums.some(e => e.name === type);
-        // Map enums to string in proto to match the Go string enums for simpler POC
+        const t = (type || 'string').toLowerCase();
+        const isEnum = enums.some(e => e.name.toLowerCase() === t);
         if (isEnum) return 'string';
 
         const map = {
-            'String': 'string',
-            'Integer': 'int32',
-            'Long': 'int64',
-            'Float': 'float',
-            'BigDecimal': 'double',
-            'Boolean': 'bool',
-            'LocalDate': 'string',
-            'Instant': 'string',
-            'Text': 'string',
-            'JSON': 'string',
-            'JSONB': 'string'
+            'string': 'string',
+            'int': 'int32',
+            'integer': 'int32',
+            'long': 'int64',
+            'float': 'float',
+            'bigdecimal': 'double',
+            'bool': 'bool',
+            'boolean': 'bool',
+            'localdate': 'string',
+            'instant': 'string',
+            'datetime': 'string',
+            'text': 'string',
+            'json': 'string',
+            'jsonb': 'string'
         };
-        return map[type] || 'string';
+        return map[t] || 'string';
     });
 
     Handlebars.registerHelper('toGoCast', (type) => {
-        const isEnum = enums.some(e => e.name === type);
-        if (isEnum) return `models.${type}`;
+        const t = (type || '').toLowerCase();
+        const isEnum = enums.some(e => e.name.toLowerCase() === t);
+        if (isEnum) {
+             const en = enums.find(e => e.name.toLowerCase() === t);
+             return `models.${en.name}`;
+        }
 
         const map = {
-            'Integer': 'int',
-            'Long': 'int64',
-            'Float': 'float64',
-            'BigDecimal': 'float64',
-            'Boolean': 'bool',
-            'JSON': 'datatypes.JSON',
-            'JSONB': 'datatypes.JSON'
+            'int': 'int',
+            'integer': 'int',
+            'long': 'int64',
+            'float': 'float64',
+            'bigdecimal': 'float64',
+            'bool': 'bool',
+            'boolean': 'bool',
+            'json': 'datatypes.JSON',
+            'jsonb': 'datatypes.JSON'
         };
-        return map[type] || '';
+        return map[t] || '';
     });
 
     Handlebars.registerHelper('toProtoCast', (type) => {
-        const isEnum = enums.some(e => e.name === type);
+        const t = (type || '').toLowerCase();
+        const isEnum = enums.some(e => e.name.toLowerCase() === t);
         if (isEnum) return 'string';
 
         const map = {
-            'Integer': 'int32',
-            'Long': 'int64',
-            'Float': 'float32',
-            'BigDecimal': 'double',
-            'JSON': 'string',
-            'JSONB': 'string'
+            'int': 'int32',
+            'integer': 'int32',
+            'long': 'int64',
+            'float': 'float32',
+            'bigdecimal': 'float64',
+            'json': 'string',
+            'jsonb': 'string'
         };
-        return map[type] || '';
+        return map[t] || '';
+    });
+
+    Handlebars.registerHelper('toProtoFieldName', (str) => {
+        if (typeof str !== 'string') return '';
+        return str.split('_').map(s => s.charAt(0).toUpperCase() + s.slice(1)).join('');
+    });
+
+    Handlebars.registerHelper('capitalize', (str) => {
+        if (typeof str !== 'string') return '';
+        return str.replace(/(?:^|_| )(\w)/g, (match, p1) => p1.toUpperCase());
     });
 
     Handlebars.registerHelper('add', (a, b) => {
@@ -79,10 +103,38 @@ export const generateKratosCode = async (entities, projectRootDir, projectName,
 
     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 => {
+            const t = (f.type || '').toLowerCase();
+            return t === 'json' || t === 'jsonb';
+        });
     });
 
-    Handlebars.registerHelper('isJson', (type) => type === 'JSON' || type === 'JSONB');
+    Handlebars.registerHelper('hasNested', (fields) => {
+        if (!fields || !Array.isArray(fields)) return false;
+        return fields.some(f => f.isNested);
+    });
+
+    Handlebars.registerHelper('isJson', (type) => {
+        const t = (type || '').toLowerCase();
+        return t === 'json' || t === 'jsonb';
+    });
+
+    Handlebars.registerHelper('or', function() {
+        return Array.prototype.slice.call(arguments, 0, -1).some(Boolean);
+    });
+
+    Handlebars.registerHelper('hasDate', (fields) => {
+        if (!fields || !Array.isArray(fields)) return false;
+        return fields.some(f => {
+            const t = (f.type || '').toLowerCase();
+            return t === 'localdate' || t === 'instant' || t === 'datetime';
+        });
+    });
+
+    Handlebars.registerHelper('hasInstant', (fields) => {
+        if (!fields || !Array.isArray(fields)) return false;
+        return fields.some(f => (f.type || '').toLowerCase() === 'instant' || (f.type || '').toLowerCase() === 'datetime');
+    });
 
     for (const entity of entities) {
         const context = {
@@ -90,6 +142,9 @@ export const generateKratosCode = async (entities, projectRootDir, projectName,
             capitalize: (s) => s.charAt(0).toUpperCase() + s.slice(1),
             lower: (s) => s.toLowerCase(),
             fields: entity.fields,
+            annotation: entity.annotation, 
+            isDocument: entity.isDocument || false,
+            isAudited: entity.isAudited || false,
             projectName,
             enums
         };
@@ -106,6 +161,62 @@ export const generateKratosCode = async (entities, projectRootDir, projectName,
     // 3. Generate Auth Middleware & gRPC Server with Kratos
     await generateKratosServer(serverDir, projectName, entities);
 
+    // 4. Generate utils.go for shared helpers
+    const utilsContent = `package service
+
+import "time"
+
+func parseDate(s string) time.Time {
+	t, _ := time.Parse("2006-01-02", s)
+	return t
+}
+
+func parseInstant(s string) time.Time {
+	t, _ := time.Parse(time.RFC3339, s)
+	return t
+}
+`;
+    await fs.writeFile(path.join(serviceDir, 'utils.go'), utilsContent);
+
+    // 5. Setup third_party dependencies (google/api) - Automated for all new projects
+    const tpDir = path.join(projectRootDir, 'third_party', 'google', 'api');
+    await fs.ensureDir(tpDir);
+    
+    // 6. Add duck.go package marker - This stops the "package not in std" error instantly
+    await fs.writeFile(path.join(apiDir, 'duck.go'), 'package v1\n');
+
+    // 7. We provide a script to download these since we want to keep the CLI lightweight but the app functional
+    const generateSh = `#!/bin/bash
+# GO-DUCK Protos Generator
+set -e
+
+# 1. Detect Path
+export GOBIN=$(go env GOPATH)/bin
+export PATH=$PATH:$GOBIN
+
+echo "🦆 Syncing Protobuf Dependencies..."
+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
+
+echo "🏗️ Compiling API Layer..."
+if ! command -v protoc &> /dev/null; then
+    echo "❌ Error: 'protoc' not found. Please install: brew install protobuf"
+    exit 1
+fi
+
+find api -name "*.proto" -exec protoc --proto_path=. \\
+        --proto_path=./api \\
+        --proto_path=./third_party \\
+        --go_out=paths=source_relative:. \\
+        --go-grpc_out=paths=source_relative:. \\
+        {} +
+
+echo "✅ Protos compiled successfully!"
+`;
+    await fs.writeFile(path.join(projectRootDir, 'generate.sh'), generateSh);
+    await fs.chmod(path.join(projectRootDir, 'generate.sh'), 0o755);
+
     console.log(chalk.green('✅ Kratos gRPC code generated successfully!'));
 };
 
@@ -114,23 +225,100 @@ const generateKratosServer = async (serverDir, projectName, entities) => {
 
 import (
 	"context"
-	"github.com/go-kratos/kratos/v2/middleware/auth/jwt"
+	kjwt "github.com/go-kratos/kratos/v2/middleware/auth/jwt"
 	"github.com/go-kratos/kratos/v2/middleware/recovery"
 	"github.com/go-kratos/kratos/v2/transport/grpc"
-	"github.com/golang-jwt/jwt/v4"
+	"github.com/go-kratos/kratos/v2/middleware"
+	"github.com/go-kratos/kratos/v2/metadata"
+	"github.com/golang-jwt/jwt/v5"
+    {{#if entities}}
     v1 "{{projectName}}/api/v1"
     "{{projectName}}/internal/service"
+    {{/if}}
     "{{projectName}}/internal/repository"
     "{{projectName}}/config"
+    "{{projectName}}/models"
+    my_middleware "{{projectName}}/middleware"
+	"gorm.io/gorm"
+	"strings"
+	"fmt"
 )
 
+func TenantServerInterceptor(conf *config.Config, db *gorm.DB) middleware.Middleware {
+    mgr := my_middleware.GetTenantManager(db, conf)
+    fallbackDB := "go_duck_fallback" // Standard fallback
+
+    return func(handler middleware.Handler) middleware.Handler {
+        return func(ctx context.Context, req interface{}) (interface{}, error) {
+            token, ok := kjwt.FromContext(ctx)
+            if !ok { return handler(ctx, req) }
+            
+            claims, ok := token.(jwt.MapClaims)
+            if !ok { return handler(ctx, req) }
+            
+            ra, ok := claims["realm_access"].(map[string]interface{})
+            if !ok { return handler(ctx, req) }
+            
+            rolesInterface, ok := ra["roles"].([]interface{})
+            if !ok { return handler(ctx, req) }
+
+            // Normalize roles (lowercase)
+            var lowerRoles []string
+            isAdmin := false
+            for _, r := range rolesInterface {
+                roleStr := strings.ToLower(fmt.Sprintf("%v", r))
+                lowerRoles = append(lowerRoles, roleStr)
+                if roleStr == "admin" || roleStr == "role_admin" { isAdmin = true }
+            }
+
+            var requestedTenant string
+            if md, ok := metadata.FromServerContext(ctx); ok {
+                requestedTenant = strings.ToLower(md.Get("x-tenant-id"))
+            }
+
+            siloConnections := make(map[string]*gorm.DB)
+            if requestedTenant != "" {
+                var mapping models.TenantRole
+                if err := db.Raw("SELECT role_name, db_name FROM tenant_roles WHERE role_name IN ? AND tenant_id = ? LIMIT 1", lowerRoles, requestedTenant).Scan(&mapping).Error; err == nil && mapping.DBName != "" {
+                     if mapping.DBName == "admin_db" && !isAdmin {
+                         conn, _ := mgr.GetDB(fallbackDB)
+                         siloConnections["fallback"] = conn
+                     } else {
+                         conn, _ := mgr.GetDB(mapping.DBName)
+                         siloConnections[mapping.RoleName] = conn
+                     }
+                }
+            } else {
+                var mappings []models.TenantRole
+                db.Raw("SELECT role_name, db_name FROM tenant_roles WHERE role_name IN ?", lowerRoles).Scan(&mappings)
+                for _, m := range mappings {
+                    if m.DBName == "admin_db" && !isAdmin { continue }
+                    if conn, err := mgr.GetDB(m.DBName); err == nil {
+                        siloConnections[m.RoleName] = conn
+                    }
+                }
+            }
+
+            if len(siloConnections) == 0 {
+                conn, _ := mgr.GetDB(fallbackDB)
+                siloConnections["fallback"] = conn
+            }
+
+            // Inject Federated Bundle
+            ctx = context.WithValue(ctx, "tenantSiloConns", siloConnections)
+            return handler(ctx, req)
+        }
+    }
+}
+
 func NewGRPCServer(conf *config.Config, repo *repository.Repository) *grpc.Server {
 	var opts = []grpc.ServerOption{
 		grpc.Middleware(
 			recovery.Recovery(),
-			jwt.Server(func(token *jwt.Token) (interface{}, error) {
-				return []byte(conf.GoDuck.Security.KeycloakSecret), nil
-			}),
+			kjwt.Server(func(token *jwt.Token) (interface{}, error) {
+				return []byte(conf.GoDuck.Security.KeycloakAppClientSecret), nil
+			}, kjwt.WithClaims(func() jwt.Claims { return &jwt.MapClaims{} })),
+			TenantServerInterceptor(conf, repo.DB),
 		),
 	}
 	if conf.GoDuck.Server.GRPC.Addr != "" {