Merge pull request #180 from manyminds/dynamic_baseurl_handling

Two new interfaces for baseurl resolving

Author: wwwdata

README.md

@@ -38,6 +38,7 @@ go get github.com/manyminds/api2go/jsonapi
   - [Fetching related IDs](#fetching-related-ids)
   - [Fetching related resources](#fetching-related-resources)
   - [Using middleware](#using-middleware)
+  - [Dynamic URL Handling](#dynamic-url-handling)
 - [Tests](#tests)
 
 ## Examples
@@ -567,6 +568,32 @@ registered with `func (api *API) UseMiddleware(middleware ...HandlerFunc)`. You
 that will be executed in order before any other api2go routes. Use this to set up database connections, user authentication
 and so on.
 
+### Dynamic URL handling
+If you have different TLDs for one api, or want to use different domains in development and production, you can implement a custom
+URLResolver in api2go. 
+
+There is a simple interface, which can be used if you get TLD information from the database, the server environment, or anything else
+that's not request dependant:
+```go
+type URLResolver interface {
+	GetBaseURL() string
+}
+```
+And a more complex one that also gets request information:
+```go
+type RequestAwareURLResolver interface {
+	URLResolver
+	SetRequest(http.Request)
+}
+```
+
+For most use cases we provide a CallbackResolver which works on a per request basis and may fill
+your basic needs. This is particulary useful if you are using an nginx proxy which sets `X-Forwarded-For` headers.
+
+```go
+resolver := NewCallbackResolver(func(r http.Request) string{})
+api := NewApiWithMarshalling("v1", resolver, marshalers)
+```
 ## Tests
 
 ```sh

api.go

@@ -37,12 +37,12 @@ func (r response) StatusCode() int {
 }
 
 type information struct {
-	prefix  string
-	baseURL string
+	prefix   string
+	resolver URLResolver
 }
 
 func (i information) GetBaseURL() string {
-	return i.baseURL
+	return i.resolver.GetBaseURL()
 }
 
 func (i information) GetPrefix() string {
@@ -235,6 +235,18 @@ func (api *API) addResource(prototype jsonapi.MarshalIdentifier, source CRUD, ma
 		marshalers:   marshalers,
 	}
 
+	requestInfo := func(r *http.Request) *information {
+		var info *information
+		if resolver, ok := api.info.resolver.(RequestAwareURLResolver); ok {
+			resolver.SetRequest(*r)
+			info = &information{prefix: api.prefix, resolver: resolver}
+		} else {
+			info = &api.info
+		}
+
+		return info
+	}
+
 	api.router.Handle("OPTIONS", api.prefix+name, func(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
 		c := api.contextPool.Get().(APIContexter)
 		c.Reset()
@@ -254,21 +266,24 @@ func (api *API) addResource(prototype jsonapi.MarshalIdentifier, source CRUD, ma
 	})
 
 	api.router.GET(api.prefix+name, func(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
+		info := requestInfo(r)
 		c := api.contextPool.Get().(APIContexter)
 		c.Reset()
 		api.middlewareChain(c, w, r)
-		err := res.handleIndex(c, w, r, api.info)
+
+		err := res.handleIndex(c, w, r, *info)
 		api.contextPool.Put(c)
 		if err != nil {
 			handleError(err, w, r, marshalers)
 		}
 	})
 
 	api.router.GET(api.prefix+name+"/:id", func(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
+		info := requestInfo(r)
 		c := api.contextPool.Get().(APIContexter)
 		c.Reset()
 		api.middlewareChain(c, w, r)
-		err := res.handleRead(c, w, r, ps, api.info)
+		err := res.handleRead(c, w, r, ps, *info)
 		api.contextPool.Put(c)
 		if err != nil {
 			handleError(err, w, r, marshalers)
@@ -282,10 +297,11 @@ func (api *API) addResource(prototype jsonapi.MarshalIdentifier, source CRUD, ma
 		for _, relation := range relations {
 			api.router.GET(api.prefix+name+"/:id/relationships/"+relation.Name, func(relation jsonapi.Reference) httprouter.Handle {
 				return func(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
+					info := requestInfo(r)
 					c := api.contextPool.Get().(APIContexter)
 					c.Reset()
 					api.middlewareChain(c, w, r)
-					err := res.handleReadRelation(c, w, r, ps, api.info, relation)
+					err := res.handleReadRelation(c, w, r, ps, *info, relation)
 					api.contextPool.Put(c)
 					if err != nil {
 						handleError(err, w, r, marshalers)
@@ -295,10 +311,11 @@ func (api *API) addResource(prototype jsonapi.MarshalIdentifier, source CRUD, ma
 
 			api.router.GET(api.prefix+name+"/:id/"+relation.Name, func(relation jsonapi.Reference) httprouter.Handle {
 				return func(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
+					info := requestInfo(r)
 					c := api.contextPool.Get().(APIContexter)
 					c.Reset()
 					api.middlewareChain(c, w, r)
-					err := res.handleLinked(c, api, w, r, ps, relation, api.info)
+					err := res.handleLinked(c, api, w, r, ps, relation, *info)
 					api.contextPool.Put(c)
 					if err != nil {
 						handleError(err, w, r, marshalers)
@@ -351,10 +368,11 @@ func (api *API) addResource(prototype jsonapi.MarshalIdentifier, source CRUD, ma
 	}
 
 	api.router.POST(api.prefix+name, func(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
+		info := requestInfo(r)
 		c := api.contextPool.Get().(APIContexter)
 		c.Reset()
 		api.middlewareChain(c, w, r)
-		err := res.handleCreate(c, w, r, api.prefix, api.info)
+		err := res.handleCreate(c, w, r, api.prefix, *info)
 		api.contextPool.Put(c)
 		if err != nil {
 			handleError(err, w, r, marshalers)

api_interfaces.go

@@ -1,5 +1,7 @@
 package api2go
 
+import "net/http"
+
 // The CRUD interface MUST be implemented in order to use the api2go api.
 type CRUD interface {
 	// FindOne returns an object by its ID
@@ -54,6 +56,29 @@ type FindAll interface {
 	FindAll(req Request) (Responder, error)
 }
 
+//URLResolver allows you to implement a static
+//way to return a baseURL for all incoming
+//requests for one api2go instance.
+type URLResolver interface {
+	GetBaseURL() string
+}
+
+//RequestAwareURLResolver allows you to dynamically change
+//generated urls.
+//
+//This is particulary useful if you have the same
+//API answering to multiple domains, or subdomains
+//e.g customer[1,2,3,4].yourapi.example.com
+//
+//SetRequest will always be called prior to
+//the GetBaseURL() from `URLResolver` so you
+//have to change the result value based on the last
+//request.
+type RequestAwareURLResolver interface {
+	URLResolver
+	SetRequest(http.Request)
+}
+
 // The Responder interface is used by all Resource Methods as a container for the Response.
 // Metadata is additional Metadata. You can put anything you like into it, see jsonapi spec.
 // Result returns the actual payload. For FindOne, put only one entry in it.

api_public.go

@@ -73,14 +73,21 @@ func (api *API) SetRedirectTrailingSlash(enabled bool) {
 	api.router.RedirectTrailingSlash = enabled
 }
 
-// NewAPIWithMarshalers does the same as NewAPIWithBaseURL with the addition
+//NewAPIWithMarshalers is DEPRECATED
+//use NewApiWithMarshalling instead
+func NewAPIWithMarshalers(prefix string, baseURL string, marshalers map[string]ContentMarshaler) *API {
+	staticResolver := newStaticResolver(baseURL)
+	return NewAPIWithMarshalling(prefix, staticResolver, marshalers)
+}
+
+// NewAPIWithMarshalling does the same as NewAPIWithBaseURL with the addition
 // of a set of marshalers that provide a way to interact with clients that
 // use a serialization format other than JSON. The marshalers map is indexed
 // by the MIME content type to use for a given request-response pair. If the
 // client provides an Accept header the server will respond using the client's
 // preferred content type, otherwise it will respond using whatever content
 // type the client provided in its Content-Type request header.
-func NewAPIWithMarshalers(prefix string, baseURL string, marshalers map[string]ContentMarshaler) *API {
+func NewAPIWithMarshalling(prefix string, resolver URLResolver, marshalers map[string]ContentMarshaler) *API {
 	if len(marshalers) == 0 {
 		panic("marshaler map must not be empty")
 	}
@@ -96,7 +103,7 @@ func NewAPIWithMarshalers(prefix string, baseURL string, marshalers map[string]C
 	router := httprouter.New()
 	router.MethodNotAllowed = notAllowedHandler{marshalers: marshalers}
 
-	info := information{prefix: prefix, baseURL: baseURL}
+	info := information{prefix: prefix, resolver: resolver}
 
 	api := &API{
 		router:           router,

api_test.go

@@ -16,6 +16,22 @@ import (
 	"gopkg.in/guregu/null.v2"
 )
 
+type requestURLResolver struct {
+	r     http.Request
+	calls int
+}
+
+func (m requestURLResolver) GetBaseURL() string {
+	if uri := m.r.Header.Get("REQUEST_URI"); uri != "" {
+		return uri
+	}
+	return "https://example.com"
+}
+
+func (m *requestURLResolver) SetRequest(r http.Request) {
+	m.r = r
+}
+
 type invalid string
 
 func (i invalid) GetID() string {
@@ -1516,4 +1532,59 @@ var _ = Describe("RestHandler", func() {
 		})
 
 	})
+
+	Context("dynamic baseurl handling", func() {
+		var (
+			api    *API
+			rec    *httptest.ResponseRecorder
+			source *fixtureSource
+		)
+
+		BeforeEach(func() {
+			source = &fixtureSource{map[string]*Post{
+				"1": {ID: "1", Title: "Hello, World!"},
+			}, false}
+
+			marshalers := map[string]ContentMarshaler{
+				`application/vnd.api+json`: JSONContentMarshaler{},
+			}
+
+			api = NewAPIWithMarshalling("/secret/", &requestURLResolver{}, marshalers)
+			api.AddResource(Post{}, source)
+			rec = httptest.NewRecorder()
+		})
+
+		It("should change dependening on request header in FindAll", func() {
+			firstURI := "https://god-mode.example.com"
+			secondURI := "https://top-secret.example.com"
+			req, err := http.NewRequest("GET", "/secret/posts", nil)
+			req.Header.Set("REQUEST_URI", firstURI)
+			Expect(err).To(BeNil())
+			api.Handler().ServeHTTP(rec, req)
+			Expect(rec.Code).To(Equal(http.StatusOK))
+			Expect(err).ToNot(HaveOccurred())
+			Expect(rec.Body.Bytes()).To(ContainSubstring(firstURI))
+			Expect(rec.Body.Bytes()).ToNot(ContainSubstring(secondURI))
+			rec = httptest.NewRecorder()
+			req2, err := http.NewRequest("GET", "/secret/posts", nil)
+			req2.Header.Set("REQUEST_URI", secondURI)
+			Expect(err).To(BeNil())
+			api.Handler().ServeHTTP(rec, req2)
+			Expect(rec.Code).To(Equal(http.StatusOK))
+			Expect(err).ToNot(HaveOccurred())
+			Expect(rec.Body.Bytes()).To(ContainSubstring(secondURI))
+			Expect(rec.Body.Bytes()).ToNot(ContainSubstring(firstURI))
+		})
+
+		It("should change dependening on request header in FindOne", func() {
+			expected := "https://god-mode.example.com"
+			req, err := http.NewRequest("GET", "/secret/posts/1", nil)
+			req.Header.Set("REQUEST_URI", expected)
+			Expect(err).To(BeNil())
+			api.Handler().ServeHTTP(rec, req)
+			Expect(rec.Code).To(Equal(http.StatusOK))
+			Expect(err).ToNot(HaveOccurred())
+			Expect(rec.Body.Bytes()).To(ContainSubstring(expected))
+		})
+	})
 })

examples/crud_example.go

@@ -2,6 +2,8 @@
 Package examples shows how to implement a basic CRUD for two data structures with the api2go server functionality.
 To play with this example server you can run some of the following curl requests
 
+In order to demonstrate dynamic baseurl handling for requests, apply the --header="REQUEST_URI:https://www.your.domain.example.com" parameter to any of the commands.
+
 Create a new user:
 	curl -X POST http://localhost:31415/v0/users -d '{"data" : [{"type" : "users" , "attributes": {"user-name" : "marvin"}}]}'
 
@@ -47,6 +49,7 @@ import (
 	"github.com/julienschmidt/httprouter"
 	"github.com/manyminds/api2go"
 	"github.com/manyminds/api2go/examples/model"
+	"github.com/manyminds/api2go/examples/resolver"
 	"github.com/manyminds/api2go/examples/resource"
 	"github.com/manyminds/api2go/examples/storage"
 )
@@ -75,17 +78,19 @@ func main() {
 		"application/vnd.api+json": PrettyJSONContentMarshaler{},
 	}
 
-	api := api2go.NewAPIWithMarshalers("v0", "http://localhost:31415", marshalers)
+	port := 31415
+	api := api2go.NewAPIWithMarshalling("v0", &resolver.RequestURL{Port: port}, marshalers)
 	userStorage := storage.NewUserStorage()
 	chocStorage := storage.NewChocolateStorage()
 	api.AddResource(model.User{}, resource.UserResource{ChocStorage: chocStorage, UserStorage: userStorage})
 	api.AddResource(model.Chocolate{}, resource.ChocolateResource{ChocStorage: chocStorage, UserStorage: userStorage})
 
-	fmt.Println("Listening on :31415")
+	fmt.Printf("Listening on :%d", port)
 	handler := api.Handler().(*httprouter.Router)
 	// It is also possible to get the instance of julienschmidt/httprouter and add more custom routes!
 	handler.GET("/hello-world", func(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
 		fmt.Fprint(w, "Hello World!\n")
 	})
-	http.ListenAndServe(":31415", handler)
+
+	http.ListenAndServe(fmt.Sprintf(":%d", port), handler)
 }

examples/resolver/resolver.go

@@ -0,0 +1,28 @@
+package resolver
+
+import (
+	"fmt"
+	"net/http"
+)
+
+//RequestURL simply returns
+//the request url from REQUEST_URI header
+//this should not be done in production applications
+type RequestURL struct {
+	r    http.Request
+	Port int
+}
+
+//SetRequest to implement `RequestAwareResolverInterface`
+func (m *RequestURL) SetRequest(r http.Request) {
+	m.r = r
+}
+
+//GetBaseURL implements `URLResolver` interface
+func (m RequestURL) GetBaseURL() string {
+	if uri := m.r.Header.Get("REQUEST_URI"); uri != "" {
+		return uri
+	}
+
+	return fmt.Sprintf("https://localhost:%d", m.Port)
+}