Leveraging Advanced TypeScript Types for Robust Data Modeling

TypeScript is more than just JavaScript with types — it offers powerful tools to model your data accurately. Using advanced types can help you catch errors early and make your code easier to maintain. In this tutorial, we'll explore how to use union types, intersection types, and mapped types to build robust data models that reflect real-world scenarios.

Let's start with union types. Imagine you need to model a user status that can only be 'active', 'inactive', or 'pending'. Instead of using strings that can accept any value, a union type restricts it to just these options.

type UserStatus = 'active' | 'inactive' | 'pending';

function updateUserStatus(status: UserStatus) {
  console.log(`User status updated to: ${status}`);
}

updateUserStatus('active'); // ✅ valid
// updateUserStatus('enabled'); // ❌ Error: Argument of type '"enabled"' is not assignable to parameter of type 'UserStatus'.

Union types improve code safety by preventing invalid values. Now, let's explore intersection types, which combine multiple types into one. For example, if you want to create a type that combines basic user info with admin privileges, you can use intersections.

type User = {
  id: number;
  name: string;
};

type Admin = {
  isAdmin: true;
  permissions: string[];
};

// Intersection of User and Admin

type AdminUser = User & Admin;

const adminUser: AdminUser = {
  id: 1,
  name: 'Alice',
  isAdmin: true,
  permissions: ['read', 'write', 'delete'],
};

console.log(adminUser);

Intersection types are great for building precise models when an object needs to satisfy multiple roles or interfaces at once. Finally, let's look at mapped types, which allow you to create new types by transforming existing ones.

type User = {
  id: number;
  name: string;
  email?: string;
};

// Make all properties required

type RequiredUser = {
  [K in keyof User]-?: User[K];
};

const user: RequiredUser = {
  id: 123,
  name: 'Bob',
  email: 'bob@example.com',
};

console.log(user);

In this example, the mapped type iterates over all keys of the User type and removes the optional modifier, making every property required. Mapped types are very useful for converting and creating flexible variations of your data models.

To conclude, leveraging advanced TypeScript types like unions, intersections, and mapped types helps create strong, maintainable models that align with real application needs. These tools improve type safety, reduce bugs, and make your code clearer. Start using them today to build more robust TypeScript applications!