Merge branch 'main' of github.com:gofr-dev/gofr

Author: Umang01-hash

Diff for: .github/workflows/go.yml

@@ -374,6 +374,6 @@ jobs:
 
       # Check file naming conventions using ls-lint
       - name: Check for file names errors
-        uses: ls-lint/action@v2.2.3
+        uses: ls-lint/action@v2.3.0
         with:
           config: .ls-lint.yml

Diff for: README.md

@@ -137,4 +137,4 @@ If your PR is merged, or if you contribute by writing articles or promoting GoFr
 
 ### Partners
 
-<img src="https://resources.jetbrains.com/storage/products/company/brand/logos/jetbrains.png" alt="JetBrains logo" width="200">
+<img src="https://resources.jetbrains.com/storage/products/company/brand/logos/jetbrains.png" alt="JetBrains logo" width="200">

Diff for: docs/advanced-guide/grpc/page.md

@@ -56,7 +56,7 @@ syntax = "proto3";
 option go_package = "path/to/your/proto/file";
 
 service {serviceName}Service {
-rpc {serviceMethod} ({serviceRequest}) returns ({serviceResponse}) {}
+  rpc {serviceMethod} ({serviceRequest}) returns ({serviceResponse}) {}
         }
 ```
 
@@ -67,16 +67,16 @@ procedure call. Below is a generic representation for services' gRPC messages ty
 
 ```protobuf
 message {serviceRequest} {
-int64 id = 1;
-        string name = 2;
-// other fields that can be passed
+    int64 id = 1;
+    string name = 2;
+    // other fields that can be passed
         }
 
 message {serviceResponse} {
-int64 id = 1;
-        string name = 2;
-string address = 3;
-// other customer related fields
+    int64 id = 1;
+    string name = 2;
+    string address = 3;
+    // other customer related fields
         }
 ```
 
@@ -146,6 +146,56 @@ func main() {
 
 >Note: By default, gRPC server will run on port 9000, to customize the port users can set `GRPC_PORT` config in the .env
 
+## Adding gRPC Server Options
+
+To customize your gRPC server, use `AddGRPCServerOptions()`.
+
+### Example: Enabling TLS & other ServerOptions
+```go
+func main() {
+    app := gofr.New()
+
+    // Add TLS credentials and connection timeout in one call
+    creds, _ := credentials.NewServerTLSFromFile("server-cert.pem", "server-key.pem")
+	
+    app.AddGRPCServerOptions(
+		grpc.Creds(creds),
+    	grpc.ConnectionTimeout(10 * time.Second),
+    )
+
+    packageName.Register{serviceName}ServerWithGofr(app, &{packageName}.New{serviceName}GoFrServer())
+
+    app.Run()
+}
+```
+
+## Adding Custom Unary Interceptors
+
+Interceptors help in implementing authentication, validation, request transformation, and error handling.
+
+### Example: Authentication Interceptor
+```go
+func main() {
+    app := gofr.New()
+
+    app.AddGRPCUnaryInterceptors(authInterceptor)
+
+    packageName.Register{serviceName}ServerWithGofr(app, &{packageName}.New{serviceName}GoFrServer())
+
+    app.Run()
+}
+
+func authInterceptor(ctx context.Context, req any, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (any, error) {
+    if !isAuthenticated(ctx) {
+        return nil, status.Errorf(codes.Unauthenticated, "authentication failed")
+    }
+
+    return handler(ctx, req)
+}
+```
+
+For more details on adding additional interceptors and server options, refer to the [official gRPC Go package](https://pkg.go.dev/google.golang.org/grpc#ServerOption).
+
 ## Generating gRPC Client using `gofr wrap grpc client`
 
 **1. Use the `gofr wrap grpc client` Command:**
@@ -159,27 +209,132 @@ This command leverages the `gofr-cli` to generate a `{serviceName}_client.go` fi
    ```go
 // gRPC Handler with context support
 func {serviceMethod}(ctx *gofr.Context) (*{serviceResponse}, error) {
-// Create the gRPC client
-srv, err := New{serviceName}GoFrClient("your-grpc-server-host", ctx.Metrics())
-if err != nil {
-return nil, err
+	// Create the gRPC client
+    srv, err := New{serviceName}GoFrClient("your-grpc-server-host", ctx.Metrics())
+    if err != nil {
+        return nil, err
+    }
+
+    // Prepare the request
+    req := &{serviceRequest}{
+    // populate fields as necessary
+    }
+
+	// Call the gRPC method with tracing/metrics enabled
+    res, err := srv.{serviceMethod}(ctx, req)
+    if err != nil {
+        return nil, err
+    }
+
+    return res, nil
 }
+```
 
-// Prepare the request
-req := &{serviceRequest}{
-// populate fields as necessary
+
+## Customizing gRPC Client with DialOptions
+
+GoFr provides flexibility to customize your gRPC client connections using gRPC `DialOptions`. This allows users to configure aspects such as transport security, interceptors, and load balancing policies.
+You can pass optional parameters while creating your gRPC client to tailor the connection to your needs. Here’s an example of a Unary Interceptor that sets metadata on outgoing requests:
+
+```go
+func main() {
+    app := gofr.New()
+
+    // Create a gRPC client for the service
+    gRPCClient, err := client.New{serviceName}GoFrClient(
+        app.Config.Get("GRPC_SERVER_HOST"),
+        app.Metrics(),
+        grpc.WithChainUnaryInterceptor(MetadataUnaryInterceptor),
+    )
+	
+    if err != nil {
+        app.Logger().Errorf("Failed to create gRPC client: %v", err)
+        return
+    }
+
+    greet := NewGreetHandler(gRPCClient)
+
+    app.GET("/hello", greet.Hello)
+
+    app.Run()
 }
 
-// Call the gRPC method with tracing/metrics enabled
-res, err := srv.{serviceMethod}(ctx, req)
-if err != nil {
-return nil, err
+// MetadataUnaryInterceptor sets a custom metadata value on outgoing requests
+func MetadataUnaryInterceptor(ctx context.Context, method string, req, reply any, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
+    md := metadata.Pairs("client-id", "GoFr-Client-123")
+    ctx = metadata.NewOutgoingContext(ctx, md)
+
+    err := invoker(ctx, method, req, reply, cc, opts...)
+    if err != nil {
+        return fmt.Errorf("Error in %s: %v", method, err)
+	}
+	
+	return err
 }
+```
+
+This interceptor sets a metadata key `client-id` with a value of `GoFr-Client-123` for each request. Metadata can be used for authentication, tracing, or custom behaviors.
+
+### Using TLS Credentials and Advanced Service Config
+By default, gRPC connections in GoFr are made over insecure connections, which is not recommended for production. You can override this behavior using TLS credentials. Additionally, a more comprehensive service configuration can define retry policies and other settings:
+
+```go
+import (
+    "google.golang.org/grpc"
+    "google.golang.org/grpc/credentials"
+)
+
+// The default serviceConfig in GoFr only sets the loadBalancingPolicy to "round_robin".
+const serviceConfig = `{
+    "loadBalancingPolicy": "round_robin", 
+    "methodConfig": [{
+        "name": [{"service": "HelloService"}],
+        "retryPolicy": {
+            "maxAttempts": 4,
+            "initialBackoff": "0.1s",
+            "maxBackoff": "1s",
+            "backoffMultiplier": 2.0,
+            "retryableStatusCodes": ["UNAVAILABLE", "RESOURCE_EXHAUSTED"]
+        }
+    }]
+}`
+
+func main() {
+    app := gofr.New()
 
-return res, nil
+    creds, err := credentials.NewClientTLSFromFile("path/to/cert.pem", "")
+    if err != nil {
+        app.Logger().Errorf("Failed to load TLS certificate: %v", err)
+        return
+    }
+
+    gRPCClient, err := client.New{serviceName}GoFrClient(
+        app.Config.Get("GRPC_SERVER_HOST"),
+        app.Metrics(),
+        grpc.WithTransportCredentials(creds),
+        grpc.WithDefaultServiceConfig(serviceConfig),
+    )
+	
+    if err != nil {
+        app.Logger().Errorf("Failed to create gRPC client: %v", err)
+        return
+    }
+
+    greet := NewGreetHandler(gRPCClient)
+
+    app.GET("/hello", greet.Hello)
+
+    app.Run()
 }
 ```
 
+In this example:
+- `WithTransportCredentials` sets up TLS security.
+- `WithDefaultServiceConfig` defines retry policies with exponential backoff and specific retryable status codes.
+
+### Further Reading
+For more details on configurable DialOptions, refer to the [official gRPC package for Go](https://pkg.go.dev/google.golang.org/grpc#DialOption).
+
 ## HealthChecks in GoFr's gRPC Service/Clients
 Health Checks in GoFr's gRPC Services
 
@@ -189,20 +344,20 @@ GoFr provides built-in health checks for gRPC services, enabling observability,
 
 ```go
 type {serviceName}GoFrClient interface {
-SayHello(*gofr.Context, *HelloRequest, ...grpc.CallOption) (*HelloResponse, error)
-health
+    SayHello(*gofr.Context, *HelloRequest, ...grpc.CallOption) (*HelloResponse, error)
+    health
 }
 
 type health interface {
-Check(ctx *gofr.Context, in *grpc_health_v1.HealthCheckRequest, opts ...grpc.CallOption) (*grpc_health_v1.HealthCheckResponse, error)
-Watch(ctx *gofr.Context, in *grpc_health_v1.HealthCheckRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[grpc_health_v1.HealthCheckResponse], error)
+    Check(ctx *gofr.Context, in *grpc_health_v1.HealthCheckRequest, opts ...grpc.CallOption) (*grpc_health_v1.HealthCheckResponse, error)
+    Watch(ctx *gofr.Context, in *grpc_health_v1.HealthCheckRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[grpc_health_v1.HealthCheckResponse], error)
 }
 ```
 
 ### Server Integration
 ```go
 type {serviceName}GoFrServer struct {
-health *healthServer
+    health *healthServer
 }
 ```
 Supported Methods for HealthCheck :

Diff for: docs/datasources/getting-started/page.md

@@ -93,7 +93,7 @@ as unnecessary database drivers are not being compiled and added to the build.
 - ✅
 - ✅
 - ✅
--
+- ✅
 
 ---
 

Diff for: docs/public/metrics-dashboard.png

@@ -4,19 +4,12 @@ Just like Redis GoFr also supports connection to SQL (MySQL, MariaDB, and Postgr
 
 ## Setup
 
-Users can run MySQL and create a database locally using the following Docker command:
+Users can run MySQL/MariaDB  and create a database locally using the following Docker command:
 
 ```bash
-docker run --name gofr-mysql -e MYSQL_ROOT_PASSWORD=root123 -e MYSQL_DATABASE=test_db -p 3306:3306 -d mysql:8.0.30
+docker run --name gofr-db -e MYSQL_ROOT_PASSWORD=root123 -e MYSQL_DATABASE=test_db -p 3306:3306 -d mysql:8.0.30
 ```
 
-For MariaDB, you would run:
-
-```bash
-docker run --name gofr-mariadb -e MYSQL_ROOT_PASSWORD=root123 -e MYSQL_DATABASE=test_db -p 3306:3306 -d mariadb:latest
-```
-
-
 Access `test_db` database and create table customer with columns `id` and `name`. Change mysql to mariadb as needed: 
 
 ```bash
@@ -43,11 +36,7 @@ DB_PASSWORD=root123
 DB_NAME=test_db
 DB_PORT=3306
 DB_DIALECT=mysql
-DB_CHARSET=
-
-# DB_CHARSET: The character set for database connection (default: utf8).
-# The `DB_CHARSET` defaults to utf8, but setting it to utf8mb4 is recommended if you need full Unicode support,
-# including emojis and special characters.
+DB_CHARSET=utf8 #(optional)
 ```
 
 Now in the following example, we'll store customer data using **POST** `/customer` and then use **GET** `/customer` to retrieve the same.

Diff for: docs/public/reviewers/aditya_joshi.webp

@@ -6,13 +6,7 @@ GoFr simplifies the process of connecting to Redis.
 
 Ensure we have Redis installed on our system.
 
-Optionally, We can use Docker to set up a development environment as described below.
-
-```bash
-docker run --name gofr-redis -p 6379:6379 -d redis
-```
-
-We can also set up a development environment with password authentication as described below.
+Optionally, We can use Docker to set up a development environment with password authentication  as described below.
 
 ```bash
 docker run --name gofr-redis -p 2002:6379 -d \

Diff for: docs/public/reviewers/ayush_mishra.webp

@@ -137,6 +137,17 @@ For example: When running application locally, we can access /metrics endpoint o
 
 GoFr also supports creating {% new-tab-link newtab=false title="custom metrics" href="/docs/advanced-guide/publishing-custom-metrics" /%}.
 
+### Example Dashboard
+
+These metrics can be easily consumed by monitoring systems like {% new-tab-link title="Prometheus" href="https://prometheus.io/" /%}
+and visualized in dashboards using tools like {% new-tab-link title="Grafana" href="https://grafana.com/" /%}.
+
+Here's a sample Grafana dashboard utilizing GoFr's metrics:
+
+{% figure src="/metrics-dashboard.png" alt="Grafana Dashboard showing GoFr metrics including HTTP request rates, 
+response times etc." caption="Example monitoring dashboard using GoFr's built-in metrics" /%}
+
+
 ## Tracing
 
 {% new-tab-link title="Tracing" href="https://opentelemetry.io/docs/concepts/signals/#traces" /%} is a powerful tool for gaining insights into your application's behavior, identifying bottlenecks, and improving

Diff for: docs/public/reviewers/christophe_colombier.webp

@@ -193,6 +193,12 @@ This document lists all the configuration options supported by the GoFr framewor
 -  Currently supported only for PostgreSQL, with Default certificate file.
 -  disable
 
+---
+
+- DB_CHARSET
+- The character set for database connection
+- utf8
+
 {% /table %}
 
 ### Redis