Pairing objects by utilizing a Universal Mapper

Question

Pairing objects by utilizing a Universal Mapper

Classes Defined:

abstract class ModelBase {
  id: string;
}

class Person extends ModelBase {
  favoriteDog: Dog | undefined;
  favoriteDogId: string | undefined;
  dogs: Dog[]
}

class Dog extends ModelBase {
  id: string;
  ownerId: string;
  name: string;
}

In the scenario of having arrays of Persons and Dogs, I wish to map them using a method like:

const persons = [{ id: 'A', favoriteDog: undefined, favoriteDogId: 'B'}];
const dogs = [{ id: 'B', name: 'Sparky'}];

mapSingle(persons, "favoriteDog", "favoriteDogId", dogs);

console.log(persons[0].favoriteDog?.name); // logs: Sparky

The code snippet for mapping:

  static mapSingle<TEntity extends ModelBase , TDestProperty extends keyof TEntity, TDestPropertyType extends (TEntity[TDestProperty] | undefined)>(
    destinations: TEntity[],
    destinationProperty: keyof TEntity,
    identityProperty: keyof TEntity,
    sources: TDestPropertyType[]) {

    destinations.forEach(dest => {
      const source = sources.find(x => x["id"] == dest[identityProperty]);
      dest[destinationProperty] = source;  // <--- Error Line
    });
  }

Error encountered:

TS2322: Type 'TDestPropertyType | undefined' is not assignable to type 'TEntity[keyof TEntity]'

Type 'undefined' is not assignable to type 'TEntity[keyof TEntity]'.

The error arises due to defining a property as nullable in the method.

Subsequently, a similar method could be created with analogous tactics;

mapMany(persons, 'Dogs', 'OwnerId', dogs);

Additional Resources:

In TypeScript, how to get the keys of an object type whose values are of a given type?

Typescript Playground Example

typescript generics

Answer 1

Answer №1

Initially, let's explore a specific version that highlights a certain issue:

abstract class ModelBase {
  id: string;
}

class Person extends ModelBase {
  favoriteDog: Dog | undefined;
  favoriteDogId: string | undefined;
  dogs: Dog[]
}

class Dog extends ModelBase {
  id: string;
  ownerId: string;
  name: string;
}

function mapSingle(persons: Person[], instanceKey: keyof Person, idKey: keyof Person, dogs: Dog[]) {
  persons.forEach(person => {
    const dog = dogs.find(dog => dog['id'] == person[idKey])
    person[instanceKey] = dog
//  ^^^^^^^^^^^^^^^^^^^
//  (parameter) instanceKey: keyof Person
//    Type 'Dog | undefined' is not assignable to type 'Dog & string & Dog[]'.
//      Type 'undefined' is not assignable to type 'Dog & string & Dog[]'.
//        Type 'undefined' is not assignable to type 'Dog'.(2322)
  })
}

The confusion arises when TypeScript interprets person[instanceKey] as a type of Dog & string & Dog[].

By referring to the keyof documentation, it becomes apparent that there are two possible outcomes: key names and key types.

Interestingly, this seems to exhibit a merging of types (&).

This realization led to the understanding that instanceKey should actually be Dog | undefined, given that we are assigning either Dog or undefined (the result of find) to it.

Delving deeper into a way to exclusively obtain the keys of a specific type, I discovered KeysOfType.

type KeysOfType<T, TProp> = { [P in keyof T]: T[P] extends TProp? P : never}[keyof T];

I proceeded to refactor the types into interfaces:

interface Identifiable {
  id: string;
}

interface DogOwning {
  favoriteDog: Dog | undefined;
  favoriteDogId: string | undefined;
  dogs: Dog[]
}

interface Person extends Identifiable, DogOwning {
}

interface Dog extends Identifiable {
  ownerId: string;
  name: string;
}

This refinement led to the following, which now allows for the assignment of dogs:

function mapSingle(
  owners: Person[], 
  assignedKey: KeysOfType<DogOwning, Dog | undefined>, 
  foreignKey: KeysOfType<DogOwning, string | undefined>, 
  ownable: Dog[]
  ) {
  
  owners.forEach(owner => {
    owner[assignedKey] = ownable.find(entity => entity['id'] == owner[foreignKey])
    
  })
}

