@yoolabs/class-transformer

> IMPORTANT NOTE!
>
> This repository is a fork of the original class-transformer package.
> It adds tweaks of
>
> - class-transformer-global-storage (exports metadata storage, so that metadata is accessible)
> - nestjs class-transformer (currently only updates, no funtionality changes or fixes)
> - yoolabs class-transformer (custom functionality documented below)

yoolabs class-transformer

This fork adds custom functionality to class transformer.
Note: To release to npm, run continuous-deployment-workflow!

$3

- ES2022 class constructor behavior fix, see https://github.com/typestack/class-transformer/issues/1216

$3

- Structure Decorator enhancement: Fill reflectedType as well to allow 3rd party libs to work correctly.

$3

- Structure Decorator enhancement: Support Map/Set being passed in plain value (plain data only supported Array+Object until now)

$3

- Restructure code and fix many lint and possibly edge case runtime errors
- Structure Decorator - like @Type() but with greater control and stricter transformation

$3

- Exposing/Excluding properties of subobjects
- export TransformOperationExecutor
- add an extra options property "dependencies", which will be passed to: (0.7.0)
- custom transform functions
- custom type factory function
- replaces extra argument "dependencies" in a way that is compatible with 3rd-party libs where transformation function call can't be modified.
- pass TransformOperationExecutor reference so that custom processing of data is possible to:
- custom transform functions
- custom type factory function
- new option transformationHandler allows to specify a custom handler for nested transformations, which will be executed instead of directly recursively calling TransformOperationExecutor.transform

Main Introduction

Its ES6 and Typescript era. Nowadays you are working with classes and constructor objects more than ever.
Class-transformer allows you to transform plain object to some instance of class and versa.
Also it allows to serialize / deserialize object based on criteria.
This tool is super useful on both frontend and backend.

Table of contents

* yoolabs class-transformer
* 1.0.3
* 1.0.2
* 1.0.1
* 1.0
* 0.7
* Main Introduction
* Table of contents
* What is class-transformer⬆
* Installation⬆
* Node.js⬆
* Browser⬆
* Methods⬆
* plainToInstance⬆
* plainToClassFromExist⬆
* instanceToPlain⬆
* instanceToInstance⬆
* serialize⬆
* deserialize and deserializeArray⬆
* Enforcing type-safe instance⬆
* Working with nested objects⬆
* Providing more than one type option⬆
* Structure Decorator
* Exposing getters and method return values⬆
* Exposing properties with different names⬆
* Skipping specific properties⬆
* Skipping depend of operation⬆
* Skipping all properties of the class⬆
* Exposing/Excluding properties of subobjects
* Skipping private properties, or some prefixed properties⬆
* Using groups to control excluded properties⬆
* Using versioning to control exposed and excluded properties⬆
* Сonverting date strings into Date objects⬆
* Working with arrays⬆
* Additional data transformation⬆
* Basic usage⬆
* Advanced usage⬆
* Other decorators⬆
* Working with generics⬆
* Implicit type conversion⬆
* How does it handle circular references?⬆
* Example with Angular2⬆
* Samples⬆
* Release notes⬆

What is class-transformer⬆

In JavaScript there are two types of objects:

- plain (literal) objects
- class (constructor) objects

Plain objects are objects that are instances of Object class.
Sometimes they are called literal objects, when created via {} notation.
Class objects are instances of classes with own defined constructor, properties and methods.
Usually you define them via class notation.

So, what is the problem?

Sometimes you want to transform plain javascript object to the ES6 classes you have.
For example, if you are loading a json from your backend, some api or from a json file,
and after you JSON.parse it you have a plain javascript object, not instance of class you have.

For example you have a list of users in your users.json that you are loading:

