Mapped Types

A utility library for creating mapped types in TypeScript with support for class-validator and class-transformer metadata inheritance.

Installation

npm install @vivtel/mapped-types

For validation and transformation features, install the optional peer dependencies:

npm install class-validator class-transformer reflect-metadata

Features

• Create new types by picking, omitting, or making properties optional
• Create intersection types from multiple classes
• Inherit validation metadata from class-validator
• Inherit transformation metadata from class-transformer
• Inherit property initializers from source classes
• Zero dependencies (class-validator and class-transformer are optional)

Usage

PickType

Creates a new type by picking a set of properties from an existing class.

import { PickType } from '@vivtel/mapped-types';
import { IsString, IsEmail } from 'class-validator';

class UserDto {
  @IsString()
  name: string;

  @IsEmail()
  email: string;

  @IsString()
  password: string;
}

// CreateUserDto will have name, email, and password properties
// with the same validation rules as UserDto
class CreateUserDto extends PickType(UserDto, ['name', 'email', 'password']) {}

OmitType

Creates a new type by omitting a set of properties from an existing class.

import { OmitType } from '@vivtel/mapped-types';
import { IsString, IsEmail } from 'class-validator';

class UserDto {
  @IsString()
  name: string;

  @IsEmail()
  email: string;

  @IsString()
  password: string;
}

// UserResponseDto will have name and email properties, but not password
// with the same validation rules as UserDto
class UserResponseDto extends OmitType(UserDto, ['password']) {}

PartialType

Creates a new type by making all properties of an existing class optional.

import { PartialType } from '@vivtel/mapped-types';
import { IsString, IsEmail } from 'class-validator';

class UserDto {
  @IsString()
  name: string;

  @IsEmail()
  email: string;
}

// UpdateUserDto will have optional name and email properties
// with the same validation rules as UserDto, but they'll only be
// applied if the properties are defined
class UpdateUserDto extends PartialType(UserDto) {}

IntersectionType

Creates a new type by intersecting multiple existing classes.

import { IntersectionType } from '@vivtel/mapped-types';
import { IsString } from 'class-validator';

class UserDto {
  @IsString()
  name: string;
}

class AddressDto {
  @IsString()
  street: string;
}

// UserWithAddressDto will have both name and street properties
// with the same validation rules as the original classes
class UserWithAddressDto extends IntersectionType(UserDto, AddressDto) {}

API Reference

For detailed API documentation, please visit our API Reference.

PickType

function PickType<T, K extends keyof T>(
  classRef: Type<T>,
  keys: readonly K[]
): MappedType<RemoveFieldsWithType<Pick<T, K>, Function>>;

OmitType

function OmitType<T, K extends keyof T>(
  classRef: Type<T>,
  keys: readonly K[]
): MappedType<RemoveFieldsWithType<Omit<T, K>, Function>>;

PartialType

function PartialType<T>(
  classRef: Type<T>,
  options: {
    skipNullProperties?: boolean;
  } = {}
): MappedType<RemoveFieldsWithType<Partial<T>, Function>>;

IntersectionType

function IntersectionType<T extends Type[]>(
  ...classRefs: T
): MappedType<
  RemoveFieldsWithType<
    UnionToIntersection<ClassRefsToConstructors<T>[number]>,
    Function
  >
>;

Contributing

Please read our Contributing Guide for details on our code of conduct and the process for submitting pull requests.

Versioning

We use SemVer for versioning and Changesets to manage releases. For the versions available, see the tags on this repository.

License

This project is licensed under the MIT License - see the LICENSE file for details.