Enforcing strict property validation on variables passed into TypeScript functions

Question

Enforcing strict property validation on variables passed into TypeScript functions

Is there a method to enforce excess-property checking, not only for an inline object literal but also one derived from a variable?

For instance, let's say I have an interface and a function

interface Animal {
    speciesName: string
    legCount: number,
}

function serializeBasicAnimalData(a: Animal) {
    // something
}

If I invoke

serializeBasicAnimalData({
    legCount: 65,
    speciesName: "weird 65-legged animal",
    specialPowers: "Devours plastic"
})

I would receive an error -- which is desired in my scenario. I only want the function to accept a general animal description without additional details.

However, if I initially assign it to a variable, the error does not occur:

var weirdAnimal = {
    legCount: 65,
    speciesName: "weird 65-legged animal",
    specialPowers: "Devours plastic"
};
serializeBasicAnimalData(weirdAnimal);

So, my question is: Is there a way to compel TypeScript to conduct "excess property checking" on the function parameter regardless of whether it's an inline object or an object previously assigned to a variable?

typescript

Answer 1

Answer №1

Here is a solution to your issue: The problem lies in Typescript's reliance on structural typing, which is considered more advantageous than Nominal typing but still presents its own challenges.

type StrictPropertyCheck<T, TExpected, TError> = Exclude<keyof T, keyof TExpected> extends never ? {} : TError;

interface Animal {
    speciesName: string
    legCount: number,
}

function serializeBasicAnimalData<T extends Animal>(a: T & StrictPropertyCheck<T, Animal, "Only allowed properties of Animal">) {
    // something
}

var weirdAnimal = {
    legCount: 65,
    speciesName: "weird 65-legged animal",
    specialPowers: "Devours plastic"
};
serializeBasicAnimalData(weirdAnimal); // this will now fail as intended

Answer 2

Here is a solution to your issue: The problem lies in Typescript's reliance on structural typing, which is considered more advantageous than Nominal typing but still presents its own challenges.

type StrictPropertyCheck<T, TExpected, TError> = Exclude<keyof T, keyof TExpected> extends never ? {} : TError;

interface Animal {
    speciesName: string
    legCount: number,
}

function serializeBasicAnimalData<T extends Animal>(a: T & StrictPropertyCheck<T, Animal, "Only allowed properties of Animal">) {
    // something
}

var weirdAnimal = {
    legCount: 65,
    speciesName: "weird 65-legged animal",
    specialPowers: "Devours plastic"
};
serializeBasicAnimalData(weirdAnimal); // this will now fail as intended

Answer 3

Answer №2

This solution was crucial for ensuring the correct object shape in my Redux implementation.

I found a helpful resource in this informative article and Shannon's response within this discussion here. By incorporating both, I discovered a more succinct approach to achieving the desired outcome:

export type StrictPropertyValidation<T, TExpected, TError> = T extends TExpected
  ? Exclude<keyof T, keyof TExpected> extends never
    ? T
    : TError
  : TExpected

Here, by including T extends TExpected in the StrictPropertyCheck, a subtle yet effective improvement is introduced. I felt it important to reference the article mentioned above to assist any others seeking similar guidance.

Application in Redux action creation:

export type UserCredentials = {
  email: string
  password: string
}

export type ValidatedCreds<T> = T &
  StrictPropertyValidation<
    T,
    UserCredentials,
    'ATTENTION: CREDENTIALS OBJECT CONTAINS REDUNDANT PROPERTIES'
  >

