├── LICENSE
├── README.md
├── _example
    └── main.go
└── jsonp.go


/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2016-Present https://github.com/go-chi authors
 2 | 
 3 | MIT License
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of
 6 | this software and associated documentation files (the "Software"), to deal in
 7 | the Software without restriction, including without limitation the rights to
 8 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 9 | the Software, and to permit persons to whom the Software is furnished to do so,
10 | subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # JSONP Go http middleware
  2 | 
  3 | JSONP is a common technique used to communicate with a JSON-serving Web Service with a
  4 | Web browser over cross-domains, in place of a XHR request. There is a lot written about
  5 | JSONP out there, but the tl;dr on it is a Javascript http client requesting JSONP
  6 | will write a `<script>` tag to the head of a page, with the `src` to an API endpoint,
  7 | with the addition of a `callback` (or `jsonp`) query parameter that represents a
  8 | randomly-named listener function that will parse the request when it comes back from
  9 | the server.
 10 | 
 11 | This middleware will work with anything that supports standard `http.Handler`. The code
 12 | is small, so go read it, but it just buffers the response from the rest of the chain,
 13 | and if its a JSON request with a callback, then it will wrap the response in the callback
 14 | function before writing it to the actual response writer.
 15 | 
 16 | Any feedback is welcome and appreciated!
 17 | 
 18 | ## Example
 19 | 
 20 | ```go
 21 | // JSONP example using Chi http router.. but anything that accepts
 22 | // a http.Handler will work
 23 | package main
 24 | 
 25 | import (
 26 | 	"log"
 27 | 	"net/http"
 28 | 
 29 | 	"github.com/go-chi/chi"
 30 | 	"github.com/go-chi/chi/middleware"
 31 | 	"github.com/go-chi/jsonp"
 32 | 	"github.com/go-chi/render"
 33 | )
 34 | 
 35 | func main() {
 36 | 	mux := chi.NewRouter()
 37 | 
 38 | 	mux.Use(middleware.Logger)
 39 | 	mux.Use(jsonp.Handler)
 40 | 
 41 | 	mux.Get("/", func(w http.ResponseWriter, r *http.Request) {
 42 | 		data := &SomeObj{"superman"}
 43 | 		render.JSON(w, r, data)
 44 | 	})
 45 | 
 46 | 	err := http.ListenAndServe(":4444", mux)
 47 | 	if err != nil {
 48 | 		log.Fatal(err)
 49 | 	}
 50 | }
 51 | 
 52 | type SomeObj struct {
 53 | 	Name string `json:"name"`
 54 | }
 55 | ```
 56 | 
 57 | *Output:*
 58 | 
 59 | ```
 60 | $ curl -v "http://localhost:4444/"
 61 | *   Trying ::1...
 62 | * Connected to localhost (::1) port 4444 (#0)
 63 | > GET / HTTP/1.1
 64 | > Host: localhost:4444
 65 | > User-Agent: curl/7.43.0
 66 | > Accept: */*
 67 | >
 68 | < HTTP/1.1 200 OK
 69 | < Content-Type: application/json; charset=UTF-8
 70 | < Date: Fri, 14 Aug 2015 19:11:44 GMT
 71 | < Content-Length: 19
 72 | <
 73 | * Connection #0 to host localhost left intact
 74 | {"name":"superman"}
 75 | 
 76 | $ curl -v "http://localhost:4444/?callback=X"
 77 | *   Trying ::1...
 78 | * Connected to localhost (::1) port 4444 (#0)
 79 | > GET /?callback=X HTTP/1.1
 80 | > Host: localhost:4444
 81 | > User-Agent: curl/7.43.0
 82 | > Accept: */*
 83 | >
 84 | < HTTP/1.1 200 OK
 85 | < Content-Length: 122
 86 | < Content-Type: application/javascript
 87 | < Date: Fri, 14 Aug 2015 19:11:49 GMT
 88 | <
 89 | * Connection #0 to host localhost left intact
 90 | X({"meta":{"content-length":19,"content-type":"application/json; charset=UTF-8","status":200},"data":{"name":"superman"}})
 91 | ```
 92 | 
 93 | ## NOTES
 94 | 
 95 | Since JSONP must always respond with a 200, as thats what the browser `<script>`
 96 | tag expects, a nice pattern that is also used in the GitHub API is to put the HTTP
 97 | response headers in a `"meta"` hash, and the HTTP response body in `"data"`. Like so..
 98 | 
 99 | ```json
100 | JsonpCallbackFn_abc123etc({
101 |   "meta": {
102 |     "Status": 200,
103 |     "Content-Type": "application/json",
104 |     "Content-Length": "19",
105 |     "etc": "etc"
106 |   },
107 |   "data": { "name": "yummy" }
108 | })
109 | ```
110 | 
111 | ## LICENSE
112 | 
113 | MIT - see LICENSE file
114 | 
115 | 


