Day 068 — 2026-10-08 | ミドルウェア設計パターン: 「next」とは何か——net/http のデコレータ・Gin／Express 型の添字・Koa 型の (ctx, next) を、同じ 6 つの問いで予想してから実物と Go で測る

📋 コピーpackage main

import (
	"bytes"
	"net/http"
)

// ── 型 A: net/http の標準形（デコレータ）──────────────────────────
// 中間件は「次のハンドラを受け取り、包んだハンドラを返す関数」。
// 合成は起動時に 1 回。リクエストごとの状態は持たない。

type Middleware func(http.Handler) http.Handler

// Chain は ms[0] が最も外側になるように h を包む。
func Chain(h http.Handler, ms ...Middleware) http.Handler {
	for i := len(ms) - 1; i >= 0; i-- {
		h = ms[i](h)
	}
	return h
}

// ── 型 B: Gin 型（添字で配列を進める next）─────────────────────────
// gin-gonic/gin context.go の Next / Abort / abortIndex を写したもの
// （2026-10-08 に master を取得して確認。Gin の他の機能は持たない）。

type GHandler func(*GCtx)

const abortIndex int8 = 127 >> 1 // Gin: math.MaxInt8 >> 1

type GCtx struct {
	W        http.ResponseWriter
	R        *http.Request
	Errors   []error
	handlers []GHandler
	index    int8
}

func (c *GCtx) Next() {
	c.index++
	for c.index < int8(len(c.handlers)) {
		c.handlers[c.index](c)
		c.index++
	}
}

func (c *GCtx) Abort()          { c.index = abortIndex }
func (c *GCtx) IsAborted() bool { return c.index >= abortIndex }

// GinChain は handlers を 1 本の http.Handler にする。GCtx はリクエストごとに作る。
func GinChain(hs ...GHandler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		c := &GCtx{W: w, R: r, handlers: hs, index: -1}
		c.Next()
	})
}

// ── 型 C: Koa 型（ctx と next を受け取り、error を返す）────────────────
// 応答は ctx に溜め、全員が戻ってから 1 回だけ書く（Koa の respond と同じ順序）。

type KCtx struct {
	R      *http.Request
	Status int
	Header http.Header
	Body   bytes.Buffer
	Log    []string
}

type KMW func(ctx *KCtx, next func() error) error

// KoaHandler は合成済みの関数を http.Handler にする。
func KoaHandler(run func(*KCtx) error) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		ctx := &KCtx{R: r, Status: http.StatusNotFound, Header: http.Header{}}
		if err := run(ctx); err != nil {
			http.Error(w, "internal error", http.StatusInternalServerError)
			return
		}
		for k, v := range ctx.Header {
			w.Header()[k] = v
		}
		w.WriteHeader(ctx.Status)
		w.Write(ctx.Body.Bytes())
	})
}

📋 コピーpackage main

import (
	"bufio"
	"errors"
	"fmt"
	"io"
	"net/http"
	"net/http/httptest"
	"strings"
	"sync"
	"testing"
	"time"
)

// ── 道具 ──────────────────────────────────────────────

type logger struct {
	mu sync.Mutex
	l  []string
}

func (g *logger) add(s string) { g.mu.Lock(); g.l = append(g.l, s); g.mu.Unlock() }
func (g *logger) String() string {
	g.mu.Lock()
	defer g.mu.Unlock()
	return strings.Join(g.l, " ")
}

func do(h http.Handler) *httptest.ResponseRecorder {
	rec := httptest.NewRecorder()
	h.ServeHTTP(rec, httptest.NewRequest("GET", "/", nil))
	return rec
}

func want(t *testing.T, name, got, exp string) {
	t.Helper()
	t.Logf("%-9s %s", name, got)
	if got != exp {
		t.Errorf("%s: got %q, want %q", name, got, exp)
	}
}

// 型 A の部品
func decoMW(g *logger, name string) Middleware {
	return func(next http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			g.add(name + ">")
			next.ServeHTTP(w, r)
			g.add("<" + name)
		})
	}
}

// 型 B の部品
func ginMW(g *logger, name string) GHandler {
	return func(c *GCtx) { g.add(name + ">"); c.Next(); g.add("<" + name) }
}

