TypeScript: Pluck has a type safety detonator in it

[Lonelind]

Bug Report

Current Behavior with reproduction example
The pluck operator is working poorly with some cases in terms of type safety.

We use a rig to generate props for React components from Rx Observables. The function uses Partial of the Component Props type and expect this type to be returned. In general we have something like this:

interface MyPropType = {
    id: number;
}
interface ComponentProps = {
    myProp: MyPropType;
}

const Component: React.FC<ComponentProps> = ({ myProp }) => (
    <div>{myProp.id}</div>
);

// It's the general idea, not the actual implementation
const Container = withRx(Component)(({ myStream$ }) => ({
    myProp: myStream$.pipe(pluck('someField')),
}));

So, it's pretty fine with that in terms of type safety. Let's assume we have the following in myStream$:

interface MyData = {
    anyField: { id: number };
}

const myStream$: Observable<MyData> = /* ... */

Type inference for pluck will work in an unexpected way. If you look carefully, you'll see that if someField is absent from the expected object type than keyof can't be inferred and we have a general overload that gets some R from what it is expected to be:

// pluck.d.ts
/* ... */
export declare function pluck<T, R>(...properties: string[]): OperatorFunction<T, R>;

The problem in this case is that we have a type for myProp field and the R is inferred from it. So, we have a false expectation that there should be MyPropType returned from pluck. But suddenly, there is an undefined there, in runtime.

Expected behavior
It's expected to have any kind of type check error if we pass a key that's absent in the object type we have in the pluck input regardless of the expectations.

Environment

• TypeScript version: 3.5.2
• RxJS version: 6.5.2

[cartant]

Yeah, this could be better. It's inferred as unknown:

const source = of({ foo: "bar" });
const plucked = source.pipe(pluck("goo")); // Observable<unknown>

Because, as you've pointed out, it matches the catch-all, rest parameter signature - but it should effect a compile-time error. The catch-all should include a rest parameter after the other parameters - as in this pipe signature.

[Lonelind]

And if you are more specific, it has specific type, not the unknown.

interface A {
    foo: string;
}

const source: Observable<A> = of({ foo: 'bar' });
const plucked: Observable<A['foo']> = source.pipe(pluck('goo'));

This pluck thinks it returns string without any type errors. Keeping in mind that we can't be less specific in interfaces as we can with const/let, this can explode in an unexpected way. Say, somebody renamed property of the interface everywhere but forgot one single pluck and nothing warned them that there is a problem. And later — BOOM.

[Lonelind]

Looks like this signature works for the catch-all and it definitely returns unknown that you should process manually:

export declare function pluck<T, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2], K4 extends keyof T[K1][K2][K3], K5 extends keyof T[K1][K2][K3][K4], K6 extends keyof T[K1][K2][K3][K4][K5]>(k1: K1, k2: K2, k3: K3, k4: K4, k5: K5, k6: K6, ...properties: string[]): OperatorFunction<T, unknown>;