`zenstack/zod` generates incompatible types for Optional fields when comparing Types generated by `zenstack/orm`and `zenstack/zod`

[iPommes]

Description and expected behavior
When I'm using the zenstack/zod generator to generate my return types (for orpc) and then comparing them to the Types generated by the $ModelResult optional fields have incompatibilites.

Screenshots
Example schema to reproduce:

type BasicFields {
    id        String   @id @default(uuid())

    createdAt DateTime @default(now())
    updatedAt DateTime @updatedAt
    metaData  Json     @default("{}")
}

model Test with BasicFields {
    name String
    description String?
}

The types generated by zenstack/zod are:

type Test = {
    id: string;
    createdAt: Date;
    updatedAt: Date;
    metaData: any;
    name: string;
    description?: string | null | undefined; //This seems to be the problem
}

but when I'm passing "test" (imported directly form the model.ts which generates:

export type Test = $ModelResult<$Schema, "Test">;
type Test = {
    id: string;
    createdAt: Date;
    updatedAt: Date;
    metaData: JsonValue;
    name: string;
    description: string | null; //This seems to be the problem
}

the compiler complains about an incompatible type on all optional fields because null and undefined are incompatible.

Argument of type '{ id: string; createdAt: Date; updatedAt: Date; metaData: any; name: string; description?: string | null | undefined; }' is not assignable to parameter of type 'FlatModelResult<SchemaType, "Test", undefined, QueryOptions<SchemaType>>'.
  Types of property 'description' are incompatible.
    Type 'string | null | undefined' is not assignable to type 'string | null'.
      Type 'undefined' is not assignable to type 'string | null'.

This is a representation of code that I'm using:

const testSchema = zodFactory.makeModelSchema("Test")
testFunction({} as z.infer<typeof testSchema>) //Calling the function with the return type returned by my orpc contract

function testFunction(test: Test) {}

I have already tried to set the strictNullChecks: false but then suddenly everything else breaks and no type of $ModelResult gets generated.

Environment (please complete the following information):

• ZenStack version: 3.6.4
• Database type: PostgreSQL
• Node.js/Bun version: Bun v1.3.13
• Package manager: bun

[iPommes]

After investigating a little bit I think the issue seems to be the type ZodOptionalAndNullableIf. Looks like it does not infer the right Zod type.

I got it working by updating the ZodOptionalAndNullableIf to this:

type ZodOptionalAndNullableIf<
  T extends z.ZodType,
  Condition extends boolean,
> = Condition extends true ? z.ZodNullable<T> : T;

It seems like it was double wrapped in ZodNullable and ZodOptional. Now it's only ZodNullable.

Is this the right solution?

[Azzerty23]

Correct me if I'm wrong but I wonder if you're not comparing two schemas of different purpose : dto and entity.
Zod validates your dto (input) and $ModelResult is your entity (from your db).

In your example, metaData has a default attribute, so it will never be undefined when you retrieve it -> $ModelResult.
But when you want to create a test you're not forced to pass metadata as input, so undefined is correct here.

// export type Test = $ModelResult<$Schema, "Test">;

const createTestSchema = zodFactory.makeModelSchema("Test")
type TestCreateInput = z.infer<typeof createTestSchema>)
createTestFunction({name: "my-name"}) // -> should be correct

function createTestFunction(test: TestCreateInput): Test {}

I answered off-topic, sorry. To validate the entity, can you add .required()?

const postSchema = factory.makeModelSchema("Post").required();
type PostSchema = z.infer<typeof postSchema>;

testFunction({} as PostSchema); // should be correct

function testFunction(test: Post) {}

[iPommes]

Yeah I will give it a try but not the metaData field is the problem, the description one is.

Normally the model created by the zod generator should match the model generated by the orm client.

In this edge case its not the case.

[iPommes]

Also sorry its confusing that the argument of the function call is {} its only for testing if it would throw any incompatibility errors.

In my real app I will input the real response data from the rpc call.

[iPommes]

Also the suggested solution does not work for me because then I need to refactor huge amounts of code cause I used the normal schema and types generated by the orm 🥲 and not by the zod package.

The function argument should have the type generated by the orm then the error occurs.

I have temporarily fixed it as described in my first comment.

[Azzerty23]

That's super weird, I tried your exact zmodel and got an error with metaData (undefined description being fixed with required()).

Argument of type '{ createdAt: Date; description: string | null; id: string; metaData: string | number | boolean | unknown[] | Record<string, unknown> | null; name: string; updatedAt: Date; }' is not assignable to parameter of type 'FlatModelResult<SchemaType, "Test", undefined, QueryOptions<SchemaType>>'.
  Types of property 'metaData' are incompatible.
    Type 'string | number | boolean | unknown[] | Record<string, unknown> | null' is not assignable to type 'JsonValue'.
      Type 'null' is not assignable to type 'JsonValue'.

Fixed with:

import type { JsonValue } from "@zenstackhq/orm";

const testSchema = factory.makeModelSchema("Test").required().extend({
  metaData: z.custom<JsonValue>(),
});
type TestSchema = z.infer<typeof testSchema>;
testFunction({} as TestSchema); //Calling the function with the return type returned by my orpc contract

function testFunction(test: Test) {}

[iPommes]

Ah yes thats the other issue that I have reported: this one

There is also an type incompatibility with the JsonValue.

But I think it should not be mandatory to modify any schema (with .required()) and the schema generated by orm and zod should be in sync.

[Azzerty23]

I created a PR to point the root cause for the json mismatch, I let @ymc9 choose how to fix it ^^
For the optionality incompatibility we should look at how optionality is inferred. I agree types should be in sync.

EDIT: turns out you were right from the start — just changing JsonZodType seems to fix it.