// 型 C の部品
func koaMW(name string) KMW {
	return func(ctx *KCtx, next func() error) error {
		ctx.Log = append(ctx.Log, name+">")
		err := next()
		ctx.Log = append(ctx.Log, "<"+name)
		return err
	}
}

func koaOK(body string) KMW {
	return func(ctx *KCtx, _ func() error) error {
		ctx.Log = append(ctx.Log, "H")
		ctx.Status = 200
		ctx.Body.WriteString(body)
		return nil
	}
}

func runKoa(mws ...KMW) (*KCtx, error) {
	ctx := &KCtx{Status: 404, Header: http.Header{}}
	err := Compose(mws...)(ctx)
	return ctx, err
}

// ── O: 3 つの型を同じ問いで比べる（予想してから -v で見る）──────────────

// O1 入る順・出る順
func TestO1_Order(t *testing.T) {
	g := &logger{}
	do(Chain(http.HandlerFunc(func(http.ResponseWriter, *http.Request) { g.add("H") }), decoMW(g, "A"), decoMW(g, "B")))
	want(t, "deco", g.String(), "A> B> H <B <A")

	g = &logger{}
	do(GinChain(ginMW(g, "A"), ginMW(g, "B"), func(*GCtx) { g.add("H") }))
	want(t, "gin", g.String(), "A> B> H <B <A")

	ctx, err := runKoa(koaMW("A"), koaMW("B"), koaOK("ok"))
	want(t, "koa", fmt.Sprint(strings.Join(ctx.Log, " "), " err=", err), "A> B> H <B <A err=<nil>")
}

// O2 中間件が next を呼ばずに戻ったら、ハンドラは走るか
func TestO2_ForgetNext(t *testing.T) {
	g := &logger{}
	silent := func(http.Handler) http.Handler {
		return http.HandlerFunc(func(http.ResponseWriter, *http.Request) { g.add("A") })
	}
	do(Chain(http.HandlerFunc(func(http.ResponseWriter, *http.Request) { g.add("H") }), silent))
	want(t, "deco", g.String(), "A")

	g = &logger{}
	do(GinChain(func(*GCtx) { g.add("A") }, func(*GCtx) { g.add("H") }))
	want(t, "gin", g.String(), "A H") // Next を呼ばなくても、外側の for が次を呼ぶ

	g = &logger{}
	do(GinChain(func(c *GCtx) { g.add("A"); c.Abort() }, func(*GCtx) { g.add("H") }))
	want(t, "gin+Abort", g.String(), "A")

	ctx, _ := runKoa(func(ctx *KCtx, _ func() error) error { ctx.Log = append(ctx.Log, "A"); return nil }, koaOK("ok"))
	want(t, "koa", strings.Join(ctx.Log, " "), "A")
}

// O3 1 つの中間件が next を 2 回呼んだら
func TestO3_NextTwice(t *testing.T) {
	calls := 0
	twice := func(next http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { next.ServeHTTP(w, r); next.ServeHTTP(w, r) })
	}
	rec := do(Chain(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { calls++; io.WriteString(w, "ok") }), twice))
	want(t, "deco", fmt.Sprintf("calls=%d body=%q", calls, rec.Body.String()), `calls=2 body="okok"`)

	calls = 0
	rec = do(GinChain(func(c *GCtx) { c.Next(); c.Next() }, func(c *GCtx) { calls++; io.WriteString(c.W, "ok") }))
	want(t, "gin", fmt.Sprintf("calls=%d body=%q", calls, rec.Body.String()), `calls=1 body="ok"`)

	calls = 0
	_, err := runKoa(func(_ *KCtx, next func() error) error {
		if err := next(); err != nil {
			return err
		}
		return next()
	}, func(*KCtx, func() error) error { calls++; return nil })
	want(t, "koa", fmt.Sprintf("calls=%d err=%v", calls, err), "calls=1 err=next() called multiple times")
}

