Ytukyg

Suppose I have a generic function that takes raw data, and an array of parsers to generate a simple object

function parseData<T extends object>(

  rawData: any,

  ...parsers: Array<{

    field: keyof T

    parser(rawData: any): any

  }>

): T {

  // Loop through and generate object

}

And the function call would look like

interface ResultData {

  name: string,

  age: number

}

const result = parseData<ResultData>(

  rawData, 

  { field: 'name', parser: nameParser },

  { field: 'age', parser: ageParser }

)

The type checking for field works beautifully. If I were to put in something that's not name or age, I get the expected syntax error. I am wondering if there's a way to ensure the parser result is the correct value type for that specific field. For example, I want to receive a syntax error if I try to pass { field: 'name', parser: ageParser } as one of the parsers

You can do something close to what you want but it involves adding type parameters which need to be inferred, and since TypeScript doesn't currently allow specifying some type paremters while allowing others to be inferred, (but it's coming soon), there's a trick you can use to sort of give that to you in the meantime.

First, let's use a mapped type with a lookup to generate the union of possible parser types for type T, assuming the "raw data" is of type R:

type Parsers<T, R> = { [K in keyof T]: { field: K, parser(rawData: R): T[K] } }[keyof T];

Then we curry the parseData() function to the user-specified T value, as well as the R value corresponding to rawData, and the tuple rest parameter type P corresponding to parsers. The implementation of the function is left to you:

declare function parseData<T extends object>(): <R, P extends Parsers<T, R>>(

  rawData: R,

  ...parsers: P

) => T;

Now let's see if it works:

interface ResultData {

  name: string,

  age: number

}



const resultDataParse = parseData<ResultData>(); // T is now ResultData



// call parser:

const result = resultDataParse(

  "hello",

  { field: 'name', parser: (x: string) => x + "!" },

  { field: 'age', parser: (x: string) => x.length }

); 

This looks good, and should fail if you switch things around:

const oops = parseData<ResultData>()(

  "hello",

  { field: 'name', parser: (x: string) => x + "!" },

  { field: 'age', parser: (x: string) => x + "!" } // error, string not number

)

It will not fail if you leave out a parser:

const noError = parseData<ResultData>()(

  "hello",

  { field: 'name', parser: (x: string) => x + "!" },      

)

so either you want the output to be Partial<T> instead of T, or you want to somehow constrain parseData() to require all parsers; but that wasn't in the question and I've got to run. 🏃‍♂️

Hope that helps. Good luck!