get keys from object shape

[navtoj]

I checked the docs but couldn't find a way to do something like the pseudo-code below...

const schema = z.object({
    foo: z.string(),
    one: z.object({
        two: z.object({
            three: z.string(),
            four: z.number(),
        }),
        five: z.string(),
    }),
    bar: z.number(),
});

const keys = schema.keys();

console.log(keys);
// [
// 	'foo',
// 	'one.two.three',
// 	'one.two.four',
// 	'one.five',
// 	'bar',
// ]

Any suggestions?

[JacobWeisenburger]

you could make a recursive function that would get the keys from schema.shape

[kimmobrunfeldt]

Thanks! Helped my use case.

[navtoj]

Thanks! Helped my use case.

@kimmobrunfeldt How did you do it? I can't figure it out.

[kimmobrunfeldt]

console.log(z.object({ a: z.number(), b: z.string() }).strict().shape)

There you can see the shape of the schema. You'd need to implement recursive function that gets all the nested keys in the format you mentioned above. My use case has no nested objects though.

[kimmobrunfeldt]

I attempted to create a utility which takes in objects, and creates a merged object where each schema value that has more than one unique schema within the input objects, it would union the values.

export function objectUnionValues(
  schemas: AnyZodObject[],
  { commonKeys = [] }: ObjectUnionOptions
): AnyZodObject {
  const allKeys = schemas.flatMap((s) => Object.keys(s.shape))

  const newObjectFields = _.fromPairs(
    allKeys.map((key) => {
      const allSchemas = schemas.map((s) => s.shape[key]).filter(isNotUndefined)
      if (allSchemas.length === 0) {
        throw new Error(`Unexpectedly no schemas found with key: '${key}'`)
      }
      return [
        key,
        allSchemas.length > 1 && !commonKeys.includes(key)
          ? z.union(
              // We just verified that there are at least 2 schemas in the array
              allSchemas as unknown as readonly [
                ZodTypeAny,
                ZodTypeAny,
                ...ZodTypeAny[]
              ]
            )
          : allSchemas[0],
      ]
    })
  )
  return z.object(newObjectFields)
}

const a = z.object({ type: z.literal('A'), value: z.number(), id: z.string() })
const b = z.object({ type: z.literal('B'), value: z.string(), id: z.string() })

const combine = objectUnionValues([a, b])

// combine would equal:
z.object({
  id: z.string(),
  type: z.union([z.literal('A'), z.literal('B')]),
  value: z.union([z.number(), z.string()]),
})

That works but the typings do not.

I wasn't able to achieve that with standard utils. object.merge only picked types from the other object etc.

[navtoj]

you could make a recursive function that would get the keys from schema.shape

// get zod object keys recursively
const zodKeys = <T extends z.ZodTypeAny>(schema: T): string[] => {
	// make sure schema is not null or undefined
	if (schema === null || schema === undefined) return [];
	// check if schema is nullable or optional
	if (schema instanceof z.ZodNullable || schema instanceof z.ZodOptional) return zodKeys(schema.unwrap());
	// check if schema is an array
	if (schema instanceof z.ZodArray) return zodKeys(schema.element);
	// check if schema is an object
	if (schema instanceof z.ZodObject) {
		// get key/value pairs from schema
		const entries = Object.entries(schema.shape);
		// loop through key/value pairs
		return entries.flatMap(([key, value]) => {
			// get nested keys
			const nested = value instanceof z.ZodType ? zodKeys(value).map(subKey => `${key}.${subKey}`) : [];
			// return nested keys
			return nested.length ? nested : key;
		});
	}
	// return empty array
	return [];
};

The code above can handle ZodObject's wrapped in ZodNullable, ZodOptional, and ZodArray.

See @kimmobrunfeldt's response for more info.

[RobertDiebels]

Hi @navtoj , first of all, big thanks for this write up.
I made some minor adjustments to your code that utilize the root type for all zod-types (ZodType) which allowed me to remove several if-statements. Thought I'd share 👍 .

    const getPropertyPaths = (schema: Zod.ZodType): string[] => {  // Adjusted: Signature now uses Zod.ZodType to eliminate null& undefined check
        // check if schema is nullable or optional
        if (
            schema instanceof Zod.ZodNullable ||
            schema instanceof Zod.ZodOptional
        ) {
            return getPropertyPaths(schema.unwrap())
        }
        // check if schema is an array
        if (schema instanceof Zod.ZodArray) {
            return getPropertyPaths(schema.element)
        }
        // check if schema is an object
        if (schema instanceof Zod.ZodObject) {
            // get key/value pairs from schema
            const entries = Object.entries<Zod.ZodType>(schema.shape) // Adjusted: Uses Zod.ZodType as generic to remove instanceof check. Since .shape returns ZodRawShape which has Zod.ZodType as type for each key.
            // loop through key/value pairs
            return entries.flatMap(([key, value]) => {
                // get nested keys
                const nested = getPropertyPaths(value).map(
                    (subKey) => `${key}.${subKey}`
                )
                // return nested keys
                return nested.length ? nested : key
            })
        }
        // return empty array
        return []
    }

