Merge remote-tracking branch 'origin' into en/rate_limiter

Author: Umang01-hash

docs/advanced-guide/grpc/page.md

@@ -194,6 +194,31 @@ func authInterceptor(ctx context.Context, req any, info *grpc.UnaryServerInfo, h
 }
 ```
 
+## Adding Custom Stream interceptors
+
+For streaming RPCs (client-stream, server-stream, or bidirectional), GoFr allows you to add stream interceptors using AddGRPCServerStreamInterceptors. These are useful for handling logic that needs to span the entire lifetime of a stream.
+```go
+func main() {
+    app := gofr.New()
+
+    app.AddGRPCServerStreamInterceptors(streamAuthInterceptor)
+
+    // ... register your service
+    app.Run()
+}
+
+func streamAuthInterceptor(srv any, ss grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error {
+	// Example: Validate metadata for the entire stream
+	md, ok := metadata.FromIncomingContext(ss.Context())
+	if !ok || !isValidToken(md["auth-token"]) {
+		return status.Errorf(codes.Unauthenticated, "invalid stream token")
+	}
+
+	// If valid, continue processing the stream
+	return handler(srv, ss)
+}
+```
+
 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`
@@ -229,7 +254,48 @@ func {serviceMethod}(ctx *gofr.Context) (*{serviceResponse}, error) {
     return res, nil
 }
 ```
+## Error Handling and Validation
+GoFr's gRPC implementation includes built-in error handling and validation:
+
+**Port Validation**: Automatically validates that gRPC ports are within valid range (1-65535)
+**Port Availability**: Checks if the specified port is available before starting the server
+**Server Creation**: Validates server creation and provides detailed error messages
+**Container Injection**: Validates container injection into gRPC services with detailed logging
+
+Port Configuration
+```bash
+// Set custom gRPC port in .env file
+GRPC_PORT=9001
+
+// Or use default port 9000 if not specified
+```
+## gRPC Reflection
+GoFr supports gRPC reflection for easier debugging and testing. Enable it using the configuration:
+```bash
+# In your .env file
+GRPC_ENABLE_REFLECTION=true
+```
+When enabled, you can use tools like grpcurl to inspect and test your gRPC services:
+
+```bash
+# List available services
+grpcurl -plaintext localhost:9000 list
+
+# Describe a service
+grpcurl -plaintext localhost:9000 describe YourService
+
+# Make a test call
+grpcurl -plaintext -d '{"name": "test"}' localhost:9000 YourService/YourMethod
+```
+
+## Built-in Metrics
+GoFr automatically registers the following gRPC metrics:
+
++ **grpc_server_status**: Gauge indicating server status (1=running, 0=stopped)
++ **grpc_server_errors_total**: Counter for total gRPC server errors
++ **grpc_services_registered_total**: Counter for total registered gRPC services
 
+These metrics are automatically available in your metrics endpoint and can be used for monitoring and alerting.
 
 ## Customizing gRPC Client with DialOptions
 

docs/advanced-guide/overriding-default/page.md

@@ -143,6 +143,15 @@ func main() {
 }
 ```
 
+In GoFr, the following HTTP methods can be redirected, along with their corresponding status codes:
+
+- **GET (302 Found)**: It is safe to redirect because the request remains a GET after the redirect.
+- **POST (303 See Other)**: The browser converts the POST request to a GET on redirect.
+- **PUT (303 See Other)**: The browser converts the PUT request to a GET on redirect.
+- **PATCH (303 See Other)**: The browser converts the PATCH request to a GET on redirect.
+- **DELETE (302 Found)**: This is a temporary redirect, but method handling is ambiguous, as most browsers historically convert the DELETE request into a GET.
+
+
 ## Favicon.ico
 
 By default, GoFr loads its own `favicon.ico` present in root directory for an application. To override `favicon.ico` user

docs/cli/cli.md

@@ -0,0 +1,74 @@
+# CLI Applications 
+
+GoFr provides a simple way to build command-line applications using `app.NewCMD()`. This creates standalone CLI tools without starting an HTTP server.
+
+## Getting Started
+
+Create a basic CLI application with subcommands:
+
+```go
+package main
+
+import (
+	"fmt"
+	"gofr.dev/pkg/gofr"
+)
+
+func main() {
+	app := gofr.NewCMD()
+
+	// Simple hello command
+	app.SubCommand("hello", func(c *gofr.Context) (any, error) {
+		return "Hello World!", nil
+	}, gofr.AddDescription("Print hello message"))
+
+	// Command with parameters
+	app.SubCommand("greet", func(c *gofr.Context) (any, error) {
+		name := c.Param("name")
+		if name == "" {
+			name = "World"
+		}
+		return fmt.Sprintf("Hello, %s!", name), nil
+	})
+
+	app.Run()
+}
+```
+
+## Key GoFr CLI Methods
+
+- **`app.NewCMD()`**: Initialize a CLI application
+- **`app.SubCommand(name, handler, options...)`**: Add a subcommand
+- **`gofr.AddDescription(desc)`**: Add help description
+- **`gofr.AddHelp(help)`**: Add detailed help text
+- **`ctx.Param(name)`**: Get command parameters
+- **`ctx.Out.Println()`**: Print to stdout
+- **`ctx.Logger`**: Access logging
+
+## Running CLI Applications
+
+Build and run your CLI:
+
+```bash
+go build -o mycli
+./mycli hello
+./mycli greet --name John
+./mycli --help
+```
+
+## Example Commands
+
+```bash
+# Basic command
+./mycli hello
+# Output: Hello World!
+
+# Command with parameter
+./mycli greet --name Alice  
+# Output: Hello, Alice!
+
+# Help
+./mycli --help
+```
+
+For more details, see the [sample-cmd example](../../examples/sample-cmd).

docs/datasources/arangodb/page.md

@@ -1,4 +1,16 @@
-## ArangoDB
+# ArangoDB
+
+
+
+## Configuration
+
+To connect to `ArangoDB`, you need to provide the following environment variables:
+- `HOST`: The hostname or IP address of your `ArangoDB` server.
+- `USER`: The username for connecting to the database.
+- `PASSWORD`: The password for the specified user.
+- `PORT`: The port number
+
+## Setup
 
 GoFr supports injecting `ArangoDB` that implements the following interface. Any driver that implements the interface can be
 added using the `app.AddArangoDB()` method, and users can use ArangoDB across the application with `gofr.Context`.
@@ -47,14 +59,13 @@ Import the GoFr's external driver for ArangoDB:
 go get gofr.dev/pkg/gofr/datasource/arangodb@latest
 ```
 
-### Example
+## Example
 
 ```go
 package main
 
 import (
 	"fmt"
-
 	"gofr.dev/pkg/gofr"
 	"gofr.dev/pkg/gofr/datasource/arangodb"
 )
@@ -69,10 +80,10 @@ func main() {
 
 	// Configure the ArangoDB client
 	arangoClient := arangodb.New(arangodb.Config{
-		Host:     "localhost",
-		User:     "root",
-		Password: "root",
-		Port:     8529,
+		Host:     app.Config.Get("HOST"),
+		User:     app.Config.Get("USER"),
+		Password: app.Config.Get("PASSWORD"),
+		Port:     app.Config.Get("PORT"),
 	})
 	app.AddArangoDB(arangoClient)
 
@@ -193,4 +204,4 @@ func GetEdgesHandler(ctx *gofr.Context) (any, error) {
 		"edges":    edges,
 	}, nil
 }
-```
+```

docs/datasources/cassandra/page.md

@@ -1,10 +1,24 @@
-## Cassandra
+# Cassandra
+GoFr supports pluggable Cassandra drivers. 
 
-GoFr supports pluggable Cassandra drivers. It defines an interface that specifies the required methods for interacting
+## Configuration
+To connect to `Cassandra`, you need to provide the following environment variables:
+
+- `HOSTS`: The hostname or IP address of your Cassandra server.
+- `KEYSPACE`: The name of the keyspace (like a database) that holds your tables and defines replication and durability settings.
+- `PORT`: The port number
+- `USERNAME`: The username for connecting to the database.
+- `PASSWORD`: The password for the specified user.
+
+
+## Setup
+
+GoFr defines an interface that specifies the required methods for interacting
 with Cassandra. Any driver implementation that adheres to this interface can be integrated into GoFr using the
 `app.AddCassandra()` method. This approach promotes flexibility and allows you to choose the Cassandra driver that best
 suits your project's needs.
 
+
 ```go
 type CassandraWithContext interface {
 	QueryWithCtx(ctx context.Context, dest any, stmt string, values ...any) error
@@ -59,11 +73,11 @@ func main() {
 	app := gofr.New()
 
 	config := cassandraPkg.Config{
-		Hosts:    "localhost",
-		Keyspace: "test",
-		Port:     2003,
-		Username: "cassandra",
-		Password: "cassandra",
+		Hosts:    app.Config.Get("HOSTS"),
+		Keyspace: app.Config.Get("KEYSPACE"),
+		Port:     app.Config.Get("PORT"),
+		Username: app.Config.Get("USERNAME"),
+		Password: app.Config.Get("PASSWORD"),
 	}
 
 	cassandra := cassandraPkg.New(config)
@@ -97,4 +111,4 @@ func main() {
 
 	app.Run()
 }
-```
+```

docs/datasources/clickhouse/page.md

@@ -1,5 +1,14 @@
-## ClickHouse
+# ClickHouse
 
+## Configuration
+To connect to `ClickHouse`, you need to provide the following environment variables and use it:
+- `HOSTS`: The hostname or IP address of your `ClickHouse` server.
+- `USERNAME`: The username for connecting to the database.
+- `PASSWORD`: The password for the specified user.
+- `DATABASE`: The name of the database to connect to.
+
+
+## Setup
 GoFr supports injecting ClickHouse that supports the following interface. Any driver that implements the interface can be added
 using `app.AddClickhouse()` method, and user's can use ClickHouse across application with `gofr.Context`.
 ```go
@@ -38,10 +47,10 @@ func main() {
 	app := gofr.New()
 
 	app.AddClickhouse(clickhouse.New(clickhouse.Config{
-		Hosts:    "localhost:9001",
-		Username: "root",
-		Password: "password",
-		Database: "users",
+		Hosts:    app.Config.Get("HOSTS"),
+		Username: app.Config.Get("USERNAME"),
+		Password: app.Config.Get("PASSWORD"),
+		Database: app.Config.Get("DATABASE"),
 	}))
 
 	app.POST("/user", Post)
@@ -69,4 +78,4 @@ func Get(ctx *gofr.Context) (any, error) {
 
 	return user, nil
 }
-```
+```

docs/datasources/couchbase/page.md

@@ -1,4 +1,14 @@
-## Couchbase
+# Couchbase
+
+## Configuration
+
+To connect to `Couchbase`, you need to provide the following environment variables and use it:
+- `HOST`: The hostname or IP address of your Couchbase server.
+- `USER`: The username for connecting to the database.
+- `PASSWORD`: The password for the specified user.
+- `BUCKET`: Top level container
+
+## Setup
 
 GoFr supports injecting `Couchbase` that implements the following interface. Any driver that implements the interface can be
 added using the `app.AddCouchbase()` method, and users can use Couchbase across the application with `gofr.Context`.
@@ -38,7 +48,6 @@ import (
     "context"
     "fmt"
     "log"
-
     "gofr.dev/pkg/gofr"
     "gofr.dev/pkg/gofr/datasource/couchbase"
 )
@@ -55,10 +64,10 @@ func main() {
 
     // Add the Couchbase datasource to the application
     a.AddCouchbase(couchbase.New(&couchbase.Config{
-        Host:     "localhost",
-        User:     "Administrator",
-        Password: "password",
-        Bucket:   "test-bucket",
+        Host:     app.Config.Get("HOST"),
+        User:     app.Config.Get("USER"),
+        Password: app.Config.Get("PASSWORD"),
+        Bucket:   app.Config.Get("BUCKET"),
     }))
 
     // Add the routes

docs/datasources/dgraph/page.md

@@ -1,5 +1,11 @@
-## Dgraph
+# Dgraph
 
+## Configuration
+To connect to `Dgraph`, you need to provide the following environment variables and use it:
+- `HOST`: The hostname or IP address of your Dgraph server.
+- `PORT`: The port number.
+
+## Setup
 GoFr supports injecting Dgraph with an interface that defines the necessary methods for interacting with the Dgraph
 database. Any driver that implements the following interface can be added using the app.AddDgraph() method.
 
@@ -55,7 +61,6 @@ package main
 import (
 	"encoding/json"
 	"fmt"
-
 	"github.com/dgraph-io/dgo/v210/protos/api"
 
 	"gofr.dev/pkg/gofr"
@@ -67,8 +72,8 @@ func main() {
 	app := gofr.New()
 
 	db := dgraph.New(dgraph.Config{
-		Host: "localhost",
-		Port: "9080",
+		Host: app.Config.Get("HOST"),
+		Port: app.Config.Get("PORT"),
 	})
 
 	// Connect to Dgraph running on localhost:9080
@@ -136,4 +141,4 @@ func DGraphQueryHandler(c *gofr.Context) (any, error) {
 
 	return result, nil
 }
-```
+```