``json
[
{
"id": 1,
"firstName": "Johny",
"lastName": "Cage",
"age": 27
},
{
"id": 2,
"firstName": "Ismoil",
"lastName": "Somoni",
"age": 50
},
{
"id": 3,
"firstName": "Luke",
"lastName": "Dacascos",
"age": 12
}
]
`

And you have a User class:

`typescript
export class User {
id: number;
firstName: string;
lastName: string;
age: number;

getName() {
return this.firstName + ' ' + this.lastName;
}

isAdult() {
return this.age > 36 && this.age < 60;
}
}
`

You are assuming that you are downloading users of type User from users.json file and may want to write
following code:

`typescript
fetch('users.json').then((users: User[]) => {
// you can use users here, and type hinting also will be available to you,
// but users are not actually instances of User class
// this means that you can't use methods of User class
});
`

In this code you can use users[0].id, you can also use users[0].firstName and users[0].lastName.
However you cannot use users[0].getName() or users[0].isAdult() because "users" actually is
array of plain javascript objects, not instances of User object.
You actually lied to compiler when you said that its users: User[].

So what to do? How to make a users array of instances of User objects instead of plain javascript objects?
Solution is to create new instances of User object and manually copy all properties to new objects.
But things may go wrong very fast once you have a more complex object hierarchy.

Alternatives? Yes, you can use class-transformer. Purpose of this library is to help you to map your plain javascript
objects to the instances of classes you have.

This library also great for models exposed in your APIs,
because it provides a great tooling to control what your models are exposing in your API.
Here is an example how it will look like:

`typescript
fetch('users.json').then((users: Object[]) => {
const realUsers = plainToInstance(User, users);
// now each user in realUsers is an instance of User class
});
`

Now you can use users[0].getName() and users[0].isAdult() methods.

Installation⬆

$3

1. Install module:

npm install class-transformer --save

2. reflect-metadata shim is required, install it too:

npm install reflect-metadata --save

and make sure to import it in a global place, like app.ts:

`typescript
import 'reflect-metadata';
`

3. ES6 features are used, if you are using old version of node.js you may need to install es6-shim:

npm install es6-shim --save

and import it in a global place like app.ts:

`typescript
import 'es6-shim';
`

$3

1. Install module:

npm install class-transformer --save

2. reflect-metadata shim is required, install it too:

npm install reflect-metadata --save

add



`

If you are using angular 2 you should already have this shim installed.

3. If you are using system.js you may want to add this into map and package config:

`json
{
"map": {
"class-transformer": "node_modules/class-transformer"
},
"packages": {
"class-transformer": { "main": "index.js", "defaultExtension": "js" }
}
}
`

Methods⬆

$3

This method transforms a plain javascript object to instance of specific class.

`typescript
import { plainToInstance } from 'class-transformer';

let users = plainToInstance(User, userJson); // to convert user plain object a single user. also supports arrays
`

$3

This method transforms a plain object into an instance using an already filled Object which is an instance of the target class.

`typescript
const defaultUser = new User();
defaultUser.role = 'user';

let mixedUser = plainToClassFromExist(defaultUser, user); // mixed user should have the value role = user when no value is set otherwise.
`

$3

This method transforms your class object back to plain javascript object, that can be JSON.stringify later.

`typescript
import { instanceToPlain } from 'class-transformer';
let photo = instanceToPlain(photo);
`

$3

This method transforms your class object into a new instance of the class object.
This may be treated as deep clone of your objects.

`typescript
import { instanceToInstance } from 'class-transformer';
let photo = instanceToInstance(photo);
`

You can also use an ignoreDecorators option in transformation options to ignore all decorators your classes are using.

$3

You can serialize your model right to json using serialize method:

`typescript
import { serialize } from 'class-transformer';
let photo = serialize(photo);
`

serialize works with both arrays and non-arrays.

$3

You can deserialize your model from json using the deserialize method:

`typescript
import { deserialize } from 'class-transformer';
let photo = deserialize(Photo, photo);
`

To make deserialization work with arrays, use the deserializeArray method:

