how do I write a TS generic for something where the inferred T will be an array?

Question

so, I have a function that operates in an RxJS stream. It gets a single object (say of type 'IPerson') through the stream and its own argument is an array of strings for date fields I want it to parse on that object. I can use this:

function dateParser<T, K extends keyof T>(dateFields: K[])

and now if I call with a typo like dateParser(['dateofbiiiirth']) then TS will warn me

but, I want to have the same safety for a similar function that works on an array passed through the stream (say of type 'IPerson[]')

and obviously here the TS warning goes off for any of my key strings because it expects the keys of array like 'length' etc, not the keys of an individual instance of my interface.

I tried using

function dateParser<T[], K extends keyof T>(dateFields: K[])

and it doesn't appear that that is allowed, it just errors the whole function

how would I write a generic that says "if you infer SomeType[] then make sure the strings given are keys of a single one of that type you got an array of"?

more explanation based on comment below

so say I have this:

getSearchResults(): Observable<IMemberSearchResult> {
    return this.http
        .get<IServiceResponse<IMemberSearchResult>>(`${this.serviceUrl}`)
        .pipe(
            stripApiResponse(),
            dateParser(['DateOfBirth', 'LastVisitDate'])
            );
}

and this:

getSearchResults(): Observable<IMemberSearchResult[]> {
    return this.http
        .get<IServiceResponse<IMemberSearchResult[]>>(`${this.serviceUrl}`)
        .pipe(
            stripApiResponse(),
            dateParser(['DateOfBirth', 'LastVisitDate'])
            );
}

the only difference is whether they are getting search result (single) or search result (array)

assume IMemberSearchResult interface does have a DateOfBirth prop but does not have a LastVisitDate prop

using the single one, TS correctly infers T, and it correctly puts an error under only 'LastVisitDate' . . . using an array, TS interprets <T, K extends keyof T> for the type it inferred and wants K to be the keys that go with Array, not the actual keys of your search result interface. Because of this it things both strings are errors. how would I re-write that so that it properly knows what keys to check for?

Answer 1

Considering that a RxJS operator is a function that should return a function whose entry argument is an Observable and the return type is another observable, you don't need to set the type.

import { Observable, OperatorFunction, of } from 'rxjs';

function dateParser<T>(keys: (keyof T)[]): OperatorFunction<T[], T[]> {
  return function(source: Observable<T[]>): Observable<T[]> {
    return source
  }
}

interface MyInterface {
  a: string;
  b: number;
}

const obj: MyInterface[] = [{
  a: '', b: 3
}]

const source = of(obj).pipe(
  dateParser(['a']), // Correct
  dateParser(['c']) // Incorrect
);

Here is an example that works

Answer 2

I think you want something like:

function callWithValidKeys<T>(objects: T[], keys: (keyof T)[]) {}

The important thing is to type the argument as the array (objects T[]). This means that T will represent the member type of the array, and not the array itself. Then keys can be be an array of the keys of that member type.

Example usage:

interface IPerson { name: string, age: number }
const people: IPerson[] = [
    { name: "Foo", age: 20 },
    { name: "Bar", age: 50 },
]

callWithValidKeys(people, ["name", "age"])

// Type '"badKey"' is not assignable to type '"name" | "age"'.(2322)
callWithValidKeys(people, ["name", "badKey"])

---

Note that in order for this to work, you need to provide the array it's operating on, otherwise typescript has no idea what the member type is.

Playground