// O4 外側が next の後でステータスとヘッダを変えられるか
func TestO4_ChangeAfterNext(t *testing.T) {
	after := func(next http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			next.ServeHTTP(w, r)
			w.Header().Set("X-After", "1")
			w.WriteHeader(201)
		})
	}
	srv := httptest.NewServer(Chain(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { io.WriteString(w, "ok") }), after))
	defer srv.Close()
	res, err := http.Get(srv.URL)
	if err != nil {
		t.Fatal(err)
	}
	res.Body.Close()
	want(t, "deco", fmt.Sprintf("%d X-After=%q", res.StatusCode, res.Header.Get("X-After")), `200 X-After=""`)

	h := KoaHandler(Compose(func(ctx *KCtx, next func() error) error {
		err := next()
		ctx.Header.Set("X-After", "1")
		ctx.Status = 201
		return err
	}, koaOK("ok")))
	srv2 := httptest.NewServer(h)
	defer srv2.Close()
	res, err = http.Get(srv2.URL)
	if err != nil {
		t.Fatal(err)
	}
	res.Body.Close()
	want(t, "koa", fmt.Sprintf("%d X-After=%q", res.StatusCode, res.Header.Get("X-After")), `201 X-After="1"`)
}

// O5 下流の失敗を外側がどう受け取るか
func TestO5_Errors(t *testing.T) {
	errBoom := errors.New("boom")
	// 型 A: 戻り値が無い。受け取る経路は panic と recover だけ
	var caught any
	rec := func(next http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			defer func() {
				if v := recover(); v != nil {
					caught = v
					http.Error(w, "internal error", 500)
				}
			}()
			next.ServeHTTP(w, r)
		})
	}
	r := do(Chain(http.HandlerFunc(func(http.ResponseWriter, *http.Request) { panic(errBoom) }), rec))
	want(t, "deco", fmt.Sprintf("%d caught=%v", r.Code, caught), "500 caught=boom")

	// 型 B: c.Errors に積み、外側は Next の後で読む
	r = do(GinChain(func(c *GCtx) {
		c.Next()
		if len(c.Errors) > 0 {
			http.Error(c.W, "internal error", 500)
		}
	}, func(c *GCtx) { c.Errors = append(c.Errors, errBoom) }))
	want(t, "gin", fmt.Sprint(r.Code), "500")

	// 型 C: next() の戻り値
	ctx, err := runKoa(func(ctx *KCtx, next func() error) error {
		if err := next(); err != nil {
			ctx.Status = 500
			ctx.Body.WriteString("handled:" + err.Error())
		}
		return nil
	}, func(*KCtx, func() error) error { return errBoom })
	want(t, "koa", fmt.Sprintf("%d %s err=%v", ctx.Status, ctx.Body.String(), err), "500 handled:boom err=<nil>")
}

// O6 溜めてから書く型は、最初の 1 バイトがいつ届くか
func TestO6_FirstByte(t *testing.T) {
	const work = 150 * time.Millisecond
	first := func(h http.Handler) time.Duration {
		srv := httptest.NewServer(h)
		defer srv.Close()
		start := time.Now()
		res, err := http.Get(srv.URL)
		if err != nil {
			t.Fatal(err)
		}
		defer res.Body.Close()
		if _, err := bufio.NewReader(res.Body).ReadByte(); err != nil {
			t.Fatal(err)
		}
		return time.Since(start)
	}
	deco := first(Chain(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		io.WriteString(w, "a")
		http.NewResponseController(w).Flush()
		time.Sleep(work)
	}), decoMW(&logger{}, "A")))
	koa := first(KoaHandler(Compose(koaMW("A"), func(ctx *KCtx, _ func() error) error {
		ctx.Status = 200
		ctx.Body.WriteString("a")
		time.Sleep(work)
		return nil
	})))
	t.Logf("deco      first byte %v", deco.Round(time.Millisecond))
	t.Logf("koa       first byte %v", koa.Round(time.Millisecond))
	if deco >= work || koa < work {
		t.Errorf("deco=%v koa=%v (work=%v)", deco, koa, work)
	}
}

// ── K: Compose（自分で書く部分）の約束 ─────────────────────────────

func TestK1_LastNextIsNoop(t *testing.T) {
	ctx, err := runKoa(koaMW("A"), koaMW("B"))
	want(t, "K1", fmt.Sprint(strings.Join(ctx.Log, " "), " err=", err), "A> B> <B <A err=<nil>")
	_, err = runKoa()
	if err != nil {
		t.Errorf("Compose() with no middleware: %v", err)
	}
}

