go-duck-cli 1.0.8 → 1.1.1

package/templates/graphql/resolver.go.hbs

@@ -1,50 +1,69 @@
 package graph
 
 import (
-"encoding/json"
 "net/http"
+{{#if entities}}
 "{{app_name}}/models"
+{{/if}}
 
 "github.com/gin-gonic/gin"
 "gorm.io/gorm"
+"fmt"
 )
 
-// HandleGraphQLRequest is the main bridge for the Gin web framework.
-// In a production app, we would use a more robust engine (like gqlgen).
-func HandleGraphQLRequest(db *gorm.DB, c *gin.Context) {
-var input struct {
-Query string \`json:"query"\`
-Variables map[string]interface{} \`json:"variables"\`
+// Resolver for each entity (Federated)
+{{#each entities}}
+func Resolve{{capitalize name}}Federated(silos map[string]*gorm.DB, id uint) ([]interface{}, error) {
+	var results []interface{}
+	for role, db := range silos {
+		var e models.{{capitalize name}}
+		if err := db.First(&e, id).Error; err == nil {
+			results = append(results, gin.H{
+				"role": role,
+				"data": e,
+			})
+		}
+	}
+	return results, nil
 }
 
-if err := c.BindJSON(&input); err != nil {
-c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid GraphQL request"})
-return
+func ResolveAll{{capitalize name}}sFederated(silos map[string]*gorm.DB) ([]interface{}, error) {
+	var results []interface{}
+	for role, db := range silos {
+		var list []models.{{capitalize name}}
+		if err := db.Find(&list).Error; err == nil {
+			results = append(results, gin.H{
+				"role":  role,
+				"items": list,
+			})
+		}
+	}
+	return results, nil
 }
+{{/each}}
 
-// We'll perform basic routing for the POC.
-// For production, this should integrate with a real schema loader.
-c.JSON(http.StatusOK, gin.H{
-"data": "GraphQL Handler Integrated Successfully!",
-"note": "Ready for schema execution.",
-})
-}
+// HandleGraphQLRequest is the main bridge for the Federated Gin context
+func HandleGraphQLRequest(c *gin.Context) {
+	siloConns, exists := c.Get("tenantSiloConns")
+	if !exists {
+		c.JSON(http.StatusForbidden, gin.H{"error": "No tenant context found"})
+		return
+	}
+	conns := siloConns.(map[string]*gorm.DB)
 
-// Resolver for each entity
-{{#each entities}}
-func Resolve{{capitalize name}}(db *gorm.DB, id uint) (*models.{{capitalize name}}, error) {
-var e models.{{capitalize name}}
-if err := db.First(&e, id).Error; err != nil {
-return nil, err
-}
-return &e, nil
-}
+	var input struct {
+		Query     string                 `json:"query"`
+		Variables map[string]interface{} `json:"variables"`
+	}
 
-func ResolveAll{{capitalize name}}s(db *gorm.DB) ([]models.{{capitalize name}}, error) {
-var list []models.{{capitalize name}}
-if err := db.Find(&list).Error; err != nil {
-return nil, err
-}
-return list, nil
-}
-{{/each}}
+	if err := c.BindJSON(&input); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid GraphQL request"})
+		return
+	}
+
+	// This is where real schema execution would happen using 'conns'
+	// For POC, return successful federation state
+	c.JSON(http.StatusOK, gin.H{
+		"data": "Federated GraphQL Handler active with " + fmt.Sprintf("%d", len(conns)) + " silos.",
+	})
+}

package/templates/graphql/schema.graphql.hbs

@@ -48,17 +48,29 @@ enum {{name}} {
 }
 {{/each}}
 
+{{#each entities}}
+type Federated{{capitalize name}}List {
+  role: String!
+  items: [{{capitalize name}}]
+}
+
+type Federated{{capitalize name}} {
+  role: String!
+  data: {{capitalize name}}
+}
+{{/each}}
+
 type Query {
 {{#each entities}}
-get{{capitalize name}}(id: ID!): {{name}}
-list{{capitalize name}}s(page: Int, size: Int): [{{name}}]
+  get{{capitalize name}}(id: ID!): [Federated{{capitalize name}}]
+  list{{capitalize name}}s(page: Int, size: Int): [Federated{{capitalize name}}List]
 {{/each}}
 }
 
 type Mutation {
 {{#each entities}}
-create{{capitalize name}}(input: Create{{name}}Input!): {{name}}
-update{{capitalize name}}(id: ID!, input: Update{{name}}Input!): {{name}}
-delete{{capitalize name}}(id: ID!): Boolean
+  create{{capitalize name}}(input: Create{{capitalize name}}Input!): Federated{{capitalize name}}
+  update{{capitalize name}}(id: ID!, input: Update{{capitalize name}}Input!): Federated{{capitalize name}}
+  delete{{capitalize name}}(id: ID!): Boolean
 {{/each}}
 }

package/templates/kratos/service.go.hbs

@@ -2,12 +2,28 @@ package service
 
 import (
 	"context"
+	{{#if isDocument}}
+	"fmt"
+	{{/if}}
+	{{#if (hasNested fields)}}
+	"encoding/json"
+	{{/if}}
+	{{#if (hasInstant fields)}}
+	"time"
+	{{/if}}
 	pb "{{projectName}}/api/v1"
 	"{{projectName}}/internal/repository"
 	"{{projectName}}/models"
 	{{#if (hasJson fields)}}
 	"gorm.io/datatypes"
 	{{/if}}
+	{{#if isDocument}}
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+	{{else}}
+	"gorm.io/gorm"
+	{{/if}}
 	"google.golang.org/protobuf/types/known/timestamppb"
 )
 
@@ -21,84 +37,203 @@ func New{{capitalize name}}Service(repo *repository.Repository) *{{capitalize na
 }
 
 func (s *{{capitalize name}}Service) Create{{capitalize name}}(ctx context.Context, req *pb.Create{{capitalize name}}Request) (*pb.{{capitalize name}}Reply, error) {
+	{{#if isDocument}}
+	db, ok := ctx.Value("tenantMongoDB").(*mongo.Database)
+	if !ok { return nil, fmt.Errorf("mongo database not found in context") }
+	{{else}}
+	siloConns, _ := ctx.Value("tenantSiloConns").(map[string]*gorm.DB)
+	{{/if}}
+	federatedData := make(map[string]*pb.{{capitalize name}})
+
 	entity := &models.{{capitalize name}}{
 		{{#each fields}}
-		{{capitalize name}}: {{#if (isJson type)}}datatypes.JSON(req.{{capitalize name}}){{else}}{{#if (toGoCast type)}}{{toGoCast type}}(req.{{capitalize name}}){{else}}req.{{capitalize name}}{{/if}}{{/if}},
+		{{#if (eq (toLowerCase type) "localdate")}}
+		{{capitalize name}}: parseDate(req.{{toProtoFieldName name}}),
+		{{else if (eq (toLowerCase type) "instant")}}
+		{{capitalize name}}: parseInstant(req.{{toProtoFieldName name}}),
+		{{else if (eq (toLowerCase type) "datetime")}}
+		{{capitalize name}}: parseInstant(req.{{toProtoFieldName name}}),
+		{{else if (isJson type)}}
+		{{capitalize name}}: datatypes.JSON(req.{{toProtoFieldName name}}),
+		{{else if isNested}}
+		// Nested fields are mapped via JSON for simplicity in gRPC
+		{{else}}
+		{{capitalize name}}: {{#if (toGoCast type)}}{{toGoCast type}}(req.{{toProtoFieldName name}}){{else}}req.{{toProtoFieldName name}}{{/if}},
+		{{/if}}
 		{{/each}}
 	}
-	if err := s.repo.DB.WithContext(ctx).Create(entity).Error; err != nil {
-		return nil, err
+	
+	{{#if isDocument}}
+	{{#each fields}}{{#if isNested}}
+	json.Unmarshal([]byte(req.{{toProtoFieldName name}}), &entity.{{capitalize name}})
+	{{/if}}{{/each}}
+	res, err := db.Collection("{{toLowerCase name}}s").InsertOne(ctx, entity)
+	if err == nil {
+		entity.ID = fmt.Sprintf("%v", res.InsertedID)
+		federatedData["tenant"] = map{{capitalize name}}ToPb(entity)
+	}
+	{{else}}
+	for role, db := range siloConns {
+		if err := db.WithContext(ctx).Create(entity).Error; err == nil {
+			federatedData[role] = map{{capitalize name}}ToPb(entity)
+		}
 	}
+	{{/if}}
+
 	return &pb.{{capitalize name}}Reply{
-		Data: map{{capitalize name}}ToPb(entity),
+		FederatedData: federatedData,
 	}, nil
 }
 
 func (s *{{capitalize name}}Service) Get{{capitalize name}}(ctx context.Context, req *pb.Get{{capitalize name}}Request) (*pb.{{capitalize name}}Reply, error) {
+	federatedData := make(map[string]*pb.{{capitalize name}})
+
+	{{#if isDocument}}
+	db, _ := ctx.Value("tenantMongoDB").(*mongo.Database)
 	var entity models.{{capitalize name}}
-	if err := s.repo.DB.WithContext(ctx).First(&entity, req.Id).Error; err != nil {
-		return nil, err
+	if err := db.Collection("{{toLowerCase name}}s").FindOne(ctx, bson.M{"_id": req.Id}).Decode(&entity); err == nil {
+		federatedData["tenant"] = map{{capitalize name}}ToPb(&entity)
+	}
+	{{else}}
+	siloConns, _ := ctx.Value("tenantSiloConns").(map[string]*gorm.DB)
+	for role, db := range siloConns {
+		var entity models.{{capitalize name}}
+		if err := db.WithContext(ctx).First(&entity, req.Id).Error; err == nil {
+			federatedData[role] = map{{capitalize name}}ToPb(&entity)
+		}
 	}
+	{{/if}}
+
 	return &pb.{{capitalize name}}Reply{
-		Data: map{{capitalize name}}ToPb(&entity),
+		FederatedData: federatedData,
 	}, nil
 }
 
 func (s *{{capitalize name}}Service) Update{{capitalize name}}(ctx context.Context, req *pb.Update{{capitalize name}}Request) (*pb.{{capitalize name}}Reply, error) {
+	federatedData := make(map[string]*pb.{{capitalize name}})
+
 	var entity models.{{capitalize name}}
-	if err := s.repo.DB.WithContext(ctx).First(&entity, req.Id).Error; err != nil {
-		return nil, err
-	}
-	
+	{{#if isDocument}}
+	entity.ID = req.Id
+	{{/if}}
 	{{#each fields}}
-	entity.{{capitalize name}} = {{#if (isJson type)}}datatypes.JSON(req.{{capitalize name}}){{else}}{{#if (toGoCast type)}}{{toGoCast type}}(req.{{capitalize name}}){{else}}req.{{capitalize name}}{{/if}}{{/if}}
+	{{#if (eq (toLowerCase type) "localdate")}}
+	entity.{{capitalize name}} = parseDate(req.{{toProtoFieldName name}})
+	{{else if (eq (toLowerCase type) "instant")}}
+	entity.{{capitalize name}} = parseInstant(req.{{toProtoFieldName name}})
+	{{else if (eq (toLowerCase type) "datetime")}}
+	entity.{{capitalize name}} = parseInstant(req.{{toProtoFieldName name}})
+	{{else if (isJson type)}}
+	entity.{{capitalize name}} = datatypes.JSON(req.{{toProtoFieldName name}})
+	{{else if isNested}}
+	json.Unmarshal([]byte(req.{{toProtoFieldName name}}), &entity.{{capitalize name}})
+	{{else}}
+	entity.{{capitalize name}} = {{#if (toGoCast type)}}{{toGoCast type}}(req.{{toProtoFieldName name}}){{else}}req.{{toProtoFieldName name}}{{/if}}
+	{{/if}}
 	{{/each}}
 
-	if err := s.repo.DB.WithContext(ctx).Save(&entity).Error; err != nil {
-		return nil, err
+	{{#if isDocument}}
+	db, _ := ctx.Value("tenantMongoDB").(*mongo.Database)
+	if _, err := db.Collection("{{toLowerCase name}}s").ReplaceOne(ctx, bson.M{"_id": req.Id}, entity); err == nil {
+		federatedData["tenant"] = map{{capitalize name}}ToPb(&entity)
+	}
+	{{else}}
+	siloConns, _ := ctx.Value("tenantSiloConns").(map[string]*gorm.DB)
+	for role, db := range siloConns {
+		if err := db.WithContext(ctx).Model(&models.{{capitalize name}}{}).Where("id = ?", req.Id).Save(&entity).Error; err == nil {
+			federatedData[role] = map{{capitalize name}}ToPb(&entity)
+		}
 	}
+	{{/if}}
+
 	return &pb.{{capitalize name}}Reply{
-		Data: map{{capitalize name}}ToPb(&entity),
+		FederatedData: federatedData,
 	}, nil
 }
 
 func (s *{{capitalize name}}Service) Delete{{capitalize name}}(ctx context.Context, req *pb.Delete{{capitalize name}}Request) (*pb.Delete{{capitalize name}}Reply, error) {
-	if err := s.repo.DB.WithContext(ctx).Delete(&models.{{capitalize name}}{}, req.Id).Error; err != nil {
-		return nil, err
+	{{#if isDocument}}
+	db, _ := ctx.Value("tenantMongoDB").(*mongo.Database)
+	db.Collection("{{toLowerCase name}}s").DeleteOne(ctx, bson.M{"_id": req.Id})
+	{{else}}
+	siloConns, _ := ctx.Value("tenantSiloConns").(map[string]*gorm.DB)
+	for _, db := range siloConns {
+		db.WithContext(ctx).Where("id = ?", req.Id).Delete(&models.{{capitalize name}}{})
 	}
-	return &pb.Delete{{capitalize name}}Reply{Message: "Success"}, nil
+	{{/if}}
+	return &pb.Delete{{capitalize name}}Reply{Message: "Delete completed"}, nil
 }
 
 func (s *{{capitalize name}}Service) List{{capitalize name}}(ctx context.Context, req *pb.List{{capitalize name}}Request) (*pb.List{{capitalize name}}Reply, error) {
-	var results []models.{{capitalize name}}
+	federatedResults := make(map[string]*pb.{{capitalize name}}List)
 	var total int64
-	
-	db := s.repo.DB.WithContext(ctx).Model(&models.{{capitalize name}}{})
-	db.Count(&total)
-	
-	offset := (req.Page - 1) * req.PageSize
-	if err := db.Limit(int(req.PageSize)).Offset(int(offset)).Find(&results).Error; err != nil {
-		return nil, err
+
+	{{#if isDocument}}
+	db, _ := ctx.Value("tenantMongoDB").(*mongo.Database)
+	var results []models.{{capitalize name}}
+	opts := options.Find().SetSkip(int64((req.Page - 1) * req.PageSize)).SetLimit(int64(req.PageSize))
+	cursor, err := db.Collection("{{toLowerCase name}}s").Find(ctx, bson.M{}, opts)
+	if err == nil {
+		cursor.All(ctx, &results)
+		items := make([]*pb.{{capitalize name}}, len(results))
+		for i, r := range results {
+			items[i] = map{{capitalize name}}ToPb(&r)
+		}
+		federatedResults["tenant"] = &pb.{{capitalize name}}List{Items: items}
+		count, _ := db.Collection("{{toLowerCase name}}s").CountDocuments(ctx, bson.M{})
+		total = count
 	}
-	
-	pbResults := make([]*pb.{{capitalize name}}, len(results))
-	for i, r := range results {
-		pbResults[i] = map{{capitalize name}}ToPb(&r)
+	{{else}}
+	siloConns, _ := ctx.Value("tenantSiloConns").(map[string]*gorm.DB)
+	for role, db := range siloConns {
+		var results []models.{{capitalize name}}
+		query := db.WithContext(ctx).Model(&models.{{capitalize name}}{})
+		
+		var count int64
+		query.Count(&count)
+		total += count
+
+		offset := (req.Page - 1) * req.PageSize
+		if err := query.Limit(int(req.PageSize)).Offset(int(offset)).Find(&results).Error; err == nil {
+			items := make([]*pb.{{capitalize name}}, len(results))
+			for i, r := range results {
+				items[i] = map{{capitalize name}}ToPb(&r)
+			}
+			federatedResults[role] = &pb.{{capitalize name}}List{Items: items}
+		}
 	}
+	{{/if}}
 	
 	return &pb.List{{capitalize name}}Reply{
-		Results: pbResults,
-		Total:   total,
+		FederatedResults: federatedResults,
+		Total:            total,
 	}, nil
 }
 
 func map{{capitalize name}}ToPb(m *models.{{capitalize name}}) *pb.{{capitalize name}} {
 	return &pb.{{capitalize name}}{
-		Id: uint64(m.ID),
+		Id: {{#if isDocument}}m.ID{{else}}uint64(m.ID){{/if}},
 		{{#each fields}}
-		{{capitalize name}}: {{#if (isJson type)}}string(m.{{capitalize name}}){{else}}{{#if (toProtoCast type)}}{{toProtoCast type}}(m.{{capitalize name}}){{else}}m.{{capitalize name}}{{/if}}{{/if}},
+		{{#if (eq (toLowerCase type) "localdate")}}
+		{{toProtoFieldName name}}: m.{{capitalize name}}.Format("2006-01-02"),
+		{{else if (eq (toLowerCase type) "instant")}}
+		{{toProtoFieldName name}}: m.{{capitalize name}}.Format(time.RFC3339),
+		{{else if (eq (toLowerCase type) "datetime")}}
+		{{toProtoFieldName name}}: m.{{capitalize name}}.Format(time.RFC3339),
+		{{else if (isJson type)}}
+		{{toProtoFieldName name}}: string(m.{{capitalize name}}),
+		{{else if isNested}}
+		{{toProtoFieldName name}}: (func() string { b, _ := json.Marshal(m.{{capitalize name}}); return string(b) })(),
+		{{else}}
+		{{toProtoFieldName name}}: {{#if (toProtoCast type)}}{{toProtoCast type}}(m.{{capitalize name}}){{else}}m.{{capitalize name}}{{/if}},
+		{{/if}}
 		{{/each}}
+		{{#if isAudited}}
+		CreatedAt: timestamppb.New(m.CreatedDate),
+		UpdatedAt: timestamppb.New(m.LastModifiedDate),
+		{{else}}
 		CreatedAt: timestamppb.New(m.CreatedAt),
 		UpdatedAt: timestamppb.New(m.UpdatedAt),
+		{{/if}}
 	}
 }

package/templates/proto/entity.proto.hbs

@@ -38,7 +38,7 @@ service {{capitalize name}}Service {
 }
 
 message {{capitalize name}} {
-  uint64 id = 1;
+  {{#if isDocument}}string{{else}}uint64{{/if}} id = 1;
   {{#each fields}}
   {{toProtoType type}} {{name}} = {{add @index 2}};
   {{/each}}
@@ -53,14 +53,14 @@ message Create{{capitalize name}}Request {
 }
 
 message Update{{capitalize name}}Request {
-  uint64 id = 1;
+  {{#if isDocument}}string{{else}}uint64{{/if}} id = 1;
   {{#each fields}}
   {{toProtoType type}} {{name}} = {{add @index 2}};
   {{/each}}
 }
 
 message Delete{{capitalize name}}Request {
-  uint64 id = 1;
+  {{#if isDocument}}string{{else}}uint64{{/if}} id = 1;
 }
 
 message Delete{{capitalize name}}Reply {
@@ -68,11 +68,15 @@ message Delete{{capitalize name}}Reply {
 }
 
 message Get{{capitalize name}}Request {
-  uint64 id = 1;
+  {{#if isDocument}}string{{else}}uint64{{/if}} id = 1;
+}
+
+message {{capitalize name}}List {
+  repeated {{capitalize name}} items = 1;
 }
 
 message {{capitalize name}}Reply {
-  {{capitalize name}} data = 1;
+  map<string, {{capitalize name}}> federated_data = 1;
 }
 
 message List{{capitalize name}}Request {
@@ -82,14 +86,6 @@ message List{{capitalize name}}Request {
 }
 
 message List{{capitalize name}}Reply {
-  repeated {{capitalize name}} results = 1;
+  map<string, {{capitalize name}}List> federated_results = 1;
   int64 total = 2;
 }
-{{#each enums}}
-enum {{capitalize name}} {
-  {{capitalize name}}_UNSPECIFIED = 0;
-{{#each values}}
-  {{capitalize ../name}}_{{this}} = {{add @index 1}};
-{{/each}}
-}
-{{/each}}

package/test_nested.gdl

@@ -0,0 +1,21 @@
+@Document @Audited @Federated
+entity PatientRecord {
+  patientId String required unique
+  clinicalData {
+    vitals {
+      bpm Integer
+      temp Float
+    }
+    notes Text
+  }
+}
+
+relationship OneToMany {
+  PatientRecord to ClinicalNote
+}
+
+enum PatientStatus {
+  ACTIVE, INACTIVE, DECEASED
+}
+
+open PatientRecord(read, create)

package/test_parser.js

@@ -1,9 +0,0 @@
-import fs from 'fs-extra';
-
-const content = fs.readFileSync('../GDL/app.gdl', 'utf8');
-const relRegex = /relationship\s+(\w+)\s*\{([^}]*)\}/g;
-let match;
-while ((match = relRegex.exec(content)) !== null) {
-    console.log('Type:', match[1]);
-    console.log('Block:', match[2]);
-}