Extend mapped types/default type utils, for better type from class experience #44735
Description
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.