feat: #7 implemented a simple Barf interface for interacting with form data

Author: opensaucerer

example/main.go

@@ -1,45 +1,83 @@
 package main
 
 import (
+	"io"
 	"net/http"
 	"os"
 
 	"github.com/opensaucerer/barf"
 )
 
 func main() {
+
+	type Env struct {
+		// Port for the server to listen on
+		Port string `barfenv:"key=PORT;required=true"`
+	}
+
+	env := new(Env) // global environment variable
+
+	// load environment variables
+	if err := barf.Env(env, "example/.env"); err != nil {
+		barf.Logger().Error(err.Error())
+		os.Exit(1)
+	}
+
 	// create server
 	allow := true
+	disallow := false
 	if err := barf.Stark(barf.Augment{
-		Port:     "5000",
+		Port:     env.Port,
 		Logging:  &allow, // enable request logging
-		Recovery: &allow, // enable panic recovery so barf returns a 500 error instead of crashing
+		Recovery: &disallow,
+		CORS: &barf.CORS{
+			AllowedOrigins: []string{"https://*.google.com"},
+			MaxAge:         3600,
+			AllowedMethods: []string{
+				http.MethodGet,
+			},
+			AllowedOriginFunc: func(origin string) bool {
+				return origin == "https://www.google.com"
+			},
+		},
 	}); err != nil {
 		barf.Logger().Error(err.Error())
 		os.Exit(1)
 	}
 
-	barf.Get("/", func(w http.ResponseWriter, r *http.Request) {
-		barf.Response(w).Status(http.StatusOK).JSON(barf.Res{
-			Status:  true,
-			Data:    nil,
-			Message: "Hello World",
-		})
-	})
-
 	// create a subrouter (retroframe)
-	s := barf.RetroFrame("/api/v1")
+	s := barf.RetroFrame("/api").RetroFrame("/v1")
 	s.Get("/about", func(w http.ResponseWriter, r *http.Request) {
+
+		message := "About"
+
+		// parsing form-data
+		body, err := barf.Request(r).Form().Body().JSON()
+		if err != nil {
+			message = err.Error()
+		}
+
+		head := barf.Request(r).Form().File().Get("file")
+		file, _ := head.Open()
+		defer file.Close()
+
+		// save file
+		f, err := os.OpenFile(head.Filename, os.O_WRONLY|os.O_CREATE, 0666)
+		if err != nil {
+			message = err.Error()
+		}
+		defer f.Close()
+		io.Copy(f, file)
+
 		barf.Response(w).Status(http.StatusOK).JSON(barf.Res{
 			Status:  true,
-			Data:    nil,
-			Message: "About",
+			Data:    body,
+			Message: message,
 		})
 	})
 
-	// start barf server
+	// start server - create & start server
 	if err := barf.Beck(); err != nil {
-		// barf exposes a logger instance
 		barf.Logger().Error(err.Error())
 		os.Exit(1)
 	}

example/multipart_formdata/main.go

@@ -0,0 +1,84 @@
+package main
+
+import (
+	"io"
+	"net/http"
+	"os"
+
+	"github.com/opensaucerer/barf"
+)
+
+func main() {
+
+	type Env struct {
+		// Port for the server to listen on
+		Port string `barfenv:"key=PORT;required=true"`
+	}
+
+	env := new(Env) // global environment variable
+
+	// load environment variables
+	if err := barf.Env(env, "example/.env"); err != nil {
+		barf.Logger().Error(err.Error())
+		os.Exit(1)
+	}
+
+	// create server
+	allow := true
+	disallow := false
+	if err := barf.Stark(barf.Augment{
+		Port:     env.Port,
+		Logging:  &allow, // enable request logging
+		Recovery: &disallow,
+		CORS: &barf.CORS{
+			AllowedOrigins: []string{"https://*.google.com"},
+			MaxAge:         3600,
+			AllowedMethods: []string{
+				http.MethodGet,
+			},
+			AllowedOriginFunc: func(origin string) bool {
+				return origin == "https://www.google.com"
+			},
+		},
+	}); err != nil {
+		barf.Logger().Error(err.Error())
+		os.Exit(1)
+	}
+
+	// create a subrouter (retroframe)
+	s := barf.RetroFrame("/api").RetroFrame("/v1")
+	s.Get("/about", func(w http.ResponseWriter, r *http.Request) {
+
+		message := "About"
+
+		// parsing form-data
+		body, err := barf.Request(r).Form().Body().JSON()
+		if err != nil {
+			message = err.Error()
+		}
+
+		head := barf.Request(r).Form().File().Get("file")
+		file, _ := head.Open()
+		defer file.Close()
+
+		// save file
+		f, err := os.OpenFile(head.Filename, os.O_WRONLY|os.O_CREATE, 0666)
+		if err != nil {
+			message = err.Error()
+		}
+		defer f.Close()
+		io.Copy(f, file)
+
+		barf.Response(w).Status(http.StatusOK).JSON(barf.Res{
+			Status:  true,
+			Data:    body,
+			Message: message,
+		})
+	})
+
+	// start server - create & start server
+	if err := barf.Beck(); err != nil {
+		barf.Logger().Error(err.Error())
+		os.Exit(1)
+	}
+}

example/subroute/main.go

@@ -52,7 +52,7 @@ func main() {
 	})
 
 	// create a subrouter (retroframe)
