go-duck-cli 1.2.0 → 1.2.2

package/README.md

@@ -43,9 +43,9 @@ But speed without strength is a house made of cards. In the digital forge of the
 
 Thus, the **GDL (Go-Duck Language)** was hatched. A single, simple tongue that could command entire legions of code. From that day forth, every developer who whispered GDL into the CLI would see their architecture evolve—bringing the Gopher's speed, the Duck's wisdom, the Gin's clarity, and the Kratos' strength into a single, unified masterpiece.
 
-## 🦆 The 375% Elite Status: Milestone Surpassed
+## 🦆 The 410% Elite Status: Milestone Surpassed
 
-GO-DUCK has officially reached the **375% Achievement Status**, evolving from a code generator into a **High-Velocity Distributed Orchestrator.** This elite status confirms that the framework has surpassed the original 350% milestone with industrial-grade Universal Storage extensions and real-time remote bootstrapping.
+GO-DUCK has officially reached the **410% Achievement Status**, evolving from a code generator into a **High-Velocity Distributed Orchestrator.** This elite status confirms that the framework has surpassed the original 350% milestone with industrial-grade Universal Storage extensions, real-time remote bootstrapping, WSO2 integration, and full-spectrum GDL evolution.
 
 | Milestone Component | Status | Technical Value Add |
 | :--- | :--- | :--- |
@@ -57,11 +57,15 @@ GO-DUCK has officially reached the **375% Achievement Status**, evolving from a
 | **Super Admin Security Boundary** | 🚀 **ELITE (+13%)** | Strict isolation between Business and Infrastructure Control APIs. |
 | **Silo Discovery & Privacy Proxy** | 🚀 **ELITE (+10%)** | Silo discovery API with physical DB name masking. |
 | **Universal Storage Mesh** | 🚀 **ELITE (+25%)** | Dynamic Hot-Swapping Registry and Distributed Cross-Scan API retrieval. |
-| **TOTAL ACHIEVEMENT STATUS** | 🏆 **375%** | **ELITE STATUS CONFIRMED.** 👑 |
+| **WSO2 API Gateway Integration** | 🚀 **ELITE (+15%)** | Automated OpenAPI registration & proxy mapping. |
+| **Full-Spectrum GDL Evolution** | 🚀 **ELITE (+15%)** | Native DROP/ALTER migrations with dead-code purging. |
+| **TOTAL ACHIEVEMENT STATUS** | 🏆 **410%** | **ELITE STATUS CONFIRMED.** 👑 |
 
-### ✨ Primary Features (The 375% Core)
+### ✨ Primary Features (The 410% Core)
 
 *   **Federated Multi-Tenancy**: Side-by-side **Database-per-Tenant isolation** with a **Master-Tenant Registry** (Role ↔ DB ↔ Opaque UUID).
+*   **Multi-Protocol REST**: Dynamically switchable REST rendering using standard `json` or high-performance `messagepack` based on configuration.
+*   **gRPC-Web Native Proxy**: Natively wraps Kratos gRPC to automatically serve a web proxy (e.g. on port `9090`) to allow direct frontend Protobuf interaction.
 *   **Industrial-Grade Parallel Harvester**: Asynchronous goroutine-based data aggregation across multiple silos with `?federated=true` opt-in.
 *   **Precision Harvesting**: Surgical multi-silo selection via comma-separated `X-Tenant-ID` headers.
 *   **Super Admin Security Boundaries**: Strict architectural separation between Business APIs and Infrastructure Control APIs.
@@ -70,9 +74,12 @@ GO-DUCK has officially reached the **375% Achievement Status**, evolving from a
 *   **Distributed Saga Consistency**: Integrated **Transactional Outbox** pattern and background workers in every silo to guarantee eventual consistency across the federation.
 *   **Zero-Trust Identity Registry**: Decoupled mapping layer ensuring physical database names and internal IDs never leak to the client.
 *   **Universal Storage Mesh**: Dynamic Multi-Provider Registry allowing hot-swapping at runtime via `?provider=` queries, alongside Distributed Cross-Scan endpoints to auto-locate files across AWS, GCS, SFTP, and GitHub lakes.
-*   **Spring-style Elasticsearch Search**: Real-time sync for entities marked with `@Searchable`, supporting fuzzy matching and complex queries.
+*   **Spring-style Elasticsearch Search**: Real-time sync for entities marked with `@Searchable`, supporting native `query_string` syntax (wildcards like `*`, booleans, ranges, and fuzzy matching).
 *   **SaaS Quota Engine**: Redis-backed API bandwidth tracking with dynamic, hierarchical limits (User vs. Role mapping).
 *   **Resilience Layer**: Sony/Gobreaker Integration + Zero-Trust Distributed Redis Rate Limiter.
+*   **Comprehensive GDL Schema Evolution**: Detects structural deltas intelligently and automatically generates Goose SQL for dropped entities (`DROP TABLE`), dropped fields (`DROP COLUMN`), and altered fields (`ALTER TYPE`, constraints) to keep databases in absolute sync.
+*   **Dead-Code Purging**: Automatically cleans up orphaned Go models and controllers when removing entities from the `.gdl` blueprint.
+*   **Saga Outbox GORM Stability**: Generates robust, compile-ready `outbox_worker.go` components with native GORM package resolution.
 
 ### 🗺️ System Topology & Identity Registry
 
@@ -151,6 +158,37 @@ docker-compose up -d
 go run main.go
 ```
 
+## 🌐 Calling the Multi-Protocol Endpoints
+
+GO-DUCK automatically exposes your microservice across three distinct ports to serve different architectural needs without code duplication:
+
+1. **REST API (Port 8080 by default)**
+   Standard HTTP endpoints for web browsers and legacy clients.
+   - **JSON (Default):** Perfect for general use.
+   - **MessagePack (High Performance):** To switch to binary MessagePack, update your `config.yaml` before generation:
+     ```yaml
+     server:
+       rest:
+         port: 8080
+         protocol: "messagepack"
+     ```
+     Clients must send the `Accept: application/msgpack` and `Content-Type: application/msgpack` headers to consume this endpoint correctly.
+   - **Pagination & Sorting:** All `GetAll` endpoints support pagination via `?page=1&size=20`, and dynamic sorting via `?sort=field,asc` or `?sort=field,desc` (e.g. `?sort=name,desc`).
+
+2. **Native Kratos gRPC (Port 9000 by default)**
+   Pure HTTP/2 Protobuf communication. Used strictly for internal **backend-to-backend** communication (e.g., Microservice A calling Microservice B) where maximum throughput is required.
+
+3. **gRPC-Web Proxy (Port 9090 by default)**
+   Web browsers cannot speak raw HTTP/2 gRPC. This port acts as an HTTP/1.1 proxy bridge, allowing frontend frameworks (React, Angular, Vue) to interact directly with the Protobuf gRPC contracts.
+   To disable or change the proxy port, update your `config.yaml`:
+   ```yaml
+   server:
+     grpc:
+       web_enabled: true
+       web_port: 9090
+   ```
+   *Frontend Tip: Use the `grpc-web` npm package to generate a frontend client that communicates with this port!*
+
 ## Usage
 
 The `go-duck-cli` has two main commands: `create` and `import-gdl`.

package/generators/ai_docs.js

@@ -52,7 +52,7 @@ export const generateAIDocs = async (config, entities, outputDir, enums, openEnt
     for (const entity of entities) {
         const routeName = entity.name.toLowerCase() + 's';
         endpointsContent += `\n#### ${entity.name}\n`;
-        endpointsContent += `- \`GET /api/${routeName}\` (Pagination, e.g. \`?page=1&size=10&eager=true\`)\n`;
+        endpointsContent += `- \`GET /api/${routeName}\` (Pagination & dynamic sorting, e.g. \`?page=1&size=10&eager=true&sort=id,asc\`)\n`;
         endpointsContent += `- \`GET /api/${routeName}/:id\`\n`;
         endpointsContent += `- \`POST /api/${routeName}\`\n`;
         endpointsContent += `- \`PUT /api/${routeName}/:id\`\n`;