export type AuthActionType =
  | {
      type: AuthAction.LOGIN
      payload: ValidatedCreds<UserCredentials>
    }
  | { type: AuthAction.LOGOUT

export const authenticateUser = <T>(credentials: ValidatedCreds<T>): AuthActionType => {
  return {
    type: AuthAction.LOGIN,
    payload: credentials as UserCredentials,
  }
}

Answer 4

This solution was crucial for ensuring the correct object shape in my Redux implementation.

I found a helpful resource in this informative article and Shannon's response within this discussion here. By incorporating both, I discovered a more succinct approach to achieving the desired outcome:

export type StrictPropertyValidation<T, TExpected, TError> = T extends TExpected
  ? Exclude<keyof T, keyof TExpected> extends never
    ? T
    : TError
  : TExpected

Here, by including T extends TExpected in the StrictPropertyCheck, a subtle yet effective improvement is introduced. I felt it important to reference the article mentioned above to assist any others seeking similar guidance.

Application in Redux action creation:

export type UserCredentials = {
  email: string
  password: string
}

export type ValidatedCreds<T> = T &
  StrictPropertyValidation<
    T,
    UserCredentials,
    'ATTENTION: CREDENTIALS OBJECT CONTAINS REDUNDANT PROPERTIES'
  >

export type AuthActionType =
  | {
      type: AuthAction.LOGIN
      payload: ValidatedCreds<UserCredentials>
    }
  | { type: AuthAction.LOGOUT

export const authenticateUser = <T>(credentials: ValidatedCreds<T>): AuthActionType => {
  return {
    type: AuthAction.LOGIN,
    payload: credentials as UserCredentials,
  }
}

Answer 5

Answer №3

While utilizing Prisma, I encountered a similar issue related to object literals and the inference of return types based on their structure. If excess properties are passed in these objects, it can lead to runtime errors. To avoid the hassle of duplicating the entire object literal in every query, I needed a way to pass an object with a known shape that could also be validated against another type.

The generated type from Prisma, representing a config object for data retrieval, plays a crucial role in determining the return type inferred by Typescript. Hence, directly declaring the object using this type was not feasible.

  export type memberInclude = {
    account?: boolean | accountArgs
    faculty?: boolean | facultyArgs
    member_type?: boolean | member_typeArgs
    has_keyword?: boolean | has_keywordFindManyArgs
    insight?: boolean | insightFindManyArgs
    ...
  }

To address this scenario, a modified version of the suggested solution was employed to ensure that only valid keys are present in the object before exporting it.

type CheckKeysAreValid<T, ValidProps> = Exclude<keyof T, keyof ValidProps> extends never
  ? T
  : "Invalid keys" | Exclude<keyof T, keyof ValidProps>;

const _includeMemberInfo = {
  account: true,
  member_type: true,
} as const;

// Excess property validation is performed before assigning the original object type upon successful completion
export const includeMemberInfo: CheckKeysAreValid<
  typeof _includeMemberInfo,
  Prisma.memberInclude
> = _includeMemberInfo;

This approach ensures that any modifications made to table names in the Prisma schema are caught during compilation rather than at runtime, enhancing development efficiency. By specifying the exact object shape, Typescript accurately infers the return type from Prisma when executing database queries.

  const member = await db.member.findUnique({
    where: { id },
    include: includeMemberInfo,
  });
  
  // The return type is member & {account: account} & {member_type: member_type}

Answer 6

While utilizing Prisma, I encountered a similar issue related to object literals and the inference of return types based on their structure. If excess properties are passed in these objects, it can lead to runtime errors. To avoid the hassle of duplicating the entire object literal in every query, I needed a way to pass an object with a known shape that could also be validated against another type.

The generated type from Prisma, representing a config object for data retrieval, plays a crucial role in determining the return type inferred by Typescript. Hence, directly declaring the object using this type was not feasible.

  export type memberInclude = {
    account?: boolean | accountArgs
    faculty?: boolean | facultyArgs
    member_type?: boolean | member_typeArgs
    has_keyword?: boolean | has_keywordFindManyArgs
    insight?: boolean | insightFindManyArgs
    ...
  }

To address this scenario, a modified version of the suggested solution was employed to ensure that only valid keys are present in the object before exporting it.

type CheckKeysAreValid<T, ValidProps> = Exclude<keyof T, keyof ValidProps> extends never
  ? T
  : "Invalid keys" | Exclude<keyof T, keyof ValidProps>;

const _includeMemberInfo = {
  account: true,
  member_type: true,
} as const;

// Excess property validation is performed before assigning the original object type upon successful completion
export const includeMemberInfo: CheckKeysAreValid<
  typeof _includeMemberInfo,
  Prisma.memberInclude
> = _includeMemberInfo;

This approach ensures that any modifications made to table names in the Prisma schema are caught during compilation rather than at runtime, enhancing development efficiency. By specifying the exact object shape, Typescript accurately infers the return type from Prisma when executing database queries.

  const member = await db.member.findUnique({
    where: { id },
    include: includeMemberInfo,
  });
  
  // The return type is member & {account: account} & {member_type: member_type}

Answer 7

Answer №4

This may seem confusing and surprising, but I have found a solution by including type annotations directly on the variable declaration.

-----------------👇
let strangeCreature: Creature = {
    legCount: 65,
    speciesName: "strange 65-legged creature",
    specialPower: "Eats plastic"
};
serializeCreatureData(strangeCreature);

Answer 8

This may seem confusing and surprising, but I have found a solution by including type annotations directly on the variable declaration.

-----------------👇
let strangeCreature: Creature = {
    legCount: 65,
    speciesName: "strange 65-legged creature",
    specialPower: "Eats plastic"
};
serializeCreatureData(strangeCreature);

Enforcing strict property validation on variables passed into TypeScript functions

Answer №1

Answer №2

Application in Redux action creation:

Answer №3

Answer №4

Similar questions

Using GSAP in an Ionic application

having difficulty sending a post request with Angular

Allow Visual Studio Code to create a constructor for Typescript class

Continue looping in Javascript until an empty array is identified

Creating a TypeScript array of objects that aligns with a specific interface: A step-by-step guide

Analyze two sets of JSON data and compile a new JSON containing only the shared values

Nexus and GraphQL: The root typing path for the "context" type is not found

Activate the drop-down menu in Angular 6 by hovering over it with your mouse

Tally up identical words without considering differences in capitalization or extra spaces

Make sure to include a property that is indexed when typing

An error has been detected: An unexpected directive was found. Kindly include a @NgModule annotation

What is the best way to make an attribute in an interface mandatory only when another attribute is set to true

transmit information from the current state to a fresh task within an rxjs effect

The validation for decimal numbers fails to function when considering the length

ReactNative: When attempting to navigate, a TypeError occurred - this.props.navigation.navigate is not a function

Encountering the issue of receiving "undefined" when utilizing the http .get() method for the first time in Angular 2

Angular Pipe: Working with Data Structures in Angular With Nested Arrays and Objects

Testing a reusable component in Angular using unit testing techniques

Utilizing Next.js App Router to Enable Static Site Generation for Dynamic Routes in Live Environments

The issue with Angular 2's router.navigate not functioning as expected within a nested JavaScript function