Merge pull request #94 from syumai/add-hono-middleware

[experimental] add Hono middleware

exp/hono/context.go

@@ -0,0 +1,64 @@
+package hono
+
+import (
+ "context"
+ "io"
+ "net/http"
+ "sync"
+ "syscall/js"
+
+ "github.com/syumai/workers/internal/jshttp"
+ "github.com/syumai/workers/internal/jsutil"
+ "github.com/syumai/workers/internal/runtimecontext"
+)
+
+type Context struct {
+ ctxObj js.Value
+ reqFunc func() *http.Request
+}
+
+func newContext(ctxObj js.Value) *Context {
+ return &Context{
+ ctxObj: ctxObj,
+ reqFunc: sync.OnceValue(func() *http.Request {
+ reqObj := ctxObj.Get("req").Get("raw")
+ req, err := jshttp.ToRequest(reqObj)
+ if err != nil {
+ panic(err)
+ }
+ ctx := runtimecontext.New(context.Background(), reqObj, jsutil.RuntimeContext)
+ req = req.WithContext(ctx)
+ return req
+ }),
+ }
+}
+
+func (c *Context) Request() *http.Request {
+ return c.reqFunc()
+}
+
+func (c *Context) SetHeader(key, value string) {
+ c.ctxObj.Call("header", key, value)
+}
+
+func (c *Context) SetStatus(statusCode int) {
+ c.ctxObj.Call("status", statusCode)
+}
+
+func (c *Context) RawResponse() js.Value {
+ return c.ctxObj.Get("res")
+}
+
+func (c *Context) ResponseBody() io.ReadCloser {
+ return jsutil.ConvertReadableStreamToReadCloser(c.ctxObj.Get("res").Get("body"))
+}
+
+func (c *Context) SetBody(body io.ReadCloser) {
+ bodyObj := convertBodyToJS(body)
+ respObj := c.ctxObj.Call("body", bodyObj)
+ c.ctxObj.Set("res", respObj)
+}
+
+func (c *Context) SetResponse(respObj js.Value) {
+ c.ctxObj.Set("res", respObj)
+}

exp/hono/middleware.go

@@ -0,0 +1,77 @@
+package hono
+
+import (
+ "fmt"
+ "syscall/js"
+
+ "github.com/syumai/workers/internal/jsutil"
+)
+
+type Middleware func(c *Context, next func())
+
+var middleware Middleware
+
+func ChainMiddlewares(middlewares ...Middleware) Middleware {
+ if len(middlewares) == 0 {
+ return nil
+ }
+ if len(middlewares) == 1 {
+ return middlewares[0]
+ }
+ return func(c *Context, next func()) {
+ for i := len(middlewares) - 1; i > 0; i-- {
+ i := i
+ f := next
+ next = func() {
+ middlewares[i](c, f)
+ }
+ }
+ middlewares[0](c, next)
+ }
+}
+
+func init() {
+ runHonoMiddlewareCallback := js.FuncOf(func(_ js.Value, args []js.Value) any {
+ if len(args) > 1 {
+ panic(fmt.Errorf("too many args given to handleRequest: %d", len(args)))
+ }
+ nextFnObj := args[0]
+ var cb js.Func
+ cb = js.FuncOf(func(_ js.Value, pArgs []js.Value) any {
+ defer cb.Release()
+ resolve := pArgs[0]
+ go func() {
+ err := runHonoMiddleware(nextFnObj)
+ if err != nil {
+ panic(err)
+ }
+ resolve.Invoke(js.Undefined())
+ }()
+ return js.Undefined()
+ })
+ return jsutil.NewPromise(cb)
+ })
+ jsutil.Binding.Set("runHonoMiddleware", runHonoMiddlewareCallback)
+}
+
+func runHonoMiddleware(nextFnObj js.Value) error {
+ if middleware == nil {
+ return fmt.Errorf("ServeMiddleware must be called before runHonoMiddleware.")
+ }
+ c := newContext(jsutil.RuntimeContext.Get("ctx"))
+ next := func() {
+ jsutil.AwaitPromise(nextFnObj.Invoke())
+ }
+ middleware(c, next)
+ return nil
+}
+
+//go:wasmimport workers ready
+func ready()
+
+// ServeMiddleware sets the Task to be executed
+func ServeMiddleware(middleware_ Middleware) {
+ middleware = middleware_
+ ready()
+ select {}
+}