@@ -88,6 +88,7 @@ export const generateAIDocs = async (config, entities, outputDir, enums, openEnt
         if (entity.isSearchable) entitiesContent += `- \`@Searchable\`\n`;
         if (entity.isAudited) entitiesContent += `- \`@Audited\`\n`;
         if (entity.isFederated) entitiesContent += `- \`@Federated\`\n`;
+        if (entity.isDelete) entitiesContent += `- \`@Delete\`\n`;
         
         entitiesContent += `\nFields:\n`;
         for (const field of entity.fields) {
@@ -101,16 +102,20 @@ export const generateAIDocs = async (config, entities, outputDir, enums, openEnt
     // 4. PROTOCOLS.md
     let protoContent = `# Additional Network Protocols\n\n`;
     protoContent += `## GraphQL Surface\n`;
-    protoContent += `- **Endpoint**: \`POST /query\`\n`;
-    protoContent += `- **Playground**: \`GET /\`\n\n`;
+    protoContent += `- **Endpoint**: \`POST /graphql\` (Secured via JWT and Tenant headers)\n`;
+    protoContent += `- **Playground**: GraphQL Playground UI is enabled on the server.\n`;
+    protoContent += `- **Queries**: \`list[Entity]s(page: Int, size: Int)\`, \`get[Entity](id: ID!)\`\n`;
+    protoContent += `- **Mutations**: \`create[Entity](input: CreateInput)\`, \`update[Entity](id: ID!, input: UpdateInput)\`, \`delete[Entity](id: ID!)\`\n`;
+    protoContent += `- **Postman Collection Integration**: The auto-generated Postman collection includes a comprehensive **GraphQL Federation Layer** folder containing test queries and mutations for all entities.\n\n`;
     
     protoContent += `## WebSocket Engine\n`;
-    protoContent += `- **Endpoint**: \`ws[s]://host/ws\`\n`;
-    protoContent += `- **Format**: JSON Envelope Payload \`{ "type": "...", "payload": {...} }\`\n\n`;
+    protoContent += `- **Endpoint**: \`ws[s]://host/ws?token={JWT}\`\n`;
+    protoContent += `- **Format**: JSON Envelope Payload with HMAC-SHA256 digital signature: \`{ "type": "...", "payload": {...} }\`\n\n`;
 
-    protoContent += `## gRPC (Kratos) Engine\n`;
-    protoContent += `- **Port**: \`9000\` (Default)\n`;
-    protoContent += `- **Proto Definitions**: Located in \`api/.../\`\n`;
+    protoContent += `## gRPC & gRPC-Web Engine\n`;
+    protoContent += `- **Native Kratos gRPC Port**: \`9000\` (TCP)\n`;
+    protoContent += `- **gRPC-Web Proxy Port**: \`9090\` (HTTP/1.1 for web clients)\n`;
+    protoContent += `- **Proto Definitions**: Located in \`api/v1/*.proto\`\n`;
 
     await fs.writeFile(path.join(aiDocsDir, 'PROTOCOLS.md'), protoContent);
 
@@ -118,6 +123,14 @@ export const generateAIDocs = async (config, entities, outputDir, enums, openEnt
     let agentInstructions = `# LLM / AI AGENT INSTRUCTIONS 🤖\n\n`;
     agentInstructions += `Welcome to the generated codebase for **${appName}**.\n\n`;
     agentInstructions += `This application was generated by the GO-DUCK-CLI (An advanced Evolutionary Go Code Generator).\n\n`;
+    agentInstructions += `### High-Velocity Commands:\n`;
+    agentInstructions += `- **Build Project**: \`go build ./...\`\n`;
+    agentInstructions += `- **Protobuf Compilation**: \`./generate.sh\` (or \`.\\generate.bat\` on Windows)\n`;
+    agentInstructions += `- **Local Dependencies & Dev Boot**: \`docker-compose up -d && go run main.go\`\n\n`;
+    agentInstructions += `### GDL Evolution & Schema Deletions:\n`;
+    agentInstructions += `- **Snapshot Merging (Multi-File GDL)**: The generator implements stateful snapshot merging. Running \`import-gdl\` on a single GDL file will NOT wipe out other entities; previous snapshots are retrieved from the \`.go-duck/\` state folder and merged automatically.\n`;
+    agentInstructions += `- **Altering/Dropping Fields**: To add, drop, or edit fields within an entity, update the fields inline in the GDL entity block. Running \`import-gdl\` generates targeted Goose SQL column-level migrations.\n`;
+    agentInstructions += `- **Dropping Entities**: To completely delete an entity, its database table, all generated code files, and its snapshot, append the \`@Delete\` annotation above the entity definition block and run \`import-gdl\`.\n\n`;
     agentInstructions += `### How to navigate this system:\n`;
     agentInstructions += `The full system specifications and dynamically generated blueprints have been exported for you in the \`docs/ai/\` folder. Look there before attempting any code modifications.\n\n`;
     agentInstructions += `- **[docs/ai/ARCHITECTURE.md](docs/ai/ARCHITECTURE.md)**: Describes the databases, caching layers, configuration structure, and middleware enabled in this project.\n`;

package/generators/config.js

@@ -25,13 +25,16 @@ type Config struct {
 		Description string \`mapstructure:"description"\`
 		
 		Server struct {
-			Port         int           \`mapstructure:"port"\`
-			ReadTimeout  time.Duration \`mapstructure:"read-timeout"\`
-			WriteTimeout time.Duration \`mapstructure:"write-timeout"\`
+			REST struct {
+				Port     int    \`mapstructure:"port"\`
+				Protocol string \`mapstructure:"protocol"\`
+			} \`mapstructure:"rest"\`
 			GRPC struct {
-				Addr    string        \`mapstructure:"addr"\`
-				Network string        \`mapstructure:"network"\`
-				Timeout time.Duration \`mapstructure:"timeout"\`
+				Addr       string        \`mapstructure:"addr"\`
+				Network    string        \`mapstructure:"network"\`
+				Timeout    time.Duration \`mapstructure:"timeout"\`
+				WebEnabled bool          \`mapstructure:"web_enabled"\`
+				WebPort    int           \`mapstructure:"web_port"\`
 			} \`mapstructure:"grpc"\`
 			CORS struct {
 				AllowOrigins []string \`mapstructure:"allow-origins"\`
@@ -237,7 +240,8 @@ func LoadConfig() (*Config, error) {
 	v.AddConfigPath(".")
 
 	// Default values
-	v.SetDefault("go-duck.server.port", 8080)
+	v.SetDefault("go-duck.server.rest.port", 8080)
+	v.SetDefault("go-duck.server.rest.protocol", "json")
 	v.SetDefault("go-duck.security.rate-limit.rps", 100.0)
 	v.SetDefault("go-duck.security.rate-limit.burst", 200)
 	v.SetDefault("go-duck.logging.datadog.enabled", false)
@@ -254,6 +258,8 @@ func LoadConfig() (*Config, error) {
 	v.SetDefault("go-duck.server.grpc.addr", ":9000")
 	v.SetDefault("go-duck.server.grpc.network", "tcp")
 	v.SetDefault("go-duck.server.grpc.timeout", "1s")
+	v.SetDefault("go-duck.server.grpc.web_enabled", false)
+	v.SetDefault("go-duck.server.grpc.web_port", 9090)
 	v.SetDefault("go-duck.resilience.circuit-breaker.enabled", true)
 	v.SetDefault("go-duck.resilience.circuit-breaker.failure-threshold", 5)
 	v.SetDefault("go-duck.resilience.circuit-breaker.timeout", "60s")

package/generators/elasticsearch.js

@@ -156,10 +156,9 @@ func ExecuteSearch(ctx context.Context, entityName string, queryStr string, cfg
 	} else {
 		query = map[string]interface{}{
 			"query": map[string]interface{}{
-				"multi_match": map[string]interface{}{
-					"query":  queryStr,
-					"fields": []string{"*"},
-					"fuzziness": "AUTO",
+				"query_string": map[string]interface{}{
+					"query":            queryStr,
+					"analyze_wildcard": true,
 				},
 			},
 		}

package/generators/migrations.js

@@ -79,7 +79,13 @@ DROP TABLE IF EXISTS api_usage CASCADE;
 
     const entitiesToCreate = delta ? delta.newEntities : entities;
 
-    if (entitiesToCreate.length === 0 && (!delta || (!delta.newFields && !delta.newRelationships))) {
+    const hasNewFields = delta && delta.newFields && Object.keys(delta.newFields).length > 0;
+    const hasNewRelationships = delta && delta.newRelationships && delta.newRelationships.length > 0;
+    const hasDeletedEntities = delta && delta.deletedEntities && delta.deletedEntities.length > 0;
+    const hasDeletedFields = delta && delta.deletedFields && Object.keys(delta.deletedFields).length > 0;
+    const hasAlteredFields = delta && delta.alteredFields && Object.keys(delta.alteredFields).length > 0;
+
+    if (entitiesToCreate.length === 0 && !hasNewFields && !hasNewRelationships && !hasDeletedEntities && !hasDeletedFields && !hasAlteredFields) {
         return;
     }
 
@@ -125,6 +131,70 @@ DROP TABLE IF EXISTS api_usage CASCADE;
         }
     }
 
+    // Delete Entities
+    if (delta && delta.deletedEntities) {
+        for (const entity of delta.deletedEntities) {
+            sqlUp += `DROP TABLE IF EXISTS ${entity.name.toLowerCase()} CASCADE;\n\n`;
+            sqlDown += `-- Cannot easily reverse DROP TABLE ${entity.name.toLowerCase()}\n`;
+        }
+    }
+
+    // Delete Fields
+    if (delta && delta.deletedFields) {
+        for (const [entityName, fields] of Object.entries(delta.deletedFields)) {
+            for (const field of fields) {
+                sqlUp += `ALTER TABLE ${entityName.toLowerCase()} DROP COLUMN IF EXISTS ${toSnakeCase(field.name)};\n`;
+                
+                let sqlType = toLiquibaseType(field, enums);
+                if (sqlType === 'JSON') sqlType = 'JSONB';
+                sqlDown += `ALTER TABLE ${entityName.toLowerCase()} ADD COLUMN IF NOT EXISTS ${toSnakeCase(field.name)} ${sqlType};\n`;
+            }
+        }
+    }
+
+    // Alter Fields
+    if (delta && delta.alteredFields) {
+        for (const [entityName, alterations] of Object.entries(delta.alteredFields)) {
+            for (const alt of alterations) {
+                const fieldName = toSnakeCase(alt.new.name);
+                
+                // Type changes
+                if (alt.new.type !== alt.old.type) {
+                    let newSqlType = toLiquibaseType(alt.new, enums);
+                    if (newSqlType === 'JSON') newSqlType = 'JSONB';
+                    let oldSqlType = toLiquibaseType(alt.old, enums);
+                    if (oldSqlType === 'JSON') oldSqlType = 'JSONB';
+                    
+                    sqlUp += `ALTER TABLE ${entityName.toLowerCase()} ALTER COLUMN ${fieldName} TYPE ${newSqlType} USING ${fieldName}::${newSqlType};\n`;
+                    sqlDown += `ALTER TABLE ${entityName.toLowerCase()} ALTER COLUMN ${fieldName} TYPE ${oldSqlType} USING ${fieldName}::${oldSqlType};\n`;
+                }
+                
+                // Required (NOT NULL) changes
+                if (!!alt.new.required !== !!alt.old.required) {
+                    if (alt.new.required) {
+                        sqlUp += `ALTER TABLE ${entityName.toLowerCase()} ALTER COLUMN ${fieldName} SET NOT NULL;\n`;
+                        sqlDown += `ALTER TABLE ${entityName.toLowerCase()} ALTER COLUMN ${fieldName} DROP NOT NULL;\n`;
+                    } else {
+                        sqlUp += `ALTER TABLE ${entityName.toLowerCase()} ALTER COLUMN ${fieldName} DROP NOT NULL;\n`;
+                        sqlDown += `ALTER TABLE ${entityName.toLowerCase()} ALTER COLUMN ${fieldName} SET NOT NULL;\n`;
+                    }
+                }
+                
+                // Unique changes
+                if (!!alt.new.unique !== !!alt.old.unique) {
+                    const constraintName = `${entityName.toLowerCase()}_${fieldName}_key`;
+                    if (alt.new.unique) {
+                        sqlUp += `ALTER TABLE ${entityName.toLowerCase()} ADD CONSTRAINT ${constraintName} UNIQUE (${fieldName});\n`;
+                        sqlDown += `ALTER TABLE ${entityName.toLowerCase()} DROP CONSTRAINT IF EXISTS ${constraintName};\n`;
+                    } else {
+                        sqlUp += `ALTER TABLE ${entityName.toLowerCase()} DROP CONSTRAINT IF EXISTS ${constraintName};\n`;
+                        sqlDown += `ALTER TABLE ${entityName.toLowerCase()} ADD CONSTRAINT ${constraintName} UNIQUE (${fieldName});\n`;
+                    }
+                }
+            }
+        }
+    }
+
     sqlUp += '-- +goose StatementEnd\n\n';
     sqlDown += '-- +goose StatementEnd\n';
 
@@ -133,7 +203,10 @@ DROP TABLE IF EXISTS api_usage CASCADE;
         descParts.push('initial_schema');
     } else {
         if (delta.newEntities?.length > 0) descParts.push('create_' + delta.newEntities.map(e => e.name.toLowerCase()).join('_'));
-        if (delta.newFields) descParts.push('add_fields');
+        if (hasNewFields) descParts.push('add_fields');
+        if (hasDeletedEntities) descParts.push('drop_tables');
+        if (hasDeletedFields) descParts.push('drop_fields');
+        if (hasAlteredFields) descParts.push('alter_fields');
     }
 
     const fileName = `${timestamp}_${descParts.join('_')}.sql`;

package/generators/outbox.js

@@ -42,6 +42,7 @@ import (
 	"{{app_name}}/models"
 	"{{app_name}}/config"
 	"{{app_name}}/middleware"
+	"gorm.io/gorm"
 	"gorm.io/gorm/clause"
 	"gorm.io/gorm/schema"
 )

package/generators/postman.js

@@ -169,11 +169,25 @@ export const generatePostmanCollection = async (config, entities, outputDir, ope
     });
 
     // 3. GraphQL
-    collection.item.push({
+    const generateGqlFieldsInput = (fields) => {
+        return fields.map(f => {
+            if (f.type === 'String' || f.type === 'Text') return `${f.name}: "Sample ${f.name}"`;
+            if (f.type === 'Integer' || f.type === 'Long') return `${f.name}: 100`;
+            if (f.type === 'Float' || f.type === 'BigDecimal') return `${f.name}: 99.99`;
+            if (f.type === 'Boolean') return `${f.name}: true`;
+            if (f.type === 'LocalDate') return `${f.name}: "2024-01-01"`;
+            if (f.type === 'Instant') return `${f.name}: "2024-01-01T12:00:00Z"`;
+            if (f.type === 'JSON' || f.type === 'JSONB') return `${f.name}: "{\\"attribute\\": \\"example_value\\"}"`;
+            return `${f.name}: "test"`;
+        }).join(',\n    ');
+    };
+
+    const graphqlFolder = {
         name: "3. GraphQL Federation Layer",
+        description: "Federated GraphQL operations for all GDL entities.",
         item: [
             {
-                name: "1. Unified GraphQL Engine",
+                name: "GraphQL Endpoint Playground",
                 request: {
                     method: "POST",
                     header: [
@@ -184,7 +198,7 @@ export const generatePostmanCollection = async (config, entities, outputDir, ope
                     body: {
                         mode: "graphql",
                         graphql: {
-                            query: `query {\n  ${entities.length > 0 ? 'list' + entities[0].name.charAt(0).toUpperCase() + entities[0].name.slice(1) + 's' : 'test'} {\n    id\n  }\n}`,
+                            query: "query {\n  __schema {\n    types {\n      name\n    }\n  }\n}",
                             variables: ""
                         }
                     },
@@ -198,7 +212,143 @@ export const generatePostmanCollection = async (config, entities, outputDir, ope
                 }
             }
         ]
-    });
+    };
+
+    for (const entity of entities) {
+        const capitalized = entity.name.charAt(0).toUpperCase() + entity.name.slice(1);
+        const entityGqlFolder = {
+            name: `${capitalized} GraphQL`,
+            item: [
+                {
+                    name: `List ${capitalized}s (GraphQL Query)`,
+                    request: {
+                        method: "POST",
+                        header: [
+                            { key: "Authorization", value: "Bearer {{token}}" },
+                            { key: "X-Tenant-ID", value: "{{tenant}}" },
+                            { key: "Content-Type", value: "application/json" }
+                        ],
+                        body: {
+                            mode: "graphql",
+                            graphql: {
+                                query: `query {\n  list${capitalized}s(page: 1, size: 10) {\n    role\n    items {\n      id\n      ${entity.fields.map(f => f.name).join('\n      ')}\n      createdAt\n      updatedAt\n    }\n  }\n}`,
+                                variables: ""
+                            }
+                        },
+                        url: {
+                            raw: "http://{{host}}:{{port}}/graphql",
+                            protocol: "http",
+                            host: ["{{host}}"],
+                            port: "{{port}}",
+                            path: ["graphql"]
+                        }
+                    }
+                },
+                {
+                    name: `Get ${capitalized} by ID (GraphQL Query)`,
+                    request: {
+                        method: "POST",
+                        header: [
+                            { key: "Authorization", value: "Bearer {{token}}" },
+                            { key: "X-Tenant-ID", value: "{{tenant}}" },
+                            { key: "Content-Type", value: "application/json" }
+                        ],
+                        body: {
+                            mode: "graphql",
+                            graphql: {
+                                query: `query {\n  get${capitalized}(id: "1") {\n    role\n    data {\n      id\n      ${entity.fields.map(f => f.name).join('\n      ')}\n      createdAt\n      updatedAt\n    }\n  }\n}`,
+                                variables: ""
+                            }
+                        },
+                        url: {
+                            raw: "http://{{host}}:{{port}}/graphql",
+                            protocol: "http",
+                            host: ["{{host}}"],
+                            port: "{{port}}",
+                            path: ["graphql"]
+                        }
+                    }
+                },
+                {
+                    name: `Create ${capitalized} (GraphQL Mutation)`,
+                    request: {
+                        method: "POST",
+                        header: [
+                            { key: "Authorization", value: "Bearer {{token}}" },
+                            { key: "X-Tenant-ID", value: "{{tenant}}" },
+                            { key: "Content-Type", value: "application/json" }
+                        ],
+                        body: {
+                            mode: "graphql",
+                            graphql: {
+                                query: `mutation {\n  create${capitalized}(input: {\n    ${generateGqlFieldsInput(entity.fields)}\n  }) {\n    role\n    data {\n      id\n      ${entity.fields.map(f => f.name).join('\n      ')}\n      createdAt\n      updatedAt\n    }\n  }\n}`,
+                                variables: ""
+                            }
+                        },
+                        url: {
+                            raw: "http://{{host}}:{{port}}/graphql",
+                            protocol: "http",
+                            host: ["{{host}}"],
+                            port: "{{port}}",
+                            path: ["graphql"]
+                        }
+                    }
+                },
+                {
+                    name: `Update ${capitalized} (GraphQL Mutation)`,
+                    request: {
+                        method: "POST",
+                        header: [
+                            { key: "Authorization", value: "Bearer {{token}}" },
+                            { key: "X-Tenant-ID", value: "{{tenant}}" },
+                            { key: "Content-Type", value: "application/json" }
+                        ],
+                        body: {
+                            mode: "graphql",
+                            graphql: {
+                                query: `mutation {\n  update${capitalized}(id: "1", input: {\n    ${generateGqlFieldsInput(entity.fields)}\n  }) {\n    role\n    data {\n      id\n      ${entity.fields.map(f => f.name).join('\n      ')}\n      createdAt\n      updatedAt\n    }\n  }\n}`,
+                                variables: ""
+                            }
+                        },
+                        url: {
+                            raw: "http://{{host}}:{{port}}/graphql",
+                            protocol: "http",
+                            host: ["{{host}}"],
+                            port: "{{port}}",
+                            path: ["graphql"]
+                        }
+                    }
+                },
+                {
+                    name: `Delete ${capitalized} (GraphQL Mutation)`,
+                    request: {
+                        method: "POST",
+                        header: [
+                            { key: "Authorization", value: "Bearer {{token}}" },
+                            { key: "X-Tenant-ID", value: "{{tenant}}" },
+                            { key: "Content-Type", value: "application/json" }
+                        ],
+                        body: {
+                            mode: "graphql",
+                            graphql: {
+                                query: `mutation {\n  delete${capitalized}(id: "1")\n}`,
+                                variables: ""
+                            }
+                        },
+                        url: {
+                            raw: "http://{{host}}:{{port}}/graphql",
+                            protocol: "http",
+                            host: ["{{host}}"],
+                            port: "{{port}}",
+                            path: ["graphql"]
+                        }
+                    }
+                }
+            ]
+        };
+        graphqlFolder.item.push(entityGqlFolder);
+    }
+    collection.item.push(graphqlFolder);
 
     // 4. REST Entities
     const restFolder = { name: "4. Standard REST & Deep Search", item: [] };
@@ -240,7 +390,7 @@ export const generatePostmanCollection = async (config, entities, outputDir, ope
                 request: {
                     method: "GET",
                     header: [ { key: "X-Tenant-ID", value: "{{tenant}}" } ],
-                    url: { raw: `http://{{host}}:{{port}}/open/api/${name}s?page=1&size=10&eager=true`, protocol: "http", host: ["{{host}}"], port: "{{port}}", path: ["open", "api", `${name}s`], query: [ { key: "page", value: "1" }, { key: "size", value: "10" }, { key: "eager", value: "true" } ] }
+                    url: { raw: `http://{{host}}:{{port}}/open/api/${name}s?page=1&size=10&eager=true&sort=id,asc`, protocol: "http", host: ["{{host}}"], port: "{{port}}", path: ["open", "api", `${name}s`], query: [ { key: "page", value: "1" }, { key: "size", value: "10" }, { key: "eager", value: "true" }, { key: "sort", value: "id,asc" } ] }
                 }
             });
             publicItems.push({
@@ -275,7 +425,7 @@ export const generatePostmanCollection = async (config, entities, outputDir, ope
                 request: {
                     method: "GET",
                     header: [ { key: "Authorization", value: "Bearer {{token}}" }, { key: "X-Tenant-ID", value: "{{tenant}}" } ],
-                    url: { raw: `http://{{host}}:{{port}}/api/${name}s?page=1&size=10&eager=true`, protocol: "http", host: ["{{host}}"], port: "{{port}}", path: ["api", `${name}s`], query: [ { key: "page", value: "1" }, { key: "size", value: "10" }, { key: "eager", value: "true" } ] }
+                    url: { raw: `http://{{host}}:{{port}}/api/${name}s?page=1&size=10&eager=true&sort=id,asc`, protocol: "http", host: ["{{host}}"], port: "{{port}}", path: ["api", `${name}s`], query: [ { key: "page", value: "1" }, { key: "size", value: "10" }, { key: "eager", value: "true" }, { key: "sort", value: "id,asc" } ] }
                 }
             },
             {

package/index.js

@@ -357,7 +357,7 @@ const getPreviousEntities = async (outputDir) => {
     return entities;
 };
 
-const generateEntities = async (gdlPath, outputDir, config) => {
+const generateEntities = async (gdlPath, outputDir, config, isImport = false) => {
     let entities = [];
     let relationships = [];
     let enums = [];
@@ -365,7 +365,7 @@ const generateEntities = async (gdlPath, outputDir, config) => {
 
     if (!await fs.pathExists(gdlPath)) {
         console.log(chalk.yellow(`⚠️  GDL path not found: ${gdlPath} - Executing Zero-Entity Infrastructure Scaffold.`));
-        const delta = { newEntities: [], newFields: {}, newRelationships: [] };
+        const delta = { newEntities: [], newFields: {}, newRelationships: [], deletedEntities: [], deletedFields: {}, alteredFields: {} };
         await generateLiquibaseChangelogs(entities, relationships, outputDir, delta, enums);
         return { entities, relationships, enums, openEntities };
     }
@@ -377,7 +377,7 @@ const generateEntities = async (gdlPath, outputDir, config) => {
 
     if (files.length === 0) {
         console.log(chalk.yellow(`⚠️  No .gdl files found in: ${gdlPath} - Executing Zero-Entity Infrastructure Scaffold.`));
-        const delta = { newEntities: [], newFields: {}, newRelationships: [] };
+        const delta = { newEntities: [], newFields: {}, newRelationships: [], deletedEntities: [], deletedFields: {}, alteredFields: {} };
         await generateLiquibaseChangelogs(entities, relationships, outputDir, delta, enums);
         return { entities, relationships, enums, openEntities };
     }
@@ -399,10 +399,54 @@ const generateEntities = async (gdlPath, outputDir, config) => {
     console.log(chalk.green(`✅ Parsed ${entities.length} entities, ${relationships.length} relationships, ${enums.length} enums, and detected ${openEntities.length} open rules`));
 
     const previousEntities = await getPreviousEntities(outputDir);
+
+    // Any parsed entity with @Delete is mapped as a deletion
+    const deletedParsed = entities.filter(e => e.isDelete);
+    
+    // Remove deleted entities from active entities array
+    entities = entities.filter(e => !e.isDelete);
+
+    // Filter out relationships & open rule entries that involve deleted entities
+    relationships = relationships.filter(rel => 
+        !deletedParsed.some(d => d.name === rel.from.entity || d.name === rel.to.entity)
+    );
+    openEntities = openEntities.filter(oe => 
+        !deletedParsed.some(d => d.name === oe.name)
+    );
+
+    if (isImport) {
+        for (const prev of previousEntities) {
+            if (!entities.some(e => e.name === prev.name) && !deletedParsed.some(d => d.name === prev.name)) {
+                entities.push(prev);
+                if (prev.relationships) {
+                    for (const r of prev.relationships) {
+                        const exists = relationships.some(rel => 
+                            (rel.from.entity === r.from.entity && rel.from.field === r.from.field && rel.to.entity === r.to.entity && rel.to.field === r.to.field) ||
+                            (rel.from.entity === r.to.entity && rel.from.field === r.to.field && rel.to.entity === r.from.entity && rel.to.field === r.from.field)
+                        );
+                        if (!exists) relationships.push(r);
+                    }
+                }
+                if (prev.enums) {
+                    for (const en of prev.enums) {
+                        if (!enums.some(e => e.name === en.name)) enums.push(en);
+                    }
+                }
+                if (prev.openEntities) {
+                    for (const oe of prev.openEntities) {
+                        if (!openEntities.some(o => o.name === oe.name)) openEntities.push(oe);
+                    }
+                }
+            }
+        }
+    }
     const delta = {
         newEntities: [],
         newFields: {},
-        newRelationships: []
+        newRelationships: [],
+        deletedEntities: [],
+        deletedFields: {},
+        alteredFields: {}
     };
 
     // Calculate Delta for Incremental Migrations
@@ -416,6 +460,42 @@ const generateEntities = async (gdlPath, outputDir, config) => {
             if (newFields.length > 0) {
                 delta.newFields[entity.name] = newFields;
             }
+
+            // Check for deleted fields
+            const deletedFields = prev.fields.filter(pf => !entity.fields.some(f => f.name === pf.name));
+            if (deletedFields.length > 0) {
+                delta.deletedFields[entity.name] = deletedFields;
+            }
+
+            // Check for altered fields
+            const alteredFields = [];
+            for (const f of entity.fields) {
+                const pf = prev.fields.find(p => p.name === f.name);
+                if (pf) {
+                    if (pf.type !== f.type || !!pf.required !== !!f.required || !!pf.unique !== !!f.unique) {
+                        alteredFields.push({ new: f, old: pf });
+                    }
+                }
+            }
+            if (alteredFields.length > 0) {
+                delta.alteredFields[entity.name] = alteredFields;
+            }
+        }
+    }
+
+    // Check for deleted entities
+    if (isImport) {
+        for (const d of deletedParsed) {
+            const prev = previousEntities.find(e => e.name === d.name);
+            if (prev) {
+                delta.deletedEntities.push(prev);
+            }
+        }
+    } else {
+        for (const prev of previousEntities) {
+            if (!entities.some(e => e.name === prev.name)) {
+                delta.deletedEntities.push(prev);
+            }
         }
     }
 
@@ -481,6 +561,21 @@ const generateEntities = async (gdlPath, outputDir, config) => {
         await saveEntitySnapshot(outputDir, entity);
     }
 
+    // Clean up files for deleted entities
+    if (delta && delta.deletedEntities) {
+        for (const deleted of delta.deletedEntities) {
+            const modelFile = path.join(outputDir, 'models', `${deleted.name.toLowerCase()}.go`);
+            const controllerFile = path.join(outputDir, 'controllers', `${deleted.name.toLowerCase()}_controller.go`);
+            const snapshotFile = path.join(outputDir, '.go-duck', `${deleted.name.toLowerCase()}.json`);
+
+            if (await fs.pathExists(modelFile)) await fs.remove(modelFile);
+            if (await fs.pathExists(controllerFile)) await fs.remove(controllerFile);
+            if (await fs.pathExists(snapshotFile)) await fs.remove(snapshotFile);
+            
+            console.log(chalk.red(`   - Removed Entity & Controller: ${deleted.name}`));
+        }
+    }
+
     // Generate Incremental Changelogs!
     await generateLiquibaseChangelogs(entities, relationships, outputDir, delta, enums);
     console.log(chalk.green('✅ Goose SQL incremental migrations updated!'));
@@ -717,7 +812,7 @@ require (
         await generateResilienceCode(config, absoluteOutputDir);
         await generateTelemetryCode(config, absoluteOutputDir);
         await generateDeploymentArtifacts(config, absoluteOutputDir);
-        const { entities, relationships, enums, openEntities } = await generateEntities(gdlPath, absoluteOutputDir, config);
+        const { entities, relationships, enums, openEntities } = await generateEntities(gdlPath, absoluteOutputDir, config, true);
         await generateKratosCode(entities, absoluteOutputDir, config.name, enums);
 
         await generateRepositoryCode(absoluteOutputDir);
@@ -783,13 +878,18 @@ const generateYAMLConfigs = async (config, outputDir) => {
     const extendedConfig = {
         ...cleanConfig,
         server: {
-            port: cleanConfig.server?.port || 8080,
+            rest: {
+                port: cleanConfig.server?.rest?.port || cleanConfig.server?.port || 8080,
+                protocol: cleanConfig.server?.rest?.protocol || 'json'
+            },
             'read-timeout': cleanConfig.server?.['read-timeout'] || '30s',
             'write-timeout': cleanConfig.server?.['write-timeout'] || '30s',
             grpc: {
                 addr: cleanConfig.server?.grpc?.addr || ':9000',
                 network: cleanConfig.server?.grpc?.network || 'tcp',
-                timeout: cleanConfig.server?.grpc?.timeout || '1s'
+                timeout: cleanConfig.server?.grpc?.timeout || '1s',
+                web_enabled: cleanConfig.server?.grpc?.web_enabled ?? true,
+                web_port: cleanConfig.server?.grpc?.web_port || 9090
             },
             cors: {
                 'allow-origins': cleanConfig.server?.cors?.['allow-origins'] || ['*'],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "go-duck-cli",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "The Ultimate Evolutionary Go Microservice Scaffolder.",
   "main": "index.js",
   "type": "module",

package/parser/gdl.js

@@ -179,6 +179,7 @@ export const parseGDL = async (filePath) => {
         const isSearchable = annotation?.includes('@Searchable');
         const isDocument = annotation?.includes('@Document') || annotation?.includes('@isDocument');
         const isEmbedded = annotation?.includes('@Embed');
+        const isDelete = annotation?.includes('@Delete');
 
         const fields = parseFields(block.fieldBlock);
 
@@ -190,6 +191,7 @@ export const parseGDL = async (filePath) => {
             isSearchable,
             isDocument,
             isEmbedded,
+            isDelete,
             fields 
         });
     }

package/templates/docs/index.html.hbs

@@ -69,7 +69,8 @@ go run main.go</code></pre>
                 <h2 class="text-2xl font-bold text-gray-800 mb-4 border-b pb-2">1. REST APIs & Generic Search</h2>
                 <p class="mb-4">The application provides standard RESTful CRUD endpoints for all generated entities (e.g., {{#if entities.length}}{{entities.[0].name}}{{else}}Entity{{/if}}).</p>
                 
-                <h3 class="font-semibold mb-2">Standard CRUD:</h3>
+                <h3 class="font-semibold mb-2">Standard CRUD (Multi-Protocol):</h3>
+                <p class="mb-2 text-sm text-gray-600">The REST API natively supports JSON and MessagePack based on your <code>application.yml</code> settings.</p>
                 <pre><code class="language-http">GET /api/{{#if entities.length}}{{toLowerCase entities.[0].name}}s{{else}}entities{{/if}}?page=1&pageSize=10
 POST /api/{{#if entities.length}}{{toLowerCase entities.[0].name}}s{{else}}entities{{/if}}
 PUT /api/{{#if entities.length}}{{toLowerCase entities.[0].name}}s{{else}}entities{{/if}}/:id
@@ -81,6 +82,17 @@ DELETE /api/{{#if entities.length}}{{toLowerCase entities.[0].name}}s{{else}}ent
   -H "Authorization: Bearer YOUR_JWT" \
   -H "X-Tenant-ID: tenant_1"</code></pre>
                 <p class="text-sm text-gray-500 mt-2">Supported operators: <code>eq, neq, gt, gte, lt, lte, like, ilike</code></p>
+
+                <h3 class="font-semibold mb-2 mt-6">Elasticsearch Global Search (Spring-style):</h3>
+                <p class="mb-2">For entities marked with <code>@Searchable</code>, use the native Elasticsearch endpoint for advanced queries (wildcards, booleans, and ranges).</p>
+                <pre><code class="language-bash">curl -G "http://localhost:{{serverPort}}/api/search/{{#if entities.length}}{{toLowerCase entities.[0].name}}{{else}}entity{{/if}}" \
+  --data-urlencode "q=name:John AND age:>18" \
+  -H "Authorization: Bearer YOUR_JWT"</code></pre>
+                <ul class="text-sm text-gray-500 mt-2 list-disc pl-5">
+                    <li><strong>Wildcards:</strong> <code>q=name*</code> (matches "name15", "name_abc")</li>
+                    <li><strong>Boolean Logic:</strong> <code>q=status:PUBLISHED AND (author:John OR author:Jane)</code></li>
+                    <li><strong>Ranges:</strong> <code>q=age:[18 TO 30]</code> or <code>q=created_at:>2023-01-01</code></li>
+                </ul>
             </section>
 
             <!-- Audit & Metering -->
@@ -127,6 +139,17 @@ mosquitto_sub -h localhost -p {{mqttPort}} -t "go-duck/events/#" -u dev_user -P
                 <p class="text-sm mt-2">Example topic: <code>go-duck/events/{{#if entities.length}}{{toLowerCase entities.[0].name}}{{else}}entity{{/if}}/CREATE</code></p>
             </section>
 
+            <!-- gRPC-Web -->
+            <section id="grpc-web" class="content-section">
+                <h2 class="text-2xl font-bold text-gray-800 mb-4 border-b pb-2">gRPC & gRPC-Web</h2>
+                <p class="mb-4">The Kratos gRPC engine powers blazing fast service-to-service communication. For frontend developers, we automatically start a <strong>gRPC-Web Proxy</strong>.</p>
+                <ul class="list-disc pl-6 space-y-2 mb-4">
+                    <li>The core Kratos gRPC server runs on <code>:9000</code> (configurable).</li>
+                    <li>The <strong>gRPC-Web Proxy</strong> runs on <code>:9090</code>, translating HTTP/1.1 calls to HTTP/2.</li>
+                    <li>Frontend apps (React/Angular) can directly call Protobuf endpoints using standard <code>grpc-web</code> generated clients without hitting the REST APIs!</li>
+                </ul>
+            </section>
+
             <!-- Kratos gRPC -->
             <section id="grpc-kratos" class="content-section">
                 <h2 class="text-2xl font-bold text-gray-800 mb-4 border-b pb-2">Kratos Secured gRPC APIs</h2>
@@ -212,7 +235,8 @@ res, err := client.Get{{#if entities.length}}{{capitalize entities.[0].name}}{{e
                 <p class="mb-4">Running <code>go-duck import-gdl</code> calculates stateful differences using the `.go-duck/` snapshot folder. It generates atomic, Go-embedded timestamped Goose SQL migrations in <code>migrations/sql/</code>.</p>
                 <ul class="list-disc pl-6 space-y-2">
                     <li>The application natively compiles SQL inside the Go binary via <code>go:embed</code>.</li>
-                    <li>Includes smart nullability and automatic indexing for Foreign Keys.</li>
+                    <li><strong>Full-Spectrum Schema Evolution:</strong> The CLI detects complex deltas, generating SQL for dropped entities (`DROP TABLE`), dropped fields (`DROP COLUMN`), and altered fields (`ALTER TYPE`, constraints).</li>
+                    <li><strong>Dead-Code Purging:</strong> The CLI natively tracks and deletes orphaned `.go` models, controllers, and state snapshots for entities you remove from the `.gdl` blueprint.</li>
                     <li><strong>Needle Support:</strong> We inject `// go-duck-needle-*` markers in <code>main.go</code> and <code>grpc.go</code> for safe evolutionary code additions without destroying manual updates.</li>
                 </ul>
             </section>

package/templates/docs/pages/cli.hbs

@@ -44,17 +44,33 @@ go-duck import-gdl my_new_schema.gdl -o ./MY_APP</code></pre>
         <span class="w-8 h-8 rounded-lg bg-emerald-100 text-emerald-600 flex items-center justify-center mr-3 text-sm">
             <svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M8 7v8a2 2 0 002 2h6M8 7V5a2 2 0 012-2h4.586a1 1 0 01.707.293l4.414 4.414a1 1 0 01.293.707V15a2 2 0 01-2 2h-2M8 7H6a2 2 0 00-2 2v10a2 2 0 002 2h8a2 2 0 002-2v-2"></path></svg>
         </span>
-        2. Persistence Intelligence & the `.go-duck/` Folder
+        2. Schema Evolution & the `.go-duck/` State
     </h2>
-    <p class="mb-4 text-slate-600 leading-relaxed font-medium">"If I run the generator twice, will it overwrite my database migrations?" <strong>No.</strong></p>
+    <p class="mb-4 text-slate-600 leading-relaxed font-medium">"If I run the generator to import a new GDL, will it overwrite my database or delete existing entities?" <strong>No, thanks to stateful evolution.</strong></p>
     
-    <p class="mb-6 text-slate-600 leading-relaxed">The generator maintains a stateful snapshot of every entity it has ever generated inside the hidden <code class="bg-slate-100 px-1 py-0.5 rounded text-slate-800 font-mono text-sm">.go-duck/</code> directory at the root of your target project. When you run <code>import-gdl</code>, the code parser literally diffs your new file against the JSON representations in <code>.go-duck/</code> to intelligently assess the exact Table changes necessary without executing ghost migrations.</p>
+    <p class="mb-6 text-slate-600 leading-relaxed">The generator maintains a stateful snapshot of every entity it has ever generated inside the hidden <code class="bg-slate-100 px-1 py-0.5 rounded text-slate-800 font-mono text-sm">.go-duck/</code> directory at the root of your target project. When you run <code>import-gdl</code>, the CLI intelligently merges existing entities with newly parsed entities and executes targeted diff operations:</p>
+
+    <!-- EVOLUTION TYPE CARDS -->
+    <div class="grid grid-cols-1 md:grid-cols-3 gap-6 mb-8">
+        <div class="p-6 bg-slate-50 border border-slate-200 rounded-2xl">
+            <span class="text-xs font-bold text-indigo-600 uppercase tracking-wide block mb-2 font-mono">1. Snapshot Merging</span>
+            <p class="text-xs text-slate-600 leading-relaxed m-0">Supports splitting your entities into multiple GDL files. Unspecified active models are loaded from the <code>.go-duck/</code> folder and merged with new entities, keeping active routers and endpoints in sync.</p>
+        </div>
+        <div class="p-6 bg-slate-50 border border-slate-200 rounded-2xl">
+            <span class="text-xs font-bold text-emerald-600 uppercase tracking-wide block mb-2 font-mono">2. Column Alterations</span>
+            <p class="text-xs text-slate-600 leading-relaxed m-0">Adding, dropping, or modifying fields inside entity blocks generates specific <code>ADD COLUMN</code> or <code>DROP COLUMN</code> SQL statements in a timestamped Goose migration file.</p>
+        </div>
+        <div class="p-6 bg-slate-50 border border-slate-200 rounded-2xl">
+            <span class="text-xs font-bold text-rose-600 uppercase tracking-wide block mb-2 font-mono">3. Complete Purging</span>
+            <p class="text-xs text-slate-600 leading-relaxed m-0">Marking an entity with the <code>@Delete</code> annotation automatically triggers a database <code>DROP TABLE</code> SQL migration, purges all generated Go/Protobuf code files, and clears its snapshot.</p>
+        </div>
+    </div>
 
     <div class="bg-rose-50 border border-rose-200 p-5 mb-6 rounded-xl flex items-start shadow-sm shadow-rose-100/50">
         <svg class="w-6 h-6 text-rose-500 mt-0.5 mr-3 flex-shrink-0" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z"></path></svg>
         <div>
             <h4 class="font-bold text-rose-900 mb-1">Warning</h4>
-            <p class="text-rose-800 text-sm leading-relaxed"><strong>Never delete `.go-duck/`</strong> unless you are intentionally wiping the database and starting configuration completely from zero.</p>
+            <p class="text-rose-800 text-sm leading-relaxed"><strong>Never manually delete `.go-duck/`</strong> unless you are intentionally wiping the entire database state and starting configuration completely from scratch.</p>
         </div>
     </div>
 </section>

package/templates/docs/pages/gdl-annotations.hbs

@@ -100,6 +100,23 @@
                 <p class="text-[11px] text-indigo-900 m-0 font-medium font-mono leading-tight">Architectural Impact: Scaffolds routes into the <code class="text-indigo-600 text-[10px]">/api/open/*</code> group, bypassing the OIDC Validator middleware chain.</p>
             </div>
         </div>
+
+        <!-- @Delete -->
+        <div class="p-10 bg-rose-50 border border-rose-100 rounded-[3rem] shadow-sm transition-all duration-300 hover:shadow-rose-200 group relative overflow-hidden">
+            <div class="absolute top-0 right-0 p-6 opacity-[0.03] group-hover:opacity-[0.07] transition-opacity">
+                <svg class="w-32 h-32 text-rose-900" fill="currentColor" viewBox="0 0 20 20"><path fill-rule="evenodd" d="M9 2a1 1 0 00-.894.553L7.382 4H4a1 1 0 000 2v10a2 2 0 002 2h8a2 2 0 002-2V6a1 1 0 100-2h-3.382l-.724-1.447A1 1 0 0011 2H9zM7 8a1 1 0 012 0v6a1 1 0 11-2 0V8zm5-1a1 1 0 00-1 1v6a1 1 0 102 0V8a1 1 0 00-1-1z" clip-rule="evenodd"></path></svg>
+            </div>
+            <div class="flex items-center justify-between mb-8">
+                <code class="text-rose-700 font-mono font-black text-2xl group-hover:scale-105 transition-transform">@Delete</code>
+                <div class="w-12 h-12 bg-white rounded-2xl flex items-center justify-center text-2xl shadow-sm">🗑️</div>
+            </div>
+            <h4 class="text-lg font-black text-slate-900 mb-4 m-0 uppercase tracking-tighter">Entity Deletion</h4>
+            <p class="text-sm text-slate-700 leading-relaxed m-0 italic mb-6">Triggers full entity cleanup. Upon import, the generator purges all generated source code (models, controllers, repositories) and generates a database <code>DROP TABLE</code> migration.</p>
+            <div class="p-4 bg-white/50 rounded-2xl border border-rose-200 border-dashed">
+                <span class="text-[10px] font-bold text-rose-400 uppercase tracking-widest block mb-2 font-mono">Architectural Impact</span>
+                <p class="text-[11px] text-rose-900 m-0 font-medium font-mono leading-tight">Removes snapshots from .go-duck/, wipes Go files, and scaffolds drop SQL statements.</p>
+            </div>
+        </div>
     </div>
 
     <!-- COMPLEX EXAMPLE -->

package/templates/docs/pages/rest.hbs

@@ -129,6 +129,27 @@
         </div>
     </section>
 
+    <!-- PAGINATION & SORTING -->
+    <section class="mb-20">
+        <h2 class="text-3xl font-black text-slate-900 mb-8 tracking-tight italic underline decoration-indigo-600 underline-offset-8">Pagination & Dynamic Sorting</h2>
+        <div class="p-8 bg-slate-50 border border-slate-200 rounded-[2.5rem] shadow-sm">
+            <p class="text-slate-600 mb-6">List endpoints support pagination and dynamic sorting for both relational (PostgreSQL) and document-based (MongoDB) silos.</p>
+            
+            <div class="grid grid-cols-1 md:grid-cols-2 gap-8">
+                <div class="p-6 bg-white rounded-2xl border border-slate-100 shadow-sm border-l-4 border-l-indigo-600">
+                    <h4 class="font-bold text-slate-900 mb-2">Pagination</h4>
+                    <p class="text-xs text-slate-500 mb-4">Specify the page number (1-indexed) and limit size via standard query parameters. The response contains total count in the <code>X-Total-Count</code> header.</p>
+                    <code class="text-xs font-mono font-bold text-indigo-700 bg-indigo-50 px-3 py-1 rounded-full">GET /api/v1/car?page=1&amp;size=20</code>
+                </div>
+                <div class="p-6 bg-white rounded-2xl border border-slate-100 shadow-sm border-l-4 border-l-emerald-600">
+                    <h4 class="font-bold text-slate-900 mb-2">Dynamic Sorting</h4>
+                    <p class="text-xs text-slate-500 mb-4">Sort fields dynamically in ascending (default or <code>asc</code>) or descending (<code>desc</code>) order. The sorting format is <code>?sort=fieldname,direction</code>.</p>
+                    <code class="text-xs font-mono font-bold text-emerald-700 bg-emerald-50 px-3 py-1 rounded-full">GET /api/v1/car?sort=price,desc</code>
+                </div>
+            </div>
+        </div>
+    </section>
+
     <!-- RPC OPERATORS -->
     <section class="mb-10 text-center">
         <h2 class="text-2xl font-black text-slate-900 mb-6 italic italic underline decoration-indigo-200 underline-offset-8 decoration-8 font-serif uppercase tracking-widest">GORM Filter Reference</h2>

package/templates/go/controller.go.hbs

@@ -3,6 +3,7 @@ package controllers
 import (
 	"net/http"
 	"strconv"
+	"strings"
 	{{#if isSearchable}}
 	"context"
 	{{/if}}
@@ -22,6 +23,8 @@ import (
 	"{{app_name}}/internal/search"
 	{{/if}}
 	"github.com/gin-gonic/gin"
+	"github.com/gin-gonic/gin/binding"
+	"github.com/gin-gonic/gin/render"
 	{{#if isDocument}}
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/mongo"
@@ -44,9 +47,16 @@ type {{capitalize name}}Controller struct {
 func (ctrl *{{capitalize name}}Controller) Create(c *gin.Context) {
 	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 ctrl.Config.GoDuck.Server.REST.Protocol == "messagepack" {
+		if err := c.ShouldBindWith(&entity, binding.MsgPack); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+	} else {
+		if err := c.ShouldBindJSON(&entity); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
 	}
 
 	{{#if isDocument}}
@@ -138,7 +148,11 @@ func (ctrl *{{capitalize name}}Controller) Create(c *gin.Context) {
 	}
 	{{/if}}
 
-	c.JSON(http.StatusCreated, entity)
+	if ctrl.Config.GoDuck.Server.REST.Protocol == "messagepack" {
+		c.Render(http.StatusCreated, render.MsgPack{Data: entity})
+	} else {
+		c.JSON(http.StatusCreated, entity)
+	}
 }
 
 // GetAll handles parallel read aggregation for both SQL and Mongo
@@ -146,6 +160,7 @@ func (ctrl *{{capitalize name}}Controller) GetAll(c *gin.Context) {
 	ctx := c.Request.Context()
 	page, _ := strconv.Atoi(c.DefaultQuery("page", "0"))
 	size, _ := strconv.Atoi(c.DefaultQuery("size", "20"))
+	sortParam := c.DefaultQuery("sort", "")
 	
 	offset := 0
 	if page > 0 {
@@ -169,6 +184,15 @@ func (ctrl *{{capitalize name}}Controller) GetAll(c *gin.Context) {
 				defer wg.Done()
 				var entities []models.{{capitalize name}}
 				opts := options.Find().SetSkip(int64(offset)).SetLimit(int64(size))
+				if sortParam != "" {
+					parts := strings.Split(sortParam, ",")
+					field := parts[0]
+					order := 1
+					if len(parts) > 1 && strings.ToLower(parts[1]) == "desc" {
+						order = -1
+					}
+					opts.SetSort(bson.D{bson.E{Key: field, Value: order}})
+				}
 				cursor, err := db.Collection("{{toLowerCase name}}s").Find(ctx, bson.M{}, opts)
 				if err == nil {
 					cursor.All(ctx, &entities)
@@ -179,7 +203,11 @@ func (ctrl *{{capitalize name}}Controller) GetAll(c *gin.Context) {
 			}(role, siloDB)
 		}
 		wg.Wait()
-		c.JSON(http.StatusOK, federatedData)
+		if ctrl.Config.GoDuck.Server.REST.Protocol == "messagepack" {
+			c.Render(http.StatusOK, render.MsgPack{Data: federatedData})
+		} else {
+			c.JSON(http.StatusOK, federatedData)
+		}
 		return
 	}
 	{{/if}}
@@ -200,13 +228,26 @@ func (ctrl *{{capitalize name}}Controller) GetAll(c *gin.Context) {
 
 	var entities []models.{{capitalize name}}
 	opts := options.Find().SetSkip(int64(offset)).SetLimit(int64(size))
+	if sortParam != "" {
+		parts := strings.Split(sortParam, ",")
+		field := parts[0]
+		order := 1
+		if len(parts) > 1 && strings.ToLower(parts[1]) == "desc" {
+			order = -1
+		}
+		opts.SetSort(bson.D{bson.E{Key: field, Value: order}})
+	}
 	cursor, err := tenantDB.Collection("{{toLowerCase name}}s").Find(ctx, filter, opts)
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
 		return
 	}
 	cursor.All(ctx, &entities)
-	c.JSON(http.StatusOK, entities)
+	if ctrl.Config.GoDuck.Server.REST.Protocol == "messagepack" {
+		c.Render(http.StatusOK, render.MsgPack{Data: entities})
+	} else {
+		c.JSON(http.StatusOK, entities)
+	}
 
 	{{else}}
 	// 🦆 GORM Path
@@ -227,7 +268,11 @@ func (ctrl *{{capitalize name}}Controller) GetAll(c *gin.Context) {
 			go func(r string, db *gorm.DB) {
 				defer wg.Done()
 				var entities []models.{{capitalize name}}
-				if err := db.WithContext(ctx).Offset(offset).Limit(size).Find(&entities).Error; err == nil {
+				query := db.WithContext(ctx)
+				if sortParam != "" {
+					query = query.Order(strings.ReplaceAll(sortParam, ",", " "))
+				}
+				if err := query.Offset(offset).Limit(size).Find(&entities).Error; err == nil {
 					mu.Lock()
 					federatedData[r] = entities
 					mu.Unlock()
@@ -235,7 +280,11 @@ func (ctrl *{{capitalize name}}Controller) GetAll(c *gin.Context) {
 			}(role, siloDB)
 		}
 		wg.Wait()
-		c.JSON(http.StatusOK, federatedData)
+		if ctrl.Config.GoDuck.Server.REST.Protocol == "messagepack" {
+			c.Render(http.StatusOK, render.MsgPack{Data: federatedData})
+		} else {
+			c.JSON(http.StatusOK, federatedData)
+		}
 		return
 	}
 	{{/if}}
@@ -248,11 +297,19 @@ func (ctrl *{{capitalize name}}Controller) GetAll(c *gin.Context) {
 	c.Header("X-Total-Count", strconv.FormatInt(totalCount, 10))
 
 	var entities []models.{{capitalize name}}
-	if err := tenantDB.WithContext(ctx).Offset(offset).Limit(size).Find(&entities).Error; err != nil {
+	query := tenantDB.WithContext(ctx)
+	if sortParam != "" {
+		query = query.Order(strings.ReplaceAll(sortParam, ",", " "))
+	}
+	if err := query.Offset(offset).Limit(size).Find(&entities).Error; err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
 		return
 	}
-	c.JSON(http.StatusOK, entities)
+	if ctrl.Config.GoDuck.Server.REST.Protocol == "messagepack" {
+		c.Render(http.StatusOK, render.MsgPack{Data: entities})
+	} else {
+		c.JSON(http.StatusOK, entities)
+	}
 	{{/if}}
 }
 
@@ -269,7 +326,11 @@ func (ctrl *{{capitalize name}}Controller) GetByID(c *gin.Context) {
 		c.JSON(http.StatusNotFound, gin.H{"error": "Not found"})
 		return
 	}
-	c.JSON(http.StatusOK, entity)
+	if ctrl.Config.GoDuck.Server.REST.Protocol == "messagepack" {
+		c.Render(http.StatusOK, render.MsgPack{Data: entity})
+	} else {
+		c.JSON(http.StatusOK, entity)
+	}
 	{{else}}
 	db, _ := c.Get("tenantDBConn")
 	tenantDB := db.(*gorm.DB)
@@ -278,7 +339,11 @@ func (ctrl *{{capitalize name}}Controller) GetByID(c *gin.Context) {
 		c.JSON(http.StatusNotFound, gin.H{"error": "Not found"})
 		return
 	}
-	c.JSON(http.StatusOK, entity)
+	if ctrl.Config.GoDuck.Server.REST.Protocol == "messagepack" {
+		c.Render(http.StatusOK, render.MsgPack{Data: entity})
+	} else {
+		c.JSON(http.StatusOK, entity)
+	}
 	{{/if}}
 }
 
@@ -286,9 +351,16 @@ func (ctrl *{{capitalize name}}Controller) Update(c *gin.Context) {
 	ctx := c.Request.Context()
 	id := c.Param("id")
 	var entity models.{{capitalize name}}
-	if err := c.ShouldBindJSON(&entity); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
-		return
+	if ctrl.Config.GoDuck.Server.REST.Protocol == "messagepack" {
+		if err := c.ShouldBindWith(&entity, binding.MsgPack); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+	} else {
+		if err := c.ShouldBindJSON(&entity); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
 	}
 
 	{{#if isDocument}}
@@ -320,7 +392,11 @@ func (ctrl *{{capitalize name}}Controller) Update(c *gin.Context) {
 	messaging.PublishEvent(ctrl.Config.GoDuck.Messaging.MQTT.TopicPrefix, "tenant", "UPDATE", "{{capitalize name}}", entity, nil)
 	{{/if}}
 
-	c.JSON(http.StatusOK, entity)
+	if ctrl.Config.GoDuck.Server.REST.Protocol == "messagepack" {
+		c.Render(http.StatusOK, render.MsgPack{Data: entity})
+	} else {
+		c.JSON(http.StatusOK, entity)
+	}
 }
 
 func (ctrl *{{capitalize name}}Controller) Delete(c *gin.Context) {
@@ -356,9 +432,16 @@ func (ctrl *{{capitalize name}}Controller) Patch(c *gin.Context) {
 	ctx := c.Request.Context()
     id := c.Param("id")
     var updates map[string]interface{}
-    if err := c.ShouldBindJSON(&updates); err != nil {
-        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
-        return
+    if ctrl.Config.GoDuck.Server.REST.Protocol == "messagepack" {
+        if err := c.ShouldBindWith(&updates, binding.MsgPack); err != nil {
+            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+            return
+        }
+    } else {
+        if err := c.ShouldBindJSON(&updates); err != nil {
+            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+            return
+        }
     }
 
     {{#if isDocument}}
@@ -383,7 +466,11 @@ func (ctrl *{{capitalize name}}Controller) Patch(c *gin.Context) {
 	messaging.PublishEvent(ctrl.Config.GoDuck.Messaging.MQTT.TopicPrefix, "tenant", "PATCH", "{{capitalize name}}", updates, nil)
 	{{/if}}
 
-    c.JSON(http.StatusOK, gin.H{"message": "Patch successful"})
+    if ctrl.Config.GoDuck.Server.REST.Protocol == "messagepack" {
+        c.Render(http.StatusOK, render.MsgPack{Data: gin.H{"message": "Patch successful"}})
+    } else {
+        c.JSON(http.StatusOK, gin.H{"message": "Patch successful"})
+    }
 }
 
 func (ctrl *{{capitalize name}}Controller) BulkCreate(c *gin.Context) { c.JSON(http.StatusNotImplemented, gin.H{"error": "Bulk operations use primary silo isolation by default."}) }

package/templates/go/main.go.hbs

@@ -14,6 +14,8 @@ import (
     "{{app_name}}/integrations/wso2"
     "gorm.io/driver/postgres"
     "gorm.io/gorm"
+    "net/http"
+    "github.com/improbable-eng/grpc-web/go/grpcweb"
 )
 
 func main() {
@@ -40,6 +42,18 @@ func main() {
         go func() {
             grpcSrv := server.NewGRPCServer(appConfig, repo)
             logger.Info("Starting Kratos gRPC server on %s", appConfig.GoDuck.Server.GRPC.Addr)
+            
+            if appConfig.GoDuck.Server.GRPC.WebEnabled {
+                wrappedGrpc := grpcweb.WrapServer(grpcSrv.Server)
+                go func() {
+                    webPort := fmt.Sprintf(":%d", appConfig.GoDuck.Server.GRPC.WebPort)
+                    logger.Info("Starting gRPC-Web Proxy on %s", webPort)
+                    if err := http.ListenAndServe(webPort, wrappedGrpc); err != nil {
+                        logger.Error("Failed to start gRPC-Web Proxy: %v", err)
+                    }
+                }()
+            }
+            
             if err := grpcSrv.Start(context.Background()); err != nil {
                 logger.Error("Failed to start Kratos gRPC server: %v", err)
             }
@@ -56,7 +70,7 @@ func main() {
 	}
 
 	// 6. Start HTTP Server
-	port := fmt.Sprintf(":%d", appConfig.GoDuck.Server.Port)
-	logger.Info("Starting HTTP server on %s", port)
+	port := fmt.Sprintf(":%d", appConfig.GoDuck.Server.REST.Port)
+	logger.Info("Starting HTTP REST server on %s", port)
 	r.Run(port)
 }

package/templates/go/router.go.hbs

@@ -115,6 +115,21 @@ func SetupRouter(appConfig *config.Config) *gin.Engine {
                     log.Printf("Warning: Failed to connect to fallback database for migration: %v", err)
                 }
             }
+            
+            // 10c. Migrate all provisioned tenant silos
+            var tenantRoles []models.TenantRole
+            if err := masterDB.Find(&tenantRoles).Error; err == nil {
+                mgr := middleware.GetTenantManager(masterDB, appConfig)
+                for _, tenant := range tenantRoles {
+                    if tenantDB, err := mgr.GetDB(tenant.DBName); err == nil {
+                        if err := migrations.RunGoNativeMigrationsForTenant(tenantDB); err != nil {
+                            log.Printf("Warning: Failed to run migrations on tenant %s silo %s: %v", tenant.RoleName, tenant.DBName, err)
+                        } else {
+                            log.Printf("✅ Migrated tenant silo: %s", tenant.DBName)
+                        }
+                    }
+                }
+            }
         }
     }
 

package/templates/kratos/service.go.hbs

@@ -2,6 +2,7 @@ package service
 
 import (
 	"context"
+	"strings"
 	{{#if needFmt}}
 	"fmt"
 	{{/if}}
@@ -283,6 +284,15 @@ func (s *{{capitalize name}}Service) List{{capitalize name}}(ctx context.Context
 	for role, db := range siloConns {
 		var results []models.{{capitalize name}}
 		opts := options.Find().SetSkip(int64((req.Page - 1) * req.PageSize)).SetLimit(int64(req.PageSize))
+		if req.Sort != "" {
+			parts := strings.Split(req.Sort, ",")
+			field := parts[0]
+			order := 1
+			if len(parts) > 1 && strings.ToLower(parts[1]) == "desc" {
+				order = -1
+			}
+			opts.SetSort(bson.D{bson.E{Key: field, Value: order}})
+		}
 		cursor, err := db.Collection("{{toLowerCase name}}s").Find(ctx, bson.M{}, opts)
 		if err == nil {
 			cursor.All(ctx, &results)
@@ -300,6 +310,15 @@ func (s *{{capitalize name}}Service) List{{capitalize name}}(ctx context.Context
 	if ok {
 		var results []models.{{capitalize name}}
 		opts := options.Find().SetSkip(int64((req.Page - 1) * req.PageSize)).SetLimit(int64(req.PageSize))
+		if req.Sort != "" {
+			parts := strings.Split(req.Sort, ",")
+			field := parts[0]
+			order := 1
+			if len(parts) > 1 && strings.ToLower(parts[1]) == "desc" {
+				order = -1
+			}
+			opts.SetSort(bson.D{bson.E{Key: field, Value: order}})
+		}
 		cursor, err := db.Collection("{{toLowerCase name}}s").Find(ctx, bson.M{}, opts)
 		if err == nil {
 			cursor.All(ctx, &results)
@@ -319,7 +338,9 @@ func (s *{{capitalize name}}Service) List{{capitalize name}}(ctx context.Context
 	for role, db := range siloConns {
 		var results []models.{{capitalize name}}
 		query := db.WithContext(ctx).Model(&models.{{capitalize name}}{})
-		
+		if req.Sort != "" {
+			query = query.Order(strings.ReplaceAll(req.Sort, ",", " "))
+		}
 		var count int64
 		query.Count(&count)
 		total += count
@@ -338,7 +359,9 @@ func (s *{{capitalize name}}Service) List{{capitalize name}}(ctx context.Context
 	if ok {
 		var results []models.{{capitalize name}}
 		query := db.WithContext(ctx).Model(&models.{{capitalize name}}{})
-		
+		if req.Sort != "" {
+			query = query.Order(strings.ReplaceAll(req.Sort, ",", " "))
+		}
 		var count int64
 		query.Count(&count)
 		total = count

package/templates/proto/entity.proto.hbs

@@ -83,6 +83,7 @@ message List{{capitalize name}}Request {
   int32 page = 1;
   int32 page_size = 2;
   string query = 3;
+  string sort = 4;
 }
 
 message List{{capitalize name}}Reply {