Raezil/Thunder - The RADDEST Backend Framework!

🚀 Features

✔️ gRPC + REST (gRPC-Gateway) – Automatically expose RESTful APIs from gRPC services.
✔️ Prisma Integration – Efficient database management and migrations.
✔️ Kubernetes Ready – Easily deploy and scale with Kubernetes.
✔️ TLS Security – Secure gRPC communications with TLS.
✔️ Structured Logging – Built-in zap logging.
✔️ Rate Limiting & Authentication – Pre-configured middleware.
✔️ Modular & Extensible – Easily extend Thunder for custom use cases.
✔️ Thunder CLI - Generate, deploy, and create new projects effortlessly.

🏗️ Architecture Overview

UNDER CONSTRUCTION! Architecture Diagram Coming Soon!

📌 Use Cases

Thunder is designed for scalable microservices and high-performance API development, particularly suited for:

High-Performance API Development gRPC-first APIs with RESTful interfaces via gRPC-Gateway. Critical performance and low latency applications. Strongly-typed APIs with protobufs.
Microservices Architecture Efficient inter-service communication. Kubernetes deployments with built-in service discovery and scaling.
Database Management with Prisma Type-safe queries and easy database migrations. Support for multiple databases (PostgreSQL, MySQL, SQLite).
Lightweight Backend Alternative A minimalist and powerful alternative to traditional frameworks like Gin or Echo. Fast, simple, and modular backend without unnecessary overhead.
Kubernetes & Cloud-Native Applications Containerized environments using Docker. Automatic service scaling and load balancing.

When Not to Use Thunder

If you need a traditional REST-only API (use Gin, Fiber, or Echo instead).
If you require a feature-heavy web framework with extensive middleware.
If you're not deploying on Kubernetes or prefer a monolithic backend.

📌 Getting Started

                        
                            git clone https://github.com/Raezil/Thunder.git
                            cd Thunder
                            chmod +x install.sh
                            ./install.sh
                            #99 Setup
                            Create a new Thunder application:
                            thunder init myapp
                            cd myapp
                            Install Dependencies
                            go mod tidy
                            Define Your gRPC Service
                            Create a .proto file (e.g., example.proto):
                            syntax = "proto3";
                            package example;
                            import "google/api/annotations.proto";
                            service Example {
                                rpc SayHello(HelloRequest) returns (HelloResponse) {
                                    option (google.api.http) = {
                                        get: "/v1/example/sayhello";
                                    };
                                };
                            }
                            message HelloRequest {
                                string name = 1;
                            }
                            message HelloResponse {
                                string message = 1;
                            }
                            Add your service entry in services.json:
                            [
                                {
                                    "ServiceName": "Example",
                                    "ServiceStruct": "ExampleServiceServer",
                                    "ServiceRegister": "RegisterExampleServer",
                                    "HandlerRegister": "RegisterExampleHandler"
                                }
                            ]

🛠️ Prisma Integration

                        
                            Define your schema in schema.prisma:
                            datasource db {
                                provider = "postgresql"
                                url      = env("DATABASE_URL")
                            }
                            model User {
                                id    String  @default(cuid()) @id
                                name  String
                                email String  @unique
                            }
                            Generate the service implementation:
                            thunder generate --proto=example.proto

🚀 Running the Server

                        
                            Start the server:
                            go run ./cmd/app/server/main.go
                            Server accessible via HTTP at localhost:8080 and gRPC at localhost:50051.

🚀 Running the Tests

                        
                           Mocking Tests:
                           cd pkg/services/generated
                           mockgen -source=yourservice_grpc.pb.go -destination=./yourservice_mock.go
                           Run Tests:
                           go test ./pkg/db ./pkg/middlewares/ ./pkg/services/ ./pkg/services/generated

🔧 Kubernetes Deployment

PgBouncer Configuration

This setup configures PgBouncer to connect to a PostgreSQL database using Kubernetes resources.

Updating the userlist.txt Secret

To regenerate and update the userlist.txt secret, use the following command to encode the credentials:

                        
                            echo '"postgres" "postgres"'|base64

Now, update pgbouncer-all.yaml under the Secret section with the new base64-encoded value:

                        
                            apiVersion: v1
                            kind: Secret
                            metadata:
                              name: pgbouncer-secret
                            type: Opaque
                            data:
                              userlist.txt: <BASE64_ENCODED_VALUE>
                            # "postgres" "postgres" in base64

Generate TLS Certificates

                        
                            cd cmd
                            mkdir certs
                            openssl req -x509 -newkey rsa:4096 -keyout certs/server.key -out certs/server.crt -days 365 -nodes \
                             -subj "/CN=localhost" \
                             -addext "subjectAltName=DNS:localhost,IP:127.0.0.1"

Generate Kubernetes Secrets

                        
                            kubectl create secret generic app-secret   --from-literal=DATABASE_URL="postgres://postgres:postgres@pgbouncer-service:6432/thunder?sslmode=disable" \
                            --from-literal=JWT_SECRET="secret"
                            kubectl create secret generic postgres-secret   --from-literal=POSTGRES_USER=postgres \
                            --from-literal=POSTGRES_PASSWORD=postgres \
                            --from-literal=POSTGRES_DB=thunder

Build & Deploy Docker Image

                        
                            thunder build
                            thunder deploy

Check pod status:

                            
                                kubectl get pods -n default
                                kubectl describe pod $NAME -n default

📡 API Testing

                        
                           curl -k --http2 -X POST https://localhost:8080/v1/auth/register \
                           -H "Content-Type: application/json" \
                           -d '{"email": "newuser@example.com","password": "password123","name": "John","surname": "Doe","age": 30}'

User Login

                        
                           curl -k --http2 -X POST https://localhost:8080/v1/auth/login \
                           -H "Content-Type: application/json" \
                           -d '{"email": "newuser@example.com","password": "password123"}'

Sample protected

                        
                           curl -k -X GET "https://localhost:8080/v1/auth/protected?text=hello" \
                           -H "Authorization: $token"
                           $token is returned by login

📜 Contributing

Fork the repository.
Create a feature branch: git checkout -b feature-new
Commit changes: git commit -m "Added feature"
Push to your branch: git push origin feature-new
Submit a pull request.

🔗 References

Go Documentation

gRPC

gRPC-Gateway

Prisma ORM

Kubernetes Docs