Relationship between schema object fields

[alexandercerutti]

Hello there! I was exploring Zod with the intent of migrating from Joi. This looks awesome and makes me feel the schemas are more solid. I think it might be an excellent ally for my open-source library!

I observed how Joi owns a way to specify a relationship between schema object fields through the properties when (doc) and with (doc).

So, I could write:

Joi.object().keys({
     ...,        
     value: Joi
        .alternatives(z.string().allow(""), z.number(), z.date().iso())
        .required(),
    numberStyle: Joi
        .string()
        .regex(
            /(aaaaa|bbbbbb|ccccccc|ddddddd)/,
        )
        .when("value", {
            is: Joi.number(),
            otherwise: Joi.string().forbidden(),
        }),
});

Which tells Joi to forbid numberStyle if value is a not a number, or

Joi.object().keys({ ... }).with("webServiceURL", "authenticationToken");

Which enforces that two properties must appear at the same time for the schema to be valid.

So, is there a way to define a relationship between keys, if necessary with a condition? I guess something could be done with z.never() but I can't figure it out right now.

A solution that comes to my mind might be to create a discriminated union of objects based on value for what concerns when.

I would do something like this:

z.object<Field>({
    /** The rest of props... */
}).merge(
    z.discriminatedUnion("value", [
        z.object<Field>({
            value: z.string().or(isoDateString),
            numberStyle: z.never(),
        }),
        z.object({
            value: z.literal(z.number()),
            numberStyle: z
                .string()
                .regex(
                    /(aaaaa|bbbbbb|ccccccc|dddddddd)/,
                )
                .optional(),
        }),
    ]),
);

But, it seems that value must be literal, but in my case, it is a generic string or a generic number. So how can I achieve this? Would union still be okay?

For what concerns what, instead, I don't yet know how to create the relationship.

I guess the big issue here is that I'm attempting to migrate my Joi schemas 1-to-1 to Zod, but it probably requires a whole mindset change. 😄

Thank you very much!

[stale[bot]]

This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.

[alexandercerutti]

Oh c'mon...

[scotttrinh]

Maybe something like this?

z.union([
  z.object({ value: z.string(), numberStyle: z.never() }),
  z.object({ value: z.number(), numberStyle: z.string().regex(abcdRegexp).optional() },
])

[scotttrinh]

Basically you're making a true union not a discriminated union. If you want to make this easier to narrow on the typescript side you could transform and add a discriminant, like:

z.union([
  z.object({ value: z.string(), numberStyle: z.never() }).transform(v => ({ ...v, type: "STRING" })),
  z.object({ value: z.number(), numberStyle: z.string().regex(abcdRegexp).optional().transform(v => ({ ...v, type: "NUMBER" })) },
])

[alexandercerutti]

Hey @scotttrinh, thanks for your reply. I have to try the solution you proposed, but it is not very clear to me the transform with "STRING" | "NUMBER". Does it have any special meaning?

Thank you

[alexandercerutti]

I've tried to apply what you said and it apparently seems to work (I have to thoroughly test it because of what follows).

I've done this:

export const OverridableProps = z.object({
        /** props **/
})
    .and(
        z.union([
            z.object({
                webService: z.never(),
                authenticationToken: z.never(),
            }),
            z.object({
                webService: z.string(),
                authenticationToken: z.string(),
            }),
        ]),
    );

This seems to return a ZodIntersection.

So I'm not able to merge it with other schemas to create a single object. Also, I'm not able to merge the union above with the object above instead of using and.

export const AllProps = z
    .object({})
    .merge(KindsProps)
    .merge(PropsFromMethods)
    .merge(OverridableProps);

(I used z.object() just as a test, but it is the same if I take, for example, KindsProps and use merge on it).

Seems like .merge does not support intersections or unions, so I'm stuck here...

[stale[bot]]

This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.

[alexandercerutti]

Don't. You. Dare.

[stale[bot]]

This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.

[alexandercerutti]

Nope.

[andreafspeziale]

Hello! This is something I'm interested too.

In my use-case I would really love to use zod along with NestJS in order to validate microservice required env variables.

For example in of my schemas using joi I have something like this:

SOME_TOKEN: Joi.when('NODE_ENV', {
    is: NodeEnv.Test,
    then: Joi.string().allow('').default(''),
    otherwise: Joi.string().required(),
  }),

For sure I'm still able to do the validation using zod setting SOME_TOKEN as string always required having

# .env
SOME_TOKEN=<real_token>

# .env.test
SOME_TOKEN=""

[stale[bot]]

This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.

[alexandercerutti]

Nope, but I'm curious about the new possible replacement switch, so let's wait!

[stale[bot]]

This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.

[alexandercerutti]

Still waiting

[stale[bot]]

This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.

[alexandercerutti]

Naaaaaa-ah.