fix: plainToInstance throws on inherited getter-only properties when either the plain object contains the key or the getter is exposed

[Woodz]

Description

Describe the bug
When using plainToInstance from class-transformer, a runtime error is thrown if a class inherits a getter-only property and either:

The plain object contains a property with the same name, or

The inherited getter is decorated with @expose() — even if the plain object is empty.

In contrast, non-inherited getter-only properties are silently ignored under the same conditions, leading to inconsistent and surprising behavior.

Minimal code-snippet showcasing the problem

import "reflect-metadata";
import { plainToInstance, Expose } from "class-transformer";

abstract class Base {
  get inheritedOnlyGetter(): string {
    return "base";
  }
}

class Example extends Base {
  get localOnlyGetter(): string {
    return "local";
  }
}

const plainWithLocalGetter = {
  localOnlyGetter: "value",
};
const plainWithInheritedGetter = {
  inheritedOnlyGetter: "value",
};

const instanceWithLocalGetter = plainToInstance(Example, plainWithLocalGetter);
console.log(
  `Plain with local getter converted successfully: ${JSON.stringify(
    instanceWithLocalGetter
  )}`
);

try {
  plainToInstance(Example, plainWithInheritedGetter);
} catch (err) {
  console.log(`Plain with inherited getter failed conversion: ${err}`);
}

class ClassWithOwnExposedGetter {
  @Expose()
  get getter(): string {
    return "own";
  }
}

class ClassWithInheritedExposedGetter extends ClassWithOwnExposedGetter {}

const instanceWithOwnExposedGetter = plainToInstance(
  ClassWithOwnExposedGetter,
  {}
);
console.log(
  `Plain with own exposed getter converted successfully: ${JSON.stringify(
    instanceWithOwnExposedGetter
  )}`
);

try {
  plainToInstance(ClassWithInheritedExposedGetter, {});
} catch (err) {
  console.log(`Plain with exposed inherited getter failed conversion: ${err}`);
}

Expected behavior

Consistency between non-inherited and inherited getters

Actual behavior

Non-inherited getters never throw. Inherited getters throw if exposed or plain object has a value for it

[Woodz]

Sandbox repro

[Woodz]

🔧 Proposed Fix
The root cause is that class-transformer uses Object.getOwnPropertyDescriptor(target, key) to determine whether a property can be written to. This only detects properties defined directly on the target, not inherited ones. As a result:

Getter-only properties defined locally are detected and skipped (no setter → not writable).

Getter-only properties inherited are not detected at all, so plainToInstance attempts to assign them directly, leading to a TypeError.

✅ Fix proposal
Replace:

const descriptor = Object.getOwnPropertyDescriptor(newValue.constructor.prototype, newValueKey);

with:

const descriptor = getPropertyDescriptorInPrototypeChain(newValue.constructor.prototype, newValueKey);

where we introduce a new recursive helper method

function getPropertyDescriptorInPrototypeChain(obj: object, key: PropertyKey): PropertyDescriptor | undefined {
  while (obj) {
    const desc = Object.getOwnPropertyDescriptor(obj, key);
    if (desc) return desc;
    obj = Object.getPrototypeOf(obj);
  }
  return undefined;
}

This allows the transformer to safely detect inherited getters and avoid assigning to them when they are read-only.

[Woodz]

I notice that this was fixed in #1258. Please inform when this is be released