{
  "compilerOptions": {
    "paths": {
      "@nestia/core": ["./source/core/src"],
      "@nestia/fetcher": ["./source/fetcher/src"],
      "@nestia/sdk": ["./source/sdk/src"]
    },
    "plugins": [{ "transform": "./source/core/src/transform.ts" }]
  }
}

2. Patch TypeScript so the transform plugin runs at compile time:

npx ts-patch install

3. Add a nestia.config.ts at project root for SDK/Swagger generation:

import { INestiaConfig } from "@nestia/sdk";

const config: INestiaConfig = {
  input: ["src/controllers"],
  swagger: {
    output: "dist/swagger.json",
    servers: [{ url: "http://localhost:3000" }],
  },
  output: "src/api",
};
export default config;

4. Run setup wizard to configure plugins interactively:

npx nestia setup

5. Generate SDK and Swagger from controllers:

npx nestia all

Public API

TypedBody

import { TypedBody } from "@nestia/core";

// Used as a parameter decorator in a NestJS controller method
@Post("/")
async create(@TypedBody() body: CreateUserDto): Promise<UserDto> { ... }

Replaces @Body() with a compile-time validated, runtime-checked body parser. Validation logic is injected by the TypeScript transformer; no class-validator decorators are needed on DTOs.

TypedRoute

import { TypedRoute } from "@nestia/core";

@TypedRoute.Get("/users/:id")
async getUser(@TypedParam("id") id: string): Promise<UserDto> { ... }

Wraps NestJS route decorators (Get, Post, Put, Patch, Delete) and adds compile-time JSON serialization using typia. Serialization is ~200x faster than class-transformer.

PlainFetcher

import { PlainFetcher } from "@nestia/fetcher";
import { IConnection } from "@nestia/fetcher";

const connection: IConnection = { host: "http://localhost:3000" };
const result = await PlainFetcher.fetch(connection, {
  method: "GET",
  path: "/users/1",
  status: 200,
  request: null,
  response: { type: "application/json" },
}, undefined);

The plain (unencrypted) HTTP client used by generated SDK functions. Use this directly when you want a typed fetch call without the generated SDK layer, or when writing manual integration tests.

EncryptedFetcher

import { EncryptedFetcher } from "@nestia/fetcher";
import { IEncryptionPassword } from "@nestia/fetcher";

const password: IEncryptionPassword = { key: "...", iv: "..." };

Handles AES-PKCS5 encrypted request/response bodies. Pair with @EncryptedBody() and @EncryptedRoute on the server side.

HttpError

import { HttpError } from "@nestia/fetcher";

try {
  await PlainFetcher.fetch(connection, route, body);
} catch (err) {
  if (err instanceof HttpError) {
    console.log(err.status, err.message);
  }
}

Thrown by fetcher utilities when the server responds with a non-2xx status. Contains status, method, path, and message fields.

Working examples

Scenario - Basic typed controller with SDK generation

Define a NestJS controller using @nestia/core decorators, then generate a type-safe SDK for frontend consumers.

// src/controllers/UserController.ts
import { TypedBody, TypedParam, TypedRoute } from "@nestia/core";
import { Controller } from "@nestjs/common";

interface CreateUserDto { name: string; email: string; }
interface UserDto { id: number; name: string; email: string; }

@Controller("users")
export class UserController {
  @TypedRoute.Post("/")
  async create(@TypedBody() body: CreateUserDto): Promise<UserDto> {
    return { id: 1, ...body };
  }

  @TypedRoute.Get("/:id")
  async findOne(@TypedParam("id") id: string): Promise<UserDto> {
    return { id: Number(id), name: "Alice", email: "alice@example.com" };
  }
}

npx nestia sdk   # generates src/api/
npx nestia swagger  # generates dist/swagger.json

Scenario - Client consuming a generated SDK

Use the generated SDK (or PlainFetcher directly) on the frontend or in E2E tests.

import { IConnection } from "@nestia/fetcher";
import { PlainFetcher } from "@nestia/fetcher";

const connection: IConnection = {
  host: "http://localhost:3000",
  headers: { "Content-Type": "application/json" },
};

// Manually invoke a typed route without the generated SDK
async function getUser(id: string) {
  return PlainFetcher.fetch(
    connection,
    {
      method: "GET",
      path: `/users/${id}`,
      status: 200,
      request: null,
      response: { type: "application/json" },
    },
    undefined,
  );
}

getUser("1").then(console.log);

Scenario - Encrypted endpoint

Use EncryptedBody and EncryptedRoute for AES-encrypted transport between trusted services.

// server
import { EncryptedBody, EncryptedRoute } from "@nestia/core";
import { Controller } from "@nestjs/common";

interface SecretDto { token: string; }

@Controller("secure")
export class SecureController {
  @EncryptedRoute.Post("/")
  async receive(@EncryptedBody() body: SecretDto): Promise<{ ok: boolean }> {
    return { ok: true };
  }
}

// client
import { EncryptedFetcher } from "@nestia/fetcher";
import type { IEncryptionPassword } from "@nestia/fetcher";

