TypeScript Type Versioning with Union Discriminators

In software development, it's common for data structures and APIs to evolve over time. Managing these changes while maintaining backward compatibility can be challenging. This challenge focuses on creating a robust system for handling different versions of a TypeScript type, enabling your application to gracefully adapt to older or newer data formats.

Problem Description

Your task is to implement a type versioning system in TypeScript. You will define a base type for a "Message" and then create specific versions of this Message type, each with a unique version property. You will then write a function that can process an incoming Message, regardless of its version, and safely extract its specific data. This will involve using discriminated unions to ensure type safety and handle different versions correctly.

Key Requirements:

• Define a base Message interface with a common version property (e.g., a string or number).
• Create at least two distinct versions of the Message type (e.g., MessageV1, MessageV2), each extending the base Message and adding or modifying properties.
• Implement a function, processMessage, that accepts a Message (which could be any of its versions) as input.
• Inside processMessage, use a switch statement or if/else if chain based on the version property to handle each message type specifically.
• Ensure that when processing a specific version, TypeScript correctly infers and provides access to the unique properties of that version.
• The function should return a string indicating which version was processed and some information from the message.

Expected Behavior:

When processMessage receives a message of a particular version, it should execute the code block corresponding to that version and return a descriptive string. For example, if it receives a MessageV1, it should access MessageV1's specific properties.

Edge Cases to Consider:

• What happens if an unknown version is encountered? The function should handle this gracefully.

Examples

Example 1:

interface BaseMessage {
  version: string;
}

interface MessageV1 extends BaseMessage {
  version: "v1";
  id: number;
  payload: string;
}

interface MessageV2 extends BaseMessage {
  version: "v2";
  messageId: string;
  data: {
    content: string;
    timestamp: number;
  };
}

// Type alias for all possible message versions
type Message = MessageV1 | MessageV2;

// --- Function to implement ---
function processMessage(message: Message): string {
  // Implementation goes here
}

// --- Usage ---
const msg1: MessageV1 = { version: "v1", id: 123, payload: "Hello, world!" };
const msg2: MessageV2 = {
  version: "v2",
  messageId: "abc-456",
  data: { content: "Important update", timestamp: Date.now() }
};

console.log(processMessage(msg1));
// Expected Output: "Processed V1 message with ID: 123 and payload: Hello, world!"

console.log(processMessage(msg2));
// Expected Output: "Processed V2 message with ID: abc-456 and content: Important update"

Example 2:

// Assume the same interfaces and type alias as Example 1

// --- Usage with an unknown version ---
const unknownMessage = { version: "v3", someOtherProp: "value" } as any; // Forcing an unknown version

console.log(processMessage(unknownMessage));
// Expected Output: "Unknown message version: v3"

Constraints

• The version property must be a literal string type (e.g., "v1", "v2").
• The processMessage function must accept a union type of all defined message versions.
• The implementation of processMessage should not use type assertions (like as) unnecessarily within the version-specific logic.
• The code should be valid TypeScript.

Notes

This challenge is designed to reinforce your understanding of discriminated unions in TypeScript. The version property acts as the discriminant. Pay close attention to how TypeScript narrows down the type within conditional blocks. Consider how you would extend this system to include more message versions in the future.