How to pick nested schemas from a global schema but keeping the original property path for errors?

[Niccober]

Hey,

first of all: Zod is a great library and I am really happy to have found it!

I have a huge object with multiple nested levels whereby the properties themselves can be objects again or also an array of objects. A snippet of the object's properties looks like this:

_entities: z.array(
        z.object({
          _units: z.number().nonnegative().nullable(),
          _unitPrice: z.number().nonnegative().nullable(),
          _unitsValue: z.number(),
          _safetyMargin: z.number().nonnegative().nullable(),
          _safetyMarginAsPercentage: z.number().nonnegative().nullable(),
          _safetyMarginLastUpdated: z.enum(['flatAmount', 'percentage']).nullable(),
          _safetyMarginInterimResult: z.number()
        })
      ),
_unitsValueTotal: z.number(),

Each object being used is built from a class and each class has setter methods for updating the individual variables. In the setter methods I am parsing against the repsective subschema that is connected to that variable. Currently these schemas are added individually in each setter method and are not stemming from a centralized global schema. Therefore, when an error is thrown the error path variable contains an empty array since the parsed schema is not embedded in a superior structure.

I would like to implement a global schema (see code snippet above) instead of defining all these little subschemas for each property setter individually, especially since I am using Zod as the single source of truth which includes inferring the TypeScript types from it. Doing so should also enable Zod to output the path to the variable when an error occurs.

Now the problem: When a nested value e.g. _units is updated it would be sufficient to just parse against the subschema that is defined for the _units property: z.number().nonnegative().nullable(). I know that I can access the subschema using the .pick() method or by recursively accessing the shape properties of the global schema but the problem is when I do this, then the path holding the information where the targeted variable resided within the global schema is lost (e.g. the path should be ["_entities", 0, "_units"] but is [] instead after extracting the subschema. For that reason when an error occurs, the helpful information about the exact location of the targeted variable within the object is not available anymore.

Of course, I could go ahead now and just always parse all existing data against the global schema to keep the path information but considering that only a single value is updated it feels like a complete overkill to always parse the whole object especially since it is a quite complex structure with many different properties and schemas.

After I googled quite a while trying to search for a solution but not finding anything helpful I would really appreciate if somebody could give me a hint how to overcome this problem. Looking forward to any kind of help that you could give me. Thank you!

[JacobWeisenburger]

Unfortunately, I don't think this is possible.

[Niccober]

Then I assume it would be reasonable to go with the approach of testing against individual subschemas within the different setter methods without having a global schema for the whole object? Or does anything scream "bad practice" about that?

[JacobWeisenburger]

I don't really know what you mean by all that, so perhaps you should make some sample code to show what you mean.

[Niccober]

By testing against individual subschemas I mean writing the setter like this and providing the schema directly within each setter instead of extracting it from a centralized global schema object (see initial post), where all the subschemas reside in:

set units(units: number | null) {
  // Validate
  this._units = z.number().nonnegative().nullable().parse(units)

 // Rest of the code to be executed if validation is successful
}

[JacobWeisenburger]

on the surface this doesn't look like a "bad practice", but without knowing the whole use case, it's hard to say for sure

[neznayer]

You could do something like that:

type ObjectSchema<T extends Record<string,any>> = Partial<Record<keyof T, z.Schema>>

const fieldsToValidate: ObjectSchema<InternalSchema> = {
  name: z.string().startsWith('A').min(2),
  project: z.object({ id: z.string().min(1), name: z.string().min(1) }),
  namespace: z.object<ObjectSchema<Namespace>>({
    uri: z.string().min(1),
  }),
};

const schemaSchema = z.object<ObjectSchema<InternalSchema>>(fieldsToValidate);

So you would have all the individual subschemas as well as a global schema without repeating code.