TypeScript object that necessitates a dynamic property type

Question

TypeScript object that necessitates a dynamic property type

I'm facing a specific scenario where I need to create an object with a property that can have one of two distinct types (custom classes).

export class MyType1 {
   // properties here
}

export class MyType2 {
   // properties here
}

class CustomType = MyType1 | MyType2

class Config {
   propOne: boolean;
   dynamicParam: { [key: string ]: CustomType }
}

The Config object is utilized in the following manner:

let config: Config = {
   propertyOne: true,
   dynamicParam: {
      key1: {
         // properties from type one
      },
      key2: {
         // properties from type two
      }
   }
}

If I explicitly specify the type when defining the object, like so:

   key1: <MyType1> {

   }

I receive intellisense for properties of MyType1 class. However, if I omit the type specification, I get intellisense for properties of both MyType1 and MyType2 classes (due to dynamicParam's type being CustomType [union type]).

So my question is, can I enforce required type definition when defining the object? Meaning that if I try to define a property as:

   key1: {

   }

I would receive an error message stating that a type must be specified?

typescript

Answer 1

Answer №1

Let's modify your code to ensure it compiles correctly and possesses particular attributes for better clarity:

interface MyType1 {
  a: string,
  b: number,
  c: boolean
}

interface MyType2 {
  d: string,
  e: number,
  f: boolean
}

type CustomType = MyType1 | MyType2

If you feel uneasy about the fact that the following code complies without any warnings:

let customType: CustomType = {
  a: "yes",
  b: 2,
  c: false,
  d: {what: "the"} // no error here
}

In TypeScript, although types are not "exact types", object literals undergo excess property checking when assigned to variables. This means unexpected properties will trigger a warning. For instance, this would result in an error:

let warnCustomType: CustomType = {
  a: "yes",
  b: 2,
  c: false,
  nope: { what: "the" } // error
  // Object literal may only specify known properties, 
  // and 'nope' does not exist in type 'CustomType'.
}

However, excess property checking doesn't work independently on each part of a union type like CustomType; instead, it checks the entire union as a whole. Hence, the property 'd' above won't raise a warning since it belongs to one part of the union. This is currently viewed as a bug in TypeScript, with potential resolution in future releases. Yet, enforcing developer-asserted property types remains unfeasible.

An alternative approach involves creating explicit exact types for unions, restricting properties accordingly. This can be achieved using conditional types like so:

type AllPossibleKeysOf<U> = U extends any ? keyof U : never;

type Exclusify<U> = [U] extends [infer V] ? V extends any ? (
  V & Partial<Record<Exclude<AllPossibleKeysOf<U>, keyof V>, never>>
) : never : never

Applying Exclusify to CustomType results in ExclusiveCustomType, limiting properties to specific parts of the union:

type ExclusiveCustomType = Exclusify<CustomType>;

This enforces stricter property constraints compared to CustomType. Exploring different approaches may yield varied outcomes. Best of luck!

Answer 2

Let's modify your code to ensure it compiles correctly and possesses particular attributes for better clarity:

interface MyType1 {
  a: string,
  b: number,
  c: boolean
}

interface MyType2 {
  d: string,
  e: number,
  f: boolean
}

type CustomType = MyType1 | MyType2

If you feel uneasy about the fact that the following code complies without any warnings:

let customType: CustomType = {
  a: "yes",
  b: 2,
  c: false,
  d: {what: "the"} // no error here
}

In TypeScript, although types are not "exact types", object literals undergo excess property checking when assigned to variables. This means unexpected properties will trigger a warning. For instance, this would result in an error:

let warnCustomType: CustomType = {
  a: "yes",
  b: 2,
  c: false,
  nope: { what: "the" } // error
  // Object literal may only specify known properties, 
  // and 'nope' does not exist in type 'CustomType'.
}

However, excess property checking doesn't work independently on each part of a union type like CustomType; instead, it checks the entire union as a whole. Hence, the property 'd' above won't raise a warning since it belongs to one part of the union. This is currently viewed as a bug in TypeScript, with potential resolution in future releases. Yet, enforcing developer-asserted property types remains unfeasible.

An alternative approach involves creating explicit exact types for unions, restricting properties accordingly. This can be achieved using conditional types like so:

type AllPossibleKeysOf<U> = U extends any ? keyof U : never;

type Exclusify<U> = [U] extends [infer V] ? V extends any ? (
  V & Partial<Record<Exclude<AllPossibleKeysOf<U>, keyof V>, never>>
) : never : never

Applying Exclusify to CustomType results in ExclusiveCustomType, limiting properties to specific parts of the union:

type ExclusiveCustomType = Exclusify<CustomType>;

This enforces stricter property constraints compared to CustomType. Exploring different approaches may yield varied outcomes. Best of luck!

Answer 3

Answer №2

When working with TypeScript's structural type system, an object literal that includes all the properties of either MyType1 or MyType2 will be valid. It seems there is no straightforward way to enforce a type assertion like <MyType1>, but if a discriminant property is added in the type definition, it becomes mandatory in the configuration. Here's an example:

export enum MyTypes { 
    TYPE1, TYPE2
}

export class MyType1 {
    kind: MyTypes.TYPE1;
   // some properties
}

export class MyType2 {
    kind: MyTypes.TYPE2;
   // some properties
}

type CustomType = MyType1 | MyType2;

class Config {
   propertyOne: boolean;
   dynamicParam: { [key: string ]: CustomType }
}

let config: Config = {
    propertyOne: true,
    dynamicParam: {
        key1: {
            kind: MyTypes.TYPE2,
            // properties from one type
        },
        key2: {
            kind: MyTypes.TYPE1,
            // properties from another type
        }
    }
};

Answer 4

When working with TypeScript's structural type system, an object literal that includes all the properties of either MyType1 or MyType2 will be valid. It seems there is no straightforward way to enforce a type assertion like <MyType1>, but if a discriminant property is added in the type definition, it becomes mandatory in the configuration. Here's an example:

export enum MyTypes { 
    TYPE1, TYPE2
}

export class MyType1 {
    kind: MyTypes.TYPE1;
   // some properties
}

export class MyType2 {
    kind: MyTypes.TYPE2;
   // some properties
}

type CustomType = MyType1 | MyType2;

class Config {
   propertyOne: boolean;
   dynamicParam: { [key: string ]: CustomType }
}

let config: Config = {
    propertyOne: true,
    dynamicParam: {
        key1: {
            kind: MyTypes.TYPE2,
            // properties from one type
        },
        key2: {
            kind: MyTypes.TYPE1,
            // properties from another type
        }
    }
};

TypeScript object that necessitates a dynamic property type

Answer №1

Answer №2

Similar questions

Determining a value that increases to yield a fresh sum

Is there a way for TS-Node to utilize type definitions from the `vite-env.d.ts` file?

Setting default selections for mat-select component in Angular 6

Every time a module is imported, it is reloaded without utilizing the cache

The error message states that the property '$refs' cannot be found on the void type

Retrieve the key values from an object of a generic type

Next.js does not support tooltips with custom children components

Svelte user interface fails to update correctly after editing a writable array type

Issue with Variable Passing Correctly to Form

Use Angular to trigger a method when the Enter key is pressed, passing the current input text as a parameter

"Exploring the world of Ionic 2: uncovering its public variables

Pause until the user selects either the confirm or deny option before proceeding with the next action

How to display ngx-toastr using the show() method in Angular 2+ with a specific type

Troubles encountered while attempting to properly mock a module in Jest

Retrieving data for a route resolver involves sending HTTP requests, where the outcome of the second request is contingent upon the response from the first request

NextJS project utilizing the power of Typescript and composite structure

Discovering a solution to extract a value from an Array of objects without explicitly referencing the key has proven to be quite challenging, as my extensive online research has failed to yield any similar or closely related problems

Retrieve values of properties from an array

Understanding the explanation of the function declaration

Securing important code sections in Node/Express using Typescript: A guide