Exposed "getters only" don't get handled in plainToInstance

[KikoCosmetics]

Description

It seems that using plainToInstance where you have a few getters (without setters) doesn't work.
I have this recollection where I converted responses in Angular and this used to work.
But I tried up to class-transformer 0.4.0 and it always behaves the same.

This is somewhat related (or clones) #1257

class ErrorResponse {
    @Expose()
    get errorCode(): number {
        return this._errorCode;
    }

    constructor(protected _errorCode: number = 800){}
}

plainToInstance(ErrorResponse, {
   "errorCode": 123
});

Blitz with full code here => https://stackblitz.com/edit/ts-class-transformer-issue

Expected behavior

I would expect to have

{
errorCode: 123
}

Actual behavior

{
errorCode: 800
}

[mezozawahra]

Typescript considers properties that have just get accessor to be readonly properties, so you can't set it
I think adding setter would solve it, like this:

class ErrorResponse {
    @Expose()
    get errorCode(): number {
        return this._errorCode;
    }
    set errorCode(value: number): number {
        this._errorCode = value;
    } 

    constructor(protected _errorCode: number = 800){}
}

plainToInstance(ErrorResponse, {
   "errorCode": 123
});

[KikoCosmetics]

@mezozawahra yeah man, I know. That's why I said "without getters".
Also if you open the blitz, there is the example with the setters and it works.

The fact is that I'm almost sure I used to do this before and it worked.

I should still have the project where I used to do this. I'll update here in case.

In any case there could be a way of marking the getter protected property to overcome this without adding a setter.

For example

class ErrorResponse {
    @Expose()
    @SerializeTo("_errorCode")
    get errorCode(): number {
        return this._errorCode;
    }
    set errorCode(value: number): number {
        this._errorCode = value;
    } 

    constructor(protected _errorCode: number = 800){}
}

That would allow keeping the member readonly.

[tonysamperi]

Cool workaound though: having a custom method to deserialize...
It would be cool if plainToInstance managed this automagically...
But in the meantime this generates the instance while preserving the readonly members

class SimpleError {
  @Expose()
  get errorCode(): number {
      return this._errorCode;
  }

  constructor(protected _errorCode: number = 800){}

  static fromPlain(plain: any): SimpleError {
    // Classe di passaggio che aggiunge i setter
    class SimpleErrorMutable extends SimpleError {
      set errorCode(value: number) {
        this._errorCode = value;
      }
    }

    // Deserializziamo in SimpleErrorMutable
    const tempInstance = plainToInstance(SimpleErrorMutable, plain, {
      excludePrefixes: ["_"],
      excludeExtraneousValues: !0
    });

    // Creiamo una vera istanza della classe base
    const instance = new SimpleError();

    // Copiamo tutti i membri da tempInstance a instance
    Object.getOwnPropertyNames(tempInstance).forEach((key) => {
      if (key in instance) {
        (instance as any)[key] = (tempInstance as any)[key];
      }
    });

    return instance;
  }
}