The challenge of ensuring type safety in abstract methods from a class by incorporating both generics and union types in Typescript

Question

The challenge of ensuring type safety in abstract methods from a class by incorporating both generics and union types in Typescript

My goal is to create a base class in TypeScript that accepts a union of string types as a generic type, and then uses these strings as keys in an abstract method that utilizes a dictionary.

The issue I'm encountering is that the child implementation of the abstract method does not throw a type error when additional properties are passed to it (even though it correctly throws an error if properties are missing):

abstract class Parent<T extends string = string> {

    abstract doSomethingWithT(options: { [key in T]: string }): void;

}

class Child extends Parent<"foo" | "morefoo"> {

    /**
     * Should trigger an error on 'bar'
     */
    doSomethingWithT(arg: { foo: string; morefoo: string; bar: string }) {

    }

}

I am searching for a solution to enforce this behavior in Typescript.

typescript

Answer 1

Answer №1

The issue lies in the fact that options: { [k in T]: string } does not fully match

{ foo: string; morefoo: string; bar: string }

because it only matches

{ foo: string; morefoo: string; }

and ignores the rest of the type. To ensure a stricter match, you can implement something like this:

abstract class Parent<T extends string = string> {

    abstract doSomethingWithT(options: { [k in T]: string } & Record<string, never>): void;

}

class Child extends Parent<"foo" | "morefoo"> {

    doSomethingWithT(arg: { foo: string; morefoo: string; bar: string }) {

    }

}

The usage of never here guarantees that an error will occur if you try to pass Record<string, never> as the parameter. Providing a parameter that aligns with { [k in T]: string } should make it work effectively.

It is uncertain what other implications this approach may have:

Playground link

Answer 2

The issue lies in the fact that options: { [k in T]: string } does not fully match

{ foo: string; morefoo: string; bar: string }

because it only matches

{ foo: string; morefoo: string; }

and ignores the rest of the type. To ensure a stricter match, you can implement something like this:

abstract class Parent<T extends string = string> {

    abstract doSomethingWithT(options: { [k in T]: string } & Record<string, never>): void;

}

class Child extends Parent<"foo" | "morefoo"> {

    doSomethingWithT(arg: { foo: string; morefoo: string; bar: string }) {

    }

}

The usage of never here guarantees that an error will occur if you try to pass Record<string, never> as the parameter. Providing a parameter that aligns with { [k in T]: string } should make it work effectively.

It is uncertain what other implications this approach may have:

Playground link

Answer 3

Answer №2

When it comes to what you're doing, there's no need for generics as it doesn't enforce the type of options in child classes, resulting in no added value.

You can simply remove it. To simplify object creation using keys, you can utilize Record.

abstract class Parent {

    abstract doSomethingWithT(options: { [key: string]: string }): void;

}

class Child extends Parent {

    /**
     * Intentionally wants an error on 'bar'
     */
    doSomethingWithT(arg: Record<"foo" | "morefoo", string>) {
        console.log(
            arg.foo,
            arg.morefoo,
            arg.bar, // This will throw an error
        );
    }

}

const t = new Child();

t.doSomethingWithT({
    foo: 'test',
    morefoo: 'test',
    bar: 'test', // This will result in an error
    test: '123', // This will result in an error
});

Answer 4

When it comes to what you're doing, there's no need for generics as it doesn't enforce the type of options in child classes, resulting in no added value.

You can simply remove it. To simplify object creation using keys, you can utilize Record.

abstract class Parent {

    abstract doSomethingWithT(options: { [key: string]: string }): void;

}

class Child extends Parent {

    /**
     * Intentionally wants an error on 'bar'
     */
    doSomethingWithT(arg: Record<"foo" | "morefoo", string>) {
        console.log(
            arg.foo,
            arg.morefoo,
            arg.bar, // This will throw an error
        );
    }

}

const t = new Child();

t.doSomethingWithT({
    foo: 'test',
    morefoo: 'test',
    bar: 'test', // This will result in an error
    test: '123', // This will result in an error
});

The challenge of ensuring type safety in abstract methods from a class by incorporating both generics and union types in Typescript

Answer №1

Answer №2

Similar questions

Creating a custom Map type in TypeScript

Tips for successfully sending properties from a parent component to a child component in a TypeScript and React application

Angular - Execute function every 30 seconds while considering the duration of the function execution

Having trouble with triggers: Unable to locate the module 'csv-parse/sync' for parsing

Error in Webpack: "Module cannot be found: unable to resolve in tsx files"

Tips for querying enum data type using GraphQL

Finding out whether the current date falls between a startDate and endDate within a nested object in mongoose can be done by using a specific method

Is there an array containing unique DateTime strings?

Retrieve the visibility and data type of an object's property in Javascript or Typescript

The error message indicates that the argument cannot be assigned to the parameter type 'AxiosRequestConfig'

Combining the values of a particular key with duplicate objects into a single object within an array of JSON objects using Angular and Typescript

Adding flair to a object's value in React JS

What is the best way to transfer user data from the backend to the frontend?

Experience screen sharing through WEBRTC without the need for any additional browser extensions

What is the best way to exclude React.js source files from a fresh Nest.js setup?

Discovering the class type in TypeScript

Testing a reusable component in Angular using unit testing techniques

Issue transferring information between non-related components in an Angular 8 application unrelated to BehaviorSubject

Is there a way to optimize Typescript compiler to avoid checking full classes and improve performance?

While attempting to index a nested object, TypeScript (error code 7053) may display a message stating that an element implicitly carries the 'any' type due to the inability to use an expression of type X to index type