TypeScript泛型字符串字面量依赖类型：switch返回与穷尽性问题

先给出修正笔误后的原始代码（假设Bucket、Table、LambdaFunction类型已提前定义）：

type Bucket = { grantWrite(lambda: LambdaFunction): void };
type Table = { grantReadData(lambda: LambdaFunction): void };
type LambdaFunction = {};

const operations = {
  DDB: ["getItem"] as const,
  S3: ["putObject"] as const,
};
type Service = keyof typeof operations;
type ServiceOperation<T extends Service> = typeof operations[T][number];
type ResourceFor<T extends Service> = T extends 'S3' ? Bucket : T extends 'DDB' ? Table : never;

const setPermission = <T extends Service>(
  serviceType: T,
  operation: ServiceOperation<T>
): ((caller: LambdaFunction, resource: ResourceFor<T>) => void) => {
  switch (serviceType) {
    case 'DDB':
      switch (operation) {
        case 'getItem':
          return (lambda: LambdaFunction, table: Table) => table.grantReadData(lambda);
      }
    case 'S3':
      switch (operation) {
        case 'putObject':
          return (lambda: LambdaFunction, bucket: Bucket) => bucket.grantWrite(lambda);
      }
  }
};

问题分析 #

• 类型兼容问题：原始代码中返回的分支函数无法被TypeScript自动推导为声明的返回类型，必须手动强制转换，不够优雅。
• 返回穷尽性问题：缺少对所有分支的兜底处理，TypeScript判定函数可能返回undefined，与声明的返回类型冲突，触发报错。

解决方案 #

1. 消除强制类型转换，让TypeScript自动推导 #

在switch分支中，TypeScript会自动细化泛型T的具体类型。比如进入case 'DDB'分支时，T会被推断为'DDB'，此时ResourceFor<T>等价于Table，返回的(lambda, table) => ...自然符合对应类型，无需手动转换。

2. 添加穷尽性检查，消除undefined报错 #

在每个switch的末尾添加default分支，用never类型变量接收当前值，确保所有可能的输入情况都被覆盖：

const setPermission = <T extends Service>(
  serviceType: T,
  operation: ServiceOperation<T>
): ((caller: LambdaFunction, resource: ResourceFor<T>) => void) => {
  switch (serviceType) {
    case 'DDB':
      switch (operation) {
        case 'getItem':
          return (lambda: LambdaFunction, table: Table) => table.grantReadData(lambda);
        default:
          const _unknownDDBOp: never = operation;
          throw new Error(`未知DDB操作: ${_unknownDDBOp}`);
      }
    case 'S3':
      switch (operation) {
        case 'putObject':
          return (lambda: LambdaFunction, bucket: Bucket) => bucket.grantWrite(lambda);
        default:
          const _unknownS3Op: never = operation;
          throw new Error(`未知S3操作: ${_unknownS3Op}`);
      }
    default:
      const _unknownService: never = serviceType;
      throw new Error(`未知服务类型: ${_unknownService}`);
  }
};

额外优化：用对象映射替代嵌套switch #

如果后续要新增更多服务或操作，对象映射的方式更简洁易维护，同时天然支持类型推导：

const permissionHandlers = {
  DDB: {
    getItem: (lambda: LambdaFunction, table: Table) => table.grantReadData(lambda),
  } as const,
  S3: {
    putObject: (lambda: LambdaFunction, bucket: Bucket) => bucket.grantWrite(lambda),
  } as const,
};

const setPermission = <T extends Service>(
  serviceType: T,
  operation: ServiceOperation<T>
): ((caller: LambdaFunction, resource: ResourceFor<T>) => void) => {
  const handler = permissionHandlers[serviceType][operation];
  if (!handler) {
    throw new Error(`未找到${serviceType}.${operation}对应的权限处理函数`);
  }
  return handler;
};

内容的提问来源于stack exchange，提问作者MBoros