const password: IEncryptionPassword = { key: "16-byte-key-here", iv: "16-byte-iv-here!" };

await EncryptedFetcher.fetch(
  { host: "http://localhost:3000" },
  password,
  { method: "POST", path: "/secure", status: 200,
    request: { type: "text/plain" }, response: { type: "text/plain" } },
  { token: "supersecret" },
);

File walkthrough

• cli/src/index.ts - Entry point for npx nestia; dispatches to NestiaStarter, NestiaTemplate, NestiaSetupWizard, or delegates to @nestia/sdk executable based on argv.
• cli/src/NestiaSetupWizard.ts - Interactive setup wizard that configures tsconfig.json, installs dependencies, and wires the compiler transform.
• cli/src/NestiaStarter.ts - Clones a starter repository into a new directory.
• cli/src/NestiaTemplate.ts - Clones a template project scaffold.
• cli/src/internal/ArgumentParser.ts - Parses CLI arguments for wizard commands.
• cli/src/internal/PackageManager.ts - Detects and invokes npm/yarn/pnpm.
• cli/src/internal/PluginConfigurator.ts - Writes transformer plugin entries into tsconfig.json.
• core/src/index.ts - Re-exports everything from module.ts; main entry for @nestia/core.
• core/src/transform.ts - TypeScript compiler transform plugin registration point.
• core/src/decorators/TypedBody.ts - @TypedBody() decorator implementation.
• core/src/decorators/TypedRoute.ts - @TypedRoute.* decorator family.
• core/src/decorators/TypedParam.ts - @TypedParam() path parameter decorator.
• core/src/decorators/TypedQuery.ts - @TypedQuery() query-string decorator.
• core/src/decorators/TypedFormData.ts - @TypedFormData.Body() multipart form decorator.
• core/src/decorators/TypedHeaders.ts - @TypedHeaders() request headers decorator.
• core/src/decorators/WebSocketRoute.ts - @WebSocketRoute() typed WebSocket endpoint decorator.
• core/src/decorators/TypedException.ts - Documents typed exception responses for Swagger.
• core/src/decorators/EncryptedBody.ts / EncryptedRoute.ts / EncryptedController.ts / EncryptedModule.ts - AES-PKCS5 encrypted transport decorators.
• core/src/adaptors/WebSocketAdaptor.ts - WebSocket server adaptor bridging NestJS and nestia typed routes.
• fetcher/src/index.ts - Exports all client-side runtime: fetchers, connection types, error class, simulator.
• editor/src/index.ts - Exports React components for the Swagger/TypeScript online editor.
• migrate/src/index.ts - Exports migration utilities for OpenAPI spec conversion.

Common pitfalls and fixes

• Transformer not running: ts-patch must be installed and npx ts-patch install run after every npm install; add it to postinstall script.
• reflect-metadata missing: Import reflect-metadata once at the very top of your application entry before any NestJS imports, or the decorator metadata will be undefined.
• ESM/CJS interop with generated SDK: The SDK output targets CJS by default; if your frontend uses ESM bundler, set "module": "ESNext" in the SDK tsconfig and verify tree-shaking works.
• @nestia/sdk not found when running CLI commands: Run npx nestia setup first; the sdk/swagger/e2e/all commands resolve @nestia/sdk at runtime and will hard-exit if it is absent.
• Type errors in DTO interfaces: Nestia uses typia for schema inference; union types containing undefined in required positions cause schema generation errors - use null or optional ? instead.
• Encryption key length: AES-PKCS5 keys must be exactly 16, 24, or 32 bytes and IVs exactly 16 bytes; passing wrong lengths throws at runtime with a cryptic OpenSSL error.

Vibe-coding prompt template

I have the Nestia monorepo source in `source/` and its integration guide in `USAGE.md`.
The upstream package is `@nestia/station@11.0.2` (packages: core, sdk, fetcher, migrate, cli, editor).

Please integrate Nestia into my existing NestJS project step by step:

1. Read `USAGE.md` and `source/core/src/index.ts` to understand available decorators.
2. Replace all `@Body()` decorators in my controllers with `@TypedBody()` from `source/core/`.
3. Replace all `@Get/@Post/@Put/@Delete` route decorators with `TypedRoute.*` equivalents.
4. Replace `@Param()` with `@TypedParam()` and `@Query()` with `@TypedQuery()`.
5. Configure `tsconfig.json` to include the transformer plugin from `source/core/src/transform.ts`.
6. Add `ts-patch` and run `npx ts-patch install` in the postinstall script.
7. Create `nestia.config.ts` pointing at my controllers directory.
8. Run `npx nestia all` to generate SDK and Swagger output.
9. Show me how to consume the generated SDK from `source/fetcher/src/index.ts` in a client file.
10. Identify any DTO types that use patterns incompatible with typia schema inference and suggest fixes.

Constraints: do not use class-validator or class-transformer; use only pure TypeScript interfaces for DTOs.

License and credit

The source is published under the MIT License (see source/cli/LICENSE, source/core/LICENSE). Upstream repository: github.com/samchon/nestia. npm package: @nestia/station.

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

完全なインストールガイドと統合プロンプトは購入後に解放されます。