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

Author: aryanmehrotra

docs/quick-start/configuration/page.md

@@ -0,0 +1,18 @@
+# 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 [12-factor](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.
+
+To set configs create a `configs` folder in the project's root and add `.env` file.
+
+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:
+
+```dotenv
+# configs/.env
+
+APP_NAME=test-service
+HTTP_PORT=9000
+```
+

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

@@ -0,0 +1,134 @@
+
+# Connecting MySQL
+
+Just like any other datasource gofr also supports connection to MySQL database based on configuration variables. It automatically manages the connection pool, connection retry etc.
+
+## Setup
+
+You can run the mysql server 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
+```
+
+Access `test_db` database and create table customer with columns `id` and `name`
+
+```bash
+docker exec -it gofr-mysql mysql -uroot -proot123 test_db -e "CREATE TABLE customers (id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(255) NOT NULL);"
+```
+
+Now the database with table is ready, we can connect our server to MySQL
+
+## Configuration & Usage
+
+After adding MySQL configs `.env` will be updated to the following.
+
+```bash
+# configs/.env
+APP_NAME=test-service
+HTTP_PORT=9000
+
+REDIS_HOST=localhost
+REDIS_PORT=6379
+
+DB_HOST=localhost
+DB_USER=root
+DB_PASSWORD=root123
+DB_NAME=test_db
+DB_PORT=3306
+```
+
+Now in the following example let's 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.
+
+```go
+package main
+
+import "gofr.dev/pkg/gofr"
+
+type Customer struct {
+	ID   int    `json:"id"`
+	Name string `json:"name"`
+}
+
+func main() {
+	// initialise gofr object
+	app := gofr.New()
+
+	app.GET("/greet", func(ctx *gofr.Context) (interface{}, error) {
+		// Get the value using the redis instance
+		value, err := ctx.Redis.Get(ctx.Context, "greeting").Result()
+
+		return value, err
+	})
+
+	app.POST("/customer/{name}", func(ctx *gofr.Context) (interface{}, error) {
+		name := ctx.PathParam("name")
+
+		// Inserting a customer row in database using SQL
+		_, err := ctx.DB.ExecContext(ctx, "INSERT INTO customers (name) VALUES (?)", name)
+
+		return nil, err
+	})
+
+	app.GET("/customer", func(ctx *gofr.Context) (interface{}, error) {
+		var customers []Customer
+
+		// Getting the customer from the database using SQL
+		rows, err := ctx.DB.QueryContext(ctx, "SELECT * FROM customers")
+		if err != nil {
+			return nil, err
+		}
+
+		for rows.Next() {
+			var customer Customer
+			if err := rows.Scan(&customer.ID, &customer.Name); err != nil {
+				return nil, err
+			}
+
+			customers = append(customers, customer)
+		}
+
+		// return the customer
+		return customers, nil
+	})
+
+	// Starts the server, it will listen on the default port 8000.
+	// it can be over-ridden through configs
+	app.Run()
+}
+```
+
+To update the database with the customer data access use through this curl command through terminal
+
+```bash
+# here abc and xyz after /customer are the path parameters
+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 the [http://localhost:9000/customer](http://localhost:9000/customer) we should see the following output
+
+```json
+{
+  "data": [
+    {
+      "id": 1,
+      "name": "abc"
+    },
+    {
+      "id": 2,
+      "name": "xyz"
+    }
+  ]
+}
+```

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

@@ -0,0 +1,88 @@
+## Prerequisite
+
+- Install or update [Go](https://go.dev/dl/).
+
+  To check the version use the following command `go version`.
+
+- Prior familiarity with Golang syntax is essential. [Golang Tour](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.
+
+```bash
+go mod init github.com/example
+```
+
+To know more about go modules refer [here](https://go.dev/ref/mod)
+
+Add [gofr](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
+
+```go
+package main
+
+import "gofr.dev/pkg/gofr"
+
+func main() {
+    // initialise gofr object
+    app := gofr.New()
+
+    // register route greet
+    app.GET("/greet", func(ctx *gofr.Context) (interface{}, error) {
+
+        return "Hello World!", nil
+    })
+
+    // Runs the server, it will listen on the default port 8000.
+    // it can be over-ridden through configs
+    a.Run()
+}
+```
+
+Before running the server run the following command to go needs to download and sync the required modules.
+
+`go mod tidy`
+
+To run the server, use the command
+
+`go run main.go`
+
+This would start the server at 8000 port, you can access [http://localhost:8000/greet](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
+
+```json
+{ "data": "Hello World!" }
+```
+
+## Understanding the example
+
+The `hello-world` server involves three essential steps:
+
+1. **Creating GoFr Server:**
+
+   When `gofr.New()` is called, it initializes the framework and handles various setup tasks like configuring database connection pools, initialising logger, setting CORS headers etc based on the configs.
+
+   _This single line is a standard part of all gofr-based 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 /hello_ maps to HandlerFunction. Likewise, `app.POST("/todo", ToDoCreationHandler)` links a _POST_ request to the /todo endpoint with _ToDoCreationHandler_.
+
+   **Good To Know**
+
+   In Go, functions are first-class citizens, allowing easy handler definition and reference.
+   Handler functions should follow the `func(ctx *gofr.Context) (interface{}, error)` signature.
+   They take a context as input, returning two values: the response data and an error (set to `nil` on success).
+
+   In GoFr `ctx *gofr.Context` serves as a wrapper for requests, responses, and dependencies, providing various functionalities.
+
+   For more details about context, refer [here](/docs/v1/references/context).
+
+3. **Starting the server**
+
+   When `app.Run()` is called, it configures ,initiates and runs the HTTP server, middlewares based on provided configs. It manages essential features such as routes for health checks, swagger UI etc. It starts the server on the default port 8000.

docs/quick-start/introduction/page.md

@@ -11,4 +11,4 @@ DB_NAME=test
 DB_PORT=2001
 
 TRACER_HOST=localhost
-TRACER_PORT=2005
+TRACER_PORT=2005