Use class name to name interface properties

I think this TS Playground shows what Im trying to achieve:

I want to use Class.name as a variable to name my properties.

class MyClass {
  readonly a: {b: number} = { b: 123 };

  constructor() {
    this.a.b = 1;
  }
}

// try1
interface Actions {
  [MyClass.name + '_action1']: string,
  [MyClass.name + '_action2']: number
}

interface Actions2 {
  MyClass_action1: string,
  MyClass_action2: number
}

// expect a and b to behave the same
const a: Actions2 = {
  MyClass_action1: '4',
  MyClass_action2: 1
}

const b: Actions = {
  MyClass_action1: '4',
  MyClass_action2: 1
}

Is this even possible?

This isn't possible without workarounds.

The name property of class constructors is of type string, as inherited from the Function interface. The compiler doesn't know the string literal type of the name. See microsoft/TypeScript#43325 and the issues to which it links.

Assuming that we know for sure that at runtime, a class Foo {⋯} will have Foo.name === "Foo" (meaning that we don't worry about weird edge cases where it is overridden by a static property or where the class is minified or mangled, etc), TypeScript still can't easily allow the type of Foo.name to be "Foo". That's because the static side of a class forms a type hierarchy, so if you have class Bar extends Foo {⋯}, then TypeScript expects Bar.name to be assignable to Foo.name. So if Foo.name is of type "Foo" then Bar.name also needs to be of type "Foo". But that's quite unlikely to be true at runtime. Essentially there's a whole mess surrounding static inheritance that TypeScript mostly tries to avoid, leading to somewhat less strong types than people would like.

It's vaguely possible that someday JavaScript will introduce a nameof operator like C# has, and then TypeScript will support that (see microsoft/TypeScript#1579), and then we can extract the name of a class in the TypeScript type system in some officially supported way.

But until and unless any of these happen, you're stuck specifying it yourself. You can do so by manually merging the information in, like this:

declare namespace MyClass {
  export const name: "MyClass"
}

And then you can define your keys via template literal types (that's the only way to get string concatenation at the type level):

const action1 = `${MyClass.name}_action1` as const;
const action2 = `${MyClass.name}_action2` as const;
interface Actions {
  [action1]: string,
  [action2]: number
}

This may or may not meet your needs, but for now, it's either do something like this, or give up.

Playground link to code