`typescript
import { deserializeArray } from 'class-transformer';
let photos = deserializeArray(Photo, photos);
`

Enforcing type-safe instance⬆

The default behaviour of the plainToInstance method is to set _all_ properties from the plain object,
even those which are not specified in the class.

`typescript
import { plainToInstance } from 'class-transformer';

class User {
id: number;
firstName: string;
lastName: string;
}

const fromPlainUser = {
unkownProp: 'hello there',
firstName: 'Umed',
lastName: 'Khudoiberdiev',
};

console.log(plainToInstance(User, fromPlainUser));

// User {
// unkownProp: 'hello there',
// firstName: 'Umed',
// lastName: 'Khudoiberdiev',
// }
`

If this behaviour does not suit your needs, you can use the excludeExtraneousValues option
in the plainToInstance method while _exposing all your class properties_ as a requirement.

`typescript
import { Expose, plainToInstance } from 'class-transformer';

class User {
@Expose() id: number;
@Expose() firstName: string;
@Expose() lastName: string;
}

const fromPlainUser = {
unkownProp: 'hello there',
firstName: 'Umed',
lastName: 'Khudoiberdiev',
};

console.log(plainToInstance(User, fromPlainUser, { excludeExtraneousValues: true }));

// User {
// id: undefined,
// firstName: 'Umed',
// lastName: 'Khudoiberdiev'
// }
`

Working with nested objects⬆

When you are trying to transform objects that have nested objects,
it's required to known what type of object you are trying to transform.
Since Typescript does not have good reflection abilities yet,
we should implicitly specify what type of object each property contain.
This is done using @Type decorator.

Lets say we have an album with photos.
And we are trying to convert album plain object to class object:

`typescript
import { Type, plainToInstance } from 'class-transformer';

export class Album {
id: number;

name: string;

@Type(() => Photo)
photos: Photo[];
}

export class Photo {
id: number;
filename: string;
}

let album = plainToInstance(Album, albumJson);
// now album is Album object with Photo objects inside
`

$3

In case the nested object can be of different types, you can provide an additional options object,
that specifies a discriminator. The discriminator option must define a property that holds the subtype
name for the object and the possible subTypes that the nested object can converted to. A sub type
has a value, that holds the constructor of the Type and the name, that can match with the property
of the discriminator.

Lets say we have an album that has a top photo. But this photo can be of certain different types.
And we are trying to convert album plain object to class object. The plain object input has to define
the additional property __type. This property is removed during transformation by default:

JSON input:

`json
{
"id": 1,
"name": "foo",
"topPhoto": {
"id": 9,
"filename": "cool_wale.jpg",
"depth": 1245,
"__type": "underwater"
}
}
`

`typescript
import { Type, plainToInstance } from 'class-transformer';

export abstract class Photo {
id: number;
filename: string;
}

export class Landscape extends Photo {
panorama: boolean;
}

export class Portrait extends Photo {
person: Person;
}

export class UnderWater extends Photo {
depth: number;
}

export class Album {
id: number;
name: string;

@Type(() => Photo, {
discriminator: {
property: '__type',
subTypes: [
{ value: Landscape, name: 'landscape' },
{ value: Portrait, name: 'portrait' },
{ value: UnderWater, name: 'underwater' },
],
},
})
topPhoto: Landscape | Portrait | UnderWater;
}

let album = plainToInstance(Album, albumJson);
// now album is Album object with a UnderWater object without __type property.
`

Hint: The same applies for arrays with different sub types. Moreover you can specify keepDiscriminatorProperty: true
in the options to keep the discriminator property also inside your resulting class.

$3

The @Structure(...) decorator is an enhanced version of @Type.
In some situations, @Type will rather _guess_ what the subobject structure should look like - is it a single object, an array, a map?
Without ts type reflection enabled, it can result in unexpected, even dangerous data being returned.

@Structure provides a more solid implementation.
It receives an explicit structure type argument at first index.
Regularly it will be Map, Array or Set. But you can also pass a child class of any of these if required.