-	var r *barf.SubRoute = barf.RetroFrame("/api/v1")
+	var r *barf.SubRoute = barf.RetroFrame("/api")
 
 	// apply middleware to subrouter. note that the only difference between this and global middlewares is that you need to pass the
 	barf.Hippocampus(r).Hijack(func(h http.Handler) http.Handler {
@@ -73,7 +73,7 @@ func main() {
 
 	// create another subrouter (retroframe)
 	// note that although the path is the same, the subroute is different and won't inherit the middleware from the previous subroute
-	s := barf.RetroFrame("/api/v1")
+	s := barf.RetroFrame("/api").RetroFrame("/v1")
 	s.Get("/about", func(w http.ResponseWriter, r *http.Request) {
 		barf.Response(w).Status(http.StatusOK).JSON(barf.Res{
 			Status:  true,

router/body/body.go

@@ -7,13 +7,14 @@ import (
 
 type B []byte
 
+// Body prepares the barf request with the request body for further formatting
 func Body(r *http.Request) []byte {
 	body := make([]byte, r.ContentLength)
 	r.Body.Read(body)
 	return body
 }
 
-// JSON formats the request body as map[string]interface{}.
+// JSON formats the body as map[string]interface{}.
 // It returns an error if the body is not a valid JSON.
 func (b B) JSON() (map[string]interface{}, error) {
 	var data map[string]interface{}

router/form/body.go

@@ -0,0 +1,18 @@
+package form
+
+import (
+	"encoding/json"
+
+	"github.com/opensaucerer/barf/router/body"
+)
+
+// Body prepares the non-file part of the form-data for further formatting
+func (m M) Body() body.B {
+	// write r.MultipartForm.Value to f.r.Body
+	val := make(map[string]string)
+	for k, v := range m.r.MultipartForm.Value {
+		val[k] = v[0]
+	}
+	b, _ := json.Marshal(val)
+	return b
+}

router/form/file.go

@@ -0,0 +1,27 @@
+package form
+
+import (
+	"mime/multipart"
+)
+
+type F map[string][]*multipart.FileHeader
+
+// File prepares the file part of the form-data for further formatting
+func (m M) File() F {
+	return F(m.r.MultipartForm.File)
+}
+
+// Get returns the first file for the given key.
+// It returns nil if the key does not exist.
+func (f F) Get(key string) *multipart.FileHeader {
+	if f[key] == nil {
+		return nil
+	}
+	return f[key][0]
+}
+
+// All returns all files for the given key.
+// It returns nil if the key does not exist.
+func (f F) All(key string) []*multipart.FileHeader {
+	return f[key]
+}

router/form/form.go

@@ -0,0 +1,15 @@
+package form
+
+import (
+	"net/http"
+)
+
+type M struct {
+	r *http.Request
+}
+
+// Form prepares the barf request with the request form or multipart/form-data for further formatting
+func Form(r *http.Request, maxMemory int64) M {
+	r.ParseMultipartForm(maxMemory)
+	return M{r}
+}

router/param/param.go

@@ -9,6 +9,7 @@ import (
 
 type P []byte
 
+// Params prepares the barf request with the request params for further formatting
 func Params(r *http.Request) []byte {
 	p := r.Context().Value(typing.ParamsCtxKey{})
 	if p == nil {

router/query/query.go

@@ -7,6 +7,7 @@ import (
 
 type Q []byte
 
+// Query prepares the barf request with the request query for further formatting
 func Query(r *http.Request) []byte {
 	q := make(map[string]string)
 	for k, v := range r.URL.Query() {

router/retroframe.go

@@ -20,6 +20,18 @@ func RetroFrame(path string) *SubRoute {
 	return s
 }
 
+// RetroFrame returns a new subrouter instance registered against the given entry path and the RetroFrame instance it is called on.
+func (r *SubRoute) RetroFrame(path string) *SubRoute {
+	s := &SubRoute{
+		entry:  r.entry + "/" + regexp.MustCompile("^/+|/+$").ReplaceAllString(path, ""),
+		routes: []*Route{},
+		stack:  []typing.Middleware{},
+	}
+	s.key = fmt.Sprintf("%p", s)
+	stable[s.key] = s
+	return s
+}
+
 // Get registers a route with the GET HTTP method against the path of the RetroFrame router instance.
 func (r *SubRoute) Get(path string, handler func(http.ResponseWriter, *http.Request)) {
 	fget(fmt.Sprintf("/%s/%s", r.entry, regexp.MustCompile("^/+|/+$").ReplaceAllString(path, "")), handler, r.key)