> ## Documentation Index
> Fetch the complete documentation index at: https://mintlify.com/honojs/hono/llms.txt
> Use this file to discover all available pages before exploring further.

# Factory Helper

> Type-safe factory for creating apps, middleware, and handlers

The Factory Helper provides utilities for creating type-safe Hono applications, middleware, and handlers with proper type inference.

## Import

```typescript theme={null}
import { createFactory, createMiddleware } from 'hono/factory'
import { Factory } from 'hono/factory'
```

## Functions

### createFactory()

Creates a factory instance for creating type-safe Hono components.

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

<ParamField path="init.initApp" type="(app: Hono<E>) => void">
  Optional function to initialize new app instances
</ParamField>

<ParamField path="init.defaultAppOptions" type="HonoOptions<E>">
  Default options for created apps
</ParamField>

<ResponseField name="return" type="Factory<E, P>">
  A factory instance with methods for creating apps, middleware, and handlers
</ResponseField>

**Example**

```typescript theme={null}
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>()
```

### createMiddleware()

Creates type-safe middleware without needing a factory instance.

```typescript theme={null}
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>
```

<ParamField path="middleware" type="MiddlewareHandler" required>
  The middleware handler function
</ParamField>

<ResponseField name="return" type="MiddlewareHandler">
  The same middleware with proper type inference
</ResponseField>

**Example**

```typescript theme={null}
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 Methods

### factory.createApp()

Creates a new Hono application instance.

```typescript theme={null}
factory.createApp(options?: HonoOptions<E>): Hono<E>
```

<ParamField path="options" type="HonoOptions<E>">
  Options for the Hono app (merged with default options)
</ParamField>

<ResponseField name="return" type="Hono<E>">
  A new Hono application instance
</ResponseField>

**Example**

```typescript theme={null}
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()

Creates type-safe middleware with the factory's environment types.

```typescript theme={null}
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>
```

<ParamField path="middleware" type="MiddlewareHandler" required>
  The middleware handler function
</ParamField>

<ResponseField name="return" type="MiddlewareHandler">
  Type-safe middleware
</ResponseField>

**Example**

```typescript theme={null}
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()

Creates an array of type-safe handlers.

```typescript theme={null}
factory.createHandlers(...handlers: H[]): H[]
```

<ParamField path="handlers" type="H[]" required>
  Variable number of handler functions
</ParamField>

<ResponseField name="return" type="H[]">
  Array of handlers with proper type inference
</ResponseField>

**Example**

```typescript theme={null}
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)
```

## Examples

### Basic Factory Usage

```typescript theme={null}
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)
```

### Reusable Middleware Factory

```typescript theme={null}
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 })
})
```

### Modular App Structure

```typescript theme={null}
// 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)
```

### Typed Input Validation

```typescript theme={null}
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)
```

## Benefits

### Type Safety

The factory ensures all components share the same environment types:

```typescript theme={null}
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()
})
```

### Reusability

Create reusable middleware and handlers:

```typescript theme={null}
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')
})
```

### Consistent Setup

Initialize all apps with common configuration:

```typescript theme={null}
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()
```