Extend mapped types/default type utils, for better type from class experience

Suggestion

🔍 Search Terms

get, set, mapped types, remove getters from type, remove setters from type, get public fields only from class

✅ Viability Checklist

My suggestion meets these guidelines:

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, new syntax sugar for JS, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

⭐ Suggestion

Being able to remove/collect keys of get set types using Mapped Types syntax + many other utils to make types from class definitions based on their access level, type, return type, etc.

📃 Motivating Example

Basically, I have classes everywhere and I want to generate for it a default constructor that is taken from BaseClass that takes all the fields passed and assigns them to the fields of the class.

E.g.

abstract class BaseClass {
  constructor(fields: Record<string, unknown>) {
    for (const field in fields) {
      this[field] = fields[field];
    }
  }
}

That then gets extended.

class User extends BaseClass {
     constructor(
    fields: DefaultConstructorFields<User>
  ) {
    super(fields)
  }
  firstName: string
  secondName: string

  get fullName(): string {
     return this.firstName + " " + this.secondName
  }

  set fullName(full: string) { ... }
}

Something like

type RemoveGetters<Type> = {
  -get [Property in keyof Type]: Type[Property];
};

type RemoveSetters<Type> = {
  -set [Property in keyof Type]: Type[Property];
};

And some "magic" type utils like PublicFields<ClassName> PrivateFields<ClassName or maybe some special syntax to do such things on class definitions to get plain type will be awesome.

Problem is that I cannot make type util e.g. that DefaultConstructorFields, that will ignore all function fields, get fields, replace set with just whatever comes as an argument to the setter.

Currently, it's possible to filter functions/read-only fields/based on type/name, but not get and set, or filter by field visibility such as public protected private and ES6 private #field. Only manual Omit is possible.

💻 Use Cases

Ideally, I want to have my default constructors up and running with minimal overhead. E.g. like Kotlin has data class that just generates POJO with default constructor/hashCode/equals etc. while still allowing for get for calculated properties and set for setting things up while initializing the instance through the constructor.

So my main use case is strict Model classes (typeorm in my case) with lots of annotations and GraphQL Types that are still classes, because it's how Nest.js GraphQL works, it needs a runtime class e.g. prototype to defer the type at runtime.

Start by reviewing the requested mapped-type behavior for getters, setters, and class visibility described in the issue; no repository file or test is named. Define the desired type-system semantics and identify the relevant compiler tests before determining what a complete implementation and regression coverage would require.