Having knowledge of the expected structure type allows class-transformer to not guess it from the value.
This ensures the value will always be of the correct type, even when the plain value is messed up or invalid.

`ts
import { Structure, plainToInstance } from 'class-transformer';

export class Album {
id: number;

name: string;

@Structure(Array, () => Photo)
photos: Photo[];

@Structure(Set, () => Camera)
photos: Set;

@Structure(Map, () => Location)
photos: Map;

// if you want to, @Structure also works with primitive Type, example:
@Structure(Map, () => Number)
priceList: Map;
}

`




Exposing getters and method return values⬆

You can expose what your getter or method return by setting an @Expose() decorator to those getters or methods:

`typescript
import { Expose } from 'class-transformer';

export class User {
id: number;
firstName: string;
lastName: string;
password: string;

@Expose()
get name() {
return this.firstName + ' ' + this.lastName;
}

@Expose()
getFullName() {
return this.firstName + ' ' + this.lastName;
}
}
`

Exposing properties with different names⬆

If you want to expose some of the properties with a different name,
you can do that by specifying a name option to @Expose decorator:

`typescript
import { Expose } from 'class-transformer';

export class User {
@Expose({ name: 'uid' })
id: number;

firstName: string;

lastName: string;

@Expose({ name: 'secretKey' })
password: string;

@Expose({ name: 'fullName' })
getFullName() {
return this.firstName + ' ' + this.lastName;
}
}
`

Skipping specific properties⬆

Sometimes you want to skip some properties during transformation.
This can be done using @Exclude decorator:

`typescript
import { Exclude } from 'class-transformer';

export class User {
id: number;

email: string;

@Exclude()
password: string;
}
`

Now when you transform a User, the password property will be skipped and not be included in the transformed result.

Skipping depend of operation⬆

You can control on what operation you will exclude a property. Use toClassOnly or toPlainOnly options:

`typescript
import { Exclude } from 'class-transformer';

export class User {
id: number;

email: string;

@Exclude({ toPlainOnly: true })
password: string;
}
`

Now password property will be excluded only during instanceToPlain operation. Vice versa, use the toClassOnly option.

Skipping all properties of the class⬆

You can skip all properties of the class, and expose only those are needed explicitly:

`typescript
import { Exclude, Expose } from 'class-transformer';

@Exclude()
export class User {
@Expose()
id: number;

@Expose()
email: string;

password: string;
}
`

Now id and email will be exposed, and password will be excluded during transformation.
Alternatively, you can set exclusion strategy during transformation:

`typescript
import { instanceToPlain } from 'class-transformer';
let photo = instanceToPlain(photo, { strategy: 'excludeAll' });
`

In this case you don't need to @Exclude() a whole class.

Exposing/Excluding properties of subobjects

By default, setting a strategy or using Exclude/Expose decorators will set the strategy deeply,
so subobjects need to specifically expose properties too.
If you use plain subobjects which shall not be stripped, use the nestedStrategy configuration property.

`typescript
import { Exclude, Expose, classToPlain } from 'class-transformer';

interface DataInterface {
prop: string;
otherProp: number;
}

export class User {
@Expose()
id: number;
@Expose()
data: DataInterface;
}

const user = new User();
user.id = 3;
user.data = { prop: 'test', otherProp: 23 };

// plain1.data will be an empty object
let plain1 = classToPlain(user, { strategy: 'excludeAll' });

// plain2.data will be {prop:'test',otherProp:23}
let plain2 = classToPlain(user, {
strategy: 'excludeAll',
nestedStrategy: 'exposeAll',
});
`

Skipping private properties, or some prefixed properties⬆

If you name your private properties with a prefix, lets say with _,
then you can exclude such properties from transformation too:

`typescript
import { instanceToPlain } from 'class-transformer';
let photo = instanceToPlain(photo, { excludePrefixes: ['_'] });
`

