"🤯 TypeScript Generics Issue: Why Does Default Param Bypass Type Check? ⚡️"

Hey there! 👋 Oh man, I feel your pain with this generic type issue - I've wrestled with similar problems when building type-safe builders myself! It's like TypeScript is being too permissive when you least want it to be, right? 😅

Here's what's happening under the hood and how to fix it:

The Root of the Problem 🌱

When you use new Example() with a default parameter, TypeScript isn't enforcing the generic constraint because the default {} as C is essentially telling the compiler "trust me, this empty object matches whatever generic type you want". It's like a sneaky type assertion bypass!

The Solution 💡

We can fix this by making the default constructor parameter more type-safe. Here's how I'd modify your class:

class Example<C extends Config> {
  constructor(private config: Readonly<C> = {} as Readonly<Config>) {}
  // ... rest remains the same
}

Or even better, make the empty constructor a separate static method:

class Example<C extends Config> {
  private constructor(private config: Readonly<C>) {}
  
  // Factory method for empty config
  static create() {
    return new Example<Config>({});
  }
  
  min<const N extends number>(min: N) {
    return new Example<C & { min: N }>({
      ...this.config,
      min,
    });
  }
}

Now your broken case will correctly error:

const broken: Example<{ min: 1 }> = Example.create(); // Error! 🎉

Pro Tips from My Experience 🧠

1. Avoid as assertions with generics - they often create these sneaky holes in your type safety
2. Factory methods are great for maintaining control over construction
3. Consider making constructors private when you want to enforce specific creation patterns

Watch Out For! ⚠️

A common mistake is thinking extends constraints will be enforced during construction - they're more about what can be passed in rather than what must be present. That's why the empty object slips through.

Final Thoughts ✨

Builder patterns in TypeScript can be tricky, but when done right, they're incredibly powerful! Your approach with min<const N> is actually really clever for literal type preservation. 👏

If you want to go even further with type safety, you could explore:

• Using branded types for your config
• Adding a "required config" generic parameter
• Using conditional types to validate the builder state

Hope this helps unblock you! Let me know if you want to dive deeper into any of these approaches. Happy coding! 🚀

#TypeScript #Generics #TypeSafety #BuilderPattern #FrontendDevelopment