mo

Author: ad3n

docs/basic.md

@@ -0,0 +1,26 @@
+# Implement Basic Auth
+
+- Add basic auth middleware to `dics/container.go`
+
+```go
+{
+    Name:  "bima:middleware:basic-auth",
+    Scope: bima.Application,
+    Build: (*middlewares.BasicAuth)(nil),
+    Params: dingo.Params{
+        "Validator": func(username, password string) bool {
+			return true
+		},
+    },
+},
+```
+
+You need to implement `Validator` with your own logic
+
+- Add to `configs/middlewares.yaml`
+
+```yaml
+middlewares:
+    - basic-auth
+```
+

docs/convert_middleware.md

@@ -0,0 +1,176 @@
+# Convert Middleware
+
+For this example, i use `https://github.com/didip/tollbooth`
+
+- Create `rate_limit.go` inside `middlewares` folder (you can create when folder not exists)
+
+- Copas placeholder code
+
+```go
+package middlewares
+
+import (
+	"net/http"
+)
+
+type RateLimit struct {
+}
+
+func (r *RateLimit) Attach(request *http.Request, response http.ResponseWriter) bool {
+}
+
+func (r *RateLimit) Priority() int {
+	return 0
+}
+
+```
+
+- Look up to the handler function
+
+From readme, we know when we want to use `https://github.com/didip/tollbooth`, we just add one line like below
+
+```go
+tollbooth.LimitFuncHandler(tollbooth.NewLimiter(1, nil), HelloHandler)
+```
+
+See inside `tollbooth.LimitFuncHandler()` and here the code
+
+```go
+middle := func(w http.ResponseWriter, r *http.Request) {
+    httpError := LimitByRequest(lmt, w, r)
+    if httpError != nil {
+        lmt.ExecOnLimitReached(w, r)
+        if lmt.GetOverrideDefaultResponseWriter() {
+            return
+        }
+        w.Header().Add("Content-Type", lmt.GetMessageContentType())
+        w.WriteHeader(httpError.StatusCode)
+        w.Write([]byte(httpError.Message))
+        return
+    }
+
+    // There's no rate-limit error, serve the next handler.
+    next.ServeHTTP(w, r)
+}
+
+return http.HandlerFunc(middle)
+```
+
+- Find `func(w http.ResponseWriter, r *http.Request)` function and copas the body to your middleware, like below (i change variable names)
+
+```go
+limiter := tollbooth.NewLimiter(1, nil)
+httpError := tollbooth.LimitByRequest(limiter, response, request)
+if httpError != nil {
+    limiter.ExecOnLimitReached(response, request)
+    if limiter.GetOverrideDefaultResponseWriter() {
+        return true
+    }
+
+    response.Header().Add("Content-Type", limiter.GetMessageContentType())
+    response.WriteHeader(httpError.StatusCode)
+    response.Write([]byte(httpError.Message))
+
+    return true
+}
+
+return false
+```
+
+Here full code
+
+```go
+package middlewares
+
+import (
+	"net/http"
+
+	"github.com/didip/tollbooth/v6"
+)
+
+type RateLimit struct {
+}
+
+func (r *RateLimit) Attach(request *http.Request, response http.ResponseWriter) bool {
+	limiter := tollbooth.NewLimiter(1, nil)
+	httpError := tollbooth.LimitByRequest(limiter, response, request)
+	if httpError != nil {
+		limiter.ExecOnLimitReached(response, request)
+		if limiter.GetOverrideDefaultResponseWriter() {
+			return true
+		}
+
+		response.Header().Add("Content-Type", limiter.GetMessageContentType())
+		response.WriteHeader(httpError.StatusCode)
+		response.Write([]byte(httpError.Message))
+
+		return true
+	}
+
+	return false
+}
+
+func (r *RateLimit) Priority() int {
+	return 0
+}
+
+```
+
+- Add definition to `dics/container.go`
+
+```go
+{
+    Name:  "bima:middleware:rate-limiter",
+    Scope: bima.Application,
+    Build: (*middlewares.RateLimit)(nil),
+},
+```
+
+- Add to `configs/middlewares.yaml`
+
+```yaml
+middlewares:
+    - rate-limiter
+```
+
+- Add `max` value optional
+
+```go
+type RateLimit struct {
+	Max float64
+}
+
+func (r *RateLimit) Attach(request *http.Request, response http.ResponseWriter) bool {
+	limiter := tollbooth.NewLimiter(r.Max, nil)
+	httpError := tollbooth.LimitByRequest(limiter, response, request)
+	if httpError != nil {
+		limiter.ExecOnLimitReached(response, request)
+		if limiter.GetOverrideDefaultResponseWriter() {
+			return true
+		}
+
+		response.Header().Add("Content-Type", limiter.GetMessageContentType())
+		response.WriteHeader(httpError.StatusCode)
+		response.Write([]byte(httpError.Message))
+
+		return true
+	}
+
+	return false
+}
+```
+
+- Change definition
+
+```go
+{
+    Name:  "bima:middleware:rate-limiter",
+    Scope: bima.Application,
+    Build: (*middlewares.RateLimit)(nil),
+    Params: dingo.Params{
+        "Max": float64(1),
+    },
+},
+```
+
+![Rate limiter](../assets/rate-limit-header.png)

