经过几天的尝试，我和一位同事想出了这个解决方案，现在看来效果不错：
添加此导入：

import { ClassConstructor, plainToClass } from 'class-transformer';
import { validate } from 'class-validator';

我们为数组和单个值做了两个方法：

public static async parseJsonArray<T>(
  cls: ClassConstructor<T>,
  json: Prisma.JsonValue,
): Promise<T[]> {
  if (!Array.isArray(json)) {
    throw new UnprocessableEntityException(
      `Json value is not a ${cls.name}[]`,
    );
  }
  const res: Promise<T>[] = [];
  for (const element of json) {
    res.push(this.parseJsonValue<T>(cls, element));
  }
  return Promise.all(res);
}

public static async parseJsonValue<T>(
  cls: ClassConstructor<T>,
  json: Prisma.JsonValue,
): Promise<T> {
  const parsed = JSON.parse(JSON.stringify(json));
  const transformed: T = plainToClass(cls, parsed, {
    excludeExtraneousValues: true,
  });
  return validate(transformed as object).then((errors) => {
    if (errors.length) {
      throw new UnprocessableEntityException(
        `Json value is not a ${cls.name}, Errors: ${errors}`,
      );
    }
    return transformed;
  });
}

plainToClass处理数组，但是我们需要有一些通用的东西，根据你解析的内容，返回明确的数组或单个对象，所以不可能有一个像T这样的带有返回签名的方法|T[]。

很不幸你不能。与许多语言（例如Java）一样，泛型在编译代码时被删除。在Typescript中更糟糕的是，“类型”被删除，这意味着它转换为弱类型的JavaScript。
因此，一旦在运行时，以下代码：

parseJsonField<T>(jsonValue: Prisma.JsonValue): T {
    return JSON.parse(JSON.stringify(jsonValue));
}

简化为：

parseJsonField(jsonValue) {
    return JSON.parse(JSON.stringify(jsonValue));
}

因此，没有类型信息可供检查。
此外，您正在使用一个类，请注意，即使您能够检查返回值是否符合T的接口，它也不会是T的 * 示例 *，而只是一个泛型对象，碰巧具有与T示例同名的属性。
必须在运行时实现检查。类似于你上面发布的解决方案，你可以概括它：

// Gets a value and deletes it from the json object
function getDelete<T>(jsonValue :any, property :string, required = false) :T {
  const ret = jsonValue[property];
  delete jsonValue[property];
  if (required && typeof ret === 'undefined') {
    throw new Error(`Property ${property} not found`);
  }
  return ret;
}

// Checks that the json object is empty, otherwise there are extraneous values
function checkEmpty(jsonValue: any) {
  if (Object.keys(jsonValue).length > 0) {
    throw new Error('Object contains extraneous properties ' + JSON.stringify(jsonValue));
  }
}

// Example of a class
public class Person {
  private firstName :string;
  private lastName :string;

  constructor(jsonValue? :any) {
    if (jsonValue) {
      // This is where we "parse" the json object into the actual class, and check it
      this.firstName = getDelete(jsonValue, 'firstName');
      this.lastName = getDelete(jsonValue, 'lastName');
    }
    checkEmpty(jsonValue);
  }
}

function parseAndCheck<T>(jsonValue :any, constructor: (...arg: any[])=>T) :T {
  return constructor(JSON.parse(JSON.stringify(jsonValue)));
}

（没有测试上面的代码，只是为了给你一个给予概念）