Is it feasible to verify the accuracy of the return type of a generic function in Typescript?

Question

Is it feasible to verify the accuracy of the return type of a generic function in Typescript?

Is there a way to validate the result of JSON.parse for different possible types? In the APIs I'm working on, various Json fields from the database need to have specific structures. I want to check if a certain JsonValue returned from the database is coherent with a given type.

I've experimented with different approaches. Here is how I defined the generic function:

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

I am looking for a solution that throws an error when the jsonValue does not match the exact properties of type T, but this approach is not successful.

I am testing using this class:

export class ProgramTagsDTO {
  key: string;
  value: string;

  constructor(key: string, value: string) {
    this.key = key;
    this.value = value;
  }
}

Running the following test:

it('should validate', () => {
  const tags: Prisma.JsonValue = [
    {
      key: 'key1',
      value: 'value1',
      wrongField: 'value',
    },
    {
      key: 'key2',
      value: 'value2',
    },
  ];
  let result = null;
  const expectedResult = [
    new ProgramTagsDTO('key1', 'value1'),
    new ProgramTagsDTO('key2', 'value2'),
  ];
  try {
    result = programmesService.parseJsonField<ProgramTagsDTO[]>(tags);
  } catch (error) {
    expect(error).toBeInstanceOf(Error);
  }
  expect(result).toEqual(expectedResult);
});

The current outcome is:

 expect(received).toEqual(expected) // deep equality

    - Expected  - 2
    + Received  + 3

      Array [
    -   ProgramTagsDTO {
    +   Object {
          "key": "key1",
          "value": "value1",
    +     "wrongField": "value",
        },
    -   ProgramTagsDTO {
    +   Object {
          "key": "key2",
          "value": "value2",
        },
      ]

However, I want the method to throw an exception instead. The expect.toEqual is used just for logging purposes.

json typescript validation prisma typechecking

Answer 1

Answer №1

My coworker and I brainstormed for a few days and finally devised a solution that seems to be functioning well at the moment:

We included this import in our code:

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

We created two methods, one for arrays and another for single values:

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;
  });
}

Although plainToClass can handle arrays, we needed a more versatile approach that can clearly indicate whether the result will be an array or a single object based on the input being parsed. This limitation prevented us from creating a single method with a return signature like T | T[].

Answer 2

My coworker and I brainstormed for a few days and finally devised a solution that seems to be functioning well at the moment:

We included this import in our code:

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

We created two methods, one for arrays and another for single values:

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;
  });
}

Although plainToClass can handle arrays, we needed a more versatile approach that can clearly indicate whether the result will be an array or a single object based on the input being parsed. This limitation prevented us from creating a single method with a return signature like T | T[].

Answer 3

Answer №2

Regrettably, it's not possible to retain generics in compiled code. This is a common issue across languages like Java, where generics are stripped during compilation. In the case of Typescript, things get even trickier as the 'types' are also removed, resulting in transpilation to weakly-typed Javascript.

As a result, when the following code:

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

is executed at runtime, it simplifies to:

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

This means that there is no type information available for validation.

Additionally, if you're working with classes, it's important to note that even if you attempt to validate that the returned value aligns with the interface of T, it won't be an instance of T. Instead, it will merely be a generic object coincidentally sharing property names with an instance of T.

To address this, runtime checks need to be implemented. Building on the provided solution, you can create a more generalized approach:

// Retrieves a value and removes 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;
}

// Validates that the json object is empty to avoid 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) {
      // Parsing the json object into the class structure and verifying 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)));
}

(Note: The above code is untested and serves as a theoretical example)

Answer 4

Regrettably, it's not possible to retain generics in compiled code. This is a common issue across languages like Java, where generics are stripped during compilation. In the case of Typescript, things get even trickier as the 'types' are also removed, resulting in transpilation to weakly-typed Javascript.

As a result, when the following code:

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

is executed at runtime, it simplifies to:

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

This means that there is no type information available for validation.

Additionally, if you're working with classes, it's important to note that even if you attempt to validate that the returned value aligns with the interface of T, it won't be an instance of T. Instead, it will merely be a generic object coincidentally sharing property names with an instance of T.

To address this, runtime checks need to be implemented. Building on the provided solution, you can create a more generalized approach:

// Retrieves a value and removes 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;
}

// Validates that the json object is empty to avoid 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) {
      // Parsing the json object into the class structure and verifying 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)));
}

(Note: The above code is untested and serves as a theoretical example)

Is it feasible to verify the accuracy of the return type of a generic function in Typescript?

Answer №1

Answer №2

Similar questions

The NetSuite https.post() method is throwing an error that reads "Encountered unexpected character while parsing value: S. Path '', line 0, position 0"

Utilize interface as a field type within a mongoose Schema

Guide on adding up the value of a property within an array of objects using AngularJS

Eliminate any spaces from the JSON string's "outside" keys and values

The object is classified as 'undetermined' (2571) upon implementation of map() function

Passing a Typescript object as a parameter in a function call

Encountered the "Error TS2300: Duplicate identifier 'Account'" issue following the upgrade to Typescript version 2.9.1

Generate a new data structure by pairing keys with corresponding values from an existing

Is TypeScript being converted to JavaScript with both files in the same directory?

Returns false: CanActivate Observable detects a delay during service validation

Filtering a multi-dimensional array in Ionic 3

XPages: create JSON data on the server, utilize on the client-side

What is the method for defining specific requirements for a generic type's implementation?

The 'flatMap' property is not found on the 'string[]' data type. This issue is not related to ES2019

Extract data from arrays within other arrays

Error: The absence of an element identified by the locator does not cause the protractor spec to fail, but rather it executes successfully

show image data from json source

Exploring JSON objects with nested structures using Jsonpath queries

The input 'Element' does not match the expected parameter 'ReactElement<any>' in this context

TypeScript's robustly-typed rest parameters