链式调用两个映射对象类型引发非预期的联合与交集类型问题

这个问题我太熟了——本质是TypeScript的类型系统默认会把映射的键值对“扁平化”成联合类型，直接丢了两个映射之间的上下文关联，导致它没法自动识别“MapA的X键输出刚好适配MapB的X键输入”这种一对一的对应关系。要解决这个问题，核心就是用泛型参数锁定单个上下文键，不让TS把所有键的类型合并成模糊的联合，而是逐个追踪每个上下文的类型匹配。

我给你举个具体的例子，一步步拆解：

首先，先明确我们的两个映射和上下文类型：

// 定义所有可能的上下文
type Context = "user" | "product" | "order";

// 第一个映射：每个上下文对应的输出类型
type MapA = {
  user: { userId: string; name: string };
  product: { productId: string; price: number };
  order: { orderId: string; total: number };
};

// 第二个映射：每个上下文需要的输入类型（和MapA对应上下文的输出完全匹配）
type MapB = {
  user: (input: MapA["user"]) => { userDetails: string };
  product: (input: MapA["product"]) => { productDetails: string };
  order: (input: MapA["order"]) => { orderDetails: string };
};

// 模拟两个映射的实际实现
const mapA: MapA = {
  user: { userId: "123", name: "Alice" },
  product: { productId: "456", price: 99.99 },
  order: { orderId: "789", total: 199.98 }
};

const mapB: MapB = {
  user: (input) => ({ userDetails: `${input.name} (ID: ${input.userId})` }),
  product: (input) => ({ productDetails: `Product ${input.productId} costs $${input.price}` }),
  order: (input) => ({ orderDetails: `Order ${input.orderId} totals $${input.total}` })
};

如果直接写一个普通函数链式调用，你会发现TypeScript报错：

// 这种写法会失败：TS把mapA[key]推断成所有MapA值的联合类型，mapB[key]的参数也是对应联合类型，没法匹配
function badChain(key: Context) {
  return mapB[key](mapA[key]); // 报错：类型“MapA[keyof MapA]”的参数不能赋给类型“MapA["user"] & MapA["product"] & MapA["order"]”的参数
}

这就是你说的“set-valued”模式问题——TS把所有键的类型合并成了联合/交集，完全丢失了上下文关联。

那怎么解决？用泛型参数锁定单个上下文键：

// 用泛型K锁定当前的上下文键，TS会追踪到具体的键对应的类型
function goodChain<K extends Context>(key: K) {
  return mapB[key](mapA[key]); // 完美通过类型检查！
}

// 测试一下，完全没问题
const userResult = goodChain("user"); // 类型是{ userDetails: string }
const productResult = goodChain("product"); // 类型是{ productDetails: string }

为什么这个方法有效？因为泛型参数K在这里是一个具体的、单个的上下文键，而不是整个Context联合类型。TS会为每个可能的K单独检查类型：当K是"user"时，mapA[K]是MapA["user"]，mapB[K]的参数刚好就是这个类型，完全匹配；同理其他键也是一样的逻辑。

如果需要批量处理所有上下文的链式调用，也可以用映射类型来生成精确的结果类型：

// 生成所有上下文的链式调用结果类型
type ChainedResults = {
  [K in Context]: ReturnType<MapB[K]>;
};

// 批量执行所有链式调用
function chainAll(): ChainedResults {
  return {
    user: mapB.user(mapA.user),
    product: mapB.product(mapA.product),
    order: mapB.order(mapA.order),
  } as const;
}

const allResults = chainAll();
// allResults.user 类型是{ userDetails: string }，完全精确

还有一种通用场景：如果你的映射是动态创建的，或者想写一个通用的链式调用工具函数，可以用泛型约束来绑定两个映射的键和类型关系：

// 通用链式调用函数，适用于任意结构匹配的映射
function genericChainMaps<
  K extends string,
  A extends Record<K, unknown>,
  B extends Record<K, (input: A[K]) => unknown>
>(key: K, mapA: A, mapB: B) {
  return mapB[key](mapA[key]);
}

// 使用时TS会自动推导类型，并且严格检查匹配性
const genericUserResult = genericChainMaps("user", mapA, mapB);

总结一下，核心思路就是不要让TypeScript处理整个联合类型的映射，而是用泛型把每个上下文键单独锁定，这样TS就能逐个检查每个变体的类型匹配，完全保留两个映射之间的上下文关联。

备注：内容来源于stack exchange，提问作者user3910279