Course contentsShow
← TypeScript
Lesson 844 of 1,79619. Template Literal TypesFree lesson

The Setters Pattern

Generate setter methods from properties using mapped types with template literal transformations.

The Setters Pattern

What you'll learn: How to automatically generate type-safe setter method names (like setName, setAge) from object properties using mapped types and template literal type transformations.

The Core Idea

You've already learned how to generate getter methods like getName() from properties. The setters pattern is the mirror image: for each property in an object, generate a corresponding setter method like setPropertyName(value) that accepts the property's type as an argument.

The pattern transforms property names into setter method names and ensures each setter accepts the correct value type.

How It Works

You combine three TypeScript features you already know:

  1. Mapped types to iterate over properties
  2. Template literal types to transform keys into setter names (name → setName)
  3. Capitalize intrinsic to properly case the setter name

Here's the pattern:

type Setters<T> = {
  [K in keyof T as `set${Capitalize<string & K>}`]: (value: T[K]) => void
}

Practical Example

type User = {
  name: string
  age: number
  active: boolean
}

type UserSetters = Setters<User>
// Result:
// {
//   setName: (value: string) => void
//   setAge: (value: number) => void
//   setActive: (value: boolean) => void
// }

Each generated setter method accepts exactly the right type for its property and returns void (standard for mutation methods).

Why This Pattern Matters

This pattern is invaluable for creating fluent APIs, class builders, or state management helpers where you need consistent setter naming conventions without manual repetition. The type system guarantees your setters stay synchronized with your data model.

Key Takeaway: The setters pattern uses mapped types with template literal key remapping to automatically generate type-safe setter methods from object properties, ensuring naming consistency and correct parameter types.