docs/cors.md

@@ -0,0 +1,23 @@
+# Enable CORS 
+
+- Add CORS middleware to `dics/container.go`
+
+```go
+{
+    Name:  "bima:middleware:cors",
+    Scope: bima.Application,
+    Build: (*middlewares.Cors)(nil),
+    Params: dingo.Params{
+        "Options": cors.Options{},
+    },
+},
+```
+
+You can refer to [cors](github.com/rs/cors) for more options
+
+- Add to `configs/middlewares.yaml`
+
+```yaml
+middlewares:
+    - cors
+```

docs/custom_action.md

@@ -0,0 +1,56 @@
+# Add Custom Action
+
+This tutorial will explain how to add custom action (service) to your gRPC (proto)
+
+- Add new service
+
+```proto
+rpc Done (Todo) returns (TodoResponse) {
+    option (google.api.http) = {
+        post: "/api/v1/todos/{id}/done"
+    };
+}
+```
+
+We add new `Done` service with `/api/v1/todos/{id}/done` as path and use `POST` HTTP method
+
+- Update generated code using `bima generate` and refresh your browser
+
+![Custom Action](../assets/custom-action.png)
+
+![Custom Action Unimplemented](../assets/custom-action-unimplemented.png)
+
+- Implement `Done` service
+
+```go
+func (m *Module) Done(ctx context.Context, r *grpcs.Todo) (*grpcs.TodoResponse, error) {
+	ctx = context.WithValue(ctx, "scope", "todo")
+	v := m.Model
+	copier.Copy(v, r)
+	if err := m.Handler.Bind(v, r.Id); err != nil {
+		loggers.Logger.Error(ctx, err.Error())
+
+		return nil, status.Error(codes.NotFound, fmt.Sprintf("Data with ID '%s' not found.", r.Id))
+	}
+
+	v.Done = true
+	if err := m.Handler.Update(v, v.Id); err != nil {
+		loggers.Logger.Error(ctx, err.Error())
+
+		return nil, status.Error(codes.Internal, "Internal server error")
+	}
+
+    r.Done = v.Done
+	m.Cache.Invalidate(r.Id)
+
+	return &grpcs.TodoResponse{
+		Todo: r,
+	}, nil
+}
+
+```
+
+- Rerun and recall your new action
+
+
+![Custom Action Unimplemented](../assets/custom-action-implemented.png)

docs/debug.md

@@ -0,0 +1,32 @@
+# Debugging using Remote Debug
+
+- Run application using debug mode `bima run debug`
+
+- Copy PID
+
+- Run debugger `bima debug <pid>`
+
+- Bima Framework reserved `16517` port number as debug port, you can use it for any IDE that support remote debug
+
+- For VS Code user, copy `launch.json` below
+
+```json
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Debug",
+            "type": "go",
+            "request": "attach",
+            "mode": "remote",
+            "port": 16517,
+            "remotePath": "${workspaceFolder}",
+            "host": "127.0.0.1",
+            "cwd": "${workspaceFolder}"
+        }
+    ]
+}
+
+```
+
+- Just use Debug Panel as usual

docs/driver.md

@@ -0,0 +1,49 @@
+# Create Own Database Driver
+
+- We use `sqlite` for this example `https://gorm.io/docs/connecting_to_the_database.html#SQLite` 
+
+- Create `sqlite.go` and here the code
+
+```go
+package drivers
+
+import (
+	"gorm.io/driver/sqlite"
+	"gorm.io/gorm"
+)
+
+type Sqlite string
+
+func (s Sqlite) Name() string {
+    return string(s)
+}
+
+func (_ Sqlite) Connect(_ string, _ int, _ string, _ string, dbname string, _ bool) *gorm.DB {
+    db, err := gorm.Open(sqlite.Open(dbname), &gorm.Config{})
+    if err != nil {
+        panic(err)
+    }
+
+	return db
+}
+
+```
+
+- Add definition to `dics/container.go`
+
+```go
+{
+    Name:  "bima:driver:sqlite",
+    Scope: bima.Application,
+    Build: func() (*drivers.Sqlite, error) {
+        return Sqlite("sqlite")
+    },
+},
+```
+
+- Add to `configs/drivers.yaml`
+
+```yaml
+drivers:
+    - sqlite
+```