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

在下面，我假设我们正在使用TS v3.1：

看起来“ OneOf”的意思是“必须完全匹配一个”，而“ AnyOf”的意思是“必须完全匹配一个”。事实证明，“至少一个”是一个更基本的概念，它对应于|符号表示的union操作（“ inclusive or”）。因此，您对问题的回答如下：

type AnyOfSample = HasName | HasEmail // Union type

请注意，与交点的进一步并集不会改变事物：

type AnyOfSample = HasName | HasEmail | (HasName & HasEmail) // same thing

因为一个联合只能添加元素，并且HasName & HasEmail的所有元素都已经存在于HasName | HasEmail中。

当然，这意味着您对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]>;

如果我们使用IntelliSense检查OneOfSample，则为：

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">)

如您所见，它正确地在周围散布了禁止的钥匙。

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

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。可以解决此问题，但是它开始变得比您可能想要的复杂。也有其他情况。这取决于您的需求。

无论如何，希望能有所帮助。祝你好运！

Answer 2

实际上，将JSON模式表示为类型定义的想法是范式不匹配。 JSON Schema并非为此类设计。它试图将一个圆形的钉子钉入一个方孔中。永远都不合适。

JSON Schema旨在转换为可用于验证JSON文档的函数。

JSON模式的anyOf类型如何转换为打字稿？

2 个答案: