TypeScript Build-Time Configuration Type Generator

This challenge involves creating a system that generates TypeScript types based on configuration data available only at build time. This is incredibly useful for ensuring that your application's configuration is both type-safe and correctly structured, catching potential errors before runtime.

Problem Description

You need to develop a TypeScript utility that, given a configuration schema (defined as a TypeScript type), generates a concrete type representing the expected configuration object that a user or an environment variable system would provide. This generated type should be usable directly within your TypeScript code to ensure type safety.

Requirements:

1. Define a Schema Type: Create a base TypeScript type that represents the structure and constraints of your configuration. This schema type will define the keys, their types, and whether they are optional or required.
2. Generate a Concrete Type: Implement a mechanism (likely using TypeScript's advanced type manipulation features like mapped types, conditional types, and infer) that takes the schema type and produces a new type. This new type should represent the actual configuration object that will be instantiated at runtime.
3. Handle Optional vs. Required: The generated type must accurately reflect whether a configuration property was marked as optional or required in the schema.
4. Enforce Build-Time Safety: The entire process of type generation and validation should happen at TypeScript compile time. No runtime checks are required by this specific utility.

Expected Behavior:

When you define a schema and use the generator, the resulting type should:

• Include all properties from the schema.
• Mark properties as optional if they were optional in the schema.
• Mark properties as required if they were required in the schema.
• Maintain the original types of the properties.

Edge Cases:

• Consider deeply nested configuration objects.
• Consider arrays of specific types within the configuration.

Examples

Example 1: Simple Configuration

// Schema Definition
type MyConfigSchema = {
  port: number; // Required
  host?: string; // Optional
  debugMode: boolean; // Required
};

// Assume you have a type generation utility `BuildTimeConfig<Schema>`
// This is what you need to implement.
// type GeneratedConfig = BuildTimeConfig<MyConfigSchema>;

/*
Expected Generated Type (conceptual, not actual TS syntax for illustration):
{
  port: number;
  host?: string;
  debugMode: boolean;
}
*/

Explanation: The schema defines three properties: port and debugMode are required, while host is optional. The generated type should mirror this exact structure.

Example 2: Nested Configuration

// Schema Definition
type DatabaseConfigSchema = {
  username: string;
  password?: string;
  connection: {
    host: string;
    port: number;
  };
};

// type GeneratedNestedConfig = BuildTimeConfig<DatabaseConfigSchema>;

/*
Expected Generated Type (conceptual):
{
  username: string;
  password?: string;
  connection: {
    host: string;
    port: number;
  };
}
*/

Explanation: This example shows how nested objects within the schema should be preserved in the generated type.

Example 3: With Union Types and Arrays

// Schema Definition
type FeatureFlagsSchema = {
  featureA: 'enabled' | 'disabled';
  featureB?: 'beta' | 'stable' | 'experimental';
  featureList: string[];
  optionalFeatureList?: number[];
};

// type GeneratedFeatureFlags = BuildTimeConfig<FeatureFlagsSchema>;

/*
Expected Generated Type (conceptual):
{
  featureA: 'enabled' | 'disabled';
  featureB?: 'beta' | 'stable' | 'experimental';
  featureList: string[];
  optionalFeatureList?: number[];
}
*/

Explanation: Demonstrates handling of union types and array types, including optional arrays.

Constraints

• The solution must be implemented purely in TypeScript.
• The type generation must occur entirely at compile time. No runtime JavaScript code should be responsible for type generation.
• The solution should leverage TypeScript's advanced type system features.
• The generated type should be directly usable by other TypeScript code for type checking.

Notes

Think about how TypeScript distinguishes between required and optional properties in type definitions. Consider how you can iterate over the properties of a given type and transform them based on their original presence (or absence of ?). This problem is a great exercise in understanding and manipulating mapped types and conditional types. The goal is to create a type utility that reflects the schema, rather than validating runtime values against it.