go-duck-cli 1.0.0

package/templates/go/controller.go.hbs

@@ -0,0 +1,236 @@
+package controllers
+
+import (
+"fmt"
+"net/http"
+"strconv"
+
+"{{app_name}}/config"
+"{{app_name}}/messaging"
+"{{app_name}}/models"
+"{{app_name}}/cache"
+"{{app_name}}/resilience"
+
+"github.com/gin-gonic/gin"
+"gorm.io/gorm"
+)
+
+type {{capitalize name}}Controller struct {
+DB *gorm.DB
+Config *config.Config
+}
+
+// Create{{capitalize name}}
+func (ctrl *{{capitalize name}}Controller) Create(c *gin.Context) {
+tenant, _ := c.Get("tenantDB")
+tenantStr := fmt.Sprintf("%v", tenant)
+ctx := c.Request.Context()
+
+var entity models.{{capitalize name}}
+if err := c.ShouldBindJSON(&entity); err != nil {
+c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+return
+}
+if err := ctrl.DB.WithContext(ctx).Create(&entity).Error; err != nil {
+c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+return
+}
+
+// Dynamic Cache Invalidation (Tenant Aware)
+cache.ClearPattern(tenantStr + ":{{capitalize name}}*")
+
+// MQTT Event (Resilient)
+resilience.Execute(func() (interface{}, error) {
+messaging.PublishEvent(ctrl.Config.GoDuck.Messaging.MQTT.TopicPrefix, "CREATE", "{{capitalize name}}", entity, nil)
+return nil, nil
+})
+
+c.JSON(http.StatusCreated, entity)
+}
+
+// GetAll{{capitalize name}}s (with filtering, pagination, and lazy/eager loading)
+func (ctrl *{{capitalize name}}Controller) GetAll(c *gin.Context) {
+var entities []models.{{capitalize name}}
+ctx := c.Request.Context()
+query := ctrl.DB.WithContext(ctx)
+
+// 1. Pagination
+page, _ := strconv.Atoi(c.DefaultQuery("page", "0"))
+size, _ := strconv.Atoi(c.DefaultQuery("size", "20"))
+query = query.Offset(page * size).Limit(size)
+
+// 2. Eager Loading (Full Bodied) vs Lazy (IDs Only)
+eager := c.Query("eager") == "true"
+if eager {
+{{#each relationships}}
+query = query.Preload("{{capitalize from.field}}")
+query = query.Preload("{{capitalize to.field}}")
+{{/each}}
+}
+
+// 3. Simple Filtering (Optimized for CRUD)
+// Example: ?name=eq.John
+for key, values := range c.Request.URL.Query() {
+if key == "page" || key == "size" || key == "eager" || key == "sort" {
+continue
+}
+for _, val := range values {
+query = query.Where(key+" = ?", val)
+}
+}
+
+if err := query.Find(&entities).Error; err != nil {
+c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+return
+}
+c.JSON(http.StatusOK, entities)
+}
+
+// GetByID
+func (ctrl *{{capitalize name}}Controller) GetByID(c *gin.Context) {
+id := c.Param("id")
+tenant, _ := c.Get("tenantDB")
+tenantStr := fmt.Sprintf("%v", tenant)
+ctx := c.Request.Context()
+
+// Tenant-Aware Cache Key
+cacheKey := fmt.Sprintf("%s:{{capitalize name}}:%s", tenantStr, id)
+
+var entity models.{{capitalize name}}
+
+// 1. Check Distributed Cache (Redis)
+if cache.Get(cacheKey, &entity) {
+c.JSON(http.StatusOK, entity)
+return
+}
+
+// 2. Fallback to DB (With Context for Tracing)
+query := ctrl.DB.WithContext(ctx)
+if c.Query("eager") == "true" {
+{{#each relationships}}
+query = query.Preload("{{capitalize from.field}}")
+query = query.Preload("{{capitalize to.field}}")
+{{/each}}
+}
+
+if err := query.First(&entity, id).Error; err != nil {
+c.JSON(http.StatusNotFound, gin.H{"error": "Resource not found"})
+return
+}
+
+// 3. Update Cache (Resilient)
+resilience.Execute(func() (interface{}, error) {
+cache.Set(cacheKey, entity, ctrl.Config.GoDuck.Cache.Redis.TTL)
+return nil, nil
+})
+
+c.JSON(http.StatusOK, entity)
+}
+
+// Update (PUT) - Full Update
+func (ctrl *{{capitalize name}}Controller) Update(c *gin.Context) {
+id := c.Param("id")
+tenant, _ := c.Get("tenantDB")
+tenantStr := fmt.Sprintf("%v", tenant)
+ctx := c.Request.Context()
+
+var entity models.{{capitalize name}}
+if err := ctrl.DB.WithContext(ctx).First(&entity, id).Error; err != nil {
+c.JSON(http.StatusNotFound, gin.H{"error": "Resource not found"})
+return
+}
+
+// Capture Previous State
+prev := entity
+
+if err := c.ShouldBindJSON(&entity); err != nil {
+c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+return
+}
+
+if err := ctrl.DB.WithContext(ctx).Save(&entity).Error; err != nil {
+c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+return
+}
+
+// Cache Invalidation (Tenant Aware)
+cache.Delete(fmt.Sprintf("%s:{{capitalize name}}:%s", tenantStr, id))
+
+// MQTT Event (Resilient)
+resilience.Execute(func() (interface{}, error) {
+messaging.PublishEvent(ctrl.Config.GoDuck.Messaging.MQTT.TopicPrefix, "UPDATE", "{{capitalize name}}", entity, prev)
+return nil, nil
+})
+
+c.JSON(http.StatusOK, entity)
+}
+
+// Patch (PATCH) - Partial Update
+func (ctrl *{{capitalize name}}Controller) Patch(c *gin.Context) {
+id := c.Param("id")
+tenant, _ := c.Get("tenantDB")
+tenantStr := fmt.Sprintf("%v", tenant)
+ctx := c.Request.Context()
+
+var entity models.{{capitalize name}}
+if err := ctrl.DB.WithContext(ctx).First(&entity, id).Error; err != nil {
+c.JSON(http.StatusNotFound, gin.H{"error": "Resource not found"})
+return
+}
+prev := entity
+
+var updates map[string]interface{}
+if err := c.ShouldBindJSON(&updates); err != nil {
+c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+return
+}
+
+if err := ctrl.DB.WithContext(ctx).Model(&entity).Updates(updates).Error; err != nil {
+c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+return
+}
+
+// Fetch updated
+ctrl.DB.WithContext(ctx).First(&entity, id)
+
+// Cache Invalidation (Tenant Aware)
+cache.Delete(fmt.Sprintf("%s:{{capitalize name}}:%s", tenantStr, id))
+
+// MQTT Event (Resilient)
+resilience.Execute(func() (interface{}, error) {
+messaging.PublishEvent(ctrl.Config.GoDuck.Messaging.MQTT.TopicPrefix, "PATCH", "{{capitalize name}}", entity, prev)
+return nil, nil
+})
+
+c.JSON(http.StatusOK, gin.H{"message": "Updated successfully", "data": entity})
+}
+
+// Delete
+func (ctrl *{{capitalize name}}Controller) Delete(c *gin.Context) {
+id := c.Param("id")
+tenant, _ := c.Get("tenantDB")
+tenantStr := fmt.Sprintf("%v", tenant)
+ctx := c.Request.Context()
+
+var entity models.{{capitalize name}}
+if err := ctrl.DB.WithContext(ctx).First(&entity, id).Error; err != nil {
+c.JSON(http.StatusNotFound, gin.H{"error": "Resource not found"})
+return
+}
+
+if err := ctrl.DB.WithContext(ctx).Delete(&entity).Error; err != nil {
+c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+return
+}
+
+// Cache Invalidation (Tenant Aware)
+cache.Delete(fmt.Sprintf("%s:{{capitalize name}}:%s", tenantStr, id))
+
+// MQTT Event (Resilient)
+resilience.Execute(func() (interface{}, error) {
+messaging.PublishEvent(ctrl.Config.GoDuck.Messaging.MQTT.TopicPrefix, "DELETE", "{{capitalize name}}", entity, nil)
+return nil, nil
+})
+
+c.JSON(http.StatusNoContent, nil)
+}

package/templates/go/entity.go.hbs

@@ -0,0 +1,34 @@
+package models
+
+import (
+"time"
+{{#if (hasJson fields)}}
+"gorm.io/datatypes"
+{{/if}}
+)
+
+type {{name}} struct {
+ID uint `gorm:"primaryKey" json:"id"`
+{{#each fields}}
+{{capitalize name}} {{toGoType type}} `{{#if unique}}gorm:"uniqueIndex" {{/if}}{{#if (isJson type)}}gorm:"type:{{toLowerCase type}};serializer:json" {{/if}}json:"{{name}}" {{#if required}}binding:"required"{{/if}}`
+{{/each}}
+{{#if (eq annotation "@Audited")}}
+CreatedBy string `gorm:"column:created_by" json:"createdBy"`
+CreatedDate time.Time `gorm:"column:created_date" json:"createdDate"`
+LastModifiedBy string `gorm:"column:last_modified_by" json:"lastModifiedBy"`
+LastModifiedDate time.Time `gorm:"column:last_modified_date" json:"lastModifiedDate"`
+LastModifiedUserID string `gorm:"column:last_modified_user_id" json:"lastModifiedUserId"`
+{{else}}
+CreatedAt time.Time `gorm:"autoCreateTime" json:"createdAt"`
+UpdatedAt time.Time `gorm:"autoUpdateTime" json:"updatedAt"`
+{{/if}}
+{{#each relationships}}
+{{#if (eq from.entity ../name)}}
+{{capitalize from.field}} []{{capitalize to.entity}} `gorm:"foreignKey:{{capitalize to.field}}ID" json:"{{from.field}}"`
+{{else}}
+{{capitalize to.field}}ID *uint `gorm:"column:{{to.field}}_id;index" json:"{{to.field}}Id"`
+{{capitalize to.field}} *{{capitalize from.entity}} `gorm:"foreignKey:{{capitalize to.field}}ID"
+json:"{{to.field}},omitempty"`
+{{/if}}
+{{/each}}
+}

package/templates/go/enum.go.hbs

@@ -0,0 +1,7 @@
+type {{name}} string
+
+const (
+{{#each values}}
+    {{../name}}_{{this}} {{../name}} = "{{this}}"
+{{/each}}
+)

package/templates/go/main.go.hbs

@@ -0,0 +1,186 @@
+package main
+
+import (
+"context"
+"fmt"
+"log"
+"net/http"
+
+"github.com/gin-gonic/gin"
+"go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin"
+"gorm.io/driver/postgres"
+"gorm.io/gorm"
+"gorm.io/plugin/opentelemetry/tracing"
+"{{app_name}}/management"
+"{{app_name}}/middleware"
+"{{app_name}}/controllers"
+"{{app_name}}/graph"
+"{{app_name}}/ws"
+"{{app_name}}/config"
+"{{app_name}}/logger"
+"{{app_name}}/messaging"
+"{{app_name}}/cache"
+"{{app_name}}/resilience"
+"{{app_name}}/internal/telemetry"
+"{{app_name}}/internal/repository"
+"{{app_name}}/internal/server"
+k_grpc "github.com/go-kratos/kratos/v2/transport/grpc"
+// go-duck-needle-add-import
+)
+
+func main() {
+// 1. Load Configuration
+appConfig, err := config.LoadConfig()
+if err != nil {
+log.Fatalf("Failed to load configuration: %v", err)
+}
+
+// 2. Initialize Logging & Observability (Datadog)
+logger.InitLogger(appConfig)
+logger.Info("Starting %s version %s...", appConfig.GoDuck.Name, appConfig.GoDuck.Version)
+
+// 3. Initialize OpenTelemetry Tracing
+shutdown, err := telemetry.InitTelemetry(appConfig)
+if err != nil {
+log.Printf("Warning: Failed to initialize OpenTelemetry: %v", err)
+}
+defer shutdown(context.Background())
+
+// 4. Initialize Resilience Layer (Circuit Breaker)
+resilience.InitResilience(appConfig)
+
+// 5. Initialize MQTT Messaging (for Webhooks/Audit)
+messaging.InitMQTT(appConfig)
+
+// 6. Initialize Distributed Caching (Redis)
+cache.InitCache(appConfig)
+
+// 7. Initialize master DB connection with Pool Tuning & Tracing
+masterDB, err := gorm.Open(postgres.Open(appConfig.GetDSN()), &gorm.Config{})
+if err != nil {
+log.Fatalf("Failed to connect to master database: %v", err)
+}
+// go-duck-needle-add-init-server
+
+// Inject GORM OTel Plugin
+if err := masterDB.Use(tracing.NewPlugin()); err != nil {
+log.Printf("Warning: Failed to inject GORM OTel plugin: %v", err)
+}
+
+sqlDB, _ := masterDB.DB()
+sqlDB.SetMaxOpenConns(appConfig.GoDuck.Datasource.MaxOpenConns)
+sqlDB.SetMaxIdleConns(appConfig.GoDuck.Datasource.MaxIdleConns)
+sqlDB.SetConnMaxLifetime(appConfig.GoDuck.Datasource.ConnMaxLifetime)
+
+// 8. Initialize Repository
+repo := repository.NewRepository(masterDB)
+// go-duck-needle-add-init-repository
+
+// 9. Initialize & Start Kratos gRPC Server (in background)
+go func() {
+    grpcSrv := server.NewGRPCServer(appConfig, repo)
+    logger.Info("Starting Kratos gRPC server on %s", appConfig.GoDuck.Server.GRPC.Addr)
+    if err := grpcSrv.Start(context.Background()); err != nil {
+        logger.Error("Failed to start Kratos gRPC server: %v", err)
+    }
+}()
+// go-duck-needle-add-grpc-start
+
+r := gin.Default()
+
+// 8. Global Middleware (OTel, Rate Limit & CORS)
+if appConfig.GoDuck.Telemetry.OTel.Enabled {
+r.Use(otelgin.Middleware(appConfig.GoDuck.Name))
+}
+r.Use(middleware.RateLimitMiddleware(appConfig))
+r.Use(middleware.CORSMiddleware(appConfig))
+
+// Health Check
+r.GET("/health", func(c *gin.Context) {
+c.JSON(http.StatusOK, gin.H{"status": "UP"})
+})
+
+// Swagger Docs & UI
+r.StaticFile("/swagger.json", "./docs/swagger.json")
+r.GET("/swagger", func(c *gin.Context) {
+c.Header("Content-Type", "text/html; charset=utf-8")
+c.String(http.StatusOK, \`
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <title>Swagger UI</title>
+    <link rel="stylesheet" type="text/css" href="https://unpkg.com/swagger-ui-dist@3/swagger-ui.css">
+</head>
+
+<body>
+    <div id="swagger-ui"></div>
+    <script src="https://unpkg.com/swagger-ui-dist@3/swagger-ui-bundle.js"> </script>
+    <script>
+        window.onload = function () {
+            window.ui = SwaggerUIBundle({
+                url: "/swagger.json",
+                dom_id: '#swagger-ui',
+                deepLinking: true,
+                presets: [SwaggerUIBundle.presets.apis],
+                layout: "BaseLayout"
+            });
+        };
+    </script>
+</body>
+
+</html>
+\`)
+})
+
+// Management APIs (Run-time DB creation)
+mgmt := r.Group("/management")
+{
+mgmt.POST("/db/create", management.CreateDatabaseAndMigrate(masterDB))
+}
+
+// 9. Secured Application APIs
+api := r.Group("/api")
+api.Use(middleware.JWTMiddleware())
+api.Use(middleware.TenantMiddleware(masterDB))
+api.Use(middleware.AuditMiddleware(masterDB))
+api.Use(middleware.MeteringMiddleware(masterDB))
+{
+// Observability
+auditCtrl := controllers.AuditController{DB: masterDB}
+api.GET("/audit", auditCtrl.GetLogs)
+
+meteringCtrl := controllers.MeteringController{DB: masterDB}
+api.POST("/metering/limit", meteringCtrl.SetLimit)
+api.GET("/metering/usage", meteringCtrl.GetUsage)
+
+// Search
+searchCtrl := controllers.SearchController{DB: masterDB}
+api.GET("/rpc/:table", searchCtrl.GenericSearch)
+
+{{#each entities}}
+// {{name}} Routes
+{{toLowerCase name}}Ctrl := controllers.{{capitalize name}}Controller{DB: masterDB, Config: appConfig}
+api.POST("/{{toLowerCase name}}s", {{toLowerCase name}}Ctrl.Create)
+api.GET("/{{toLowerCase name}}s", {{toLowerCase name}}Ctrl.GetAll)
+api.GET("/{{toLowerCase name}}s/:id", {{toLowerCase name}}Ctrl.GetByID)
+api.PUT("/{{toLowerCase name}}s/:id", {{toLowerCase name}}Ctrl.Update)
+api.PATCH("/{{toLowerCase name}}s/:id", {{toLowerCase name}}Ctrl.Patch)
+api.DELETE("/{{toLowerCase name}}s/:id", {{toLowerCase name}}Ctrl.Delete)
+{{/each}}
+// go-duck-needle-add-route
+}
+
+// 10. GraphQL
+r.POST("/graphql", func(c *gin.Context) {
+graph.HandleGraphQLRequest(masterDB, c)
+})
+
+// 11. WebSockets
+wsDispatcher := ws.NewDispatcher(masterDB)
+r.GET("/ws", middleware.JWTMiddleware(), wsDispatcher.HandleConnection)
+
+port := fmt.Sprintf(":%d", appConfig.GoDuck.Server.Port)
+r.Run(port)
+}

package/templates/graphql/resolver.go.hbs

@@ -0,0 +1,50 @@
+package graph
+
+import (
+"encoding/json"
+"net/http"
+"{{app_name}}/models"
+
+"github.com/gin-gonic/gin"
+"gorm.io/gorm"
+)
+
+// 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"\`
+}
+
+if err := c.BindJSON(&input); err != nil {
+c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid GraphQL request"})
+return
+}
+
+// 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.",
+})
+}
+
+// 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
+}
+
+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}}

package/templates/graphql/schema.graphql.hbs

@@ -0,0 +1,64 @@
+{{#each entities}}
+type {{name}} {
+id: ID!
+{{#each fields}}
+{{name}}: {{gql_type type}}{{#if required}}!{{/if}}
+{{/each}}
+{{#if (eq annotation "@Audited")}}
+createdBy: String
+createdDate: String
+lastModifiedBy: String
+lastModifiedDate: String
+lastModifiedUserId: String
+{{/if}}
+{{#each relationships}}
+{{#if (eq from.entity ../name)}}
+{{from.field}}: [{{capitalize to.entity}}]
+{{else}}
+{{to.field}}: {{capitalize from.entity}}
+{{/if}}
+{{/each}}
+createdAt: String
+updatedAt: String
+}
+
+input Create{{name}}Input {
+{{#each fields}}
+{{name}}: {{gql_type type}}{{#if required}}!{{/if}}
+{{/each}}
+{{#each relationships}}
+{{#if (eq to.entity ../name)}}
+{{to.field}}Id: ID!
+{{/if}}
+{{/each}}
+}
+
+input Update{{name}}Input {
+{{#each fields}}
+{{name}}: {{gql_type type}}
+{{/each}}
+}
+{{/each}}
+
+{{#each enums}}
+enum {{name}} {
+{{#each values}}
+  {{this}}
+{{/each}}
+}
+{{/each}}
+
+type Query {
+{{#each entities}}
+get{{capitalize name}}(id: ID!): {{name}}
+list{{capitalize name}}s(page: Int, size: Int): [{{name}}]
+{{/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
+{{/each}}
+}

package/templates/kratos/service.go.hbs

@@ -0,0 +1,104 @@
+package service
+
+import (
+	"context"
+	pb "{{projectName}}/api/v1"
+	"{{projectName}}/internal/repository"
+	"{{projectName}}/models"
+	{{#if (hasJson fields)}}
+	"gorm.io/datatypes"
+	{{/if}}
+	"google.golang.org/protobuf/types/known/timestamppb"
+)
+
+type {{capitalize name}}Service struct {
+	pb.Unimplemented{{capitalize name}}ServiceServer
+	repo *repository.Repository
+}
+
+func New{{capitalize name}}Service(repo *repository.Repository) *{{capitalize name}}Service {
+	return &{{capitalize name}}Service{repo: repo}
+}
+
+func (s *{{capitalize name}}Service) Create{{capitalize name}}(ctx context.Context, req *pb.Create{{capitalize name}}Request) (*pb.{{capitalize name}}Reply, error) {
+	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}},
+		{{/each}}
+	}
+	if err := s.repo.DB.WithContext(ctx).Create(entity).Error; err != nil {
+		return nil, err
+	}
+	return &pb.{{capitalize name}}Reply{
+		Data: map{{capitalize name}}ToPb(entity),
+	}, nil
+}
+
+func (s *{{capitalize name}}Service) Get{{capitalize name}}(ctx context.Context, req *pb.Get{{capitalize name}}Request) (*pb.{{capitalize name}}Reply, error) {
+	var entity models.{{capitalize name}}
+	if err := s.repo.DB.WithContext(ctx).First(&entity, req.Id).Error; err != nil {
+		return nil, err
+	}
+	return &pb.{{capitalize name}}Reply{
+		Data: map{{capitalize name}}ToPb(&entity),
+	}, nil
+}
+
+func (s *{{capitalize name}}Service) Update{{capitalize name}}(ctx context.Context, req *pb.Update{{capitalize name}}Request) (*pb.{{capitalize name}}Reply, error) {
+	var entity models.{{capitalize name}}
+	if err := s.repo.DB.WithContext(ctx).First(&entity, req.Id).Error; err != nil {
+		return nil, err
+	}
+	
+	{{#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}}
+	{{/each}}
+
+	if err := s.repo.DB.WithContext(ctx).Save(&entity).Error; err != nil {
+		return nil, err
+	}
+	return &pb.{{capitalize name}}Reply{
+		Data: map{{capitalize name}}ToPb(&entity),
+	}, 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
+	}
+	return &pb.Delete{{capitalize name}}Reply{Message: "Success"}, 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}}
+	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
+	}
+	
+	pbResults := make([]*pb.{{capitalize name}}, len(results))
+	for i, r := range results {
+		pbResults[i] = map{{capitalize name}}ToPb(&r)
+	}
+	
+	return &pb.List{{capitalize name}}Reply{
+		Results: pbResults,
+		Total:   total,
+	}, nil
+}
+
+func map{{capitalize name}}ToPb(m *models.{{capitalize name}}) *pb.{{capitalize name}} {
+	return &pb.{{capitalize name}}{
+		Id: uint64(m.ID),
+		{{#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}},
+		{{/each}}
+		CreatedAt: timestamppb.New(m.CreatedAt),
+		UpdatedAt: timestamppb.New(m.UpdatedAt),
+	}
+}