Deep Readonly & Recursive Type Aliases

Type Inference & Literal Types (const vs. let)

Discover how TypeScript infers types automatically and how let versus const declarations shape wide types versus narrow literal types.

1. Handling Nested Data Graphs

Built-in Readonly<T> only marks top-level properties as read-only. For deeply nested object graphs (like state trees or JSON configs), you need Deep Readonly recursive types.

2. Recursive Type Aliases (JSON & Trees)

A type alias is recursive when it refers to itself inside its own definition. This is ideal for modeling JSON values or folder tree structures:

// Recursive JSON Value Type
type JSONValue =
  | string
  | number
  | boolean
  | null
  | JSONValue[]
  | { [key: string]: JSONValue };

const configData: JSONValue = {
  appName: "DevLoom",
  versions: [1, 2, 3],
  nested: {
    enabled: true,
  },
};

3. DeepReadonly Utility Type

Map through object properties recursively to enforce immutability at all nesting levels:

type DeepReadonly<T> = {
  readonly [K in keyof T]: T[K] extends object ? DeepReadonly<T[K]> : T[K];
};

type AppState = {
  user: {
    profile: {
      name: string;
    };
  };
};

const state: DeepReadonly<AppState> = {
  user: { profile: { name: "Alex" } },
};

// state.user.profile.name = "New Name"; // Error: Cannot assign to read-only property!

4. Common Mistakes

• Infinite Recursion Compiler Slowdowns: Recursive types without a termination check on non-object primitives can cause TypeScript compiler timeouts. Always check T[K] extends object before recursing!

5. Next Steps

Use recursive types for complex state trees. Next, let's enter Phase 4 and explore Classes, Access Modifiers, and Implements!