add patch method to app (#396)

Author: Umang01-hash

docs/advanced-guide/circuit-breaker/page.md

@@ -1,6 +1,6 @@
 # Circuit Breaker in HTTP Communication
 
-Calls to remote resources and services can fail due to temporary issues like slow network connections or timeouts, as well as longer-lasting problems such as service unavailability. While transient faults can be mitigated using the "Retry pattern," there are cases where continual retries are futile, such as during severe service failures.
+Calls to remote resources and services can fail due to temporary issues like slow network connections or timeouts, service unavailability. While transient faults can be mitigated using the "Retry pattern", there are cases where continual retries are futile, such as during severe service failures.
 
 In such scenarios, it's crucial for applications to recognize when an operation is unlikely to succeed and handle the failure appropriately rather than persistently retrying. Indiscriminate use of HTTP retries can even lead to unintentional denial-of-service attacks within the software itself, as multiple clients may flood a failing service with retry attempts.
 

docs/advanced-guide/custom-spans-in-tracing/page.md

@@ -1,21 +1,21 @@
 # Custom Spans In Tracing
 
-GoFr's built-in tracing provides valuable insights into your application's behavior. However, sometimes you might need 
-even more granular details about specific operations within your application. This is where `custom spans` come in.
+GoFr's built-in tracing provides valuable insights into application's behavior. However, sometimes you might need 
+even more granular details about specific operations within your application. This is where `custom spans` can be used.
 
 ## How it helps?
 By adding custom spans in traces to your requests, you can:
 
 - **Gain granular insights:** Custom spans allow you to track specific operations or functions within your application, 
      providing detailed performance data.
-- **Identify bottlenecks:** By analyzing custom spans, you can pinpoint areas of your code that may be causing 
+- **Identify bottlenecks:** Analyzing custom spans helps to pinpoint areas of your code that may be causing 
       performance bottlenecks or inefficiencies.
-- **Improve debugging:** Custom spans enhance your ability to debug issues by providing visibility into the execution 
-      flow of your application.
+- **Improve debugging:** Custom spans enhance the ability to debug issues by providing visibility into the execution 
+      flow of an application.
 
 ## Usage
 
-To add a custom trace to a request, you can use the `Trace()` method of GoFr context, which takes the name of the span as an argument 
+To add a custom trace to a request, GoFr context provides `Trace()` method, which takes the name of the span as an argument 
 and returns a trace.Span. 
 
 ```go
@@ -28,7 +28,7 @@ func MyHandler(c context.Context) error {
 }
 ```
 
-In this example, **my-custom-span** is the name of the custom span that you want to add to the request.
+In this example, **my-custom-span** is the name of the custom span that is added to the request.
 The defer statement ensures that the span is closed even if an error occurs to ensure that the trace is properly recorded.
 
 

docs/advanced-guide/grpc/page.md

@@ -1,8 +1,8 @@
 # gRPC
 We have already seen how GoFr can help ease the development of HTTP servers, but there are
 cases where performance is primiraliy required sacrificing flexibility. In these types of 
-scenarios gRPC protocol comes into picture. gRPC is an open-source RPC(Remote Procedure Call)
-framework initially developed by Google. {% new-tab-link title="Learn more" href="https://grpc.io/docs/what-is-grpc/introduction/" /%}
+scenarios gRPC protocol comes into picture. {% new-tab-link title="gRPC" href="https://grpc.io/docs/what-is-grpc/introduction/" /%} is an open-source RPC(Remote Procedure Call)
+framework initially developed by Google. 
 
 ## Prerequisites
 - Install the `protoc` protocol buffer compilation
@@ -30,7 +30,7 @@ framework initially developed by Google. {% new-tab-link title="Learn more" href
 ## Creating protocol buffers
 For a detailed guide, please take a look at the {% new-tab-link title="Tutorial" href="https://grpc.io/docs/languages/go/basics/" /%} at official gRPC docs.
 
-Fistly, we need to create a `customer.proto` file to define our service and the rpc methods that the service provides.
+We need to create a `customer.proto` file to define our service and the rpc methods that the service provides.
 ```protobuf
 // Indicates the protocol buffer version that is being used
 syntax = "proto3";
@@ -67,7 +67,7 @@ message CustomerData {
 }
 ```
 
-Now run the following command to gegnerate go code using the Go gRPC plugins:
+Now run the following command to generate go code using the Go gRPC plugins:
 ```shell
 protoc \
 --go_out=. \

docs/advanced-guide/handling-data-migrations/page.md

@@ -47,7 +47,7 @@ func createTableEmployee() migration.Migrate {
 ```
 
 `migration.Datasource` have the datasources whose migrations are supported i.e. Redis and SQL (MySQL and PostgreSQL).
-All the migrations always run in a transaction.
+All migrations always run in a transaction.
 
 For MySQL it is highly recommended to use `IF EXISTS` and `IF NOT EXIST` in DDL commands as MySQL implicitly commits these commands.
 
@@ -67,7 +67,7 @@ func All() map[int64]migration.Migrate {
 }
 ```
 
-Migrations will run in ascending order of keys in this map.
+Migrations run in ascending order of keys in this map.
 
 ### Initialisation from main.go
 
@@ -99,7 +99,6 @@ INFO [16:55:46] Migration 20240226153000 ran successfully
 ```
 
 GoFr maintains the records in the database itself which helps in tracking which migrations have already been executed and ensures that only migrations that have never been run are executed.
-This way, you only need to ensure that your migrations are properly in place. {% new-tab-link  title="Learn more" href="https://cloud.google.com/architecture/database-migration-concepts-principles-part-1" /%}
 
 ## Migration Records
 

docs/advanced-guide/remote-log-level-change/page.md

@@ -1,14 +1,13 @@
 # Remote Log Level Change
 
-Gofr makes it easy to adjust the detail captured in your application's logs, even while it's running!
+Gofr makes it easy to adjust the details captured in the application's logs, even while it's running!
 
 This feature allows users to effortlessly fine-tune logging levels without the need for redeployment, enhancing the monitoring and debugging experience.
 It is facilitated through simple configuration settings.
 
 ## How it helps?
 
-- **Effortless Adjustments:** Modify the level of detail in your logs anytime without restarting your application.
-  This is especially helpful during troubleshooting.
+- **Effortless Adjustments:** Modify the log level anytime without restarting the application. This is especially helpful during troubleshooting.
 - **Enhanced Visibility:** Easily switch to a more detailed log level (e.g., `DEBUG`) to gain deeper insights into specific issues,
   and then switch back to a less detailed level (e.g., `INFO`) for regular operation.
 - **Improved Performance:** Generating a large number of logs can overwhelm the logging system, leading to increased I/O operations and resource consumption,
@@ -19,7 +18,7 @@ It is facilitated through simple configuration settings.
 To enable remote log level update, users need to specify the following configuration parameter:
 
 ```bash
-REMOTE_LOG_URL=<URL to your remote log level endpoint> (e.g., https://your-service.com/log-levels)
+REMOTE_LOG_URL=<URL to user's remote log level endpoint> (e.g., https://log-service.com/log-levels)
 REMOTE_LOG_FETCH_INTERVAL=<Interval in seconds> (default: 15)
 ```
 
@@ -44,6 +43,6 @@ The remote log level endpoint should return a JSON response in the following for
 ```
 
 - **serviceName:** Identifies the service for which log levels are configured.
-- **logLevel:** The new log level you want to set for the specified service.
+- **logLevel:** The new log level user want to set for the specified service.
 
 GoFr parses this response and adjusts log levels based on the provided configurations.

docs/advanced-guide/using-publisher-subscriber/page.md

@@ -115,7 +115,7 @@ func (ctx *gofr.Context) error
 ```
 
 `Subscribe` method of GoFr App will continuously read a message from the configured `PUBSUB_BACKEND` which
-can be either `KAFKA` or `GOOGLE` as of now. These can be configured in your configs folder under `.env`
+can be either `KAFKA` or `GOOGLE` as of now. These can be configured in the configs folder under `.env`
 
 > The returned error determines which messages are to be committed and which ones are to be consumed again.
 
@@ -127,7 +127,7 @@ app.Subscribe("order-status", func(ctx *gofr.Context)error{
 })
 ```
 
-The context `ctx` provides you with the following methods :
+The context `ctx` provides user with the following methods :
 
 Bind() - Bind the message value to a given interface.
 Param(p string)/PathParam(p string) - Will return the topic when the same is passed as param.

docs/quick-start/configuration/page.md

@@ -1,10 +1,23 @@
 # Configurations
 
-GoFr reads configuration via environment variables. It provides an easy way to manage this. Application code is decoupled from how configuration is managed as per the {% new-tab-link title="12-factor" href="https://12factor.net/config" /%}.
-Configs in GoFr can be used to initialise datasources, tracing. In doing so it abstract the logic and gives an easy interface to setup different things.
+GoFr simplifies configuration management by reading configuration via environment variables.
+Application code is decoupled from how configuration is managed as per the {%new-tab-link title="12-factor" href="https://12factor.net/config" %}.
+Configs in GoFr can be used to initialise datasources, tracing , setting log levels, changing default http or metrics port.
+This abstraction provides a user-friendly interface for configuring your application without modifying the code itself.
 
 To set configs create a `configs` directory in the project's root and add `.env` file.
 
+Follow this directory structure within your GoFr project:
+```dotenv
+my-gofr-app/
+├── config/
+│   ├── dev.env
+│   ├── staging.env
+│   └── prod.env
+├── main.go
+└── ...
+```
+
 By default, GoFr starts HTTP server at port 8000, in order to change that we can add the config `HTTP_PORT`
 Similarly to Set the app-name you can add `APP_NAME`. For example:
 

docs/quick-start/connecting-mysql/page.md

@@ -4,7 +4,7 @@ Just like Redis gofr also supports connection to SQL(mysql and postgres) databas
 
 ## Setup
 
-You can run MySQL and create a database locally using the following docker command:
+Users can run MySQL 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
@@ -38,7 +38,7 @@ DB_PORT=3306
 DB_DIALECT=mysql
 ```
 
-Now in the following example let's store customer data using **POST** `/customer` and then use **GET** `/customer` to retrieve the same.
+Now in the following example, we'll store customer data using **POST** `/customer` and then use **GET** `/customer` to retrieve the same.
 We will be storing the customer data with `id` and `name`.
 
 After adding code to add and retrieve data from MySQL datastore, `main.go` will be updated to the following.
@@ -118,13 +118,6 @@ curl --location --request POST 'http://localhost:9000/customer/abc'
 
 curl --location --request POST 'http://localhost:9000/customer/xyz'
 ```
-
-You will see the following output if database is successfully updated
-
-```json
-{}
-```
-
 Now when we access {% new-tab-link title="http://localhost:9000/customer" href="http://localhost:9000/customer" /%} we should see the following output
 
 ```json

docs/quick-start/connecting-redis/page.md

@@ -4,33 +4,39 @@ GoFr simplifies the process of connecting to Redis.
 
 ## Setup:
 
-Before using Redis with GoFr, you need to have Redis installed. You can use Docker to set up a Redis container:
+Ensure you have Redis installed on your system.
+
+Optionally, you can use Docker to set up a development environment as described below.
 
 ```bash
 docker run --name gofr-redis -p 6379:6379 -d redis
 ```
 
-To set a sample key, run the following command:
+You can set a sample key `greeting` using the following command:
 
 ```bash
-docker exec -it gofr-redis bash -c 'redis-cli SET greeting "Hello from Redis."'docker exec -it gofr-redis bash -c 'redis-cli SET greeting "Hello from Redis."'
+docker exec -it gofr-redis bash -c 'redis-cli SET greeting "Hello from Redis."'
 ```
 
 ## Configuration & Usage
 
-GoFr requires certain configurations to connect to Redis. The necessary configurations include
-`REDIS_HOST`and `REDIS_PORT`. Update the `.env` file in the configs directory with the following content:
+GoFr applications relies on environment variables to configure and connect to a Redis server. 
+These variables are stored in a file named `.env` located within the configs directory in your project root.
+
+Following configuration keys are required for Redis connectivity:
+
+* `REDIS_HOST`: It specifies the hostname or IP address of your Redis server.
+* `REDIS_PORT`: It specifies the port number on which your Redis server is listening. The default Redis port is 6379.
 
-```swift
+```bash
 APP_NAME=test-service
 HTTP_PORT=9000
 
 REDIS_HOST=localhost
 REDIS_PORT=6379
 ```
 
-Once the Redis configurations are set, you can use Redis in your GoFr application.
-Below is an example of how to retrieve data from Redis in the `main.go` file:
+The following code snippet demonstrates how to retrieve data from a Redis key named "greeting":
 
 ```go
 package main
@@ -64,6 +70,3 @@ func main() {
 	app.Run()
 }
 ```
-
-The above code demonstrates how to perform Redis operations using the latest GoFr syntax.
-You can adapt this example to fit your application's specific requirements.

docs/quick-start/introduction/page.md

@@ -1,27 +1,26 @@
 # Prerequisite
 
 - Go 1.20 or above.
-  To check the version use the following command `go version`.
+  To check Go version use the following command `go version`.
 
 - Prior familiarity with Golang syntax is essential. {% new-tab-link title="Golang Tour" href="https://tour.golang.org/" /%} is highly recommended as it has an excellent guided tour.
 
 ## Write your first GoFr API
 
-Let's start by initializing the go module by using the following command.
+Let's start by initializing the {% new-tab-link title="go module" href="https://go.dev/ref/mod" /%} by using the following command.
 
 ```bash
 go mod init github.com/example
 ```
 
-To know more about go modules refer {% new-tab-link title="here" href="https://go.dev/ref/mod" /%}.
-
-Add {% new-tab-link title="gofr" href="https://github.com/gofr-dev/gofr" /%} package to the project using the following command
+Add {% new-tab-link title="gofr" href="https://github.com/gofr-dev/gofr" /%} package to the project using the following command.
 
 ```bash
 go get gofr.dev
 ```
 
-Now add the following code to _main.go_ file
+This code snippet showcases the creation of a simple GoFr application that defines a route and serves a response. 
+You can add this code to your main.go file.
 
 ```go
 package main
@@ -44,15 +43,15 @@ func main() {
 }
 ```
 
-Before running the server run the following go command to download and sync the required modules.
+Before starting the server, run the following command in your terminal to ensure you have downloaded and synchronized all required dependencies for your project.
 
 `go mod tidy`
 
-To run the server, use the command
+Once the dependencies are synchronized, start the GoFr server using the following command:
 
 `go run main.go`
 
-This would start the server at 8000 port, you can access {% new-tab-link title="http://localhost:8000/greet" href="http://localhost:8000/greet" /%} from your browser, you would be able to see the output as following with _Status Code 200_ as per REST Standard
+This would start the server at 8000 port, `/greet` endpoint can be accessed from your browser at {% new-tab-link title="http://localhost:8000/greet" href="http://localhost:8000/greet" /%} , you would be able to see the output as following with _Status Code 200_ as per REST Standard.
 
 ```json
 { "data": "Hello World!" }
@@ -66,11 +65,11 @@ The `hello-world` server involves three essential steps:
 
    When `gofr.New()` is called, it initializes the framework and handles various setup tasks like initialising logger, metrics, datasources etc based on the configs.
 
-   _This single line is a standard part of all gofr-based servers._
+   _This single line is a standard part of all gofr servers._
 
 2. **Attaching a Handler to a Path:**
 
-   In this step, we instruct the server to associate an HTTP request with a specific handler function. This is achieved through `app.GET("/greet", HandlerFunction)`, where _GET /greet_ maps to HandlerFunction. Likewise, `app.POST("/todo", ToDoCreationHandler)` links a _POST_ request to the /todo endpoint with _ToDoCreationHandler_.
+   In this step, the server is instructed to associate an HTTP request with a specific handler function. This is achieved through `app.GET("/greet", HandlerFunction)`, where _GET /greet_ maps to HandlerFunction. Likewise, `app.POST("/todo", ToDoCreationHandler)` links a _POST_ request to the /todo endpoint with _ToDoCreationHandler_.
 
    **Good To Know**