func TestK2_NextTwiceDoesNotRerun(t *testing.T) {
	runs := 0
	_, err := runKoa(func(_ *KCtx, next func() error) error {
		next()
		return next()
	}, koaMW("B"), func(*KCtx, func() error) error { runs++; return nil })
	if !errors.Is(err, ErrNextTwice) || runs != 1 {
		t.Errorf("err=%v runs=%d, want ErrNextTwice and 1", err, runs)
	}
}

func TestK3_ErrorBubbles(t *testing.T) {
	errX := errors.New("x")
	ctx, err := runKoa(koaMW("A"), func(*KCtx, func() error) error { return errX }, koaOK("unreached"))
	if !errors.Is(err, errX) || strings.Contains(strings.Join(ctx.Log, " "), "H") {
		t.Errorf("err=%v log=%v", err, ctx.Log)
	}
}

func TestK4_ShortCircuit(t *testing.T) {
	ctx, err := runKoa(func(ctx *KCtx, _ func() error) error { ctx.Status = 401; return nil }, koaOK("secret"))
	if err != nil || ctx.Status != 401 || ctx.Body.Len() != 0 {
		t.Errorf("status=%d body=%q err=%v", ctx.Status, ctx.Body.String(), err)
	}
}

// K5 合成した関数を、同時に 200 リクエストで使い回す（-race で流す）
func TestK5_ReusedConcurrently(t *testing.T) {
	run := Compose(koaMW("A"), func(ctx *KCtx, next func() error) error {
		time.Sleep(time.Millisecond)
		return next()
	}, koaOK("ok"))
	var wg sync.WaitGroup
	var mu sync.Mutex
	bad := 0
	for i := 0; i < 200; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			ctx := &KCtx{Status: 404, Header: http.Header{}}
			if err := run(ctx); err != nil || ctx.Status != 200 {
				mu.Lock()
				bad++
				mu.Unlock()
			}
		}()
	}
	wg.Wait()
	if bad != 0 {
		t.Errorf("%d / 200 requests failed", bad)
	}
}

// K6 2 回目の next が「下流の途中から」走らない（Express 5 で実測した飛ばしを起こさない）
func TestK6_NoSkipAfterSlowMiddleware(t *testing.T) {
	ctx, err := runKoa(func(ctx *KCtx, next func() error) error {
		e1 := next()
		e2 := next()
		ctx.Log = append(ctx.Log, fmt.Sprintf("e1=%v e2=%v", e1, e2))
		return nil
	}, func(ctx *KCtx, next func() error) error {
		ctx.Log = append(ctx.Log, "auth")
		return nil // 認証に失敗したので next を呼ばない
	}, koaOK("secret"))
	if err != nil || strings.Contains(strings.Join(ctx.Log, " "), "H") {
		t.Errorf("handler ran after auth refused: log=%v err=%v", ctx.Log, err)
	}
}

// ── 費用（割り当て数は決定的。時間は参考）──────────────────────

func BenchmarkDeco3(b *testing.B) {
	g := func(next http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { next.ServeHTTP(w, r) })
	}
	h := Chain(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { w.WriteHeader(200) }), g, g, g)
	w, r := httptest.NewRecorder(), httptest.NewRequest("GET", "/", nil)
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		h.ServeHTTP(w, r)
	}
}

func BenchmarkGin3(b *testing.B) {
	m := func(c *GCtx) { c.Next() }
	h := GinChain(m, m, m, func(c *GCtx) { c.W.WriteHeader(200) })
	w, r := httptest.NewRecorder(), httptest.NewRequest("GET", "/", nil)
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		h.ServeHTTP(w, r)
	}
}

func BenchmarkKoa3(b *testing.B) {
	m := func(_ *KCtx, next func() error) error { return next() }
	run := Compose(m, m, m, func(ctx *KCtx, _ func() error) error { ctx.Status = 200; return nil })
	ctx := &KCtx{Header: http.Header{}}
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		ctx.Status = 404
		run(ctx)
	}
}

「2 回目の next を止める」には、どこまで進んだかを覚えておく変数が要ります。その変数をどこに置くか（合成したときの外側か、1 回の呼び出しの中か）が K5 の分かれ目です。

koa-compose は 17 行です。dispatch(i) という再帰関数を作り、中間件 i には next = () => dispatch(i+1) を渡します。「i が最後に進んだ位置以下なら拒否」という 1 行で 2 回目を止めています。Express の next は i+1 ではなく共有の添字 idx から次を探すので、2 回目は「いま下流が進んでいる位置の次」から走ります（問 3 の Express 列はここから予想できる）。