Again, thank you for the write up.

[ozzyfromspace]

@navtoj you just saved me a lot of work. Thank you! I needed this to compare keys like "a.b.c" against a zod schema before doing a targeted resource update in my database. I barely altered your recursive function. Best wishes 🎊

[krisgrm]

hey this is for runtime? I'd like to achieve this for build time, if it makes sense what i am saying...

• i am able to get attributes inferred, but only for non-nested object

function zodEnumFromObjKeys<K extends string>(
  obj: Record<K, unknown>,
): z.ZodEnum<[K, ...K[]]> {
  const [firstKey, ...otherKeys] = Object.keys(obj) as K[];
  return z.enum([firstKey!, ...otherKeys]);
}

const testSchema = zodEnumFromObjKeys(MySchema.shape);
type TestSchema = z.infer<typeof testSchema>;
const testSchema2: TestSchema = "name"; // properties here is union type of all top-level attributes
// infer if testSchema2 is a string or a number or a boolean
const type = IDScanCredentialSubjectSchema.shape[testSchema2]; // get type from the selected object 
type TestType = z.infer<typeof type>;
const testType: TestType = "kris"; // if "name" would have been number in the schema, this would throw error
console.log("testType", testType);

now id like to extend this to work with nested objects... to reference the nested object, I should be able to do:

const testSchema = zodEnumFromObjKeys(MySchema.shape);
type TestSchema = z.infer<typeof testSchema>;
const testSchema2: TestSchema = "school.departement.name"; 

[ptim]

Further enhancement (super hacky?) unwrap schemas with .refine and .superRefine appended:

const getPropertyPaths = (schema: Zod.ZodType): string[] => {
  // check if schema has .refine or .superRefine
  if (schema instanceof Zod.ZodEffects) {
    return getPropertyPaths(schema._def?.schema ?? schema);
  }
  // ...
}

[McKayMower]

is there a way to use 'as const' here and declare all the keys as read only?

e.g.

const schema = z.object({
name: z.string()
})

const keys = zodKeys(schema) as const

here, the type of keys would be

keys: readonly ['name']

instead of general string[] if that makes sense. like keys won't contain just any string, it will contain ONLY the keys of the object and we can guarantee that through 'as const'.

[raflymln]

Hey guys, i just created a library for this:
https://www.npmjs.com/package/zod-key-parser

[krisgrm]

Sheesh man, I was just thinking about this last night.
Will test !

[demux]

Why not have the built-in parser do the work for us...

Simplest solution for extracting the keys of a flat zod schema:

import type { ZodSchema } from 'zod';

export function getZodSchemaFieldsShallow(schema: ZodSchema) {
  const fields: Record<string, true> = {};
  const proxy = new Proxy(fields, {
    get(_, key) {
      if (key === 'then' || typeof key !== 'string') {
        return;
      }
      fields[key] = true;
    },
  });
  schema.safeParse(proxy);
  return fields;
}

With nesting:

import type { ZodSchema } from 'zod';

type ZodSchemaFields = { [K: string]: ZodSchemaFields | true };
type DirtyZodSchemaFields = { [K: string]: DirtyZodSchemaFields };

const _proxyHandler = {
  get(fields: DirtyZodSchemaFields, key: string | symbol) {
    if (key === 'then' || typeof key !== 'string') {
      return;
    }
    if (!fields[key]) {
      fields[key] = new Proxy({}, _proxyHandler);
    }
    return fields[key];
  },
};

function _clean(fields: DirtyZodSchemaFields) {
  const cleaned: ZodSchemaFields = {};
  Object.keys(fields).forEach((k) => {
    const val = fields[k];
    cleaned[k] = Object.keys(val).length ? _clean(val) : true;
  });
  return cleaned;
}

export function getZodSchemaFields(schema: ZodSchema): ZodSchemaFields {
  const fields = {};
  schema.safeParse(new Proxy(fields, _proxyHandler));
  return _clean(fields);
}

Only thing is, you can't have any keys named then 🤷🏻‍♂️

[vgjenks]

Nice, thanks!

[Oguntoye]

Not working well when there's a zod array of object

[janvorwerk]

FWIW, I did not need the recursion but my search engine still took me to this discussion... for the reference, here is what I came up with. It's simple enough that I thought it was worth mentionning it:

const keys = [...schema.keyof().options]

It seems to work.

[schalkventer]

@janvorwerk Thanks! This is exactly what I needed, but got a bit of a fright when I saw the extent of what is required above.

[gunhaxxor]

Interesting! But whats the reason for spreading the options into a new array? Can't you assign the options to keys directly? like so:
const keys = schema.keyof().options

[janvorwerk]

@gunhaxxor you may not need the spreading... but then you get a ZodEnum<> type which may not suit your needs. If you want a simple array, then the spreading is useful.