exp/hono/middleware_test.go

@@ -0,0 +1,32 @@
+package hono
+
+import "testing"
+
+func TestChainMiddlewares(t *testing.T) {
+ result := ""
+ middlewares := []Middleware{
+ func(c *Context, next func()) {
+ result += "1"
+ next()
+ result += "1"
+ },
+ func(c *Context, next func()) {
+ result += "2"
+ next()
+ result += "2"
+ },
+ func(c *Context, next func()) {
+ result += "3"
+ next()
+ result += "3"
+ },
+ }
+ m := ChainMiddlewares(middlewares...)
+ m(nil, func() {
+ result += "0"
+ })
+ const want = "1230321"
+ if result != want {
+ t.Errorf("result: got %q, want %q", result, want)
+ }
+}

exp/hono/response.go

@@ -0,0 +1,35 @@
+package hono
+
+import (
+ "io"
+ "net/http"
+ "syscall/js"
+
+ "github.com/syumai/workers/internal/jshttp"
+ "github.com/syumai/workers/internal/jsutil"
+)
+
+func convertBodyToJS(body io.ReadCloser) js.Value {
+ if sr, ok := body.(jsutil.RawJSBodyGetter); ok {
+ return sr.GetRawJSBody()
+ }
+ return jsutil.ConvertReaderToReadableStream(body)
+}
+
+func NewJSResponse(body io.ReadCloser, statusCode int, headers http.Header) js.Value {
+ bodyObj := convertBodyToJS(body)
+ opts := jsutil.ObjectClass.New()
+ if statusCode != 0 {
+ opts.Set("status", statusCode)
+ }
+ if headers != nil {
+ headersObj := jshttp.ToJSHeader(headers)
+ opts.Set("headers", headersObj)
+ }
+ return jsutil.ResponseClass.New(bodyObj, opts)
+}
+
+func NewJSResponseWithBase(body io.ReadCloser, baseRespObj js.Value) js.Value {
+ bodyObj := convertBodyToJS(body)
+ return jsutil.ResponseClass.New(bodyObj, baseRespObj)
+}

internal/jsutil/stream.go

@@ -11,6 +11,10 @@ type RawJSBodyWriter interface {
  WriteRawJSBody(body js.Value)
 }
 
+type RawJSBodyGetter interface {
+ GetRawJSBody() 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/[email protected]/streams/conversion.ts#L76
@@ -21,8 +25,9 @@ type readableStreamToReadCloser struct {
 }
 
 var (
- _ io.ReadCloser = (*readableStreamToReadCloser)(nil)
- _ io.WriterTo = (*readableStreamToReadCloser)(nil)
+ _ io.ReadCloser = (*readableStreamToReadCloser)(nil)
+ _ io.WriterTo = (*readableStreamToReadCloser)(nil)
+ _ RawJSBodyGetter = (*readableStreamToReadCloser)(nil)
 )
 
 // Read reads bytes from ReadableStreamDefaultReader.
@@ -91,6 +96,10 @@ func (sr *readableStreamToReadCloser) WriteTo(w io.Writer) (n int64, err error)
  return io.Copy(w, &readerWrapper{sr})
 }
 
+func (sr *readableStreamToReadCloser) GetRawJSBody() js.Value {
+ return sr.stream
+}
+
 // ConvertReadableStreamToReadCloser converts ReadableStream to io.ReadCloser.
 func ConvertReadableStreamToReadCloser(stream js.Value) io.ReadCloser {
  return &readableStreamToReadCloser{