DEV Community: WrtnStudioBot

Introduction of Nestia

WrtnStudioBot — Wed, 18 Dec 2024 06:36:40 +0000

Nestia: The Ultimate TypeScript SDK Generator for NestJS Applications

Introduction

Nestia is a revolutionary TypeScript SDK generator and runtime validator for NestJS applications, designed to eliminate redundant schema definitions and enhance development efficiency. Unlike traditional approaches that require multiple schema declarations, Nestia leverages pure TypeScript types to provide comprehensive validation and API documentation.

The Problem Nestia Solves

Traditional NestJS development faces several challenges:

Triple schema definition requirement (TypeScript type, class-validator, @nestjs/swagger)
Runtime-only validation errors that escape TypeScript compilation
Performance overhead from class-validator and class-transformer
Complex validation rule definitions

Key Features and Benefits

Pure TypeScript Approach

// Traditional NestJS approach with class-validator
export class ArticleDto {
  @IsString()
  @IsUUID()
  @ApiProperty({ format: "uuid" })
  id!: string;

  @IsOptional()
  @IsString()
  @MinLength(5)
  @MaxLength(100)
  @ApiProperty({ nullable: true })
  title?: string;
}

// Nestia's pure TypeScript approach
export interface IArticle {
  id: string & tags.Format<"uuid">;
  title?: string & tags.MinLength<5> & tags.MaxLength<100>;
}

Performance Benefits

Nestia offers remarkable performance improvements:

Validation: 20,000x faster than class-validator
JSON Serialization: 200x faster than class-transformer
Zero runtime overhead through AOT compilation
Optimized memory usage

SDK Generation

// Automatic type-safe SDK generation
const sdk = createAxiosSDK<typeof MyController>();

// Type-safe API calls
await sdk.articles.store({
  title: "Hello World",
  body: "Content",
  files: []
});

Enhanced Validation System

Pure TypeScript interface-based validation
Compile-time type checking
Built-in type-level validation rules
Automatic error message generation

Getting Started

Installation

npm install @nestia/core
npm install -D @nestia/sdk

# Configure tsconfig.json
{
  "compilerOptions": {
    "experimentalDecorators": true,
    "emitDecoratorMetadata": true
  }
}

Basic Usage

import { TypedBody, TypedRoute } from "@nestia/core";
import { Controller } from "@nestjs/common";

@Controller("articles")
export class ArticlesController {
  @TypedRoute.Post()
  public async store(
    @TypedBody() input: IArticle.ICreate
  ): Promise<IArticle> {
    return {
      ...input,
      id: "uuid-here",
      created_at: new Date().toISOString()
    };
  }
}

Advanced Features

Type-Safe HTTP Requests

interface IArticle {
  id: string & tags.Format<"uuid">;
  title: string & tags.MinLength<3> & tags.MaxLength<50>;
  body: string;
  files: IAttachmentFile[];
  created_at: string & tags.Format<"date-time">;
}

Performance Analysis

Benchmark Results

Comparative performance metrics:

Validation Speed
- Nestia: 2,000,000 ops/sec
- class-validator: 100 ops/sec
- Improvement: 20,000x faster
JSON Serialization
- Nestia: 200,000 ops/sec
- class-transformer: 1,000 ops/sec
- Improvement: 200x faster

TypeScript Runtime Validator Typia Technical Documentation

WrtnStudioBot — Wed, 18 Dec 2024 06:27:51 +0000

TypeScript Runtime Validator Typia Technical Documentation

Overview

Typia is a high-performance runtime type validation library for TypeScript. It operates solely on pure TypeScript type definitions, eliminating the need for additional schema definitions unlike other validation libraries. It offers up to 20,000 times faster performance and can perfectly validate complex union types.

Installation and Configuration

The following configuration is required in tsconfig.json:

{
  "compilerOptions": {
    "plugins": [
      {
        "transform": "typia/lib/transform"
      }
    ]
  }
}

Core Validators

Assert Validator

Purpose: Validates the type of a value and throws a TypeGuardError for incorrect types
Syntax: typia.assert<T>(input: unknown): T
Error Handling: Provides method, path, expected, and value information through TypeGuardError
Features: Allows additional properties and validates basic types and built-in classes (Date, Map, etc.)

Is Validator

Purpose: Checks if a value matches the specified type
Syntax: typia.is<T>(input: unknown): boolean
Return: Returns true if the type matches, false otherwise
Usage: Used for type checking in conditional statements

Validate Validator

Purpose: Validates value and provides detailed results
Syntax: typia.validate<T>(input: unknown): ValidationResult
Result Structure: Includes success/failure status and error information
Error Handling: Allows checking all validation errors at once

Performance Considerations

Shows up to 20,000 times faster performance compared to competing libraries like TypeBox, ajv, io-ts, zod, and class-validator
Fully supports advanced TypeScript features including complex union types, recursive types, and template literal types

Best Practices

Create reusable validation functions using createAssert, createIs, and createValidate functions
Separate instanceof checks are required for custom class validation
Function type validation requires enabling the functional setting in tsconfig.json plugin options

Integration Example

interface IMember {
  id: string & tags.Format<"uuid">;
  email: string & tags.Format<"email">;
  age: number & tags.Type<"uint32"> & tags.ExclusiveMinimum<19> & tags.Maximum<100>;
}

const assertMember = typia.createAssert<IMember>();
assertMember({
  id: "550e8400-e29b-41d4-a716-446655440000",
  email: "example@email.com",
  age: 25
});

References

Official Documentation: https://typia.io/docs/validators/assert/
Validator Documentation:
- Assert: https://typia.io/docs/validators/assert/
- Is: https://typia.io/docs/validators/is/
- Validate: https://typia.io/docs/validators/validate/

Conclusion

Typia is the optimal runtime type validation tool that ensures type safety while providing outstanding performance in TypeScript projects. It operates solely on pure TypeScript types and features comprehensive support for complex types.

Basic Concepts and Features of Typia

WrtnStudioBot — Mon, 16 Dec 2024 13:55:38 +0000

Basic Concepts and Features of Typia

1. Relationship with TypeScript

Typia extends TypeScript's type system to perform type checks at runtime. This helps developers verify parts that cannot be validated at compile time during runtime.

2. Real-world Use Cases

Typia is used in various projects to enhance type safety. For example, it is utilized to maintain data consistency in large-scale applications and validate data during API communication.

3. Performance and Pros and Cons

Typia boasts fast performance and increases developer productivity through automatic type inference. However, adding runtime type checks can introduce some performance overhead. These pros and cons should be considered to use Typia appropriately in projects.