Required dependencies

npm install @deepkit/type @deepkit/type-compiler
npm install @deepkit/app @deepkit/framework
npm install @deepkit/http @deepkit/rpc @deepkit/rpc-tcp
npm install @deepkit/orm @deepkit/sqlite   # swap sqlite for postgres/mysql/mongo as needed
npm install @deepkit/injector
npm install @deepkit/event @deepkit/logger
npm install @deepkit/broker
npm install reflect-metadata rxjs

The @deepkit/type-compiler package must be registered as a TypeScript compiler plugin. No native build steps are required for the pure-TS packages; SQLite links a native module via better-sqlite3, so a C++ build toolchain is needed when using that adapter.

Project setup

1. Copy source: place the contents of source/ alongside your project, or install the individual @deepkit/* npm packages (the source mirrors the published packages).

2. Enable the compiler plugin in tsconfig.json:

{
  "compilerOptions": {
    "plugins": [{ "transform": "@deepkit/type-compiler" }],
    "experimentalDecorators": true,
    "emitDecoratorMetadata": false,
    "strict": true
  }
}

3. For ts-node / tsx add the plugin via a tsconfig that ts-node picks up, or use ts-node --compiler @deepkit/type-compiler/ts-node.

4. For Vite import the plugin from source/vite:

import { deepkitType } from '@deepkit/vite';
export default { plugins: [deepkitType()] };

5. Environment variables — none are required by the framework itself. Adapter-specific env vars (DB connection strings) are passed directly to Database or FrameworkModule configuration objects.

Public API

App (from app/)

import { App } from '@deepkit/app';
const app = new App({ imports: [FrameworkModule] });
app.run(); // starts CLI; call app.setup() for programmatic use

Use App as the top-level container that composes modules, wires DI, and starts the server. Pass a providers array for root-level services and imports for reusable modules.

routes / provideApiConsoleRegistry (from api-console-gui/)

import { routes } from '@deepkit/api-console-gui';
import { provideApiConsoleRegistry } from '@deepkit/api-console-gui';

routes is an Angular Routes array that mounts the API console browser UI. provideApiConsoleRegistry is an Angular provider factory that registers the codec registry needed by the UI. Use these when embedding the API console into a custom Angular shell app.

Module export from api-console-module/

import { ApiConsoleModule } from '@deepkit/api-console-module';

new App({
  imports: [
    new FrameworkModule(),
    new ApiConsoleModule({ path: '/_console' }),
  ],
}).run();

ApiConsoleModule activates the interactive HTTP/RPC console at the configured path. Drop it into any Deepkit App import list to expose introspectable endpoints in development.

Working examples

Scenario - Minimal HTTP server with runtime validation

A single class drives route parameter validation and response serialization without any external schema library.

import { App } from '@deepkit/app';
import { FrameworkModule } from '@deepkit/framework';
import { http, HttpBody } from '@deepkit/http';
import { MinLength, Positive } from '@deepkit/type';

class CreateUserDto {
  username!: string & MinLength<3>;
  age!: number & Positive;
}

class UserController {
  @http.POST('/users')
  create(body: HttpBody<CreateUserDto>) {
    // body is already validated and typed
    return { id: 1, ...body };
  }
}

new App({
  controllers: [UserController],
  imports: [new FrameworkModule({ debug: true })],
}).run();

Scenario - Type-safe RPC over WebSocket

Define a controller once; the same TypeScript interface governs the client call signature and server implementation.

// server.ts
import { App } from '@deepkit/app';
import { FrameworkModule } from '@deepkit/framework';
import { rpc } from '@deepkit/rpc';

@rpc.controller('math')
class MathController {
  @rpc.action()
  add(a: number, b: number): number {
    return a + b;
  }
}

new App({
  controllers: [MathController],
  imports: [new FrameworkModule()],
}).run();

// client.ts
import { RpcWebSocketClient } from '@deepkit/rpc';
import type { MathController } from './server';

const client = new RpcWebSocketClient('ws://localhost:8080');
const math = client.controller<MathController>('math');
const result = await math.add(3, 4); // result: 7
client.disconnect();

Scenario - Embedding the API console GUI in an Angular app

Wire the pre-built API console routes into an existing Angular application shell.

// app.config.ts
import { ApplicationConfig } from '@angular/core';
import { provideRouter, withHashLocation } from '@angular/router';
import { provideRpcWebSocketClient } from '@deepkit/rpc';
import { routes as consoleRoutes, provideApiConsoleRegistry } from '@deepkit/api-console-gui';

export const appConfig: ApplicationConfig = {
  providers: [
    provideApiConsoleRegistry(),
    provideRouter(
      [{ path: 'console', children: consoleRoutes }],
      withHashLocation()
    ),
    provideRpcWebSocketClient(undefined, { 4200: 8080 }),
  ],
};

File walkthrough

• angular-ssr/ - Re-exports ./src/angular.ts; provides the Angular SSR integration point for Deepkit's HTTP server.
• api-console-api/ - Re-exports ./src/api.ts; defines the RPC controller interface and DTOs that both the module and GUI share.
• api-console-gui/ - Re-exports routes and provideApiConsoleRegistry from its Angular app; bootstrapped via src/main.ts for standalone deployment.
• api-console-module/ - Re-exports ./src/module.ts; the installable Deepkit module that serves the console and registers the debug RPC controller.
• app/ - Entry point for application bootstrapping; contains App, AppModule, and CLI machinery.
• broker/ - Message broker implementation; exports channel, key-value, and lock primitives.
• broker-redis/ - Redis-backed transport for the broker.
• bson/ - BSON codec driven by runtime types; used internally by the MongoDB adapter.
• core/ - Utility belt: ClassType, empty, asyncOperation, custom error types, and more.
• core-rxjs/ - RxJS Subject/Observable bridge utilities for Deepkit services.
• event/ - EventDispatcher, EventToken, and async event listener registration.
• framework/ - FrameworkModule; composes all subsystems and exposes server lifecycle hooks.
• http/ - HttpRouter, @http decorator set, middleware, guards, and body parsing.
• injector/ - InjectorContext, InjectorModule, provider resolution without decorators.
• logger/ - Logger, ScopedLogger, and transport interfaces.
• orm/ - Database, Query, Session, entity change tracking, and migration engine.
• rpc/ - RpcServer, RpcClient, @rpc decorators, kernel, and transport abstraction.
• type/ - cast, validate, serialize, deserialize, typeOf, and reflection API.
• type-compiler/ - TypeScript transformer that embeds ReflectionOp bytecode into compiled output.
• workflow/ - WorkflowDefinition, state transitions, and event-driven FSM execution.

Common pitfalls and fixes

• Types not reflected at runtime - The @deepkit/type-compiler plugin must be active during compilation; verify tsconfig.json plugins or use the ts-node integration, otherwise typeOf() and cast() silently return incomplete metadata.
• ESM/CJS interop errors - Deepkit packages ship dual ESM/CJS; if bundlers resolve the wrong format set "moduleResolution": "bundler" or "node16" in tsconfig.json and ensure your bundler honors exports in package.json.
• experimentalDecorators conflicts with the type compiler - Set experimentalDecorators: true but emitDecoratorMetadata: false; Deepkit replaces the built-in metadata emission entirely.
• reflect-metadata not imported - Import reflect-metadata once at your application entry point before any Deepkit code if using legacy decorator APIs.
• SQLite native build failures - better-sqlite3 requires node-gyp; install python3 and a C++ toolchain (build-essential on Linux, Xcode CLT on macOS) before running npm install.
• RPC WebSocket port mismatch in dev - The default provideRpcWebSocketClient(undefined, { 4200: 8080 }) port map only applies when the Angular dev server runs on 4200; adjust the map when using a different dev port.

Vibe-coding prompt template

I have the Deepkit Framework source in the `source/` directory and a usage
guide at `USAGE.md`. The upstream package is `deepkit-framework` from
https://github.com/deepkit/deepkit-framework.

My project is a Node.js TypeScript backend (describe your project here).

Please help me integrate Deepkit step by step:

1. Read `USAGE.md` fully before writing any code.
2. Configure `tsconfig.json` to enable `@deepkit/type-compiler` as a plugin.
3. Create a minimal `App` using `@deepkit/app` and `@deepkit/framework` that
   starts an HTTP server.
4. Add at least one HTTP controller that uses runtime type validation via
   `HttpBody<T>` from `@deepkit/http`.
5. Add an RPC controller using `@deepkit/rpc` and show how a client connects.
6. If I need a database, wire up `@deepkit/orm` with the adapter I specify.
7. Show me how to enable the API console via `api-console-module/`.
8. Point out any pitfalls from `USAGE.md` that apply to my setup.

Do not invent APIs. Only use exports visible in `USAGE.md` and the source files
under `source/`.

License and credit

Deepkit Framework is released under the MIT License. See source/*/package.json or the repository root LICENSE file for the full text. Upstream source: https://github.com/deepkit/deepkit-framework, published on npm as the @deepkit/* family of packages.

This product’s unique contribution is clean room implementation of valuable code block into AVCP compatible standard.

The full install guide and integration prompts unlock after purchase.