This will skip all properties that start with _ prefix.
You can pass any number of prefixes and all properties that begin with these prefixes will be ignored.
For example:

`typescript
import { Expose, instanceToPlain } from 'class-transformer';

export class User {
id: number;
private _firstName: string;
private _lastName: string;
_password: string;

setName(firstName: string, lastName: string) {
this._firstName = firstName;
this._lastName = lastName;
}

@Expose()
get name() {
return this._firstName + ' ' + this._lastName;
}
}

const user = new User();
user.id = 1;
user.setName('Johny', 'Cage');
user._password = '123';

const plainUser = instanceToPlain(user, { excludePrefixes: ['_'] });
// here plainUser will be equal to
// { id: 1, name: "Johny Cage" }
`

Using groups to control excluded properties⬆

You can use groups to control what data will be exposed and what will not be:

`typescript
import { Exclude, Expose, instanceToPlain } from 'class-transformer';

export class User {
id: number;

name: string;

@Expose({ groups: ['user', 'admin'] }) // this means that this data will be exposed only to users and admins
email: string;

@Expose({ groups: ['user'] }) // this means that this data will be exposed only to users
password: string;
}

let user1 = instanceToPlain(user, { groups: ['user'] }); // will contain id, name, email and password
let user2 = instanceToPlain(user, { groups: ['admin'] }); // will contain id, name and email
`

Using versioning to control exposed and excluded properties⬆

If you are building an API that has different versions, class-transformer has extremely useful tools for that.
You can control which properties of your model should be exposed or excluded in what version. Example:

`typescript
import { Exclude, Expose, instanceToPlain } from 'class-transformer';

export class User {
id: number;

name: string;

@Expose({ since: 0.7, until: 1 }) // this means that this property will be exposed for version starting from 0.7 until 1
email: string;

@Expose({ since: 2.1 }) // this means that this property will be exposed for version starting from 2.1
password: string;
}

let user1 = instanceToPlain(user, { version: 0.5 }); // will contain id and name
let user2 = instanceToPlain(user, { version: 0.7 }); // will contain id, name and email
let user3 = instanceToPlain(user, { version: 1 }); // will contain id and name
let user4 = instanceToPlain(user, { version: 2 }); // will contain id and name
let user5 = instanceToPlain(user, { version: 2.1 }); // will contain id, name and password
`

Сonverting date strings into Date objects⬆

Sometimes you have a Date in your plain javascript object received in a string format.
And you want to create a real javascript Date object from it.
You can do it simply by passing a Date object to the @Type decorator:

`typescript
import { Type } from 'class-transformer';

export class User {
id: number;

email: string;

password: string;

@Type(() => Date)
registrationDate: Date;
}
`

Same technique can be used with Number, String, Boolean
primitive types when you want to convert your values into these types.

Working with arrays⬆

When you are using arrays you must provide a type of the object that array contains.
This type, you specify in a @Type() decorator:

`typescript
import { Type } from 'class-transformer';

export class Photo {
id: number;

name: string;

@Type(() => Album)
albums: Album[];
}
`

You can also use custom array types:

`typescript
import { Type } from 'class-transformer';

export class AlbumCollection extends Array {
// custom array functions ...
}

export class Photo {
id: number;

name: string;

@Type(() => Album)
albums: AlbumCollection;
}
`

Library will handle proper transformation automatically.

ES6 collections Set and Map also require the @Type decorator:

`typescript
export class Skill {
name: string;
}

export class Weapon {
name: string;
range: number;
}

export class Player {
name: string;

@Type(() => Skill)
skills: Set;

@Type(() => Weapon)
weapons: Map;
}
`

Additional data transformation⬆

$3

You can perform additional data transformation using @Transform decorator.
For example, you want to make your Date object to be a moment object when you are
transforming object from plain to class:

