1// Copyright 2018 The Go Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style
3// license that can be found in the LICENSE file.
4
5// +build js,wasm
6
7package http
8
9import (
10	"errors"
11	"fmt"
12	"io"
13	"strconv"
14	"syscall/js"
15)
16
17var uint8Array = js.Global().Get("Uint8Array")
18
19// jsFetchMode is a Request.Header map key that, if present,
20// signals that the map entry is actually an option to the Fetch API mode setting.
21// Valid values are: "cors", "no-cors", "same-origin", "navigate"
22// The default is "same-origin".
23//
24// Reference: https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters
25const jsFetchMode = "js.fetch:mode"
26
27// jsFetchCreds is a Request.Header map key that, if present,
28// signals that the map entry is actually an option to the Fetch API credentials setting.
29// Valid values are: "omit", "same-origin", "include"
30// The default is "same-origin".
31//
32// Reference: https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters
33const jsFetchCreds = "js.fetch:credentials"
34
35// jsFetchRedirect is a Request.Header map key that, if present,
36// signals that the map entry is actually an option to the Fetch API redirect setting.
37// Valid values are: "follow", "error", "manual"
38// The default is "follow".
39//
40// Reference: https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters
41const jsFetchRedirect = "js.fetch:redirect"
42
43var useFakeNetwork = js.Global().Get("fetch").IsUndefined()
44
45// RoundTrip implements the RoundTripper interface using the WHATWG Fetch API.
46func (t *Transport) RoundTrip(req *Request) (*Response, error) {
47	if useFakeNetwork {
48		return t.roundTrip(req)
49	}
50
51	ac := js.Global().Get("AbortController")
52	if !ac.IsUndefined() {
53		// Some browsers that support WASM don't necessarily support
54		// the AbortController. See
55		// https://developer.mozilla.org/en-US/docs/Web/API/AbortController#Browser_compatibility.
56		ac = ac.New()
57	}
58
59	opt := js.Global().Get("Object").New()
60	// See https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch
61	// for options available.
62	opt.Set("method", req.Method)
63	opt.Set("credentials", "same-origin")
64	if h := req.Header.Get(jsFetchCreds); h != "" {
65		opt.Set("credentials", h)
66		req.Header.Del(jsFetchCreds)
67	}
68	if h := req.Header.Get(jsFetchMode); h != "" {
69		opt.Set("mode", h)
70		req.Header.Del(jsFetchMode)
71	}
72	if h := req.Header.Get(jsFetchRedirect); h != "" {
73		opt.Set("redirect", h)
74		req.Header.Del(jsFetchRedirect)
75	}
76	if !ac.IsUndefined() {
77		opt.Set("signal", ac.Get("signal"))
78	}
79	headers := js.Global().Get("Headers").New()
80	for key, values := range req.Header {
81		for _, value := range values {
82			headers.Call("append", key, value)
83		}
84	}
85	opt.Set("headers", headers)
86
87	if req.Body != nil {
88		// TODO(johanbrandhorst): Stream request body when possible.
89		// See https://bugs.chromium.org/p/chromium/issues/detail?id=688906 for Blink issue.
90		// See https://bugzilla.mozilla.org/show_bug.cgi?id=1387483 for Firefox issue.
91		// See https://github.com/web-platform-tests/wpt/issues/7693 for WHATWG tests issue.
92		// See https://developer.mozilla.org/en-US/docs/Web/API/Streams_API for more details on the Streams API
93		// and browser support.
94		body, err := io.ReadAll(req.Body)
95		if err != nil {
96			req.Body.Close() // RoundTrip must always close the body, including on errors.
97			return nil, err
98		}
99		req.Body.Close()
100		if len(body) != 0 {
101			buf := uint8Array.New(len(body))
102			js.CopyBytesToJS(buf, body)
103			opt.Set("body", buf)
104		}
105	}
106
107	fetchPromise := js.Global().Call("fetch", req.URL.String(), opt)
108	var (
109		respCh           = make(chan *Response, 1)
110		errCh            = make(chan error, 1)
111		success, failure js.Func
112	)
113	success = js.FuncOf(func(this js.Value, args []js.Value) interface{} {
114		success.Release()
115		failure.Release()
116
117		result := args[0]
118		header := Header{}
119		// https://developer.mozilla.org/en-US/docs/Web/API/Headers/entries
120		headersIt := result.Get("headers").Call("entries")
121		for {
122			n := headersIt.Call("next")
123			if n.Get("done").Bool() {
124				break
125			}
126			pair := n.Get("value")
127			key, value := pair.Index(0).String(), pair.Index(1).String()
128			ck := CanonicalHeaderKey(key)
129			header[ck] = append(header[ck], value)
130		}
131
132		contentLength := int64(0)
133		if cl, err := strconv.ParseInt(header.Get("Content-Length"), 10, 64); err == nil {
134			contentLength = cl
135		}
136
137		b := result.Get("body")
138		var body io.ReadCloser
139		// The body is undefined when the browser does not support streaming response bodies (Firefox),
140		// and null in certain error cases, i.e. when the request is blocked because of CORS settings.
141		if !b.IsUndefined() && !b.IsNull() {
142			body = &streamReader{stream: b.Call("getReader")}
143		} else {
144			// Fall back to using ArrayBuffer
145			// https://developer.mozilla.org/en-US/docs/Web/API/Body/arrayBuffer
146			body = &arrayReader{arrayPromise: result.Call("arrayBuffer")}
147		}
148
149		code := result.Get("status").Int()
150		respCh <- &Response{
151			Status:        fmt.Sprintf("%d %s", code, StatusText(code)),
152			StatusCode:    code,
153			Header:        header,
154			ContentLength: contentLength,
155			Body:          body,
156			Request:       req,
157		}
158
159		return nil
160	})
161	failure = js.FuncOf(func(this js.Value, args []js.Value) interface{} {
162		success.Release()
163		failure.Release()
164		errCh <- fmt.Errorf("net/http: fetch() failed: %s", args[0].Get("message").String())
165		return nil
166	})
167
168	fetchPromise.Call("then", success, failure)
169	select {
170	case <-req.Context().Done():
171		if !ac.IsUndefined() {
172			// Abort the Fetch request.
173			ac.Call("abort")
174		}
175		return nil, req.Context().Err()
176	case resp := <-respCh:
177		return resp, nil
178	case err := <-errCh:
179		return nil, err
180	}
181}
182
183var errClosed = errors.New("net/http: reader is closed")
184
185// streamReader implements an io.ReadCloser wrapper for ReadableStream.
186// See https://fetch.spec.whatwg.org/#readablestream for more information.
187type streamReader struct {
188	pending []byte
189	stream  js.Value
190	err     error // sticky read error
191}
192
193func (r *streamReader) Read(p []byte) (n int, err error) {
194	if r.err != nil {
195		return 0, r.err
196	}
197	if len(r.pending) == 0 {
198		var (
199			bCh   = make(chan []byte, 1)
200			errCh = make(chan error, 1)
201		)
202		success := js.FuncOf(func(this js.Value, args []js.Value) interface{} {
203			result := args[0]
204			if result.Get("done").Bool() {
205				errCh <- io.EOF
206				return nil
207			}
208			value := make([]byte, result.Get("value").Get("byteLength").Int())
209			js.CopyBytesToGo(value, result.Get("value"))
210			bCh <- value
211			return nil
212		})
213		defer success.Release()
214		failure := js.FuncOf(func(this js.Value, args []js.Value) interface{} {
215			// Assumes it's a TypeError. See
216			// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypeError
217			// for more information on this type. See
218			// https://streams.spec.whatwg.org/#byob-reader-read for the spec on
219			// the read method.
220			errCh <- errors.New(args[0].Get("message").String())
221			return nil
222		})
223		defer failure.Release()
224		r.stream.Call("read").Call("then", success, failure)
225		select {
226		case b := <-bCh:
227			r.pending = b
228		case err := <-errCh:
229			r.err = err
230			return 0, err
231		}
232	}
233	n = copy(p, r.pending)
234	r.pending = r.pending[n:]
235	return n, nil
236}
237
238func (r *streamReader) Close() error {
239	// This ignores any error returned from cancel method. So far, I did not encounter any concrete
240	// situation where reporting the error is meaningful. Most users ignore error from resp.Body.Close().
241	// If there's a need to report error here, it can be implemented and tested when that need comes up.
242	r.stream.Call("cancel")
243	if r.err == nil {
244		r.err = errClosed
245	}
246	return nil
247}
248
249// arrayReader implements an io.ReadCloser wrapper for ArrayBuffer.
250// https://developer.mozilla.org/en-US/docs/Web/API/Body/arrayBuffer.
251type arrayReader struct {
252	arrayPromise js.Value
253	pending      []byte
254	read         bool
255	err          error // sticky read error
256}
257
258func (r *arrayReader) Read(p []byte) (n int, err error) {
259	if r.err != nil {
260		return 0, r.err
261	}
262	if !r.read {
263		r.read = true
264		var (
265			bCh   = make(chan []byte, 1)
266			errCh = make(chan error, 1)
267		)
268		success := js.FuncOf(func(this js.Value, args []js.Value) interface{} {
269			// Wrap the input ArrayBuffer with a Uint8Array
270			uint8arrayWrapper := uint8Array.New(args[0])
271			value := make([]byte, uint8arrayWrapper.Get("byteLength").Int())
272			js.CopyBytesToGo(value, uint8arrayWrapper)
273			bCh <- value
274			return nil
275		})
276		defer success.Release()
277		failure := js.FuncOf(func(this js.Value, args []js.Value) interface{} {
278			// Assumes it's a TypeError. See
279			// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypeError
280			// for more information on this type.
281			// See https://fetch.spec.whatwg.org/#concept-body-consume-body for reasons this might error.
282			errCh <- errors.New(args[0].Get("message").String())
283			return nil
284		})
285		defer failure.Release()
286		r.arrayPromise.Call("then", success, failure)
287		select {
288		case b := <-bCh:
289			r.pending = b
290		case err := <-errCh:
291			return 0, err
292		}
293	}
294	if len(r.pending) == 0 {
295		return 0, io.EOF
296	}
297	n = copy(p, r.pending)
298	r.pending = r.pending[n:]
299	return n, nil
300}
301
302func (r *arrayReader) Close() error {
303	if r.err == nil {
304		r.err = errClosed
305	}
306	return nil
307}
308