TS: parse with an explicit record type and `columns: function` may error with "Type 'keyof T' is not assignable to type 'ColumnOption<string>'"

[beta382]

Describe the bug

csv-parse v6.2.1, sync API, typescript

When supplying an explicit record type to parse<T>, and when using the columns option with function type, the accepted type of columns does not properly resolve to (record: T) => (keyof T)[]. It instead resolves to (record: string[]) => string[] (there are other types in the union, which I've excluded for brevity).

It appears that the intention is for it to resolve to (record: T) => (keyof T)[], given the logic here and here. However, the type arguments are not passed through here. This means that Options["columns"] will always default to T = string[], and thus the ternary linked to yields string.

This can cause TS compile failures if keyof T cannot be trivially coerced to string (e.g. if they're not string, or if they're coming from some other generic type).

To Reproduce

Here is a minimal TS example. The expectation is that it should compile.

test("should compile", () => {
  interface Foobar {
    1: string;
    2: string;
  }

  const columnMapping = new Map<string, keyof Foobar>([
    ["col_1", 1],
    ["col_2", 2],
  ]);

  const records = parse<Foobar>('col_1,col_2\n"foo","bar"', {
    columns: (header) =>
      header.map((column) => columnMapping.get(column)),
  });

  expect(records).toEqual([{ 1: "foo", 2: "bar" }]);
});

Instead it errors with:

Type '(header: string[]) => (keyof Foobar | undefined)[]' is not assignable to type 'true | ColumnOption<string>[] | ((record: string[]) => ColumnOption<string>[])'.
  Type '(header: string[]) => (keyof Foobar | undefined)[]' is not assignable to type '(record: string[]) => ColumnOption<string>[]'.
    Type '(keyof Foobar | undefined)[]' is not assignable to type 'ColumnOption<string>[]'.
      Type 'keyof Foobar | undefined' is not assignable to type 'ColumnOption<string>'.
        Type '1' is not assignable to type 'ColumnOption<string>'.

Workaround

(differs slightly based on the specific scenario)

const records = parse<Foobar>('col_1,col_2\n"foo","bar"', {
  columns: (header) =>
    header.map((column) => columnMapping.get(column) as undefined),
});

[wdavidw]

Hi @beta382, not a TS expert, do you have a solution in mind ?

[beta382]

Not a TS expert either unfortunately. I took a quick stab at this, but ended up running into a wall of needing to understand the internals more than I can commit to. Once the seemingly-obvious solution was attempted, some of the tests started to have TS whine about them violating type safety (which is probably right, as many nuances get masked when everything in Options gets assumed to have T = string[]).

At minimum, I'm pretty sure that the type parameters from e.g. OptionsWithColumns and Options ought to be propagated through to Options and OptionsNormalized respectively.

I'm also pretty sure that the type here (the record parameter for the columns callback) should be string[] instead of T. My understanding is that T is intended to be the output row type, but the record parameter for the columns callback is still just an array of strings at that point in the parse (there perhaps is more internals nuance here that I'm missing, but I'm fairly sure T is wrong).

Finally, I think that there is some trickiness that solving this will expose around on_record. What the record parameter for its callback is given differs based on the values given to raw and info (I think, but didn't dig deep enough to verify, that these parameters also influence the shape of the parse output; more trickiness).