`typescript
import { Transform } from 'class-transformer';
import * as moment from 'moment';
import { Moment } from 'moment';

export class Photo {
id: number;

@Type(() => Date)
@Transform(({ value }) => moment(value), { toClassOnly: true })
date: Moment;
}
`

Now when you call plainToInstance and send a plain representation of the Photo object,
it will convert a date value in your photo object to moment date.
@Transform decorator also supports groups and versioning.

$3

The @Transform decorator is given more arguments to let you configure how you want the transformation to be done.

`ts
@Transform(({ value, key, obj, type }) => value)
`

| Argument | Description |
| --------- | ------------------------------------------------------- |
| value | The property value before the transformation. |
| key | The name of the transformed property. |
| obj | The transformation source object. |
| type | The transformation type. |
| options | The options object passed to the transformation method. |

Other decorators⬆

| Signature | Example | Description |
| ------------------------ | ---------------------------------------------------- | ------------------------------------------------------------------------------------- |
| @TransformClassToPlain | @TransformClassToPlain({ groups: ["user"] }) | Transform the method return with classToPlain and expose the properties on the class. |
| @TransformInstanceToInstance | @TransformInstanceToInstance({ groups: ["user"] }) | Transform the method return with instanceToInstance and expose the properties on the class. |
| @TransformPlainToClass | @TransformPlainToClass(User, { groups: ["user"] }) | Transform the method return with plainToClass and expose the properties on the class. |

The above decorators accept one optional argument:
ClassTransformOptions - The transform options like groups, version, name

An example:

`typescript
@Exclude()
class User {
id: number;

@Expose()
firstName: string;

@Expose()
lastName: string;

@Expose({ groups: ['user.email'] })
email: string;

password: string;
}

class UserController {
@TransformClassToPlain({ groups: ['user.email'] })
getUser() {
const user = new User();
user.firstName = 'Snir';
user.lastName = 'Segal';
user.password = 'imnosuperman';

return user;
}
}

const controller = new UserController();
const user = controller.getUser();
`

the user variable will contain only firstName,lastName, email properties because they are
the exposed variables. email property is also exposed because we metioned the group "user.email".

Working with generics⬆

Generics are not supported because TypeScript does not have good reflection abilities yet.
Once TypeScript team provide us better runtime type reflection tools, generics will be implemented.
There are some tweaks however you can use, that maybe can solve your problem.
Checkout this example.

Implicit type conversion⬆

> NOTE If you use class-validator together with class-transformer you propably DON'T want to enable this function.

Enables automatic conversion between built-in types based on type information provided by Typescript. Disabled by default.

`ts
import { IsString } from 'class-validator';

class MyPayload {
@IsString()
prop: string;
}

const result1 = plainToInstance(MyPayload, { prop: 1234 }, { enableImplicitConversion: true });
const result2 = plainToInstance(MyPayload, { prop: 1234 }, { enableImplicitConversion: false });

/**
* result1 will be { prop: "1234" } - notice how the prop value has been converted to string.
* result2 will be { prop: 1234 } - default behaviour
*/
`

How does it handle circular references?⬆

Circular references are ignored.
For example, if you are transforming class User that contains property photos with type of Photo,
and Photo contains link user to its parent User, then user will be ignored during transformation.
Circular references are not ignored only during instanceToInstance operation.

Example with Angular2⬆

Lets say you want to download users and want them automatically to be mapped to the instances of User class.

`typescript
import { plainToInstance } from 'class-transformer';

this.http
.get('users.json')
.map(res => res.json())
.map(res => plainToInstance(User, res as Object[]))
.subscribe(users => {
// now "users" is type of User[] and each user has getName() and isAdult() methods available
console.log(users);
});
`

You can also inject a class ClassTransformer as a service in providers`, and use its methods.

Example how to use with angular 2 in plunker.
Source code is here.

Samples⬆

Take a look on samples in ./sample for more examples of
usages.

Release notes⬆

See information about breaking changes and release notes here.