--------------------------------------------------------------------------------
/_example/main.go:
--------------------------------------------------------------------------------
 1 | // JSONP example using Chi http router.. but anything that accepts
 2 | // a http.Handler will work
 3 | package main
 4 | 
 5 | import (
 6 | 	"log"
 7 | 	"net/http"
 8 | 
 9 | 	"github.com/go-chi/chi"
10 | 	"github.com/go-chi/chi/middleware"
11 | 	"github.com/go-chi/jsonp"
12 | 	"github.com/go-chi/render"
13 | )
14 | 
15 | func main() {
16 | 	mux := chi.NewRouter()
17 | 
18 | 	mux.Use(middleware.Logger)
19 | 	mux.Use(jsonp.Handler)
20 | 
21 | 	mux.Get("/", func(w http.ResponseWriter, r *http.Request) {
22 | 		data := &SomeObj{"superman"}
23 | 		render.JSON(w, r, data)
24 | 	})
25 | 
26 | 	err := http.ListenAndServe(":4444", mux)
27 | 	if err != nil {
28 | 		log.Fatal(err)
29 | 	}
30 | }
31 | 
32 | type SomeObj struct {
33 | 	Name string `json:"name"`
34 | }
35 | 


--------------------------------------------------------------------------------
/jsonp.go:
--------------------------------------------------------------------------------
  1 | package jsonp
  2 | 
  3 | import (
  4 | 	"bytes"
  5 | 	"encoding/json"
  6 | 	"fmt"
  7 | 	"net/http"
  8 | 	"strconv"
  9 | 	"strings"
 10 | )
 11 | 
 12 | func Handler(next http.Handler) http.Handler {
 13 | 	fn := func(w http.ResponseWriter, r *http.Request) {
 14 | 		callback := r.URL.Query().Get("callback")
 15 | 		if callback == "" {
 16 | 			callback = r.URL.Query().Get("jsonp")
 17 | 		}
 18 | 		if callback == "" {
 19 | 			next.ServeHTTP(w, r)
 20 | 			return
 21 | 		}
 22 | 
 23 | 		wb := NewResponseBuffer(w)
 24 | 		next.ServeHTTP(wb, r)
 25 | 
 26 | 		if strings.Index(wb.Header().Get("Content-Type"), "/json") >= 0 {
 27 | 			status := wb.Status
 28 | 			data := wb.Body.Bytes()
 29 | 			wb.Body.Reset()
 30 | 
 31 | 			resp := &jsonpResponse{
 32 | 				Meta: map[string]interface{}{"status": status},
 33 | 				Data: data,
 34 | 			}
 35 | 			for k, v := range wb.Header() {
 36 | 				resp.Meta[strings.ToLower(k)] = v[0]
 37 | 			}
 38 | 			resp.Meta["content-length"] = len(data)
 39 | 
 40 | 			body, err := json.Marshal(resp)
 41 | 			if err != nil {
 42 | 				panic(err.Error())
 43 | 			}
 44 | 
 45 | 			wb.Body.Write([]byte(callback + "("))
 46 | 			wb.Body.Write(body)
 47 | 			wb.Body.Write([]byte(")"))
 48 | 
 49 | 			wb.Header().Set("Content-Type", "application/javascript")
 50 | 			wb.Header().Set("Content-Length", strconv.Itoa(wb.Body.Len()))
 51 | 		}
 52 | 
 53 | 		wb.Flush()
 54 | 	}
 55 | 	return http.HandlerFunc(fn)
 56 | }
 57 | 
 58 | type jsonpResponse struct {
 59 | 	Meta map[string]interface{}
 60 | 	Data interface{}
 61 | }
 62 | 
 63 | func (j *jsonpResponse) MarshalJSON() ([]byte, error) {
 64 | 	meta, err := json.Marshal(j.Meta)
 65 | 	if err != nil {
 66 | 		return nil, err
 67 | 	}
 68 | 	b := fmt.Sprintf("{\"meta\":%s,\"data\":%s}", meta, j.Data)
 69 | 	return []byte(b), nil
 70 | }
 71 | 
 72 | type responseBuffer struct {
 73 | 	Response http.ResponseWriter // the actual ResponseWriter to flush to
 74 | 	Status   int                 // the HTTP response code from WriteHeader
 75 | 	Body     *bytes.Buffer       // the response content body
 76 | 	Flushed  bool
 77 | }
 78 | 
 79 | func NewResponseBuffer(w http.ResponseWriter) *responseBuffer {
 80 | 	return &responseBuffer{
 81 | 		Response: w, Status: 200, Body: &bytes.Buffer{},
 82 | 	}
 83 | }
 84 | 
 85 | func (w *responseBuffer) Header() http.Header {
 86 | 	return w.Response.Header() // use the actual response header
 87 | }
 88 | 
 89 | func (w *responseBuffer) Write(buf []byte) (int, error) {
 90 | 	w.Body.Write(buf)
 91 | 	return len(buf), nil
 92 | }
 93 | 
 94 | func (w *responseBuffer) WriteHeader(status int) {
 95 | 	w.Status = status
 96 | }
 97 | 
 98 | func (w *responseBuffer) Flush() {
 99 | 	if w.Flushed {
100 | 		return
101 | 	}
102 | 	w.Response.WriteHeader(w.Status)
103 | 	if w.Body.Len() > 0 {
104 | 		_, err := w.Response.Write(w.Body.Bytes())
105 | 		if err != nil {
106 | 			panic(err)
107 | 		}
108 | 		w.Body.Reset()
109 | 	}
110 | 	w.Flushed = true
111 | }
112 | 


--------------------------------------------------------------------------------