How can a fixed type value be assigned to a portion of a type that is constrained by generics?

Question

How can a fixed type value be assigned to a portion of a type that is constrained by generics?

Experience a new aspect of Ids with my basic interface:

interface Identifiable {
    id?: number;
}

Behold, a universal function that transforms record objects into entities with ids:

function transformRowToObject<T extends Identifiable>(row: { id: number; }): Partial<T> {
    return { id: row.id };
    // Type '{ id: number; }' is not assignable to type 'Partial<T>'.
}

The reason for this error lies within the extensibility of T from Identifiable. Certain types like { id: undefined } or { id: 1 } could make the return statement invalid. Hence, I made a modification to mandate a numerical id:


type Identified<T extends Identifiable> = {
    [K in keyof T]?: K extends "id" ? number : T[K];
}

function adjustObjectType<T extends Identifiable>(row: { id: number; }): Identified<T> {
    return { id: row.id };
    // Type '{ id: number; }' is not assignable to type 'Identified<T>'.
}

But why does this occur? What combination of T (where T extends Identifiable) prevents { id: number } from being assigned to Identified<T>?

If there's no way to rectify the Identified type for compatibility, is there an alternative method to define the conversion process for generic subtypes of Identifiable?

Link to playground.

typescript

Answer 1

Answer №1

If you are dealing with a certain issue, it has been extensively explained here. The problem arises from the various subtypes of T extends Identifiable which make the return value { id: row.id } invalid in specific cases like Identified<{id?: never}>. This demonstrates that { id: row.id } will not be valid for every subtype of Identified. Despite this, using Never as a type for id is permissible since all keys of Identified are declared optional. When T extends Identifiable, Identified<T> essentially becomes equivalent to Partial<T>. Therefore, Typescript rightly throws an error in such scenarios. However, there are workarounds available by setting suitable default values ((playground)):

interface Identifiable {
    id?: number;
}

// results in optional id
function fromRowToObj1<T extends Identifiable>(row: { id: number; }) {
    const result: Partial<T> = {} // valid for all subtypes of Partial<T>
    result.id = row.id
    return result;
}

// results in non optional id
function fromRowToObj2<T extends Identifiable>(row: { id: number; } ) {
    const partial: Partial<T> = {}; // valid for all subtypes of Partial<T>
    const result = {
        ...partial,
        id: row.id
    };
    return result;
}

interface TestObject {
    id: number,
    arg1: string;
    arg2: boolean;
}

const result1 = fromRowToObj1<TestObject>({id: 5});
result1.id // optional
result1.arg1 = "test" // intellisense works
result1.arg2 = true; // intellisense works

const result2 = fromRowToObj2<TestObject>({id: 5});
result2.id // not optional
result2.arg1 = "test" // intellisense works
result2.arg2 = true; // intellisense works

Answer 2

If you are dealing with a certain issue, it has been extensively explained here. The problem arises from the various subtypes of T extends Identifiable which make the return value { id: row.id } invalid in specific cases like Identified<{id?: never}>. This demonstrates that { id: row.id } will not be valid for every subtype of Identified. Despite this, using Never as a type for id is permissible since all keys of Identified are declared optional. When T extends Identifiable, Identified<T> essentially becomes equivalent to Partial<T>. Therefore, Typescript rightly throws an error in such scenarios. However, there are workarounds available by setting suitable default values ((playground)):

interface Identifiable {
    id?: number;
}

// results in optional id
function fromRowToObj1<T extends Identifiable>(row: { id: number; }) {
    const result: Partial<T> = {} // valid for all subtypes of Partial<T>
    result.id = row.id
    return result;
}

// results in non optional id
function fromRowToObj2<T extends Identifiable>(row: { id: number; } ) {
    const partial: Partial<T> = {}; // valid for all subtypes of Partial<T>
    const result = {
        ...partial,
        id: row.id
    };
    return result;
}

interface TestObject {
    id: number,
    arg1: string;
    arg2: boolean;
}

const result1 = fromRowToObj1<TestObject>({id: 5});
result1.id // optional
result1.arg1 = "test" // intellisense works
result1.arg2 = true; // intellisense works

const result2 = fromRowToObj2<TestObject>({id: 5});
result2.id // not optional
result2.arg1 = "test" // intellisense works
result2.arg2 = true; // intellisense works

How can a fixed type value be assigned to a portion of a type that is constrained by generics?

Answer №1

Similar questions

TypeScript combined with Vue 3: Uncaught ReferenceError - variable has not been declared

Issue with Ionic Native File: File.writeFile function - file is not being created and there is no callback response

Encountering a Next.js TypeScript Build Error related to the Type 'OmitWithTag<InputFormProps, keyof PageProps, "default">' issue

The Dynamic Duo: Typescript and Knex

Is there a way to receive a comprehensive report in case the deletion process encounters an error?

Angular is having trouble with the toggle menu button in the Bootstrap template

Creating folders and writing data to text files in Angular 4/5 with TypeScript: A tutorial

Having difficulty accessing an element within ng-template during the unit test writing process with Jasmine

How can we enhance intellisense to recognize instance members of an interface when using dynamic indices?

Leveraging interfaces with the logical OR operator

Dynamic Setting of Content-Type Header (Multipart/Data) Through Http Interceptor

The type 'number | { percent: number; }' cannot be assigned to the type 'string | number | undefined' according to ts(2322) error message

Transforming a detailed JSON structure into a more simplified format with Angular 2

Conditional validation in Typescript based on the nullability of a field

NextJS - The server attempted to execute the find() function, which is only available on the client side

Inaccurate recommendations for type safety in function overloading

Using TypeScript to chain observables in a service and then subscribing to them in the component at the end

When incorporating an array as a type in Typescript, leverage the keyof keyword for improved

How to exclude specific {} from TypeScript union without affecting other types

What is the process for generating an alert box with protractor?