Regrettably, it appears challenging to make this generic. When we introduce generics for Person, DogOwning, and Dog, we encounter a similar issue. I am unsure if TypeScript imposes a limitation on the nesting of generics, but it seems to be the case here.

There is a concern that assignedKey and foreignKey are merely validated as properties within the owner object type and of the expected type, without ensuring they are the correct keys. This potential issue might also apply to direct property assignments, posing a potential risk of bugs. Exploring alternative approaches, such as encapsulating this logic in methods on Person or a Coordinator class, could help isolate the code and reduce the likelihood of errors. The alternative solution I proposed moves towards this direction.

Answer 2

Initially, let's explore a specific version that highlights a certain issue:

abstract class ModelBase {
  id: string;
}

class Person extends ModelBase {
  favoriteDog: Dog | undefined;
  favoriteDogId: string | undefined;
  dogs: Dog[]
}

class Dog extends ModelBase {
  id: string;
  ownerId: string;
  name: string;
}

function mapSingle(persons: Person[], instanceKey: keyof Person, idKey: keyof Person, dogs: Dog[]) {
  persons.forEach(person => {
    const dog = dogs.find(dog => dog['id'] == person[idKey])
    person[instanceKey] = dog
//  ^^^^^^^^^^^^^^^^^^^
//  (parameter) instanceKey: keyof Person
//    Type 'Dog | undefined' is not assignable to type 'Dog & string & Dog[]'.
//      Type 'undefined' is not assignable to type 'Dog & string & Dog[]'.
//        Type 'undefined' is not assignable to type 'Dog'.(2322)
  })
}

The confusion arises when TypeScript interprets person[instanceKey] as a type of Dog & string & Dog[].

By referring to the keyof documentation, it becomes apparent that there are two possible outcomes: key names and key types.

Interestingly, this seems to exhibit a merging of types (&).

This realization led to the understanding that instanceKey should actually be Dog | undefined, given that we are assigning either Dog or undefined (the result of find) to it.

Delving deeper into a way to exclusively obtain the keys of a specific type, I discovered KeysOfType.

type KeysOfType<T, TProp> = { [P in keyof T]: T[P] extends TProp? P : never}[keyof T];

I proceeded to refactor the types into interfaces:

interface Identifiable {
  id: string;
}

interface DogOwning {
  favoriteDog: Dog | undefined;
  favoriteDogId: string | undefined;
  dogs: Dog[]
}

interface Person extends Identifiable, DogOwning {
}

interface Dog extends Identifiable {
  ownerId: string;
  name: string;
}

This refinement led to the following, which now allows for the assignment of dogs:

function mapSingle(
  owners: Person[], 
  assignedKey: KeysOfType<DogOwning, Dog | undefined>, 
  foreignKey: KeysOfType<DogOwning, string | undefined>, 
  ownable: Dog[]
  ) {
  
  owners.forEach(owner => {
    owner[assignedKey] = ownable.find(entity => entity['id'] == owner[foreignKey])
    
  })
}

Regrettably, it appears challenging to make this generic. When we introduce generics for Person, DogOwning, and Dog, we encounter a similar issue. I am unsure if TypeScript imposes a limitation on the nesting of generics, but it seems to be the case here.

There is a concern that assignedKey and foreignKey are merely validated as properties within the owner object type and of the expected type, without ensuring they are the correct keys. This potential issue might also apply to direct property assignments, posing a potential risk of bugs. Exploring alternative approaches, such as encapsulating this logic in methods on Person or a Coordinator class, could help isolate the code and reduce the likelihood of errors. The alternative solution I proposed moves towards this direction.

Answer 3

Answer №2

Another Perspective

I started to understand that there existed an alternate approach to solving the model problem (potentially). However, I acknowledge that the example may have been simplified and may transcend a mere simplification of the solution.

In simple terms, Person.favouriteDog functions as a getter, rather than necessitating a specific Dog to be copied (by reference) to the Person.

Here is a basic alternative, but it will require further development with utility methods on Person and Dog to ensure referential integrity (or perhaps a Coordinator instance that handles assigning Dogs to Persons)

interface Identifiable {
  id: string
}

interface DogOwning {
  favoriteDog?: Dog
  favoriteDogId?: string
  dogs: Dog[]
}

