export class CreateEventDto {
  @Expose()
  @Exclude( { toPlainOnly: true })
  type: number;

  @Expose()
  get eventTypeId() {
    return this.type;
  }
}

import {
 ClassSerializerContextOptions,
 ClassSerializerInterceptor,
 NestInterceptor,
 PlainLiteralObject,
} from '@nestjs/common';

import { defaultMetadataStorage } from 'class-transformer/cjs/storage.js';
import type { MetadataStorage } from 'class-transformer/types/MetadataStorage';

/**
* This serializer is being used to fix an issue with the class-transformer library where
* instanceToPlain is not abiding by certain expose flags. This aims to remedy incorrectly keyed properties
* when specified as toClassOnly.
*
* Once the issue is resolved in the package, this should be able to be removed.
* @see https://github.com/typestack/class-transformer/issues/1324
*/
export class AppClassSerializerInterceptor
 extends ClassSerializerInterceptor
 implements NestInterceptor
{
 /** Load in the default local storage... I realize this isn't supposed to be public and used */
 private readonly metadata: MetadataStorage = defaultMetadataStorage;

 override transformToPlain(
   plainOrClass: any,
   options: ClassSerializerContextOptions,
 ): PlainLiteralObject {
   // Perform normal transform. This will have incorrect keys as it will have ignored the toClassOnly
   const result = super.transformToPlain(plainOrClass, options);

   // Recursively fix the result object and nested class objects
   this.fixExposedKeys(plainOrClass, result);

   return result;
 }

 /**
  * Traverse the resulting object and compare it with class instance version. Patch the result model recursively
  * checking nested objects.
  */
 private fixExposedKeys(plainOrClass: any, result: PlainLiteralObject) {
   // Get all the fields that are exposed and their options for the target class
   const exposed = this.metadata.getExposedMetadatas(plainOrClass.constructor);
   const toRevert = new Map<string, string>();

   // Cache this classes exposed properties to lookup
   for (const field of exposed) {
     if (
       field.options.toClassOnly &&
       field.options.name &&
       field.propertyName
     ) {
       toRevert.set(field.options.name, field.propertyName);
     }
   }

   for (const key in result) {
     const val = result[key];
     const correctKey = toRevert.get(key) ?? key;

     // Convert the keys back to the originals and delete the incorrectly converted ones.
     if (correctKey !== key) {
       result[correctKey] = val;
       delete result[key];
     }

     // We need to also fix nested models...
     if (val && typeof val === 'object') {
       this.fixExposedKeys(plainOrClass[correctKey], val);
     }
   }
 }
}