Type Safe Deep Property Access in TypeScript

Imagine you have a deeply nested JavaScript object, and you need to access a property at a specific path within that object. Doing this safely in TypeScript can be tricky, as the compiler often struggles to infer the exact type of the deeply nested property. This challenge asks you to implement a utility function that not only safely retrieves a property by its path but also correctly infers its type in TypeScript, ensuring type safety throughout your application.

Problem Description

Your task is to create a TypeScript function named get that takes an object and a path (represented as a string of dot-separated property names) and returns the value at that path. The function should be type-safe, meaning it should infer the correct type of the returned value based on the input object and the provided path.

Key Requirements:

1. Path Traversal: The function must correctly traverse the object using the provided dot-separated path.
2. Type Inference: The return type of the get function must be accurately inferred by TypeScript based on the object structure and the path.
3. Handling Missing Properties: If any part of the path does not exist in the object, the function should return undefined. The inferred type should also reflect this possibility.
4. Generics: Utilize TypeScript generics to achieve type safety.

Expected Behavior:

• When a property exists at the given path, return its value and infer its specific type.
• When a property is missing at any point in the path, return undefined and infer the type as potentially undefined.
• The function should be able to handle objects with varying levels of nesting.

Edge Cases to Consider:

• Empty path.
• Path leading to null or undefined values within the object.
• Object is null or undefined.

Examples

Example 1:

const user = {
  name: "Alice",
  address: {
    street: "123 Main St",
    city: "Anytown",
  },
  isActive: true,
};

// get(user, "name") should return "Alice" and infer its type as string.
// get(user, "address.city") should return "Anytown" and infer its type as string.
// get(user, "isActive") should return true and infer its type as boolean.

Example 2:

const config = {
  database: {
    host: "localhost",
    port: 5432,
    credentials: {
      username: "admin",
      password: "secure_password",
    },
  },
  logging: {
    level: "INFO",
    enabled: false,
  },
};

// get(config, "database.port") should return 5432 and infer its type as number.
// get(config, "logging.level") should return "INFO" and infer its type as string.

Example 3: (Handling missing properties and edge cases)

const data = {
  id: 1,
  details: {
    tags: ["typescript", "coding"],
  },
  settings: null,
};

// get(data, "details.tags.0") should return "typescript" and infer its type as string.
// get(data, "details.country") should return undefined and infer its type as undefined.
// get(data, "settings.theme") should return undefined and infer its type as undefined.
// get(null, "any.path") should return undefined and infer its type as undefined.
// get(data, "") should return data and infer its type as typeof data.

Constraints

• The input object can be any valid JavaScript object, including nested objects and arrays.
• The path will be a string, potentially empty, and use dot notation (.) for property access. Array indices will be represented as numbers within the path string (e.g., "details.tags.0").
• The function should handle cases where intermediate properties or the final property might be null or undefined.
• Performance is not a critical concern for this challenge, but the solution should be reasonably efficient for typical object sizes.

Notes

• Consider how to break down the path string into individual property keys.
• The core challenge lies in defining the generic types to accurately represent the return type, accounting for potential undefined values due to missing properties.
• Think about the base case for your recursive or iterative traversal.
• Leveraging TypeScript's mapped types and conditional types might be beneficial for achieving precise type inference.
• For array access, you'll need to parse numeric indices from the path string.