class-transformer#instanceToPlain TypeScript Examples

@Get(':id')
  @ApiOperation({ summary: '유저 정보 조회 API' })
  @ApiOkResponse({
    description: 'Id가 일치하는 유저 정보를 조회한다.',
    type: UserResponseDto,
  })
  async findOne(
    @Param('id', new ParseIntPipe()) id: number,
    @Res() res: Response,
  ) {
    const responseDto = await this.userService.findById(id);

    return res.status(HttpStatus.OK).json(instanceToPlain(responseDto));
  }

// Convenience method for retrieving selected observations queries (metric, unit, params) for a given sensor
  private getObservationQueriesForSensor$(id: string, returnFirstQueryOnly = false): Observable<ObservationQuery[]> {
    return IModelSettingsService.iModelSettings$()
      .pipe(
        map((iModelSettings: IModelSettings) => {
          return iModelSettings.getAssociation(id)?.getObservationQueries() || [];
        }),
        distinctUntilChanged((p: ObservationQuery[], c: ObservationQuery[]) => {
          return _isEqual(
            instanceToPlain(returnFirstQueryOnly ? p[0] : p),
            instanceToPlain(returnFirstQueryOnly ? c[0] : c)
          );
        })
      );
  }

private saveSettings(): void {

    // Get current auth state because we need the project id
    AuthService.authState$()
      .pipe(
        filter((authState: AuthState | null) => !!authState),
        first()
      )
      .subscribe((authState: AuthState | null) => {
        if (authState) {
          const newSettings = instanceToPlain(this.iModelSettings.getValue());
          ConfigSettingsService.saveConfigSettings$(authState.getProjectId(), newSettings)
            .subscribe({
              next: (() => {
                LoggerService.log("iModel settings saved:", this.iModelSettings.getValue());
              }),
            });
        } else {
          LoggerService.warn("Error saving iModel settings: Auth State not available");
        }
      });
  }

public async transform(value: any, metadata: ArgumentMetadata): Promise<any> {
        const opts = this.options || {};
        const { argType } = metadata;
        if (!argType || !this.toValidate(metadata)) {
            return value;
        }
        const originalValue = value;
        value = this.toEmptyIfNil(value);

        const isNil = value !== originalValue;
        const isPrimitive = this.isPrimitive(value);
        this.stripProtoKeys(value);
        let entity = plainToInstance(
            argType,
            value,
            opts.transformOptions,
        );

        const originalEntity = entity;
        const isCtorNotEqual = entity.constructor !== argType;

        if (isCtorNotEqual && !isPrimitive) {
            entity.constructor = argType;
        } else if (isCtorNotEqual) {
            // when "entity" is a primitive value, we have to temporarily
            // replace the entity to perform the validation against the original
            // metatype defined inside the handler
            entity = { constructor: argType } as any;
        }

        const errors = await validate(entity, opts.validatorOptions);
        if (errors.length > 0) {
            throw new ValidationErrors(opts.detailedOutputDisabled ? undefined : errors);
        }
        if (isPrimitive) {
            // if the value is a primitive value and the validation process has been successfully completed
            // we have to revert the original value passed through the pipe
            entity = originalEntity;
        }
        if (opts.transformEnabled) {
            return entity;
        }
        if (isNil) {
            // if the value was originally undefined or null, revert it back
            return originalValue;
        }
        return Object.keys(opts.validatorOptions).length > 0
            ? instanceToPlain(entity, opts.transformOptions)
            : value;
    }

L.debug({ config: instanceToPlain(config) });