class Person implements Identifiable, DogOwning {
  constructor(public id: string) {}
  favoriteDogId?: string
  get favoriteDog(): Dog | undefined {
    if (!this.favoriteDogId) {
      return undefined
    }

    const favorite = this.dogs.find(dog => dog.id === this.favoriteDogId)
    if (favorite) {
      return favorite
    }
    throw "Referential Integrity Failure: favoriteDogId must be found in Persons dogs"
  
  }
  public readonly dogs: Dog[] = []
}

class Dog implements Identifiable {
  public ownerId?: string
  constructor(public id: string, public name: string) {}
}

const personA = new Person('A')
console.log(`favoriteDog is ${personA.favoriteDog?.name}`)

const sparky = new Dog('B', 'Sparky')
personA.dogs.push(sparky)
personA.favoriteDogId = sparky.id

console.log(`favoriteDog is ${personA.favoriteDog?.name}`)

personA.dogs.splice(personA.dogs.findIndex(dog => dog.id === sparky.id), 1)

console.log(`favoriteDog is ${personA.favoriteDog?.name}`)

Playground Link

Answer 4

Another Perspective

I started to understand that there existed an alternate approach to solving the model problem (potentially). However, I acknowledge that the example may have been simplified and may transcend a mere simplification of the solution.

In simple terms, Person.favouriteDog functions as a getter, rather than necessitating a specific Dog to be copied (by reference) to the Person.

Here is a basic alternative, but it will require further development with utility methods on Person and Dog to ensure referential integrity (or perhaps a Coordinator instance that handles assigning Dogs to Persons)

interface Identifiable {
  id: string
}

interface DogOwning {
  favoriteDog?: Dog
  favoriteDogId?: string
  dogs: Dog[]
}

class Person implements Identifiable, DogOwning {
  constructor(public id: string) {}
  favoriteDogId?: string
  get favoriteDog(): Dog | undefined {
    if (!this.favoriteDogId) {
      return undefined
    }

    const favorite = this.dogs.find(dog => dog.id === this.favoriteDogId)
    if (favorite) {
      return favorite
    }
    throw "Referential Integrity Failure: favoriteDogId must be found in Persons dogs"
  
  }
  public readonly dogs: Dog[] = []
}

class Dog implements Identifiable {
  public ownerId?: string
  constructor(public id: string, public name: string) {}
}

const personA = new Person('A')
console.log(`favoriteDog is ${personA.favoriteDog?.name}`)

const sparky = new Dog('B', 'Sparky')
personA.dogs.push(sparky)
personA.favoriteDogId = sparky.id

console.log(`favoriteDog is ${personA.favoriteDog?.name}`)

personA.dogs.splice(personA.dogs.findIndex(dog => dog.id === sparky.id), 1)

console.log(`favoriteDog is ${personA.favoriteDog?.name}`)

Playground Link

Pairing objects by utilizing a Universal Mapper

Answer №1

Answer №2

Similar questions

What is the best way to individually update elements in an array in Ionic v5?

Creating a generic class in Typescript that can only accept two specific types is a powerful

Using ReactJS with Typescript: attempting to interpret a value as a type error is encountered (TS2749)

State in Angular stubbornly refuses to switch despite condition changes

What should I do about typescript and ES6?

What is the best way to define types for an array of objects with interconnected properties?

Incorporate the {{ }} syntax to implement the Function

Having trouble obtaining search parameters in page.tsx with Next.js 13

What causes the cursor in an editable div to automatically move to the front of the div?

When transferring the code to the src folder, tRPC encounters issues and stops functioning

Adjusting the position of Angular Mat-Badge in Chrome browser

Tips for creating basic Jasmine and Karma tests for an Angular application to add an object to an array of objects

What are the best practices for preventing risky assignments between Ref<string> and Ref<string | undefined>?

Enhancing Angular functionality with the addition of values to an array in a separate component

how to enhance Request type in Express by adding a custom attribute

Error in TypeScript due to object being undefined

The Relationship between Field and Parameter Types in TypeScript

How can I access a file uploaded using dxFileUploader?

Exploring the integration of LeafLet into Next JS 13 for interactive mapping

Utilizing AMD Modules and TypeScript to Load Bootstrap