/
pipes-context-creator.ts
102 lines (94 loc) 路 2.76 KB
/
pipes-context-creator.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
import { PIPES_METADATA } from '@nestjs/common/constants';
import {
Controller,
PipeTransform,
Transform,
} from '@nestjs/common/interfaces';
import { isEmpty, isFunction } from '@nestjs/common/utils/shared.utils';
import iterate from 'iterare';
import { ApplicationConfig } from '../application-config';
import { ContextCreator } from '../helpers/context-creator';
import { NestContainer } from '../injector/container';
import { InstanceWrapper } from '../injector/instance-wrapper';
import { STATIC_CONTEXT } from './../injector/constants';
export class PipesContextCreator extends ContextCreator {
private moduleContext: string;
constructor(
private readonly container: NestContainer,
private readonly config?: ApplicationConfig,
) {
super();
}
public create(
instance: Controller,
callback: (...args: any[]) => any,
module: string,
contextId = STATIC_CONTEXT,
inquirerId?: string,
): Transform<any>[] {
this.moduleContext = module;
return this.createContext(
instance,
callback,
PIPES_METADATA,
contextId,
inquirerId,
);
}
public createConcreteContext<T extends any[], R extends any[]>(
metadata: T,
contextId = STATIC_CONTEXT,
inquirerId?: string,
): R {
if (isEmpty(metadata)) {
return [] as R;
}
return iterate(metadata)
.filter((pipe: any) => pipe && (pipe.name || pipe.transform))
.map(pipe => this.getPipeInstance(pipe, contextId, inquirerId))
.filter(pipe => pipe && pipe.transform && isFunction(pipe.transform))
.map(pipe => pipe.transform.bind(pipe))
.toArray() as R;
}
public getPipeInstance(
pipe: Function | PipeTransform,
contextId = STATIC_CONTEXT,
inquirerId?: string,
): PipeTransform | null {
const isObject = (pipe as PipeTransform).transform;
if (isObject) {
return pipe as PipeTransform;
}
const instanceWrapper = this.getInstanceByMetatype(pipe as Function);
if (!instanceWrapper) {
return null;
}
const instanceHost = instanceWrapper.getInstanceByContextId(
contextId,
inquirerId,
);
return instanceHost && instanceHost.instance;
}
public getInstanceByMetatype<T extends { name: string } = any>(
metatype: T,
): InstanceWrapper | undefined {
if (!this.moduleContext) {
return undefined;
}
const collection = this.container.getModules();
const module = collection.get(this.moduleContext);
if (!module) {
return undefined;
}
return module.injectables.get(metatype.name);
}
public getGlobalMetadata<T extends any[]>(): T {
if (!this.config) {
return [] as T;
}
return this.config.getGlobalPipes() as T;
}
public setModuleContext(context: string) {
this.moduleContext = context;
}
}