Infer generic subtype in dynamic record

I'm trying to create a configuration management class that maps keys with some resolution strategies. In doing so, I'd like to have an accessor function that retrieves the value, and the correct type from the dynamic map.

type ParameterDescription<T> = {
  default: T;
};

type ParameterDictionary = Record<
  string,
  ParameterDescription<string | number | boolean>
>;

type ParameterSubType<T> = T extends ParameterDescription<infer U> ? U : never;

const config: ParameterDictionary = {
  foo: { default: "test" },
  bar: { default: 1 },
  baz: { default: true },
};

function get<T extends ParameterDictionary, K extends keyof T>(config: T, key: K): ParameterSubType<T[K]>;
function get<T extends ParameterDictionary>(config: T, key: string): undefined {
  return config[key].default || undefined;
}

const a = get(config, "foo"); // type is string
const b = get(config, "bar"); // type is number
const c = get(config, "baz"); // type is boolean
const d = get(config, "boz"); // type is undefined

Is something like this possible? I'd like to avoid having to declare an interface that explicitly lists the key types; ie:

interface {
  foo: ParameterDescription<string>
  bar: ParameterDescription<number>
}

Your main problem is that you annotated the config variable to be of type ParameterDictionary like

const config: ParameterDictionary = {
  foo: { default: "test" },
  bar: { default: 1 },
  baz: { default: true },
}

but by doing that you are explicitly throwing away any more specific information the compiler might have had from the object literal initializer. Instead you should probably just let the compiler infer its type:

const config = {
  foo: { default: "test" },
  bar: { default: 1 },
  baz: { default: true },
};

Or, if you really want to see some kind of warning if config fails to be a ParameterDictionary, you could use the satisfies operator on the initializer:

const config = {
  foo: { default: "test" },
  bar: { default: 1 },
  baz: { default: true },
} satisfies ParameterDictionary;

Once you do that, the compiler will know that config.foo.default is a string, etc.

Then you need to modify the call signature of get() to allow key to be any property key and not just known keys of config. Perhaps like this:

function get<T extends ParameterDictionary, K extends PropertyKey>(
  config: T, key: K
): K extends keyof T ? T[K]["default"] : undefined;

function get(config: ParameterDictionary, key: string) {
  return config[key]?.default; // <-- note that this fixes your broken impl
}

Here the return type of get() is a conditional type that checks if K (the type of key) is known to be a key of T (the type of config). If so, you get the type of the default property of T[K]. If not, you get undefined. This gives you the desired behavior:

const a = get(config, "foo"); // const a: string
const b = get(config, "bar"); // const b: number
const c = get(config, "baz"); // const c: boolean
const d = get(config, "boz"); // const d: undefined

(Note that I had to fix the implementation so that the last would be undefined at runtime and not a TypeError)

So that's the answer to the question as asked. There's a caveat here: TypeScript object types are not "sealed"; just because a type doesn't mention a key, doesn't mean there isn't such a key present on a value of that type. So technically returning undefined when a key isn't known to exist might not be correct. For example:

const config2 = {
  foo: { default: "test" },
  bar: { default: 1 },
  baz: { default: true },
  oops: { default: "oops" }
} satisfies ParameterDictionary; // okay

const oops: typeof config = config2; // okay
const e = get(oops, "oops");
// const e: undefined
console.log(e); // "oops" <-- not undefined

That's pretty unlikely, since it relies on aliasing and widening, but you might want to be aware. The "safe" way to implement get() is either to have the return value be unknown instead of undefined, or to make the compiler reject any keys that aren't known. But that's digressing from the question, so I'll stop here.

Playground link to code