add jsutil.RawJSWriter and use it in jshttp.ResponseWriter

cloudflare/kv.go

@@ -66,7 +66,7 @@ func (kv *KVNamespace) GetReader(key string, opts *KVNamespaceGetOptions) (io.Re
 	if err != nil {
 		return nil, err
 	}
-	return jsutil.ConvertStreamReaderToReader(v.Call("getReader")), nil
+	return jsutil.ConvertReadableStreamToReadCloser(v), nil
 }
 
 // KVNamespaceListOptions represents Cloudflare KV namespace list options.

cloudflare/r2object.go

@@ -54,7 +54,7 @@ func toR2Object(v js.Value) (*R2Object, error) {
 	bodyVal := v.Get("body")
 	var body io.Reader
 	if !bodyVal.IsUndefined() {
-		body = jsutil.ConvertStreamReaderToReader(v.Get("body").Call("getReader"))
+		body = jsutil.ConvertReadableStreamToReadCloser(v.Get("body"))
 	}
 	return &R2Object{
 		instance:       v,

cloudflare/sockets/socket.go

@@ -14,12 +14,13 @@ import (
 func newSocket(ctx context.Context, sockVal js.Value, readDeadline, writeDeadline time.Time) *Socket {
 	ctx, cancel := context.WithCancel(ctx)
 	writerVal := sockVal.Get("writable").Call("getWriter")
-	readerVal := sockVal.Get("readable").Call("getReader")
+	readerVal := sockVal.Get("readable")
+	readCloser := jsutil.ConvertReadableStreamToReadCloser(readerVal)
 	return &Socket{
 		ctx:    ctx,
 		cancel: cancel,
 
-		reader:    jsutil.ConvertStreamReaderToReader(readerVal),
+		reader:    readCloser,
 		writerVal: writerVal,
 
 		readDeadline:  readDeadline,
@@ -27,7 +28,7 @@ func newSocket(ctx context.Context, sockVal js.Value, readDeadline, writeDeadlin
 
 		startTLS:   func() js.Value { return sockVal.Call("startTls") },
 		close:      func() { sockVal.Call("close") },
-		closeRead:  func() { readerVal.Call("close") },
+		closeRead:  func() { readCloser.Close() },
 		closeWrite: func() { writerVal.Call("close") },
 	}
 }

internal/jshttp/request.go

@@ -17,8 +17,7 @@ func ToBody(streamOrNull js.Value) io.ReadCloser {
 	if streamOrNull.IsNull() {
 		return nil
 	}
-	sr := streamOrNull.Call("getReader")
+	return jsutil.ConvertReadableStreamToReadCloser(streamOrNull)
-	return io.NopCloser(jsutil.ConvertStreamReaderToReader(sr))
 }
 
 // ToRequest converts JavaScript sides Request to *http.Request.

internal/jshttp/response.go

@@ -25,19 +25,19 @@ func ToResponse(res js.Value) (*http.Response, error) {
 		Status:        strconv.Itoa(status) + " " + res.Get("statusText").String(),
 		StatusCode:    status,
 		Header:        header,
-		Body:          io.NopCloser(jsutil.ConvertStreamReaderToReader(blob.Call("stream").Call("getReader"))),
+		Body:          jsutil.ConvertReadableStreamToReadCloser(blob.Call("stream")),
 		ContentLength: contentLength,
 	}, nil
 }
 
 // ToJSResponse converts *http.Response to JavaScript sides Response class object.
 func ToJSResponse(res *http.Response) js.Value {
-	return newJSResponse(res.StatusCode, res.Header, res.Body)
+	return newJSResponse(res.StatusCode, res.Header, res.Body, nil)
 }
 
 // newJSResponse creates JavaScript sides Response class object.
 //   - Response: https://developer.mozilla.org/docs/Web/API/Response
-func newJSResponse(statusCode int, headers http.Header, body io.ReadCloser) js.Value {
+func newJSResponse(statusCode int, headers http.Header, body io.ReadCloser, rawBody *js.Value) js.Value {
 	status := statusCode
 	if status == 0 {
 		status = http.StatusOK
@@ -52,6 +52,11 @@ func newJSResponse(statusCode int, headers http.Header, body io.ReadCloser) js.V
 		status == http.StatusNotModified {
 		return jsutil.ResponseClass.New(jsutil.Null, respInit)
 	}
-	readableStream := jsutil.ConvertReaderToReadableStream(body)
+	var readableStream js.Value
+	if rawBody != nil {
+		readableStream = *rawBody
+	} else {
+		readableStream = jsutil.ConvertReaderToReadableStream(body)
+	}
 	return jsutil.ResponseClass.New(readableStream, respInit)
 }

internal/jshttp/responsewriter.go

@@ -5,6 +5,8 @@ import (
 	"net/http"
 	"sync"
 	"syscall/js"
+
+	"github.com/syumai/workers/internal/jsutil"
 )
 
 type ResponseWriter struct {
@@ -14,9 +16,13 @@ type ResponseWriter struct {
 	Writer      *io.PipeWriter
 	ReadyCh     chan struct{}
 	Once        sync.Once
+	RawJSBody   *js.Value
 }
 
-var _ http.ResponseWriter = &ResponseWriter{}
+var (
+	_ http.ResponseWriter    = (*ResponseWriter)(nil)
+	_ jsutil.RawJSBodyWriter = (*ResponseWriter)(nil)
+)
 
 // Ready indicates that ResponseWriter is ready to be converted to Response.
 func (w *ResponseWriter) Ready() {
@@ -38,8 +44,12 @@ func (w *ResponseWriter) WriteHeader(statusCode int) {
 	w.StatusCode = statusCode
 }
 
+func (w *ResponseWriter) WriteRawJSBody(body js.Value) {
+	w.RawJSBody = &body
+}
+
 // ToJSResponse converts *ResponseWriter to JavaScript sides Response.
 //   - Response: https://developer.mozilla.org/docs/Web/API/Response
 func (w *ResponseWriter) ToJSResponse() js.Value {
-	return newJSResponse(w.StatusCode, w.HeaderValue, w.Reader)
+	return newJSResponse(w.StatusCode, w.HeaderValue, w.Reader, w.RawJSBody)
 }

internal/jsutil/stream.go

@@ -7,16 +7,30 @@ import (
 	"syscall/js"
 )
 
-// streamReaderToReader implements io.Reader sourced from ReadableStreamDefaultReader.
+type RawJSBodyWriter interface {
-//   - ReadableStreamDefaultReader: https://developer.mozilla.org/en-US/docs/Web/API/ReadableStreamDefaultReader
+	WriteRawJSBody(body js.Value)
-//   - This implementation is based on: https://deno.land/std@0.139.0/streams/conversion.ts#L76
-type streamReaderToReader struct {
-	buf          bytes.Buffer
-	streamReader js.Value
 }
 
+// readableStreamToReadCloser implements io.Reader sourced from ReadableStreamDefaultReader.
+//   - ReadableStreamDefaultReader: https://developer.mozilla.org/en-US/docs/Web/API/ReadableStreamDefaultReader
+//   - This implementation is based on: https://deno.land/std@0.139.0/streams/conversion.ts#L76
+type readableStreamToReadCloser struct {
+	buf          bytes.Buffer
+	stream       js.Value
+	streamReader *js.Value
+}
+
+var (
+	_ io.ReadCloser = (*readableStreamToReadCloser)(nil)
+	_ io.WriterTo   = (*readableStreamToReadCloser)(nil)
+)
+
 // Read reads bytes from ReadableStreamDefaultReader.
-func (sr *streamReaderToReader) Read(p []byte) (n int, err error) {
+func (sr *readableStreamToReadCloser) Read(p []byte) (n int, err error) {
+	if sr.streamReader == nil {
+		r := sr.stream.Call("getReader")
+		sr.streamReader = &r
+	}
 	if sr.buf.Len() == 0 {
 		promise := sr.streamReader.Call("read")
 		resultCh := make(chan js.Value)
@@ -56,10 +70,31 @@ func (sr *streamReaderToReader) Read(p []byte) (n int, err error) {
 	return sr.buf.Read(p)
 }
 
-// ConvertStreamReaderToReader converts ReadableStreamDefaultReader to io.Reader.
+func (sr *readableStreamToReadCloser) Close() error {
-func ConvertStreamReaderToReader(sr js.Value) io.Reader {
+	if sr.streamReader == nil {
-	return &streamReaderToReader{
+		return nil
-		streamReader: sr,
+	}
+	sr.streamReader.Call("close")
+	return nil
+}
+
+// readerWrapper is wrapper to disable readableStreamToReadCloser's WriteTo method.
+type readerWrapper struct {
+	io.Reader
+}
+
+func (sr *readableStreamToReadCloser) WriteTo(w io.Writer) (n int64, err error) {
+	if w, ok := w.(RawJSBodyWriter); ok {
+		w.WriteRawJSBody(sr.stream)
+		return 0, nil
+	}
+	return io.Copy(w, &readerWrapper{sr})
+}
+
+// ConvertReadableStreamToReadCloser converts ReadableStream to io.ReadCloser.
+func ConvertReadableStreamToReadCloser(stream js.Value) io.ReadCloser {
+	return &readableStreamToReadCloser{
+		stream: stream,
 	}
 }