What is the best way to create a type guard for a path containing a dynamic field

Question

What is the best way to create a type guard for a path containing a dynamic field

In certain scenarios, my field can potentially contain both a schema and an object where this schema is defined by key. How can a guard effectively tackle this issue?

Below is an example of the code:

import * as z from 'zod';
import type { ZodTypeAny } from 'zod'

type Key = 'test' | 'test2' | 'test3'

type Schema = {
  schema?: ZodTypeAny |  {
    [Property in Key]?: ZodTypeAny
  }
}

const userSchema = z.object({
  name: z.string(),
  email: z.string(),
});


const getSchema = (key: Key, path: Schema) {
  return path.schema?.[key] || path.schema
}

getSchema('test', { schema: {'test':  userSchema}})
getSchema('test', { schema: userSchema})

You can test the code on TypeScript Playground here

typescript

Answer 1

Answer №1

Although I'm not well-versed in Zod, based on your description, this code snippet seems to align with what you're looking for:

import * as z from 'zod';
import type { ZodTypeAny } from 'zod'

type Key = 'test' | 'test2' | 'test3'

type SchemaObject = {
    [Property in Key]?: ZodTypeAny
}

type Schema = {
  schema?: ZodTypeAny | SchemaObject
}

const userSchema = z.object({
  name: z.string(),
  email: z.string(),
});

function isSchemaObject(z: Schema['schema']): z is SchemaObject {
  return Object.prototype.hasOwnProperty.call(z, 'test')
    || Object.prototype.hasOwnProperty.call(z, 'test2') 
    || Object.prototype.hasOwnProperty.call(z, 'test3') 
}

const getSchema = (key: Key, path: Schema) => {
  const schema = path.schema;
  return isSchemaObject(schema) ? schema[key] : schema
}

getSchema('test', { schema: {'test':  userSchema}})
getSchema('test', { schema: userSchema})

This code introduces a SchemaObject type for easier reference and employs a type guard isSchemaObject to determine the component of the union type.

Answer 2

Although I'm not well-versed in Zod, based on your description, this code snippet seems to align with what you're looking for:

import * as z from 'zod';
import type { ZodTypeAny } from 'zod'

type Key = 'test' | 'test2' | 'test3'

type SchemaObject = {
    [Property in Key]?: ZodTypeAny
}

type Schema = {
  schema?: ZodTypeAny | SchemaObject
}

const userSchema = z.object({
  name: z.string(),
  email: z.string(),
});

function isSchemaObject(z: Schema['schema']): z is SchemaObject {
  return Object.prototype.hasOwnProperty.call(z, 'test')
    || Object.prototype.hasOwnProperty.call(z, 'test2') 
    || Object.prototype.hasOwnProperty.call(z, 'test3') 
}

const getSchema = (key: Key, path: Schema) => {
  const schema = path.schema;
  return isSchemaObject(schema) ? schema[key] : schema
}

getSchema('test', { schema: {'test':  userSchema}})
getSchema('test', { schema: userSchema})

This code introduces a SchemaObject type for easier reference and employs a type guard isSchemaObject to determine the component of the union type.

Answer 3

Answer №2

To determine if schema is of type ZodType<any, any, any>, you can add a type predicate. Here's an example:

const isSchemaZodType = (schema: unknown): schema is ZodTypeAny => schema instanceof z.ZodType<any, any, any>

You can then use it in your code like this:

const getSchema = (key: Key, path: Schema) => {
  if (!path.schema) {
    return path
  }

  if (isSchemaZodType(path.schema)) {
    return path.schema
  }

  return path.schema[key]
}

Feel free to test it out on the TypeScript Playground here

Answer 4

To determine if schema is of type ZodType<any, any, any>, you can add a type predicate. Here's an example:

const isSchemaZodType = (schema: unknown): schema is ZodTypeAny => schema instanceof z.ZodType<any, any, any>

You can then use it in your code like this:

const getSchema = (key: Key, path: Schema) => {
  if (!path.schema) {
    return path
  }

  if (isSchemaZodType(path.schema)) {
    return path.schema
  }

  return path.schema[key]
}

Feel free to test it out on the TypeScript Playground here

What is the best way to create a type guard for a path containing a dynamic field

Answer №1

Answer №2

Similar questions

MUI version 5 with styled-components and ListItemButton: The specified property 'to'/'component' is not recognized

Try querying again if you receive no results from an http.get request in Angular using RXJS Operators

Troubleshooting Issue with Angular Library: Live Reload Feature Not Functioning

Ways to access the chosen value from Ionic's popover modal

Angular 8 delivers an observable as a result following a series of asynchronous requests

What is the reason behind the ability to reassign an incompatible function to another in TypeScript?

Managing API responses using Redux and Typescript

Unable to pass a parameter through an Angular http.get request

Icon for closing Mui Snackbar

What is the best way to save a string for future use in Angular after receiving it from a POST request API?

When `strictNullChecks` is turned on, how does the `void` type differ from the `undefined` literal type?

What is the reason for not hashing the password in this system?

Verify the completeness of data types within an array in typescript

Utilize a dynamically defined union type to create a versatile callback function

Create dynamic modals in ReactJS that appear when a row is clicked

What is the best way to prevent the hassle of manually reloading a VS Code extension each time I make updates

express-validator not providing any feedback from endpoint when integrated with TypeScript

Pinia is having trouble importing the named export 'computed' from a non-ECMAScript module. Only the default export is accessible in this case

Can a TypeScript generator function be accurately typed with additional functionality?

Using TypeScript's conditional types for assigning types in React