fix(types): Calculate Context<Env> type for each handler

[sushichan044]

closes #3587

This PR makes all Context<Env> in handlers respect type changes made by previous handlers.

The author should do the following, if applicable

• Add tests
• Run tests
• bun run format:fix && bun run lint:fix to format the code
• Add TSDoc/JSDoc to document the code

[codecov]

Codecov Report

All modified and coverable lines are covered by tests ✅

Project coverage is 91.31%. Comparing base (ac4d42c) to head (cfd71e3).
Report is 1 commits behind head on main.

Additional details and impacted files

@@           Coverage Diff           @@
##             main    #3675   +/-   ##
=======================================
  Coverage   91.31%   91.31%           
=======================================
  Files         161      161           
  Lines       10240    10240           
  Branches     2999     2998    -1     
=======================================
  Hits         9351     9351           
  Misses        888      888           
  Partials        1        1           

☔ View full report in Codecov by Sentry.
📢 Have feedback on the report? Share it here.

[sushichan044]

I used the following code to investigate how much type calculation costs vary.
( Method is the same as ci / perf-measures-type-check )

import { Hono } from '../../../src'
import { createMiddleware } from '../../../src/helper/factory'

const mw1 = createMiddleware<{ Variables: { foo: string } }>(async (c, next) => {
  c.set('foo', 'bar')
  await next()
})

const mw2 = createMiddleware<{ Variables: { bar: string } }>(async (c, next) => {
  c.set('bar', 'baz')
  await next()
})

const mw3 = createMiddleware<{ Variables: { baz: string } }>(async (c, next) => {
  c.set('baz', 'qux')
  await next()
})

const mw4 = createMiddleware<{ Variables: { qux: string } }>(async (c, next) => {
  c.set('qux', 'quux')
  await next()
})

const mw5 = createMiddleware<{ Variables: { quux: string } }>(async (c, next) => {
  c.set('quux', 'corge')
  await next()
})

const mw6 = createMiddleware<{ Variables: { corge: string } }>(async (c, next) => {
  c.set('corge', 'grault')
  await next()
})

const mw7 = createMiddleware<{ Variables: { grault: string } }>(async (c, next) => {
  c.set('grault', 'garply')
  await next()
})

const mw8 = createMiddleware<{ Variables: { garply: string } }>(async (c, next) => {
  c.set('garply', 'waldo')
  await next()
})

export const app = new Hono().get(
  '/route1',
  mw1,
  mw2,
  mw3,
  mw4,
  mw5,
  mw6,
  mw7,
  mw8,
  // Context<Env> at this 'c' is combined from all middlewares
  async (c, next) => {
    await next()
  },
  (c) => {
    const foo = c.get('foo')
    return c.json({ foo })
  }
)

[sushichan044]

The result is as follows.
I think this is an acceptable increase in type calculation cost.

		 Before      After
Files:              257        257
Lines:           114406     114406
Identifiers:     112267     113315
Symbols:         206710     274767
Types:           125123     135373
Instantiations:  492334     548281
Memory used:    271995K    317189K
I/O read:         0.02s      0.02s
I/O write:        0.00s      0.00s
Parse time:       0.49s      0.49s
Bind time:        0.18s      0.19s
Check time:       2.31s      2.52s
Emit time:        0.00s      0.00s
Total time:       2.98s      3.19s

[yusukebe]

@sushichan044 Thank you for handling it.

Exactly. I also thought the decrease in performance would possibly be a pain point.

I think this is an acceptable increase in type calculation cost.

@m-shaka What do you think of it?

[yusukebe]

@sushichan044

I haven't merged yet because I'm concerned about performance. TypeScript performance is critical to DX, so I am considering whether or not to allow performance degradation due to this change.

[sushichan044]

@yusukebe

Yes, the experience gained, and performance degraded by this PR should be discussed in depth.

[yusukebe]

Hi @sushichan044

I've considered it. In my current opinion, we can merge this. It introduces a performance decrease for type inferences, but it is also important that the type inference works as expected correctly. Fortunately, the tiny changes #3836 and #3837 can improve the TypeScript performance. So, first, merge this PR and improve the types with some techniques (though I don't know if we have room for improvement). Are you okay?

[sushichan044]

Hello @yusukebe
That sounds good!

[yusukebe]

LGTM!

[yusukebe]

@sushichan044 Thanks!

I'll merge this now.