Typescript Generics type does not pass validation

Question

Typescript Generics type does not pass validation

// BaseRepository.ts
export type FieldMappings<T> = { readonly [k in keyof Required<T>]: string };

export abstract class BaseRepository<T> {
    protected abstract readonly FIELDS: FieldMappings<T>;
}

// ProductsRepository.ts
import { FieldMappings, BaseRepository } from './BaseRepository';

interface Product {
    name: string;
    price: number;
    category?: string;
}

export class ProductsRepository extends BaseRepository<Product> {
    protected readonly FIELDS = {
        name: 'product_name',
        price: 'product_price',
        category: 'product_category',
        description: 'description', // extra field
    };
}

There is no compile error when adding an additional description field to the FIELDS declaration in the ProductsRepository, even though it's not part of the Product interface.

Addition of a type declaration to the FIELDS property in the ProductsRepository, like

FIELDS: FieldMappings<Product>

, will result in a compilation error.

Avoiding redeclaration of the type for every class inheriting from BaseRepository is desired. Is this behavior possibly linked to the use of abstract? Or perhaps it relates to some settings in the tsconfig.json file? Any insights on how to rectify this issue would be appreciated.

typescript generics

Answer 1

Answer №1

Expanding on an interface or a class using extends allows you to refine the subinterface/subclass, either by introducing new properties or refining existing ones. In TypeScript, it is perfectly valid for the COLUMNS property of UserRepository to be more specialized than the COLUMNS property of RepositoryBase<User>. This is the main purpose of the extends keyword.

If you decide to define the type of the COLUMNS property in UserRepository as Record<keyof User, string> (similar to your FieldsMapping<User>) and use a new object literal during assignment, TypeScript's excess property checking will come into play, signaling any additional properties.

If this approach suits your needs, go ahead with it, even though it may seem somewhat redundant since you have to specify User both as a generic parameter in RepositoryBase<User> and in the annotation for the COLUMNS property.

If the above solution does not meet your requirements, there isn't a straightforward fix due to the complexity associated with manipulating protected properties programmatically. For instance, keyof UserRepository does not include COLUMNS, making UserRepository["COLUMNS"] invalid.

A potential workaround could involve creating a generic method like strictColumns() that only accepts a field mapping without any additional properties. The method would simply return its input, allowing you to initialize the COLUMNS property:

abstract class RepositoryBase<T> {
  protected abstract readonly COLUMNS: Record<keyof T, string>;
  strictColumns<
    U extends { [K in keyof T | keyof U]: K extends keyof T ? string : never }
  >(u: U) {
    return u;
  }
}

Implementing this method as shown below:

class UsersRepository extends RepositoryBase<User> {
  protected readonly COLUMNS = this.strictColumns({
    firstName: "first_name",
    lastName: "last_name",
    email: "email"
  });
} // works fine

class BadUsersRepository extends RepositoryBase<User> {
  protected readonly COLUMNS = this.strictColumns({
    firstName: "first_name",
    lastName: "last_name",
    email: "email",
    extra: "extra" // error! cannot assign string to never
  });
}

Although this method works, the added complexity might not justify the marginal reduction in redundancy. Nevertheless, give it a try and see if it fits your needs.

Hopefully, these suggestions are helpful. Best of luck!

Code Reference

Answer 2

Expanding on an interface or a class using extends allows you to refine the subinterface/subclass, either by introducing new properties or refining existing ones. In TypeScript, it is perfectly valid for the COLUMNS property of UserRepository to be more specialized than the COLUMNS property of RepositoryBase<User>. This is the main purpose of the extends keyword.

If you decide to define the type of the COLUMNS property in UserRepository as Record<keyof User, string> (similar to your FieldsMapping<User>) and use a new object literal during assignment, TypeScript's excess property checking will come into play, signaling any additional properties.

If this approach suits your needs, go ahead with it, even though it may seem somewhat redundant since you have to specify User both as a generic parameter in RepositoryBase<User> and in the annotation for the COLUMNS property.

If the above solution does not meet your requirements, there isn't a straightforward fix due to the complexity associated with manipulating protected properties programmatically. For instance, keyof UserRepository does not include COLUMNS, making UserRepository["COLUMNS"] invalid.

A potential workaround could involve creating a generic method like strictColumns() that only accepts a field mapping without any additional properties. The method would simply return its input, allowing you to initialize the COLUMNS property:

abstract class RepositoryBase<T> {
  protected abstract readonly COLUMNS: Record<keyof T, string>;
  strictColumns<
    U extends { [K in keyof T | keyof U]: K extends keyof T ? string : never }
  >(u: U) {
    return u;
  }
}

Implementing this method as shown below:

class UsersRepository extends RepositoryBase<User> {
  protected readonly COLUMNS = this.strictColumns({
    firstName: "first_name",
    lastName: "last_name",
    email: "email"
  });
} // works fine

class BadUsersRepository extends RepositoryBase<User> {
  protected readonly COLUMNS = this.strictColumns({
    firstName: "first_name",
    lastName: "last_name",
    email: "email",
    extra: "extra" // error! cannot assign string to never
  });
}

Although this method works, the added complexity might not justify the marginal reduction in redundancy. Nevertheless, give it a try and see if it fits your needs.

Hopefully, these suggestions are helpful. Best of luck!

Code Reference

Answer 3

Answer №2

const userDetails = {
    firstName: '',
    lastName: '',
    email: '',
    username: ''
};

const userInformation: User = userDetails;

In Typescript, you can make this type of 'flexible' assignment, although it enforces stricter rules during declaration.

An interesting proposal addressing this issue can be found here: https://github.com/microsoft/TypeScript/issues/12936

Answer 4

const userDetails = {
    firstName: '',
    lastName: '',
    email: '',
    username: ''
};

const userInformation: User = userDetails;

In Typescript, you can make this type of 'flexible' assignment, although it enforces stricter rules during declaration.

An interesting proposal addressing this issue can be found here: https://github.com/microsoft/TypeScript/issues/12936

Typescript Generics type does not pass validation

Answer №1

Answer №2

Similar questions

The `setState` function is failing to change the current value

What is the best way to ensure that dynamic routes from the server do not fail upon refreshing?

Turning HTML into PDF using Angular 10

What is the Process for Integrating TypeScript into a Hook Function in SvelteKit?

What methods can we employ to ensure that Typescript adheres to the default generic argument type in this situation?

What is the reason for the undefined value of "this.memberSkills"?

Why is Zod making every single one of my schema fields optional?

Guide on generating a video thumbnail using JavaScript Application

Remove all input fields within an HTML file using a TypeScript method implemented in an Angular 2 component

Why is TypeScript only supporting Promise<T> params and not Promise<T1,T2>?

Could someone provide some insights on how the ( !! ) operator functions?

Is it possible to define a new type in TypeScript using "runtime" keys?

Using Typescript: Undefined arrays could cause issues in the array map function

What is the best way to tally the elements of a nested object within a group of objects?

What is the best way to invoke a TypeScript function within a jQuery function?

When executing tests in jest, imports from node_modules may become undefined

Leveraging Angular 2 to retrieve information from mongoDB

Harnessing the power of external Javascript functions within an Angular 2 template

The parameter 'NextApiRequest' cannot be assigned to the parameter 'Request'

Using TypeScript to Bind a Class Method as a jQuery EventHandler