📋 コピーfunc Compose(mws ...KMW) func(*KCtx) error {
	return func(ctx *KCtx) error {
		index := -1                    // ← 呼び出しごと。外に出すと？
		var dispatch func(i int) error
		dispatch = func(i int) error {
			// (1) i が index 以下なら ErrNextTwice
			// (2) index = i
			// (3) i が末尾なら nil
			// (4) mws[i] に「dispatch(i+1) を呼ぶ関数」を渡して、その error を返す
		}
		return dispatch(0)
	}
}

📋 コピー// 実物の Express（4.19.2 / 5.2.1）と koa-compose 4.1.0 で、合成の性質を測る
const http = require('http');
const E5 = require('/Users/kainumadaishi/.npm/_npx/55d1233f1980185b/node_modules/express');
const E4 = require('/Users/kainumadaishi/Learning/Udemy/TypeScript_超TypeScript 完全ガイド 2024/section13_own_typescript-node/node_modules/express');
const compose = require('/Users/kainumadaishi/.vscode/extensions/oderwat.indent-rainbow-8.3.1/node_modules/koa-compose');
const sleep = ms => new Promise(r => setTimeout(r, ms));
process.on('unhandledRejection', e => console.log('  !! unhandledRejection: ' + e.message));

async function hit(app, path) {
  const srv = http.createServer(app); await new Promise(r => srv.listen(0, '127.0.0.1', r));
  const res = await fetch(`http://127.0.0.1:${srv.address().port}${path}`);
  const body = await res.text(); await sleep(30); srv.close();
  return `${res.status} ${JSON.stringify(body)}`;
}

async function express(E, name) {
  // E1: 同期のハンドラ / 非同期のハンドラで、外側の「後処理」がいつ走るか
  for (const asyncH of [false, true]) {
    const log = []; const app = E();
    app.use((req, res, next) => { log.push('A>'); next(); log.push('<A'); });
    app.use(async (req, res, next) => { log.push('B>'); await next(); log.push('<B'); });
    app.get('/', async (req, res) => { log.push('H>'); if (asyncH) await sleep(5); res.send('ok'); log.push('<H'); });
    const r = await hit(app, '/');
    console.log(`${name} E1 asyncH=${asyncH}: ${log.join(' ')} | ${r}`);
  }
  // E2: next() を 2 回呼ぶ
  { const log = []; const app = E();
    app.use((req, res, next) => { log.push('A'); next(); next(); });
    app.use((req, res, next) => { log.push('B'); next(); });
    app.use((req, res, next) => { log.push('C'); next(); });
    app.get('/', (req, res) => { log.push('H'); if (!res.headersSent) res.send('ok'); });
    const r = await hit(app, '/');
    console.log(`${name} E2 next x2: ${log.join(' ')} | ${r}`); }
  // E3: 外側が next() の後でステータスを変える
  { const app = E(); let err = '';
    app.use((req, res, next) => { next(); try { res.status(201); res.set('X-After', '1'); } catch (e) { err = e.code || e.message; } });
    app.get('/', (req, res) => res.send('ok'));
    const r = await hit(app, '/');
    console.log(`${name} E3 status after next: ${r} err=${err}`); }
  // E4: async ミドルウェアが投げた例外
  { const app = E();
    app.use(async (req, res, next) => { await sleep(1); throw new Error('boom'); });
    app.get('/', (req, res) => res.send('ok'));
    app.use((err, req, res, next) => res.status(500).send('handled:' + err.message));
    const r = await Promise.race([hit(app, '/'), sleep(1500).then(() => 'TIMEOUT(応答なし)')]);
    console.log(`${name} E4 async throw: ${r}`); }
  // E5: next() を呼ばない
  { const app = E(); const log = [];
    app.use((req, res, next) => { log.push('A'); res.status(401).send('no'); });
    app.get('/', (req, res) => { log.push('H'); res.send('ok'); });
    const r = await hit(app, '/');
    console.log(`${name} E5 no next: ${log.join(' ')} | ${r}`); }
}

