Factory Helper

import { createFactory, createMiddleware } from 'hono/factory'
import { Factory } from 'hono/factory'

function createFactory<E extends Env = Env, P extends string = string>(init?: {
  initApp?: InitApp<E>
  defaultAppOptions?: HonoOptions<E>
}): Factory<E, P>

import { createFactory } from 'hono/factory'

// Create a factory with environment types
type Env = {
  Bindings: {
    DB: Database
    API_KEY: string
  }
  Variables: {
    user: User
  }
}

const factory = createFactory<Env>()

function createMiddleware<
  E extends Env = any,
  P extends string = string,
  I extends Input = {},
  R extends HandlerResponse<any> | void = void
>(
  middleware: MiddlewareHandler<E, P, I, R extends void ? Response : R>
): MiddlewareHandler<E, P, I, R extends void ? Response : R>

import { createMiddleware } from 'hono/factory'

const logger = createMiddleware(async (c, next) => {
  console.log(`[${c.req.method}] ${c.req.url}`)
  await next()
})

app.use(logger)

factory.createApp(options?: HonoOptions<E>): Hono<E>

const factory = createFactory<Env>({
  initApp: (app) => {
    // Initialize all apps with common middleware
    app.use('*', logger())
  },
  defaultAppOptions: {
    strict: false
  }
})

const app = factory.createApp()
const apiApp = factory.createApp({ strict: true })

factory.createMiddleware<I extends Input = {}, R extends HandlerResponse<any> | void = void>(
  middleware: MiddlewareHandler<E, P, I, R extends void ? Response : R>
): MiddlewareHandler<E, P, I, R extends void ? Response : R>

type Env = {
  Bindings: {
    DB: Database
  }
  Variables: {
    user: User
  }
}

const factory = createFactory<Env>()

const authMiddleware = factory.createMiddleware(async (c, next) => {
  const token = c.req.header('Authorization')
  
  if (!token) {
    return c.text('Unauthorized', 401)
  }
  
  const user = await verifyToken(token, c.env.DB)
  c.set('user', user) // Type-safe: user must match Env.Variables.user
  
  await next()
})

app.use(authMiddleware)

factory.createHandlers(...handlers: H[]): H[]

const factory = createFactory<Env>()

const handlers = factory.createHandlers(
  // Middleware
  async (c, next) => {
    console.log('Before')
    await next()
    console.log('After')
  },
  // Handler
  (c) => {
    const user = c.get('user') // Type-safe
    return c.json({ user })
  }
)

app.get('/profile', ...handlers)

import { createFactory } from 'hono/factory'
import type { User, Database } from './types'

type Env = {
  Bindings: {
    DB: Database
  }
  Variables: {
    user: User
  }
}

const factory = createFactory<Env>()

// Create middleware
const authMiddleware = factory.createMiddleware(async (c, next) => {
  const user = await authenticate(c.req.header('Authorization'))
  c.set('user', user)
  await next()
})

// Create handlers
const getUser = factory.createHandlers(
  authMiddleware,
  (c) => {
    const user = c.get('user')
    return c.json(user)
  }
)

const app = factory.createApp()
app.get('/user', ...getUser)

import { createFactory } from 'hono/factory'

type Env = {
  Variables: {
    requestId: string
  }
}

const factory = createFactory<Env>()

// Create a reusable middleware generator
function createRequestId() {
  return factory.createMiddleware(async (c, next) => {
    c.set('requestId', crypto.randomUUID())
    await next()
  })
}

const app = factory.createApp()
app.use('*', createRequestId())

app.get('/', (c) => {
  const requestId = c.get('requestId') // Type-safe
  return c.json({ requestId })
})

// factories/app.ts
import { createFactory } from 'hono/factory'
import { logger } from 'hono/logger'

export type AppEnv = {
  Bindings: {
    DB: Database
  }
  Variables: {
    user: User | null
  }
}

export const factory = createFactory<AppEnv>({
  initApp: (app) => {
    app.use('*', logger())
  }
})

// middleware/auth.ts
import { factory } from '../factories/app'

export const authMiddleware = factory.createMiddleware(async (c, next) => {
  const user = await getUser(c.req.header('Authorization'))
  c.set('user', user)
  await next()
})

// routes/users.ts
import { factory } from '../factories/app'
import { authMiddleware } from '../middleware/auth'

const userHandlers = factory.createHandlers(
  authMiddleware,
  (c) => {
    const user = c.get('user')
    return c.json({ user })
  }
)

export const userRoutes = factory.createApp()
userRoutes.get('/', ...userHandlers)

// app.ts
import { factory } from './factories/app'
import { userRoutes } from './routes/users'

const app = factory.createApp()
app.route('/users', userRoutes)

import { createFactory } from 'hono/factory'
import { zValidator } from '@hono/zod-validator'
import { z } from 'zod'

const factory = createFactory()

const schema = z.object({
  name: z.string(),
  age: z.number()
})

const handlers = factory.createHandlers(
  zValidator('json', schema),
  (c) => {
    const data = c.req.valid('json') // Type is inferred
    return c.json({ message: `Hello ${data.name}` })
  }
)

app.post('/create', ...handlers)

const factory = createFactory<Env>()

// All created components have access to Env types
const middleware = factory.createMiddleware(async (c, next) => {
  c.env.DB // ✓ Type-safe
  c.get('user') // ✓ Type-safe
  await next()
})

function createAuthMiddleware(requiredRole: string) {
  return factory.createMiddleware(async (c, next) => {
    const user = c.get('user')
    if (user.role !== requiredRole) {
      return c.text('Forbidden', 403)
    }
    await next()
  })
}

app.get('/admin', createAuthMiddleware('admin'), (c) => {
  return c.text('Admin panel')
})

const factory = createFactory<Env>({
  initApp: (app) => {
    app.use('*', logger())
    app.use('*', cors())
  }
})

// All apps automatically have logger and cors
const app1 = factory.createApp()
const app2 = factory.createApp()