Amp up your NestJS and `class-transformer` stack with dependency injection!

Installation and setup

Install the dependency

npm install nestjs-inject-transformer --save

Import the InjectTransformModule

1import { InjectTransformModule } from 'nestjs-inject-transformer';
2
3@Module({
4    imports: [InjectTransformModule]
5})
6export class ApplicationModule {}

Usage

This package provides the InjectTransform and InjectType decorators which support all options of their class-transformer respective counterparts Transform and Type.

InjectTransform

To inject a dependencies pass an array of injection tokens to the inject option. They will be passed as additional arguments to your transform function, in the order they were given:

1import { InjectTransform } from 'nestjs-inject-transformer';
2
3export class MyDTO {
4    @InjectTransform(
5        (params, myService: MyService) => myService.parse(params.value),
6        {inject: [MyService]}
7    )
8    myAttr: number;
9}

[!WARN]

class-transformer operates strictly synchronously. Promises can not be awaited!

Alternatively, you can pass an InjectTransformer to tidy up more extensive use cases:

1import {InjectTransform, InjectTransformer} from 'nestjs-inject-transformer';
2import {TransformFnParams} from "class-transformer";
3
4export class MyTransformer implements InjectTransformer {
5    constructor(
6        private readonly dep1: Dependency1,
7        private readonly dep2: Dependency2,
8        private readonly dep3: Dependency3
9    ) {}
10
11    transform(params: TransformFnParams): any {
12        return this.dep1.parse(this.dep2.format(this.dep3.trim(params.value)));
13    }
14}
15
16export class MyDTO {
17    @InjectTransform(MyTransformer)
18    myAttr: number;
19}

InjectType

A TypeInjector lets you inject types similar to the Type decorator. Its inject function is called with the same arguments as the Type function would have been and should return the type to be used.

The following example illustrates how you could return different DTO types (and thereby different validation schemes when used with class-validator), based on a supposed client's configuration:

1@Injectable()
2class AccountDtoInjector implements TypeInjector {
3    constructor(
4        private readonly service: ClientConfigurationService
5    ) {}
6
7    inject(type?: TypeHelpOptions) {
8        const client = type.object['client'] ?? 'default';
9        const clientConfig = this.service.getClientConfiguration(client);
10        if (clientConfig.accountType === 'named') {
11            return NamedAccountDTO;
12        } else if (clientConfig.accountType === 'numbered') {
13            return NumberedAccountDTO;
14        }
15        return AccountDTO;
16    }
17}
18
19class AccountDTO {
20    @IsString()
21    name: string;
22}
23
24class NamedAccountDTO extends AccountDTO {
25    @IsString()
26    id: string
27}
28
29class NumberedAccountDTO extends AccountDTO  {
30    @IsNumber()
31    id: number
32}
33
34class CreateAccountDTO {
35    @IsString()
36    client: string;
37
38    @ValidateNested()
39    @InjectType(AccountDtoInjector)
40    accountInfo: NamedAccountDTO | NumberedAccountDTO;
41}

📜 License

nestjs-inject-transformer is MIT licensed.