typescript - JSON 模式的 anyOf 类型如何转换为 typescript ？

Question

假设我们有这样一个模式(我借用了 OpenAPI 3.0 格式，但我认为意图很明确):

{
  "components": {
    "schemas": {
      "HasName": {
        "type": "object",
        "properties": {
          "name": { "type": "string" }
        }
      },
      "HasEmail": {
        "type": "object",
        "properties": {
          "email": { "type": "string" }
        }
      },
      "OneOfSample": {
        "oneOf": [
          { "$ref": "#/components/schemas/HasName" },
          { "$ref": "#/components/schemas/HasEmail" }
        ]
      },
      "AllOfSample": {
        "allOf": [
          { "$ref": "#/components/schemas/HasName" },
          { "$ref": "#/components/schemas/HasEmail" }
        ]
      },
      "AnyOfSample": {
        "anyOf": [
          { "$ref": "#/components/schemas/HasName" },
          { "$ref": "#/components/schemas/HasEmail" }
        ]
      }
    }
  }
}

基于这个模式和我目前阅读的文档，我会像这样表达类型 OneOfSample 和 AllOfSample:

type OneOfSample = HasName | HasEmail // Union type
type AllOfSample = HasName & HasEmail // Intersection type

但是我将如何表达 AnyOfSample 类型？基于此页面:https://swagger.io/docs/specification/data-models/oneof-anyof-allof-not/我会想到这样的事情:

type AnyOfSample = HasName | HasEmail | (HasName & HasEmail)

问题是如何在 typescript 中正确表达 JSON 模式中的 anyOf 类型？

Answer 1

看起来“OneOf”的意思是“必须完全一个”，而“AnyOf”的意思是“必须至少个匹配”。事实证明，“至少一个”是一个更基本的概念，对应于union。 | 表示的操作(“inclusive or ”)象征。因此，您的问题的答案是:

type AnyOfSample = HasName | HasEmail // Union type

与交集的进一步并集不会改变接受的值:

type AnyOfSample = HasName | HasEmail | (HasName & HasEmail) 

因为联合只能添加元素，而HasName & HasEmail的所有元素已经出现在 HasName | HasEmail 中.观察:

type HasName = { name: string }
type HasEmail = { email: string };

type AnyOfIntersection = HasName | HasEmail | (HasName & HasEmail)
type AnyOfWithout = HasName | HasEmail

const aI: AnyOfIntersection = { name: "", email: "" }; // of course
const aW: AnyOfWithout = { name: "", email: "" }; // also accepted

如果要使用 the in operator to narrow values，您可能希望保留交集，这做出了技术上不正确但通常有用的假设，即如果某个键未知存在于某个类型中，那么它不存在:

function processAnyOf(aI: AnyOfIntersection, aW: AnyOfWithout) {
    if (("name" in aI) && ("email" in aI)) {
        aI; // (HasName & HasEmail)
    }
    if (("name" in aW) && ("email" in aW)) {
        aW; // never
    }
}

---

当然，这意味着您对 OneOfSample 的定义不正确.这个操作更像是一个 disjunctive union ( "exclusive or" )，虽然不完全是因为当你有三个或更多集合时，析取并集的通常定义意味着“匹配奇数”，这不是你想要的。顺便说一句，我找不到我们在这里谈论的析取联合类型的广泛使用的名称，尽管这里有一个 interesting paper。讨论它。

那么，我们如何在 TypeScript 中表示“完全匹配”？这并不简单，因为它最容易根据 negation 构建或 subtraction TypeScript 目前无法做到的类型。也就是说，您想说这样的话:

type OneOfSample = (HasName | HasEmail) & Not<HasName & HasEmail>; // Not doesn't exist

但是没有Not在这里工作。因此，您所能做的就是某种解决方法……那么有什么可能呢？您可以告诉 TypeScript 一个类型可能没有特定的属性。例如类型 NoFoo可能没有 foo键:

type ProhibitKeys<K extends keyof any> = {[P in K]?: never}; 
type NoFoo = ProhibitKeys<'foo'>; // becomes {foo?: never};

并且您可以使用条件类型获取一个键名列表并从另一个列表中删除键名(即减去字符串文字):

type Subtract = Exclude<'a'|'b'|'c', 'c'|'d'>; // becomes 'a'|'b'

这让您可以执行以下操作:

type AllKeysOf<T> = T extends any ? keyof T : never; // get all keys of a union
type ProhibitKeys<K extends keyof any> = {[P in K]?: never }; // from above
type ExactlyOneOf<T extends any[]> = {
  [K in keyof T]: T[K] & ProhibitKeys<Exclude<AllKeysOf<T[number]>, keyof T[K]>>;
}[number];

在这种情况下，ExactlyOneOf需要一个类型的元组，并将表示元组的每个元素的联合，明确禁止来自其他类型的键。让我们看看它的实际效果:

type HasName = { name: string };
type HasEmail = { email: string };
type OneOfSample = ExactlyOneOf<[HasName, HasEmail]>;

如果我们检查 OneOfSample使用 IntelliSense，它是:

type OneOfSample = (HasEmail & ProhibitKeys<"name">) | (HasName & ProhibitKeys<"email">);

这是说“没有 HasEmail 属性的 name，或者没有 HasName 属性的 email。它有效吗？

const okayName: OneOfSample = { name: "Rando" }; // okay
const okayEmail: OneOfSample = { email: "rando@example.com" }; // okay
const notOkay: OneOfSample = { name: "Rando", email: "rando@example.com" }; // error

看起来像。

元组语法允许您添加三种或更多类型:

type HasCoolSunglasses = { shades: true };
type AnotherOneOfSample = ExactlyOneOf<[HasName, HasEmail, HasCoolSunglasses]>;

这检查为

type AnotherOneOfSample = (HasEmail & ProhibitKeys<"name" | "shades">) | 
  (HasName & ProhibitKeys<"email" | "shades">) | 
  (HasCoolSunglasses & ProhibitKeys<"email" | "name">)

如您所见，它正确地分发了被禁止的 key 。

---

还有其他方法可以做到这一点，但这就是我继续进行的方式。这是一种变通方法而不是完美的解决方案，因为它无法正确处理某些情况，例如具有相同键的两种类型的属性是不同类型:

declare class Animal { legs: number };
declare class Dog extends Animal { bark(): void };
declare class Cat extends Animal { meow(): void };
type HasPetCat = { pet: Cat };
type HasPetDog = { pet: Dog };
type HasOneOfPetCatOrDog = ExactlyOneOf<[HasPetCat, HasPetDog]>;
declare const abomination: Cat & Dog;
const oops: HasOneOfPetCatOrDog = { pet: abomination }; // not an error

在上面，ExactlyOneOf<>无法向下递归到 pet 的属性属性以确保它不是一个 Cat和一个 Dog .这可以解决，但它开始变得比您可能想要的更复杂。还有其他边缘情况。这取决于您的需求。

Playground link to code