// RUNTIME VALIDATORS
export function is<T>(input: unknown | T): input is T; // returns boolean
export function assert<T>(input: unknown | T): T; // throws TypeGuardError
export function validate<T>(input: unknown | T): IValidation<T>; // detailed
// STRICT VALIDATORS
export function equals<T>(input: unknown | T): input is T;
export function assertEquals<T>(input: unknown | T): T;
export function validateEquals<T>(input: unknown | T): IValidation<T>;
// JSON
export function application<T>(): IJsonApplication; // JSON schema
export function assertParse<T>(input: string): T; // type safe parser
export function assertStringify<T>(input: T): string; // safe and faster
// +) isParse, validateParse
// +) stringify, isStringify, validateStringify
typia
is a transformer library of TypeScript, supporting below features:
- Super-fast Runtime Validators
- Safe JSON parse and fast stringify functions
- JSON schema generator
All functions in typia
require only one line. You don't need any extra dedication like JSON schema definitions or decorator function calls. Just call typia
function with only one line like typia.assert<T>(input)
.
Also, as typia
performs AOT (Ahead of Time) compilation skill, its performance is much faster than other competitive libaries. For an example, when comparing validate function is()
with other competitive libraries, typia
is maximum 15,000x times faster than class-validator
.
Measured on Intel i5-1135g7, Surface Pro 8
Thanks for your support.
Your donation would encourage typia
development.
npx typia setup
Just type npx typia setup
, that's all.
Also, you can specify package manager by --manager
argument.
npx typia setup --manager npm
npx typia setup --manager pnpm
npx typia setup --manager yarn
After the setup, you can compile typia
utilization code by using ttsc
(ttypescript
) command. If you want to run your TypeScript file directly through ts-node
, add -C ttypescript
argument like below:
# COMPILE THROUGH TTYPESCRIPT
npx ttsc
# RUN TS-NODE WITH TTYPESCRIPT
npx ts-node -C ttypescript src/index.ts
If you want to install and setup typia
manually, read Guide Documents - Setup.
Also, by Guide Documents - Setup section, you can learn how to use pure TypeScript compiler tsc
with ts-patch
, instead of installing the ttypescript
compiler with ttsc
command.
When you want to setup typia
on your frontend project with vite
, just configure vite.config.ts
like below.
For reference, don't forget running Setup Wizard before.
import { defineConfig } from "vite";
import react from "@vitejs/plugin-react";
import typescript from "@rollup/plugin-typescript";
import ttsc from "ttypescript";
// https://vitejs.dev/config/
export default defineConfig({
plugins: [
react(),
typescript({
typescript: ttsc,
})
]
});
In here README documents, only summarized informations are provided.
For more details, refer to the Guide Documents (wiki).
// ALLOW SUPERFLUOUS PROPERTIES
export function is<T>(input: T | unknown): input is T; // returns boolean
export function assert<T>(input: T | unknown): T; // throws `TypeGuardError`
export function validate<T>(input: T | unknown): IValidation<T>; // detailed
// DO NOT ALLOW SUPERFLUOUS PROPERTIES
export function equals<T>(input: T | unknown): boolean;
export function assertEquals<T>(input: T | unknown): T;
export function validateEquals<T>(input: T | unknown): IValidation<T>;
// REUSABLE FACTORY FUNCTIONS
export function createIs<T>(): (input: unknown) => T;
export function createAssert<T>(): (input: unknown) => T;
export function createValidate<T>(): (input: unknown) => IValidation<T>;
export function createEquals<T>(): (input: unknown) => boolean;
export function createAssertEquals<T>(): (input: unknown) => T;
export function createValidateEquals<T>(): (input: unknown) => IValidation<T>;
typia
supports three type of validator functions:
is()
: returnsfalse
if not matched with the typeT
assert()
: throws aTypeGuardError
when not matchedvalidate()
- when matched, returns
IValidation.ISuccess<T>
withvalue
property - when not matched, returns
IValidation.IFailure
witherrors
property
- when matched, returns
Also, if you want more strict validator functions that even do not allowing superfluous properties not written in the type T
, you can use those functions instead; equals()
, assertEquals()
, validateEquals()
. Otherwise you want to create resuable validator functions, you can utilize factory functions like createIs()
instead.
When you want to add special validation logics, like limiting range of numeric values, you can do it through comment tags. If you want to know about it, visit the Guide Documents (Features > Runtime Validators > Comment Tags).
// JSON SCHEMA GENERATOR
export function application<
Types extends unknown[],
Purpose extends "swagger" | "ajv" = "swagger",
Prefix extends string = Purpose extends "swagger"
? "#/components/schemas"
: "components#/schemas",
>(): IJsonApplication;
// SAFE PARSER FUNCTIONS
export function isParse<T>(input: string): T | null;
export function assertParse<T>(input: string): T;
export function validateParse<T>(input: string): IValidation<T>;
// FASTER STRINGIFY FUNCTIONS
export function stringify<T>(input: T): string; // unsafe
export function isStringify<T>(input: T): string | null; // safe
export function assertStringify<T>(input: T): string;
export function validateStringify<T>(input: T): IValidation<string>;
// FACTORY FUNCTIONS
export function createAssertParse<T>(): (input: string) => T;
export function createAssertStringify<T>(): (input: T) => string;
// +) createIsParse, createValidateParse
// +) createStringify, createIsStringify, createValidateStringify
typia
supports enhanced JSON functions.
application()
: generate JSON schema with only one line- you can complement JSON schema contents through comment tags
assertParse()
: parse JSON string safely with type validationisStringify()
: maximum 10x faster JSON stringify fuction even type safe
Measured on AMD R7 5800H
Nestia is a helper library set for NestJS
, supporting below features:
@nestia/core
: 15,000x times faster validation decorator usingtypia
@nestia/sdk
: evolved SDK and Swagger generator for@nestia/core
nestia
: just CLI (command line interface) tool
import { Controller } from "@nestjs/common";
import { TypedBody, TypedRoute } from "@nestia/core";
import { IBbsArticle } from "@bbs-api/structures/IBbsArticle";
@Controller("bbs/articles")
export class BbsArticlesController {
/**
* Store a new content.
*
* @param inupt Content to store
* @returns Newly archived article
*/
@TypedRoute.Post() // 10x faster and safer JSON.stringify()
public async store(
// super-fast validator
@TypedBody() input: IBbsArticle.IStore
): Promise<IBbsArticle>;
}