Merge pull request #402 from gofr-dev/release/v1.2.0

Release/v1.2.0

Author: aryanmehrotra

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.
 
@@ -23,12 +23,12 @@ import (
 func main() {
 	// Create a new application
 	app := gofr.New()
-	
+
 	app.AddHTTPService("order", "https://order-func",
 		&service.CircuitBreakerConfig{
 		    // Number of consecutive failed requests after which circuit breaker will be enabled
 			Threshold: 4,
-			// Time interval at which circuit breaker will hit the aliveness endpoint.  
+			// Time interval at which circuit breaker will hit the aliveness endpoint.
 			Interval:  1 * time.Second,
 		},
 	)
@@ -41,6 +41,4 @@ func main() {
 ```
 
 Circuit breaker state changes to open when number of consecutive failed requests increases the threshold.
-When it is in open state, GoFr makes request to the aliveness endpoint (default being -  /.well-known/alive) at an equal interval of time provided in config.
-
-To override the default aliveness endpoint {% new-tab-link title="refer" href="/docs/advanced-guide/monitoring-service-health" /%}.
+When it is in open state, GoFr makes request to the aliveness endpoint (default being - /.well-known/alive) at an equal interval of time provided in config.

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

@@ -1,7 +1,7 @@
 # Handling Data Migrations
 
 Suppose you manually make changes to your database, and now it's your responsibility to inform other developers to execute them. Additionally, you need to keep track of which changes should be applied to production machines in the next deployment.
-Gofr supports data migrations for MySQL, Postgres and Redis which allows to alter the state of a database, be it adding a new column to existing table or modifying the data type of  existing column or adding constraints to an existing table, setting and removing keys etc.
+Gofr supports data migrations for MySQL, Postgres and Redis which allows to alter the state of a database, be it adding a new column to existing table or modifying the data type of existing column or adding constraints to an existing table, setting and removing keys etc.
 
 ## Usage
 
@@ -11,12 +11,13 @@ It is recommended to maintain a migrations directory in your project root to enh
 
 **Migration file names**
 
-It is recommended that each migration file should be numbered in the format of *YYYYMMDDHHMMSS* when the migration was created.
+It is recommended that each migration file should be numbered in the format of _YYYYMMDDHHMMSS_ when the migration was created.
 This helps prevent numbering conflicts and allows for maintaining the correct sort order by name in different filesystem views.
 
 Create the following file in migrations directory.
 
 **Filename : 20240226153000_create_employee_table.go**
+
 ```go
 package migrations
 
@@ -45,14 +46,15 @@ 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.
+`migration.Datasource` have the datasources whose migrations are supported i.e. Redis and SQL (MySQL and PostgreSQL).
+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.
 
 **Create a function which returns all the migrations in a map**
 
 **Filename : all.go**
+
 ```go
 package migrations
 
@@ -65,9 +67,10 @@ 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
 
-### Initialisation from main.go 
 ```go
 package main
 
@@ -95,11 +98,7 @@ When we run the app we will see the following logs for migrations which ran succ
 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
 
@@ -108,21 +107,32 @@ This way, you only need to ensure that your migrations are properly in place. {%
 Migration records are stored and maintained in **gofr_migrations** table which has the following schema:
 
 {% table %}
-* Field
-* Type
+
+- Field
+- Type
+
 ---
-* version
-* bigint
+
+- version
+- bigint
+
 ---
-* method
-* varchar(4)
+
+- method
+- varchar(4)
+
 ---
-* start_time
-* timestamp
+
+- start_time
+- timestamp
+
 ---
-* duration
-* bigint
+
+- duration
+- bigint
+
 ---
+
 {% /table %}
 
 **REDIS**

docs/advanced-guide/http-authentication/page.md

@@ -1,26 +1,26 @@
 # HTTP Authentication
+
 Authentication is a crucial aspect of web applications, controlling access to resources based on user roles or permissions. 
-It is the process of verifying a user's identity to grant access to protected resources. It ensures only
-authenticated users can perform actions or access data within an application.
+It is the process of verifying a user's identity to grant access to protected resources. It ensures that only authenticated
+users can perform actions or access data within an application.
 
 GoFr offer various approaches to implement authorization.
 
 ## 1. HTTP Basic Auth
 *Basic Authentication* is a simple HTTP authentication scheme where the user's credentials (username and password) are 
 transmitted in the request header in a Base64-encoded format.
 
-Basic auth is the simplest way to authenticate your APIs.  It's built on
-{% new-tab-link title="HTTP protocol authentication scheme" href="https://datatracker.ietf.org/doc/html/rfc7617" /%}. It involves sending the term
-
-`Basic` trailed by the Base64-encoded `<username>:<password>` within the standard `Authorization` header.
+Basic auth is the simplest way to authenticate your APIs. It's built on
+{% new-tab-link title="HTTP protocol authentication scheme" href="https://datatracker.ietf.org/doc/html/rfc7617" /%}.
+It involves sending the prefix `Basic` trailed by the Base64-encoded `<username>:<password>` within the standard `Authorization` header.
 
 ### Basic Authentication in GoFr
 
 GoFr offers two ways to implement basic authentication:
 
 **1. Predefined Credentials**
 
-Use `EnableBasicAuth(username, password)` to configure Gofr with pre-defined credentials.
+Use `EnableBasicAuth(username, password)` to configure GoFr with pre-defined credentials.
 
 ```go
 func main() {
@@ -39,7 +39,8 @@ func main() {
 
 **2. Custom Validation Function**
 
-Use `EnableBasicAuthWithFunc(validationFunc)` to implement your own validation logic for credentials. The `validationFunc` takes the username and password as arguments and returns true if valid, false otherwise.
+Use `EnableBasicAuthWithFunc(validationFunc)` to implement your own validation logic for credentials.
+The `validationFunc` takes the username and password as arguments and returns true if valid, false otherwise.
 
 ```go
 func validateUser(username string, password string) bool {
@@ -63,7 +64,6 @@ func main() {
 ```
 
 ### Adding Basic Authentication to HTTP Services
-
 This code snippet demonstrates how to add basic authentication to an HTTP service in GoFr and make a request with the appropriate Authorization header:
 
 ```go
@@ -73,13 +73,13 @@ app.AddHTTPService("order", "https://localhost:2000",
 ```
 
 ## 2. API Keys Auth
-Users include a unique API key in the request header for validation against a store of authorized keys.
+*API Key Authentication* is an HTTP authentication scheme where a unique API key is included in the request header for validation against a store of authorized keys.
 
 ### Usage:
 GoFr offers two ways to implement API Keys authentication.
 
 **1. Framework Default Validation**
-- Users can select the framework's default validation using **_EnableAPIKeyAuth(apiKeys ...string)_**
+- GoFr's default validation can be selected using **_EnableAPIKeyAuth(apiKeys ...string)_**
 
 ```go
 package main
@@ -97,7 +97,7 @@ func main() {
 ```
 
 **2. Custom Validation Function**
-- Users can create their own validator function `apiKeyValidator(apiKey string) bool` for validating APIKeys and pass the func in **_EnableAPIKeyAuthWithFunc(validator)_**
+- GoFr allows a custom validator function `apiKeyValidator(apiKey string) bool` for validating APIKeys and pass the func in **_EnableAPIKeyAuthWithFunc(validator)_**
 
 ```go
 package main
@@ -128,11 +128,10 @@ app.AddHTTPService("http-server-using-redis", "http://localhost:8000", &service.
 ```
 
 ## 3. OAuth 2.0
-OAuth 2.0 is the industry-standard protocol for authorization. 
+{% new-tab-link title="OAuth" href="https://www.rfc-editor.org/rfc/rfc6749" /%} 2.0 is the industry-standard protocol for authorization. 
 It focuses on client developer simplicity while providing specific authorization flows for web applications, desktop applications, mobile phones, and living room devices.
-To know more about it refer {% new-tab-link title="here" href="https://www.rfc-editor.org/rfc/rfc6749" /%}
 
-It involves sending the term `Bearer` trailed by the encoded token within the standard `Authorization` header.
+It involves sending the prefix `Bearer` trailed by the encoded token within the standard `Authorization` header.
 
 ### OAuth Authentication in GoFr
 
@@ -141,7 +140,7 @@ GoFr supports authenticating tokens encoded by algorithm `RS256/384/512`.
 ### App level Authentication
 Enable OAuth 2.0 with three-legged flow to authenticate requests
 
-Use `EnableOAuth(jwks-endpoint,refresh_interval)` to configure Gofr with pre-defined credentials.
+Use `EnableOAuth(jwks-endpoint,refresh_interval)` to configure GoFr with pre-defined credentials.
 
 ```go
 func main() {
@@ -163,17 +162,17 @@ For server-to-server communication it follows two-legged OAuth, also known as "c
 where the client application directly exchanges its own credentials (ClientID and ClientSecret)
 for an access token without involving any end-user interaction.
 
-This code snippet demonstrates how two-legged OAuth authentication is added to an HTTP service in GoFr and make a request with the appropriate Authorization header.
+This code snippet demonstrates how two-legged OAuth authentication is added to an HTTP service in GoFr and make a request with the appropriate Authorization header:
 
 ```go
-a.AddHTTPService("orders", "http://localhost:9000",
+app.AddHTTPService("orders", "http://localhost:9000",
     &service.OAuthConfig{   // Replace with your credentials
-    ClientID:     "0iyeGcLYWudLGqZfD6HvOdZHZ5TlciAJ",
-    ClientSecret: "GQXTY2f9186nUS3C9WWi7eJz8-iVEsxq7lKxdjfhOJbsEPPtEszL3AxFn8k_NAER",
-    TokenURL:     "https://dev-zq6tvaxf3v7p0g7j.us.auth0.com/oauth/token",
-    Scopes:       []string{"read:order"},
-    EndpointParams: map[string][]string{
-    "audience": {"https://dev-zq6tvaxf3v7p0g7j.us.auth0.com/api/v2/"},
+        ClientID:     "0iyeGcLYWudLGqZfD6HvOdZHZ5TlciAJ",
+        ClientSecret: "GQXTY2f9186nUS3C9WWi7eJz8-iVEsxq7lKxdjfhOJbsEPPtEszL3AxFn8k_NAER",
+        TokenURL:     "https://dev-zq6tvaxf3v7p0g7j.us.auth0.com/oauth/token",
+        Scopes:       []string{"read:order"},
+        EndpointParams: map[string][]string{
+            "audience": {"https://dev-zq6tvaxf3v7p0g7j.us.auth0.com/api/v2/"},
     },
 })
-```
+```