ZnightCompile-time dependency injection for TypeScript

Write plain classes. Get a compiled container. ​

You write services and controllers with familiar decorators. At build time, the compiler turns them into a plain module: every provider, its dependencies, its scope and the order to create them in.

import { Injectable } from '@znight/core'
import { UserRepository } from './user.repository.js'

@Injectable()
export class UserService {
  constructor(private readonly users: UserRepository) {}

  findById(id: number) {
    return this.users.findById(id)
  }
}

import { Controller, Get, Param } from '@znight/http'
import { UserService } from './user.service.js'

@Controller('/users')
export class UserController {
  constructor(private readonly users: UserService) {}

  @Get('/:id')
  getUser(@Param('id') id: number) {
    return this.users.findById(id)
  }
}

import { Application } from '@znight/core'
import { HttpPlugin } from '@znight/http'
import { __ZNIGHT_METADATA__ } from './.znight/container.generated.js'

const app = await Application.create({
  metadata: __ZNIGHT_METADATA__,
  plugins: [HttpPlugin.configure({ port: 3000 })],
})
await app.start()

// AUTO-GENERATED by @znight/compiler. Do not edit.
export const __ZNIGHT_METADATA__: ZnightMetadata = {
  version: 1,
  providers: {
    ['src/users/pg-user.repository.ts#PgUserRepository']: {
      scope: 'singleton',
      class: PgUserRepository,
      deps: ['src/db/db.factory.ts#DbFactory.createPool'],
      factory: d => new PgUserRepository(d[0]),
    },
    ['src/users/user.service.ts#UserService']: {
      scope: 'singleton',
      class: UserService,
      deps: ['src/users/pg-user.repository.ts#PgUserRepository'],
      factory: d => new UserService(d[0]),
    },
    // ...
  },
  resolutionOrder: [
    'src/db/db.factory.ts#DbFactory',
    'src/db/db.factory.ts#DbFactory.createPool',
    'src/users/pg-user.repository.ts#PgUserRepository',
    'src/users/user.service.ts#UserService',
    'src/users/user.controller.ts#UserController',
  ],
  aliases: { ['src/users/user.repository.ts#UserRepository']: 'src/users/pg-user.repository.ts#PgUserRepository' },
}

UserRepository is an interface: the compiler found its only implementation, PgUserRepository, and bound it. Nothing is looked up by name or reflected at runtime.

Why Znight ​

Runtime DI containers (NestJS, InversifyJS, tsyringe...) discover your dependency graph while the application boots, using reflect-metadata and decorator side effects. Znight does that work once, in the compiler.

Read the full comparison →

Mistakes surface while you build ​

$ vite build

✗ ZNIGHT001: Missing provider for 'EmailService' required by NotificationService
  --> src/notification/notification.service.ts:12:29
   |
12 |     private readonly email: EmailService,
   |                             ^^^^^^^^^^^^
   = hint: EmailService (src/email/email.service.ts:3) is not a provider: add @Injectable()

Build failed with 1 error

Every diagnostic has a stable code documented in the error reference, with an example and the usual fixes.

Your database, your library ​

Znight wires your data layer; it does not replace it. A @Factory() opens the client at boot (async, awaited before the first request), closes it on shutdown, and repositories behind interfaces keep services testable with mocks. Use the library that fits your data: for SQL, we recommend Drizzle. Read the data access guide →

Learn from complete applications ​

The repository ships seven production-shaped example applications, each with unit, application and end-to-end tests on Node.js and Bun:

• rest-api: the reference HTTP service, Drizzle on PostgreSQL, API keys, file uploads;
• secure-api: JWT, API keys, cookie sessions, CSRF, rate limiting and webhooks, the source of the Security guide;
• storefront-api: an OpenAPI document generated from the code and a typed client;
• uptime-monitor: scheduled and dynamic jobs, one runner across instances, live results over Server-Sent Events;
• microservice, worker and monorepo: messaging, retries and dead letters, background workers, provider libraries shared between services.