Intersection of an object's value types in TypeScript

Question

I have a TypeScript interface that defines the HTTP methods and query parameter types I can use on a REST endpoint (see crosswalk for details on why you might want to do this):

interface API {
  '/endpoint': {
    get: {a?: string, b?: string};
    post: {b?: string, c?: string};
  } 
}

I want to define a function that takes this API type, the endpoint ('/endpoint') and, optionally, the HTTP verb ('get', 'post', etc.) and appropriate query parameters:

const urlMaker = apiUrlMaker<API>();
urlMaker('/endpoint')({a: 'a', b: 'b'});  // should be an error, we don't know that "a" is OK.
urlMaker('/endpoint')({b: 'b'});  // fine, "b" is always safe. Should return "/endpoint?b=b".
urlMaker('/endpoint', 'get')({a: 'a', b: 'b'});
// fine, we're explicitly using get. Should return "/endpoint?a=a&b=b".

In the case the user omits the HTTP verb, I want to accept the intersection of the query parameter types for this method (i.e. the query parameter types that can be passed to any verb).

I can get the union of the types this way:

type ParamUnion = API['/endpoint'][keyof API['/endpoint']];
// type is {a?: string, b?: string} | {b?: string, c?: string}

I'm aware of the trick for converting unions to intersections, but I'm wondering if there's a way to do that in this case that doesn't go through the union. There could, of course, be any number of HTTP verbs defined for an endpoint in addition to get and post (delete, put, patch, etc.).

jcalz · Accepted Answer · 2021-03-02T19:39:52.920

I would use the same basic technique, since as far as I know, conditional type inference with infer is the only feature in TS which will automatically generate an intersection of an arbitrary number of types (without resorting to recursion). You don't have to explicitly go through a union first, although it is still implicitly in there:

type ParamIntersection = {
  [K in keyof API['/endpoint']]: (x: API['/endpoint'][K]) => void
}[keyof API['/endpoint']] extends
  (x: infer I) => void ? I : never;

/* type ParamIntersection = {
    a?: string | undefined;
    b?: string | undefined;
} & {
    b?: string | undefined;
    c?: string | undefined;
} */

I'm turning each property type into the argument to a function and then getting the union of such functions, and inferring a single argument from this, which turns the union into an intersection via the magic of contravariance of function arguments.

This type is a bit ugly and would get worse with more intersection constitutents, so you could also merge them into a single object type:

type ParamMerged = {
  [K in keyof API['/endpoint']]: (x: API['/endpoint'][K]) => void
}[keyof API['/endpoint']] extends
  (x: infer I) => void ? { [K in keyof I]: I[K] } : never;

/* type ParamIntersection = {
    a?: string | undefined;
    b?: string | undefined;
    c?: string | undefined;
} */

Playground link to code

You're awesome. This answer was the key to getting [joinAdapters](https://state-adapt.github.io/docs/core#joinadapters) to work in StateAdapt. I owe you big time. Seriously, do you have a "buy me coffee" link or anything like that? I spent literally an entire day on this. Never would have guessed to wrap it in a function like that. — Michael Pearson, Jul 12 '23 at 23:10

Intersection of an object's value types in TypeScript

1 Answers1