async function koa() {
  const run = async (mws) => { const ctx = { log: [], status: 404, body: undefined };
    try { await compose(mws)(ctx); } catch (e) { ctx.err = e.message; } return ctx; };
  let c = await run([
    async (ctx, next) => { ctx.log.push('A>'); await next(); ctx.log.push('<A'); },
    async (ctx, next) => { ctx.log.push('B>'); await next(); ctx.log.push('<B'); },
    async (ctx) => { ctx.log.push('H>'); await sleep(5); ctx.body = 'ok'; ctx.status = 200; ctx.log.push('<H'); }]);
  console.log(`koa E1 asyncH=true: ${c.log.join(' ')}`);
  c = await run([
    async (ctx, next) => { ctx.log.push('A'); await next(); await next(); },
    async (ctx, next) => { ctx.log.push('B'); await next(); },
    async (ctx) => { ctx.log.push('H'); }]);
  console.log(`koa E2 next x2: ${c.log.join(' ')} | err=${c.err}`);
  c = await run([
    async (ctx, next) => { await next(); ctx.status = 201; },
    async (ctx) => { ctx.status = 200; ctx.body = 'ok'; }]);
  console.log(`koa E3 status after next: status=${c.status} body=${c.body}`);
  c = await run([
    async (ctx, next) => { try { await next(); } catch (e) { ctx.status = 500; ctx.body = 'handled:' + e.message; } },
    async () => { await sleep(1); throw new Error('boom'); }]);
  console.log(`koa E4 async throw: ${c.status} ${c.body}`);
  c = await run([
    async (ctx, next) => { ctx.log.push('A'); next(); ctx.log.push('A-after(no await)'); },
    async (ctx) => { await sleep(5); ctx.log.push('H'); ctx.body = 'late'; }]);
  console.log(`koa E6 next without await: ${c.log.join(' ')} | body=${c.body}`);
}

(async () => {
  await express(E4, 'express4.19.2');
  await express(E5, 'express5.2.1');
  await koa();
  process.exit(0);
})();

📋 コピーconst http = require('http');
const E5 = require('/Users/kainumadaishi/.npm/_npx/55d1233f1980185b/node_modules/express');
const sleep = ms => new Promise(r => setTimeout(r, ms));
(async () => {
  const log = []; const app = E5();
  app.use((req, res, next) => { log.push('A'); next(); next(); });
  app.use(async (req, res, next) => { log.push('B>'); await sleep(5); log.push('B-next'); next(); });
  app.use((req, res, next) => { log.push('C'); next(); });
  app.get('/', (req, res) => { log.push('H'); if (!res.headersSent) res.send('ok'); else log.push('H(headersSent)'); });
  const srv = http.createServer(app); await new Promise(r => srv.listen(0, '127.0.0.1', r));
  const res = await fetch(`http://127.0.0.1:${srv.address().port}/`); const body = await res.text();
  await sleep(50); srv.close();
  console.log(`express5.2.1 E2b next x2 + async B: ${log.join(' ')} | ${res.status} ${body}`);
})();

出力（Node 22.23.2、2026-10-08）:

📋 コピーexpress4.19.2 E1 asyncH=false: A> B> H> <H <A <B | 200 "ok"
express4.19.2 E1 asyncH=true: A> B> H> <A <B <H | 200 "ok"
express4.19.2 E2 next x2: A B C H | 200 "ok"
express4.19.2 E3 status after next: 200 "ok" err=ERR_HTTP_HEADERS_SENT
  !! unhandledRejection: boom
express4.19.2 E4 async throw: TIMEOUT(応答なし)
express4.19.2 E5 no next: A | 401 "no"
express5.2.1 E1 asyncH=false: A> B> H> <H <A <B | 200 "ok"
express5.2.1 E1 asyncH=true: A> B> H> <A <B <H | 200 "ok"
express5.2.1 E2 next x2: A B C H | 200 "ok"
express5.2.1 E3 status after next: 200 "ok" err=ERR_HTTP_HEADERS_SENT
express5.2.1 E4 async throw: 500 "handled:boom"
express5.2.1 E5 no next: A | 401 "no"
koa E1 asyncH=true: A> B> H> <H <B <A
koa E2 next x2: A B H | err=next() called multiple times
koa E3 status after next: status=201 body=ok
koa E4 async throw: 500 handled:boom
koa E6 next without await: A A-after(no await) | body=undefined
express5.2.1 E2b next x2 + async B: A B> C H B-next | 200 ok