Step-by-step guide on developing a fresh zod schema while automatically determining its type

Question

Step-by-step guide on developing a fresh zod schema while automatically determining its type

Is there a way to reassign the value of an object using TypeScript?

I have an interface defined as follows:

interface Root {
    userId: number;
    id: number;
    title: string;
    completed: boolean;
}

I am familiar with creating a zod schema from this interface like so:

const zRoot: z.ZodType<Root> = z.object({
    userId: z.number(),
    id: z.number(),
    title: z.string(),
    completed: z.boolean(),
});

However, I am unsure how to create a schema that types like this:

type RootObjectArray = {
    [F in keyof Root]: Root[F][];
};

typescript types interface schema zod

Answer 1

Answer №1

This specific demonstration showcases the utilization of a validating schema for the RootObjectArray that has been provided. It also includes evidence that it aligns with the specified requirements (you can hover over RootMatches and RootObjectArrayMatches to verify). The script has been rigorously evaluated only through testing in the sandbox environment.

import { z, ZodObject, ZodArray, ZodRawShape } from "zod";

export function safeKeys<Lookup extends { [k in string]: unknown }>(
  lookup: Lookup
) {
  return Object.keys(lookup) as (keyof Lookup)[];
}

export function mapFrom<Map extends object>(
  keys: readonly (keyof Map)[],
  mapFn: <Key extends keyof Map>(key: Key) => Map[Key]
) {
  return Object.fromEntries(keys.map((key) => [key, mapFn(key)])) as {
    [K in keyof Map]: Map[K];
  };
}

interface Root {
  userId: number;
  id: number;
  title: string;
  completed: boolean;
}

type RootObjectArray = {
  [F in keyof Root]: Root[F][];
};

const zRoot = z.object({
  userId: z.number(),
  id: z.number(),
  title: z.string(),
  completed: z.boolean(),
});

function toArraySchema<Shape extends ZodRawShape>(schema: ZodObject<Shape>) {
  const shape: Shape = schema.shape;
  return mapFrom<{ [K in keyof Shape]: ZodArray<Shape[K]> }>(
    safeKeys(shape),
    (key) => z.array(shape[key])
  );
}

const zRootObjectArray = z.object(toArraySchema(zRoot));

type ZodRoot = z.infer<typeof zRoot>;
type ZodRootObjectArray = z.infer<typeof zRootObjectArray>

type Equivalent<X, Y> = X extends Y ? (Y extends X ? true : false) : false;

type RootMatches = Equivalent<Root, ZodRoot>;
type RootObjectArrayMatches = Equivalent<RootObjectArray, ZodRootObjectArray>;

Answer 2

This specific demonstration showcases the utilization of a validating schema for the RootObjectArray that has been provided. It also includes evidence that it aligns with the specified requirements (you can hover over RootMatches and RootObjectArrayMatches to verify). The script has been rigorously evaluated only through testing in the sandbox environment.

import { z, ZodObject, ZodArray, ZodRawShape } from "zod";

export function safeKeys<Lookup extends { [k in string]: unknown }>(
  lookup: Lookup
) {
  return Object.keys(lookup) as (keyof Lookup)[];
}

export function mapFrom<Map extends object>(
  keys: readonly (keyof Map)[],
  mapFn: <Key extends keyof Map>(key: Key) => Map[Key]
) {
  return Object.fromEntries(keys.map((key) => [key, mapFn(key)])) as {
    [K in keyof Map]: Map[K];
  };
}

interface Root {
  userId: number;
  id: number;
  title: string;
  completed: boolean;
}

type RootObjectArray = {
  [F in keyof Root]: Root[F][];
};

const zRoot = z.object({
  userId: z.number(),
  id: z.number(),
  title: z.string(),
  completed: z.boolean(),
});

function toArraySchema<Shape extends ZodRawShape>(schema: ZodObject<Shape>) {
  const shape: Shape = schema.shape;
  return mapFrom<{ [K in keyof Shape]: ZodArray<Shape[K]> }>(
    safeKeys(shape),
    (key) => z.array(shape[key])
  );
}

const zRootObjectArray = z.object(toArraySchema(zRoot));

type ZodRoot = z.infer<typeof zRoot>;
type ZodRootObjectArray = z.infer<typeof zRootObjectArray>

type Equivalent<X, Y> = X extends Y ? (Y extends X ? true : false) : false;

type RootMatches = Equivalent<Root, ZodRoot>;
type RootObjectArrayMatches = Equivalent<RootObjectArray, ZodRootObjectArray>;

Step-by-step guide on developing a fresh zod schema while automatically determining its type

Answer №1

Similar questions

Tips to successfully save and retrieve a state from storage

Efficiently storing a newly shuffled list of tasks into the db.json file using Angular

In order to view current data on the chart, I need to use array.slice() in the markup which unfortunately disables the ability to select specific points. Check out the Stackbl

Issue with rendering HTML tags when replacing strings within Ionic 2 and Angular 2

It appears that TypeScript is generating incorrect 'this' code without giving any warning

Calculating the minimum value of a number in Angular 8

The unit test is not passing due to inconsistencies between the mock data generated in the constructors and the original mock data

Creating dynamic key objects in TypeScript with index signatures: A beginner's guide

Guide to extracting the JSON array from a JSON object with Angular

What is the reason `addEventListener` does not work with a class method?

Can anyone provide guidance on incorporating lodash into an Ionic 2 project?

Guide on retrieving a nested JSON array to extract a comprehensive list of values from every parameter within every object

Utilizing the axios create method: troubleshooting and best practices

Jasmine's await function often leads to variables remaining undefined

Is it possible to enter NaN in Vue3?

Error! Element not found in cloned iframe #2460, promise unhandled

Is it possible for a redis client to function without having a redis datastore installed?

"Troubleshooting Typecscript and Angular: Dealing with mismatched argument

What is the best approach for setting up a global pipe that can be utilized across various modules?

Implement a query in Mongoose using the Schema First methodology within NestJS