TypeScript - 基于通用枚举或字符串列表限制抽象成员的键

Question

I'm having trouble figuring out how to even find the right words to explain what I'm trying to do, so apologies if I mix up terminology. What I'm trying to do is restrict the keys of an object / interface to a list of keys belonging to an enum (or string[] list). This is already possible at a basic level, like so:

enum RestrictKeysTo {
    name = 'name',
    age = 'age'
}
type Person = {
    [K in RestrictKeysTo]?: string | number;
}
const phil: Person = {
    // Allowed
    age: 24,
    name: 'Phillip'
    // Throws error
    occupation: 'developer'
};

This is great! However, I want to use this in a more flexible way, where the list of accepted keys can be passed in via an interface or class, and the list can be used to restrict keys elsewhere. The specific end goal I'm looking for is something like this:

abstract class BaseClass {
    public abstract keys: string[];
    // How do I restrict ages to be keyed by keys?
    public abstract ages: //...
}

class Final extends BaseClass {
    public keys = ['joe', 'ralph'];
    public ages = {
        joe: 24,
        ralph: 50
    }
}

I'm guessing that if a solution exists, it involves passing generics to the base class, but I'm having trouble working out the specifics... for example, this is the closest I can seem to get ( working ):

abstract class BaseClass<T extends string> {
    public abstract ages: {
        [K in T]: number
    }
}

type Keys = 'joe' | 'ralph' | 'betty'

class Final extends BaseClass<Keys> {
    public ages = {
        joe: 24,
        ralph: 50,
        betty: 32
    };
}

However, this is less than ideal, as I want to be able to reuse the keys across base and filled in (abstract) methods. I was thinking I would pass it via the constructor, but I'm running into two issues:

• It requires the dev to retype the union as an array
• I can't get it to type guard quite right

Here is a non-functional example, where I might be close:

type KeyArr<T extends string> = {
    [K in T]?: keyof T;
}

abstract class BaseClass<T extends string> {
    public keys: KeyArr<T>;
    constructor(keys: KeyArr<T>) {
        this.keys = keys;
    }
    public abstract ages: {
        [K in T]?: number
    }
}

type Keys = 'joe' | 'ralph' | 'betty'

class Final extends BaseClass<Keys> {
    constructor() {
        // This should ideally throw an error, since it is missing 'betty', and 'joe' does not belong to Keys
        // Not working - says nothing in common with KeyArr
        super(['joe', 'ralph', 'joe'])
    }
    public ages = {
        joe: 24,
        ralph: 50,
        betty: 24
    };
}

---

To be completely honest, for some reason I have a mental block with TS generics - so it is very likely I am missing something basic here. Any help is appreciated!

Answer 1

Playing with your code shows following solution to be working correctly and it should match your requirements.

Solution with enum

abstract class BaseClass<T extends string> {
    public abstract keys: T[];
    public abstract ages: {
        [K in T]?: number
    }
}

enum Keys {
    Joe = "Joe",
    Ralph = "Ralph",
    Betty = "Betty"
}

class Final extends BaseClass<Keys> {
    public keys = [Keys.Betty, Keys.Joe, Keys.Ralph];
    public ages = {
        [Keys.Betty]: 24
    };
}

const final = new Final();
const a = final.ages[Keys.Betty] // number

As you can see I did few things: 1. I am using enum instead of string literal 2. I removed constructor, as in final class you were not using argument of it 3. I changed types of keys into simple T[]

Now why I did those changes.

1. Problem with string literal was - in extending class passing ['betty', 'ralph'] was inferencing it as string[], to fix it I needed to do - ['betty' as const, 'ralph' as const]. As I wanted to avoid that, I have chosen enum.

2. I removed constructor as your implementation shows you want to define keys inside class, and not to pass them from outside.

3. KeyArr was no difference from simple T[]

Solution with string literal type

Below implementation with string literal form comparison:

abstract class BaseClass<T extends string> {
    public abstract keys: T[];
    public abstract ages: {
        [K in T]?: number
    }
}

type Keys = 'joe' | 'ralph' | 'betty'

class Final extends BaseClass<Keys> {
    public keys = ['betty' as const, 'joe' as const]; // as const because inference showing string
    public ages = {
        'betty': 24
    };
}

const final = new Final();
const a = final.ages.betty // number

Both solutions look valid.

About exhaustiveness.

Boths solution given by me allows on putting array of not all keys. It is done because your type for ages not requires value for every key - {[K in T]?: number} means its a partial record. In my opinion the whole would have a sense if keys would not be exhaustive but ages would be. Consider:

abstract class BaseClass<T extends string> {
    public abstract keys: T[];
    public abstract ages: {
        [K in T]: number // pay attention removed ?
    }
}

type Keys = 'joe' | 'ralph' | 'betty'

class Final extends BaseClass<Keys> {
    public keys = ['betty' as const, 'joe' as const]; // as const because inference showing string
    public ages = {
        'betty': 24 // error total record of all keys needs to be provided
    };
}

This difference means that in our Final class we can define which keys we are requiring for ages to be provided.