Simulating Dependent Types for Enhanced Data Integrity in TypeScript

Dependent types are a powerful feature found in some programming languages that allow types to be parameterized by values. This enables expressing more precise invariants and guarantees about data. This challenge aims to simulate a simplified form of dependent types in TypeScript, allowing you to define data structures whose shape or contents depend on specific values within the structure itself. This is useful for creating strongly typed APIs and validating complex data relationships at compile time.

Problem Description

Your task is to create a system in TypeScript that simulates dependent types, specifically focusing on the scenario where the type of a field within an object depends on the value of another field in the same object.

You need to implement a mechanism that allows for defining a base type and then conditional types that vary based on a specific discriminant value.

Key Requirements:

1. Discriminant Field: Define a way to specify a "discriminant" field within a type. This field's value will determine the shape of other parts of the object.
2. Variant Types: Create a mechanism to define different "variant" types, each corresponding to a specific value of the discriminant.
3. Conditional Typing: Implement a way to represent an object type where one or more fields have a type that is conditionally determined by the discriminant field.
4. Type Safety: Ensure that TypeScript's type checking correctly enforces these dependencies. If an object has a specific discriminant value, the other fields must conform to the type associated with that discriminant value.

Expected Behavior:

• When creating an object that conforms to a dependent type, TypeScript should prevent you from assigning a value to a conditional field if it doesn't match the type expected for the current discriminant value.
• When inferring types, TypeScript should accurately reflect the dependent relationships.

Edge Cases:

• Consider scenarios where the discriminant has multiple possible values.
• Think about how to handle cases where a field might be optional depending on the discriminant.

Examples

Example 1: Simple Event Type

Imagine you're modeling different types of events. The eventType field will determine the structure of the payload.

// Hypothetical desired syntax and behavior:

// Define a base event structure with a discriminant
interface BaseEvent<TDiscriminant extends string> {
  timestamp: number;
  eventType: TDiscriminant;
}

// Define specific payloads for different event types
interface UserCreatedPayload {
  userId: string;
  username: string;
}

interface OrderPlacedPayload {
  orderId: string;
  amount: number;
  userId: string;
}

// A dependent type for events, where payload type depends on eventType
type Event =
  | (BaseEvent<'userCreated'> & { payload: UserCreatedPayload })
  | (BaseEvent<'orderPlaced'> & { payload: OrderPlacedPayload });

// --- How TypeScript should behave ---

// Valid
const userEvent: Event = {
  timestamp: 1678886400,
  eventType: 'userCreated',
  payload: {
    userId: 'abc-123',
    username: 'Alice'
  }
};

// Invalid (TypeScript should complain here)
/*
const invalidUserEvent: Event = {
  timestamp: 1678886401,
  eventType: 'userCreated',
  payload: {
    orderId: 'xyz-789', // Incorrect payload type for 'userCreated'
    amount: 100,
    userId: 'abc-123'
  }
};
*/

// Valid
const orderEvent: Event = {
  timestamp: 1678886402,
  eventType: 'orderPlaced',
  payload: {
    orderId: 'xyz-789',
    amount: 100,
    userId: 'abc-123'
  }
};

Example 2: Configuration Object

Consider a configuration object where the type of config depends on the mode.

// Hypothetical desired syntax and behavior:

type Mode = 'development' | 'production';

interface DevelopmentConfig {
  logLevel: 'debug' | 'info';
  hotReload: boolean;
}

interface ProductionConfig {
  minify: boolean;
  cacheEnabled: boolean;
}

// Dependent type for configuration
type AppConfig = {
  mode: Mode;
} & (
  Mode extends 'development'
    ? { config: DevelopmentConfig }
    : Mode extends 'production'
      ? { config: ProductionConfig }
      : never // Should not happen with current Mode definition
);

// --- How TypeScript should behave ---

// Valid
const devConfig: AppConfig = {
  mode: 'development',
  config: {
    logLevel: 'debug',
    hotReload: true
  }
};

// Invalid (TypeScript should complain here)
/*
const invalidDevConfig: AppConfig = {
  mode: 'development',
  config: {
    minify: true, // Incorrect config type for 'development' mode
    cacheEnabled: false
  }
};
*/

// Valid
const prodConfig: AppConfig = {
  mode: 'production',
  config: {
    minify: true,
    cacheEnabled: true
  }
};

Constraints

• You must achieve this simulation using standard TypeScript features (type aliases, interfaces, conditional types, mapped types, etc.).
• No runtime checks are expected. The goal is to leverage TypeScript's static type system.
• The solution should be declarative – defining the types should be sufficient to enforce the dependencies.
• Aim for a solution that is reasonably readable and maintainable for complex scenarios.

Notes

This challenge is about understanding and applying advanced TypeScript type manipulation techniques. Think about how you can use conditional types and discriminated unions to model relationships where one part of a type dictates another. The examples provided illustrate the desired outcome and how TypeScript should behave. Your implementation will be a way to achieve this descriptive typing. Consider how you can create a base type and then use unions or intersection with conditional types to achieve the dependency.