fix(factory): revert PR #3498 (#3515)

src/helper/factory/index.test.ts

@@ -37,35 +37,31 @@ describe('createMiddleware', () => {
     expect(url.pathname).toBe('/message')
   })
 
-  describe('Relax types for Bindings and Variables', () => {
-    it('Should not throw a type error', () => {
+  it('Should pass generics types to chained handlers', () => {
     type Bindings = {
       MY_VAR_IN_BINDINGS: string
     }
 
-      const app = new Hono<{ Bindings: Bindings }>()
-
     type Variables = {
       MY_VAR: string
     }
 
-      const middleware = (_variable: string) =>
-        createMiddleware<{ Variables: Variables }>(async (c, next) => {
-          await next()
-        })
+    const app = new Hono<{ Bindings: Bindings }>()
 
     app.get(
       '/',
-        createMiddleware<{ Bindings: Bindings }>(async (c, next) => {
-          const mw = middleware(c.env.MY_VAR_IN_BINDINGS)
-          await mw(c, next) // `c` does not throw an error
+      createMiddleware<{ Variables: Variables }>(async (c, next) => {
+        await next()
       }),
-        (c) => {
-          return c.json({})
+      createMiddleware(async (c, next) => {
+        await next()
+      }),
+      async (c) => {
+        const v = c.get('MY_VAR')
+        expectTypeOf(v).toEqualTypeOf<string>()
       }
     )
   })
-  })
 })
 
 describe('createHandler', () => {

src/helper/factory/index.ts

@@ -6,7 +6,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { Hono } from '../../hono'
 import type { Env, H, HandlerResponse, Input, MiddlewareHandler } from '../../types'
-import type { Simplify } from '../../utils/types'
 
 type InitApp<E extends Env = Env> = (app: Hono<E>) => void
 
@@ -238,20 +237,10 @@ export const createFactory = <E extends Env = any, P extends string = any>(init?
   initApp?: InitApp<E>
 }): Factory<E, P> => new Factory<E, P>(init)
 
-// Add `any` if it's undefined to relax types
-// { Variables: Variables } => { Bindings: any, Variables: any }
-// { Bindings: Bindings } => { Bindings: Bindings, Variables: any }
-
-type AddAnyToEnv<T extends { Variables?: object; Bindings?: object }> = {
-  Bindings: undefined extends T['Bindings'] ? any : T['Bindings']
-  Variables: undefined extends T['Variables'] ? any : T['Variables']
-}
-
 export const createMiddleware = <
   E extends Env = any,
   P extends string = string,
-  I extends Input = {},
-  E2 extends Env = Simplify<AddAnyToEnv<E>>
+  I extends Input = {}
 >(
-  middleware: MiddlewareHandler<E2, P, I>
-): MiddlewareHandler<E2, P, I> => createFactory<E2, P>().createMiddleware<I>(middleware)
+  middleware: MiddlewareHandler<E, P, I>
+): MiddlewareHandler<E, P, I> => createFactory<E, P>().createMiddleware<I>(middleware)