What is the best way to combine the attributes of multiple objects within a union type?

Question

What is the best way to combine the attributes of multiple objects within a union type?

I have a clearly defined schema

type Schema = {
    a: { a: 1 }
    b: { b: 2 }
}

I am in need of a function that can generate objects that adhere to multiple schemas.

function createObject<K extends keyof Schema>(schema: Array<K>, obj: Schema[K]) {}

createObject(["a"], { a: 1 }) // works
createObject(["b"], { b: 2 }) // works
createObject(["a", "b"], { b: 2 }) // should error but it doesn't
createObject(["a", "b"], { a: 1, b: 2 }) // works

playground link

I have experimented with various approaches. It's intriguing that when you & a union with itself, the & is distributed across all items in the union and does not quite achieve the desired outcome. I am looking for a solution to operate on {a: 1} | {b: 2} in order to obtain {a: 1, b: 2}. Any suggestions?

typescript

Answer 1

Answer №1

If the types within the properties of your Schema are not unions themselves, you have the option to transform the union type Schema[K] into an intersection using conditional types. Here's an example:

type Schema = {
    a: { a: 1 }
    b: { b: 2 }
};    

type UnionToIntersection<U> =
    (U extends any ? (k: U) => void : never) extends
    ((k: infer I) => void) ? I : never

function createObject<K extends keyof Schema>(
    schema: Array<K>, 
    obj: UnionToIntersection<Schema[K]>
) { }

createObject(["a"], { a: 1 }) // works
createObject(["b"], { b: 2 }) // works
createObject(["a", "b"], { b: 2 }) // error! 
createObject(["a", "b"], { a: 1, b: 2 }) // works

This approach may suit your needs. However, if you encounter a different scenario (e.g., if Schema includes a property like cd: {c: 3} | {d: 4} and you wish to retain a union in the final type), an alternative solution might be more suitable:

type PropsToIntersection<T, K extends keyof T> =
    { [P in K]: (k: T[P]) => void }[K] extends
    ((k: infer I) => void) ? I : never;

function createObject<K extends keyof Schema>(
    schema: Array<K>,
    obj: PropsToIntersection<Schema, K>
) { }

This second method involves iterating through the keys of Schema and then performing an intersection, instead of spreading the union of Schema[K]. The distinction is most noticeable in cases where some properties of your schema are union types themselves.

Hopefully, this explanation proves useful to you. Best of luck on your current project!

Answer 2

If the types within the properties of your Schema are not unions themselves, you have the option to transform the union type Schema[K] into an intersection using conditional types. Here's an example:

type Schema = {
    a: { a: 1 }
    b: { b: 2 }
};    

type UnionToIntersection<U> =
    (U extends any ? (k: U) => void : never) extends
    ((k: infer I) => void) ? I : never

function createObject<K extends keyof Schema>(
    schema: Array<K>, 
    obj: UnionToIntersection<Schema[K]>
) { }

createObject(["a"], { a: 1 }) // works
createObject(["b"], { b: 2 }) // works
createObject(["a", "b"], { b: 2 }) // error! 
createObject(["a", "b"], { a: 1, b: 2 }) // works

This approach may suit your needs. However, if you encounter a different scenario (e.g., if Schema includes a property like cd: {c: 3} | {d: 4} and you wish to retain a union in the final type), an alternative solution might be more suitable:

type PropsToIntersection<T, K extends keyof T> =
    { [P in K]: (k: T[P]) => void }[K] extends
    ((k: infer I) => void) ? I : never;

function createObject<K extends keyof Schema>(
    schema: Array<K>,
    obj: PropsToIntersection<Schema, K>
) { }

This second method involves iterating through the keys of Schema and then performing an intersection, instead of spreading the union of Schema[K]. The distinction is most noticeable in cases where some properties of your schema are union types themselves.

Hopefully, this explanation proves useful to you. Best of luck on your current project!

What is the best way to combine the attributes of multiple objects within a union type?

Answer №1

Similar questions

Exploring the functionalities of class methods within an Angular export function

Cloning a repository does not support Typescript compilation

Angular 2 forms are displaying ngvalid when input fields are marked as nginvalid

Tips for choosing the node_modules distribution flavor to include in your webpack bundle

Leverage the exported data from Highcharts Editor to create a fresh React chart

I'm trying to figure out the best way to successfully pass a prop to another component in TypeScript without running into the frustrating issue of not being able to

Debugger for Visual Code unable to locate URL in Microsoft Office Add-in

Running a Vue.js 3 application with TypeScript and Vite using docker: A step-by-step guide

Navigating back to the login page in your Ionic V2 application can be achieved by utilizing the `this.nav

Converting a nested JSON object into a specific structure using TypeScript

What method can be used to verify if a username exists within Angular data?

In Angular, the data retrieved from the API will only appear on the page once it has been manually

Zod vow denial: ZodError consistently delivers an empty array

Looking to execute a service method within an authguard service?

Implementing reduce for filtering and mapping in TypeScript: A comprehensive guide

Struggling with an issue in React and Bootstrap4 while developing an application with create-react-app

Removing data from a table using an identifier in Typescript

What is the process of transforming a basic JavaScript function into a TypeScript function?

What is the most effective method for merging two arrays in JavaScript?

Data from graphql is not being received in Next.js