typescript object paths as param

Charlotte

2 min read

·

01-03-2025

1

0

Share

TypeScript's type system is incredibly powerful, but accessing deeply nested properties within objects can become cumbersome. Hardcoding property names leads to brittle code that breaks when object structures change. This article explores how to use TypeScript's type system to safely and dynamically access nested object properties using object paths as parameters. This technique makes your code more flexible, maintainable, and less prone to runtime errors.

Why Use Object Paths?

Imagine you have a complex object representing user data:

interface User {
  name: string;
  address: {
    street: string;
    city: string;
    zip: string;
  };
  contact: {
    email: string;
    phone: string;
  };
}

To access user.address.city, you'd need to explicitly write that path. If the address structure changes, you'll need to update every line of code that accesses it. Object paths provide a solution:

Defining Object Paths

We'll represent object paths as arrays of strings:

type Path = string[];

// Examples:
const namePath: Path = ['name'];
const cityPath: Path = ['address', 'city'];
const emailPath: Path = ['contact', 'email'];

Safely Accessing Nested Properties

The core challenge is creating a function that safely accesses nested properties using a given path, while also ensuring TypeScript catches errors at compile time. Here's how we can achieve this using generics and recursive type definitions:

type Get<T, P extends Path> = P extends [infer Head, ...infer Tail]
  ? Head extends keyof T
    ? Get<T[Head], Tail>
    : never //Type Error if path is invalid
  : T;

function getValue<T, P extends Path>(obj: T, path: P): Get<T, P> {
  return path.reduce((acc, curr) => acc[curr], obj) as Get<T, P>;
}

const user: User = {
  name: "John Doe",
  address: { street: "123 Main St", city: "Anytown", zip: "12345" },
  contact: { email: "[email protected]", phone: "555-1212" }
};

const city = getValue(user, ['address', 'city']); //city is string
const name = getValue(user, ['name']);           //name is string
// const invalid = getValue(user, ['address', 'country']); // Type Error at compile time!

This getValue function uses reduce to traverse the object path. The Get type ensures that the return type is correctly inferred based on the provided path. Crucially, if the path is invalid (e.g., trying to access country in the address object), TypeScript will generate a compile-time error.

Handling Optional Properties

Real-world objects often contain optional properties. Let's extend our approach to handle this:

type GetOptional<T, P extends Path> = P extends [infer Head, ...infer Tail]
  ? Head extends keyof T
    ? T[Head] extends undefined | null ? (GetOptional<NonNullable<T[Head]>, Tail> | undefined | null) : GetOptional<T[Head], Tail>
    : never
  : T;


function getOptionalValue<T, P extends Path>(obj: T, path: P): GetOptional<T, P> {
  let current = obj;
  for (const key of path) {
      if (current === undefined || current === null || !(key in current)) return undefined;
      current = current[key];
  }
  return current as GetOptional<T, P>;
}


const user2: User = {
    name: "Jane Doe",
    address: { street: "456 Oak Ave", city: "Smallville" },
    contact: { email: "[email protected]" }
  };

const zip = getOptionalValue(user2, ['address', 'zip']); // zip is string | undefined

The GetOptional type and getOptionalValue function gracefully handle cases where properties along the path might be undefined or null, preventing runtime errors.

Conclusion: Robust and Type-Safe Object Access

Using object paths as parameters offers a significant improvement in handling nested object properties in TypeScript. This approach promotes cleaner, more maintainable code, and the type safety ensures errors are caught during compilation, rather than at runtime. The added complexity is worth the substantial benefits in terms of code reliability and developer experience. Remember to adapt these examples to handle your specific data structures and error handling needs.