Code Smell | Primitive Obsession

This code smell is given by the abusive use of primitive types when modeling our classes.

Code Smell | Primitive Obsession featured image

Hello, today I am writing again and this time I am going to introduce you to how we incur in a very common code smell called Primitive Obsession, this code smell is given by the abusive use of primitive types when modeling our classes, was it not very clear? let's go with a reduced example:

class User { #locale: string #age: number #email: string #SPANISH_LANGUAGE: string = 'es' #UNDERAGE_UNTIL_AGE: number = 18 #EMAIL_REGEX: RegExp = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/ constructor(locale: string, age: number, email: string) { this.#locale = locale this.#age = age this.#email = email if (!this.isValidEmail()) throw new Error('Invalid email format') } understandSpanish(): boolean { const language = this.#locale.substring(0, 2) return language === this.#SPANISH_LANGUAGE } isOlderAge(): boolean { return this.#age >= this.#UNDERAGE_UNTIL_AGE } isValidEmail(): boolean { return this.#EMAIL_REGEX.test(this.#email) } }
const user = new User('es', 18, 'test@email.com') user.understandSpanish() // true user.isOlderAge() // true user.isValidEmail() // true

You might be thinking, Well, it's not so bad, right?

This example, being small, can be a bit misleading, but as the code of our User class begins to grow, we will begin to see more clearly that there is still some logic that we have within the class that we could abstract so that our class looks much better


Our best friends: Value Objects

A value object is simply a modeling of a primitive type, let's see an example:

class Email { #email: string #EMAIL_REGEX: RegExp = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/ constructor(email: string) { this.#email = email if (!this.isValid()) throw new Error('Invalid email format') } isValid(): boolean { return this.#EMAIL_REGEX.test(this.#email) } value(): string { return this.#email } } new Email('suso@gmail.com').value() // "suso@gmail.com" new Email('susogmail.com').value() // Error: Invalid email format

As we can see, we are simply creating an abstraction of a primitive string type, within which we are adding logic to validate that the email we receive is valid, in this way we can reuse this VO in different parts of our application

What advantages does a VO offer me?

  • Immutability

  • Greater robustness in validations

  • Greater semantics, better readability in the class signature

  • Logic magnet

  • Helps IDE/editor autocomplete

  • They simplify the API

  • They can be reused in various parts of our application as they are not coupled to any class


Refactoring time

Initial state:

class User { #locale: string #age: number #email: string #SPANISH_LANGUAGE: string = 'es' #UNDERAGE_UNTIL_AGE: number = 18 #EMAIL_REGEX: RegExp = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/ constructor(locale: string, age: number, email: string) { this.#locale = locale this.#age = age this.#email = email if (!this.isValidEmail()) throw new Error('Invalid email format') } understandSpanish(): boolean { const language = this.#locale.substring(0, 2) return language === this.#SPANISH_LANGUAGE } isOlderAge(): boolean { return this.#age >= this.#UNDERAGE_UNTIL_AGE } isValidEmail(): boolean { return this.#EMAIL_REGEX.test(this.#email) } }

Split User class code into three value objects: Locale, Age and Email

Locale

class Locale { #locale: string #SPANISH_LANGUAGE: string = 'es' constructor(locale: string) { this.#locale = locale } understandSpanish(): boolean { const language = this.#locale.substring(0, 2) return language === this.#SPANISH_LANGUAGE } value(): string { return this.#locale } }

Age

class Age { #age: number #UNDERAGE_UNTIL_AGE: number = 18 constructor(age: number) { this.#age = age } isOlderAge(): boolean { return this.#age >= this.#UNDERAGE_UNTIL_AGE } value(): number { return this.#age } }

Email

class Email { #email: string #EMAIL_REGEX: RegExp = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/ constructor(email: string) { this.#email = email if (!this.isValid()) throw new Error('Invalid email format') } isValid(): boolean { return this.#EMAIL_REGEX.test(this.#email) } value(): string { return this.#email } }

Finally the User class, it would stay like this:

class User { #locale: Locale #age: Age #email: Email constructor(locale: Locale, age: Age, email: Email) { this.#locale = locale this.#age = age this.#email = email } understandSpanish(): boolean { return this.#locale.understandSpanish() } isOlderAge(): boolean { return this.#age.isOlderAge() } }

As you can see in this way, we manage to encapsulate each functionality in its corresponding value object in such a way that the user class is not responsible for carrying out any validation, so that we will achieve a more readable and maintainable code over time

Using new refactored User class:

// with valid email const user1 = new User( new Locale('es'), new Age(18), new Email('suso@gmail.com') ) user1.understandSpanish() // true // with invalid email const user2 = new User( new Locale('es'), new Age(18), new Email('susogmail.com') ) user2.understandSpanish() // Error: Invalid email format

Warning!

Not all are advantages, below we will see some disadvantages that we must consider when applying these abstractions:

  • In some cases we can incur in a premature optimization, especially in small projects that do not need much maintenance

  • They can have many classes if the project has considerable dimensions


Thanks for reading me 😊