TypeScript 类型安全服务注册表

Question

How can I create a type-safe service registry in Typescript. Basically, a function that returns a concrete type based on the argument.

get("a") would return an object of type ServiceA.
get("b") would return an object of type ServiceB.

I followed the answer from here: https://stackoverflow.com/a/47098963/12116498 but am still getting typing errors.

I have reduced my problem to the following and added the type errors I am getting:

console.log("Test get");
console.log("Get foo from AlertsService:", get('AlertsService').foo);
console.log("Get foo from AlertsService:", get('ModalService').foo);
console.log("Get foo from AlertsService:", get('ModalService').bar);
 
function get<T extends keyof ServiceMapping>(serviceType: T): ServiceMapping[T] {
  const t: keyof ServiceMapping = serviceType;
 
  switch (t) {
    case 'AlertsService':
 
// TS2322: Type '{ type: "AlertsService"; foo: string; }' is not assignable to type 'ServiceMapping[T]'.
// Type '{ type: "AlertsService"; foo: string; }' is not assignable to type 'never'.
// The intersection 'AlertsService & ModalService' was reduced to 'never' because property 'type' has conflicting types in some constituents.
 
      return {
        type: 'AlertsService',
        foo: 'testing'
      };
    case 'ModalService':
     
// TS2322: Type '{ type: "ModalService"; foo: string; bar: string; }' is not assignable to type 'ServiceMapping[T]'.
// Type '{ type: "ModalService"; foo: string; bar: string; }' is not assignable to type 'never'.
// The intersection 'AlertsService & ModalService' was reduced to 'never' because property 'type' has conflicting types in some constituents.
     
      return {
        type: 'ModalService',
        foo: 'testing',
        bar: 'bar test'
      };
 
    default:
      throw new Error("nope");
  }
}
 
export type ServiceMapping = {
  AlertsService: AlertsService;
  ModalService: ModalService;
}
 
export type AlertsService = {
  type: 'AlertsService',
  foo: string
}
 
export type ModalService = {
  type: 'ModalService',
  foo: string,
  bar: string
}

It is important to have the return type be narrowly scoped and not a union of other types.

Answer 1

@kruschid please tell me why overloadings are bad

  type AlertsService = {
    type: 'AlertsService',
    foo: string,
  }

  type ModalService = {
    type: 'ModalService',
    foo: string,
    bar: string
  }

  function get<T extends 'AlertsService'>(arg: 'AlertsService'): AlertsService
  function get<T extends 'ModalService'>(arg: T): ModalService
  function get<T extends 'AlertsService' | 'ModalService'>(arg: T) {

    switch (arg) {
      case 'AlertsService':
        return {
          type: 'AlertsService',
          foo: 'testing'
        };
      case 'ModalService':
        return {
          type: 'ModalService',
          foo: 'testing',
          bar: 'bar test'
        };

      default:
        throw new Error("nope");
    }
  }


  const result = get('AlertsService') // AlertsService
  const result2 = get('ModalService') // ModalService