Prevent assignment of properties from a subclass

Question

Prevent assignment of properties from a subclass

Let's consider the scenario below:

interface Base {
  a: string;
}

interface Derived extends Base {
  b: string;
}

const x: Derived = {
  a: "a",
  b: "b",
};

How can we configure the linter and/or compiler to detect any issues with the following line:

const y : Base = x;

The objective is to identify any extra properties being assigned to y that are not defined in the Base class.

typescript

Answer 1

Answer №1

The comment provided at this link explains that TypeScript follows a structurally-typed approach.

This implies that when extending Derived from Base, it is not possible to exclude properties of Base from Derived.

However, by utilizing structural typing, you can create an additional type that remains compatible with Base while excluding any "extra" properties present in Derived. This can be achieved by defining them as optional properties of type never (using certain type utilities), like so:

Take a look at the TS Playground for implementation details.

interface Base {
  a: string;
}

interface Derived extends Base {
  b: string;
}

const x: Derived = {
  a: "a",
  b: "b",
};

type PreventExtendedProps<Base, Derived extends Base> = Base & Partial<Record<Exclude<keyof Derived, keyof Base>, never>>;

type BaseNotDerived = PreventExtendedProps<Base, Derived>;

// Check the type's properties:
declare const b: BaseNotDerived;
b.a // string
b.b // undefined

// Example assignment scenario:
const y: BaseNotDerived = x; /*
      ^
Type 'Derived' cannot be assigned to type 'BaseNotDerived'.
  Type 'Derived' cannot be assigned to type 'Partial<Record<"b", never>>'.
    Properties of 'b' are incompatible.
      Type 'string' cannot be assigned to type 'never'.(2322) */

Answer 2

The comment provided at this link explains that TypeScript follows a structurally-typed approach.

This implies that when extending Derived from Base, it is not possible to exclude properties of Base from Derived.

However, by utilizing structural typing, you can create an additional type that remains compatible with Base while excluding any "extra" properties present in Derived. This can be achieved by defining them as optional properties of type never (using certain type utilities), like so:

Take a look at the TS Playground for implementation details.

interface Base {
  a: string;
}

interface Derived extends Base {
  b: string;
}

const x: Derived = {
  a: "a",
  b: "b",
};

type PreventExtendedProps<Base, Derived extends Base> = Base & Partial<Record<Exclude<keyof Derived, keyof Base>, never>>;

type BaseNotDerived = PreventExtendedProps<Base, Derived>;

// Check the type's properties:
declare const b: BaseNotDerived;
b.a // string
b.b // undefined

// Example assignment scenario:
const y: BaseNotDerived = x; /*
      ^
Type 'Derived' cannot be assigned to type 'BaseNotDerived'.
  Type 'Derived' cannot be assigned to type 'Partial<Record<"b", never>>'.
    Properties of 'b' are incompatible.
      Type 'string' cannot be assigned to type 'never'.(2322) */

Answer 3

Answer №2

Consider this scenario...

interface ModelA = {
    propertyA: string;
};

interface ModelB = {
    propertyB: string;
};

type UnionModel = ModelA | ModelB;

const value: UnionModel = {
    propertyA: "value A",
    propertyB: "value B",
};

const objectA: ModelA = { propertyA: "123" };
const objectB: ModelB = { propertyB: "234" };
const unionObject: UnionModel = value;

const objB: ModelB = value; // <---- Error
const objA: ModelA = value; // <---- Error

It appears that using only interfaces will not suffice in this case

Answer 4

Consider this scenario...

interface ModelA = {
    propertyA: string;
};

interface ModelB = {
    propertyB: string;
};

type UnionModel = ModelA | ModelB;

const value: UnionModel = {
    propertyA: "value A",
    propertyB: "value B",
};

const objectA: ModelA = { propertyA: "123" };
const objectB: ModelB = { propertyB: "234" };
const unionObject: UnionModel = value;

const objB: ModelB = value; // <---- Error
const objA: ModelA = value; // <---- Error

It appears that using only interfaces will not suffice in this case

Prevent assignment of properties from a subclass

Answer №1

Answer №2

Similar questions

Guide on linking a trust policy to an IAM role through CDK

Retrieve objects from an array that contain a certain specified key

Ways to resolve the issue of npm being unable to globally install typescript

Struggling to properly import the debounce function in ReactJS when using TypeScript

I'm encountering an issue with my Next.js development server at localhost:3001 where all routes are displaying a 404 not found page. What

`Is There a Solution When Compilation Fails?`

Locate the nearest upcoming date and time to today's date in the JSON response

Data can be retrieved in a React/Next.js application when a button is clicked, even if the button is located in a separate

Achieving the incorporation of multiple components within a parent component using Angular 6

Utilizing the "as" keyword for type assertion in a freshly created react application using create-react-app leads to the error message `Parsing error: Unexpected token, expected ";"`

Creating dynamic Kafka topic names within a NestJS microservice

Learn how to alter the website's overall appearance by changing the background or text color with a simple click on a color using Angular

Tips for transferring state information from a client to a server component within Nextjs?

Utilizing pattern matching in switch statements

Choose the object's property name using TypeScript through an interface

The flatMap function is not operating as intended in the sequence of function calls

using outlines for FontAwesome icons in React Native

"Exploring the process of extracting data from a JSON URL using NextJS, TypeScript, and presenting the

What method can be used to inherit the variable type of a class through its constructor

Utilizing References in React Components