Working on POC

Author: roshangade

.gitignore

@@ -10,3 +10,8 @@
 
 # Output of the go coverage tool, specifically when used with LiteIDE
 *.out
+
+# editors
+.idea
+.DS_Store
+.vscode

README.md

@@ -3,7 +3,14 @@ REST API framework for go lang
 
 # Framework is under development
 ## Status: 
-- Working on POC as per concept
+- Working on POC
+  - Request Interceptors/Middlewares
+  - Routes with URL pattern 
+  - Methods [GET, POST, PUT, DELETE, OPTIONS, HEAD, PATCH]
+  - Extend routes with namespace
+  - Error handler
+  - HTTP, HTTPS support
+  
 ```
 var api rest.API
 

api.go

@@ -0,0 +1,129 @@
+/*!
+ * utils-api-framework
+ * Copyright(c) 2019 Roshan Gade
+ * MIT Licensed
+ */
+package rest
+
+import (
+	"./utils"
+	"fmt"
+	"net/http"
+	"regexp"
+)
+
+type API struct {
+	routes       []route
+	interceptors []interceptor
+	errors       []errorHandler
+}
+
+type route struct {
+	method  string
+	pattern string
+	regex   *regexp.Regexp
+	params  []string
+	handle  func(ctx *Context)
+}
+
+type interceptor struct {
+	handle func(ctx *Context)
+}
+
+//TODO: check errors in language specifications
+type errorHandler struct {
+	code   string
+	handle func(ctx *Context)
+}
+
+func (api *API) handler(method string, pattern string, handle func(ctx *Context)) {
+	regex, params, err := utils.Compile(pattern)
+	if err != nil {
+		fmt.Println("Error in pattern", err)
+		panic(1)
+	}
+	api.routes = append(api.routes, route{
+		method:  method,
+		pattern: pattern,
+		regex:   regex,
+		params:  params,
+		handle:  handle,
+	})
+}
+
+func (api API) ServeHTTP(res http.ResponseWriter, req *http.Request) {
+	//fmt.Println("-------------------------------------")
+	//fmt.Println("URI: ", req.RequestURI)
+	//fmt.Println("Method: ", req.Method)
+	//fmt.Println("Form: ", req.Form)
+	//fmt.Println("RawPath: ", req.URL.RawPath)
+	//fmt.Println("Header: ", req.Header)
+	//fmt.Println("Path: ", req.URL.Path)
+	//fmt.Println("RawQuery: ", req.URL.RawQuery)
+	//fmt.Println("Opaque: ", req.URL.Opaque)
+	//fmt.Println("-------------------------------------")
+	urlPath := []byte(req.URL.Path)
+
+	ctx := Context{
+		req: req,
+		res: res,
+	}
+
+	ctx.init()
+
+	for _, route := range api.interceptors {
+		if ctx.err != nil {
+			break
+		}
+
+		if ctx.end == true {
+			break
+		}
+
+		route.handle(&ctx)
+	}
+
+	for _, route := range api.routes {
+		if ctx.err != nil {
+			break
+		}
+
+		if ctx.end == true {
+			break
+		}
+
+		if route.method == req.Method && route.regex.Match(urlPath) {
+			ctx.Params = utils.Exec(route.regex, route.params, urlPath)
+			route.handle(&ctx)
+		}
+	}
+
+	//TODO: NOT FOUND, INTERNAL SERVER ERROR, ETC
+
+	for _, route := range api.errors {
+		if ctx.end == true {
+			break
+		}
+
+		if ctx.err != nil && route.code == ctx.err.Error() {
+			route.handle(&ctx)
+		}
+	}
+}
+
+func (api *API) Use(handle func(ctx *Context)) {
+	api.interceptors = append(api.interceptors, interceptor{handle: handle})
+}
+
+func (api *API) GET(pattern string, handle func(ctx *Context)) {
+	api.handler("GET", pattern, handle)
+}
+
+//TODO: POST, PUT, DELETE, OPTIONS, HEAD, PATCH
+
+func (api *API) Error(code string, handle func(ctx *Context)) {
+	api.errors = append(api.errors, errorHandler{
+		code:   code,
+		handle: handle,
+	})
+}

context.go

@@ -0,0 +1,75 @@
+/*!
+ * utils-api-framework
+ * Copyright(c) 2019 Roshan Gade
+ * MIT Licensed
+ */
+package rest
+
+import (
+	"encoding/json"
+	"errors"
+	"net/http"
+)
+
+type Context struct {
+	req    *http.Request
+	res    http.ResponseWriter
+	Params *map[string]string
+	data   map[string]interface{}
+	err    error
+	end    bool
+}
+
+func (ctx *Context) init() {
+	ctx.data = make(map[string]interface{})
+	//TODO: initialization
+}
+
+func (ctx *Context) Set(key string, val interface{}) {
+	ctx.data[key] = val
+}
+
+func (ctx *Context) Get(key string) interface{} {
+	return ctx.data[key]
+}
+
+func (ctx *Context) Status(code int) *Context {
+	ctx.res.WriteHeader(code)
+	return ctx
+}
+
+func (ctx *Context) SetHeader(key string, val string) *Context {
+	ctx.res.Header().Set(key, val)
+	return ctx
+}
+
+func (ctx *Context) Throw(err error) {
+	ctx.err = err
+}
+
+func (ctx *Context) Write(data []byte) {
+	if ctx.end == true {
+		return
+	}
+	_, err := ctx.res.Write(data)
+	if err != nil {
+		ctx.err = errors.New("RESPONSE ERROR")
+		return
+	}
+
+	ctx.end = true
+}
+
+func (ctx *Context) Send(data string) {
+	ctx.Write([]byte(data))
+}
+
+func (ctx *Context) SendJSON(data interface{}) {
+	body, err := json.Marshal(data)
+	if err != nil {
+		ctx.err = errors.New("INVALID JSON")
+		return
+	}
+	ctx.SetHeader("Content-Type", "application/json")
+	ctx.Write(body)
+}

examples/server.go

@@ -0,0 +1,40 @@
+package main
+
+import (
+	".."
+	"errors"
+	"fmt"
+	"net/http"
+)
+
+func main() {
+	var api rest.API
+
+	// request interceptor / middleware
+	api.Use(func(ctx *rest.Context) {
+		ctx.Set("authtoken", "roshangade")
+	})
+
+	// routes
+	api.GET("/", func(ctx *rest.Context) {
+		ctx.Send("Hello World!")
+	})
+
+	api.GET("/foo", func(ctx *rest.Context) {
+		ctx.Status(401).Throw(errors.New("UNAUTHORIZED"))
+	})
+
+	api.GET("/:bar", func(ctx *rest.Context) {
+		fmt.Println("authtoken", ctx.Get("authtoken"))
+		ctx.SendJSON(ctx.Params)
+	})
+
+	// error handler
+	api.Error("UNAUTHORIZED", func(ctx *rest.Context) {
+		ctx.Send("You are unauthorized")
+	})
+
+	fmt.Println("Starting server.")
+
+	http.ListenAndServe(":8080", api)
+}

utils/url.go

@@ -0,0 +1,68 @@
+/*!
+ * utils-api-framework
+ * Copyright(c) 2019 Roshan Gade
+ * MIT Licensed
+ */
+package utils
+
+import (
+	"regexp"
+	"strings"
+)
+
+const sep = "/"
+
+func Compile(str string) (*regexp.Regexp, []string, error) {
+	pattern := ""
+	keys := make([]string, 0)
+	_str := strings.Split(str, "/")
+
+	for _, val := range _str {
+		if val != "" {
+			switch val[0] {
+			case 42:
+				pattern += "(?:/(.*))"
+				keys = append(keys, "*")
+
+			case 58:
+				length := len(val)
+				lastChar := val[length-1]
+				if lastChar == 63 {
+					pattern += "(?:/([^/]+?))?"
+					keys = append(keys, val[1:(length-1)])
+				} else {
+					pattern += sep + "([^/]+?)"
+					keys = append(keys, val[1:])
+				}
+
+			default:
+				pattern += sep + val
+			}
+		}
+	}
+
+	// if len(keys) == 0 {
+	// 	pattern += "(?:/)?"
+	// }
+
+	regex, err := regexp.Compile("^" + pattern + "/?$")
+
+	return regex, keys, err
+}
+
+func Exec(regex *regexp.Regexp, keys []string, uri []byte) *map[string]string {
+	params := make(map[string]string)
+
+	matches := regex.FindAllSubmatch(uri, -1)
+
+	for _, val := range matches {
+		for i, k := range val[1:] {
+			params[keys[i]] = string(k)
+			if keys[i] == "*" {
+				params["*"] = sep + params["*"]
+			}
+		}
+	}
+
+	return &params
+}