Thoughts on Validating Exact Type Equality in TypeScript

type User = {
  name: string;
};

function printUser(user: User) {
  console.log(user);
}

printUser({ name: 'Joe', email: 'joe@email.com' });
// ❌ Error: Object literal may only specify known properties, and 'email' does not exist in type 'AllowedType'.

const userData = {
  name: 'Joe',
  email: 'joe@email.com',
};

printUser(userData);
// ✅ No error

TypeScript follows a Structural Type system, meaning that if two types have the same structure, in this case, “objects with the same property names and types” they are considered the same, even if they have different type names. Therefore, when passing a variable to a function, TypeScript determines type compatibility based on structure; as long as the variable contains all the properties required by the function, they are compatible.

However, when directly passing an object literal🔗 to a function, TypeScript performs stricter checks, requiring the object literal to fully conform to the type definition of the function parameters due to the concept of Freshness🔗. In other words, this is Strict Object Literal Checking.

This checking mechanism is primarily to enhance the accuracy and reliability of the code, avoiding spelling mistakes.

If you want TypeScript to perform strict type checking, here is a generic workaround for Exact that can be used:

type Exact<A, B> = A extends B ? (B extends A ? A : never) : never;

type User = {
  name: string;
};

function printUser<T>(user: Exact<T, User>) {
  console.log(user);
}

printUser({ name: 'Joe', email: 'joe@email.com' });
// ❌ Error: Argument of type '{ name: string; email: string; }' is not assignable to parameter of type 'never'.

const userData = {
  name: 'Joe',
  email: 'joe@email.com',
};

printUser(userData);
// ❌ Error: Argument of type '{ name: string; email: string; }' is not assignable to parameter of type 'never'

Further Reading:

• TypeScript Exact Types🔗