Nullable and scheme not matching definition.

[frontenders-game]

I got this error when i try to use Type.Null() to serialize prisma returns:

{
  "statusCode": 500,
  "error": "Internal Server Error",
  "message": "The value of 'responseProductSchema#/properties/discountPercent' does not match schema definition."
}

This is what i am getting with prisma:

{
  subcategories: 
    { 
        products: [
                             ...,
                             {... discountPercent: null,   } 
                        ]

}

This is typebox scheme:

export const TypeNullable = <T extends TSchema>(schema: T) => Type.Union([schema, Type.Null()])

export const responseProductSchema = Type.Object({
         ... 
         discountPercent: TypeNullable(Type.Number()),
         ...  
        },
    {$id: "responseProductSchema", additionalProperties: true}
)

I use it with Ref in category scheme:

products: Type.Optional(Type.Array(Type.Ref(Type.Omit(responseProductSchema, ['categoryId'])))),

[sinclairzx81]

@frontenders-game Hi. I'm not all that familiar with Primsa code generation with TypeBox (would need to see more of the setup), It's possible other developers may be able to assist you so will leave the discussion open for others, or alternatively it may be best to submit an issue on the prisma generator repository (you will likely have better luck there)

Just looking at your question though, just be mindful that TypeBox provides a lot of flexibility over more constrained schematics representations (such as those required to define database schematics), so there may be types expressible in TypeBox that simply can't be converted to Primsa schematics. Here's some notes if they're helpful.

1. The Type.Union([T, Type.Null()]) used to express nullable may not be supported in the Primsa generator. It's possible that you might have better luck with Type.Optional(T) as the generator may interpret optional as nullable.

2. The Type.Ref() may not be supported by the Prisma generator. TypeBox doesn't internally cache $id or $ref references, so it's possible you may need to explicitly pass any referenced types to the generator so it knows how to find the reference. If the generator doesn't support passing reference types, you may want to avoid using Type.Ref().

3. The Type.Optional(Type.Array(Type.Ref(Type.Omit(responseProductSchema, ['categoryId'])))) type looks incorrect. You will want to define this type as follows.

// create type with it's own targetable `$id`
const omittedResponseProductSchema = Type.Omit(responseProductSchema, ['categoryId'], { $id: 'omittedResponseProductSchema' })

// define the `products` property as follows.
const T = Type.Object({
  products: Type.Ref(omittedResponseProductSchema) // { $ref: 'omittedResponseProductSchema' }
})

// pseudo code for the generator

Primsa.Generate(T, [omittedResponseProductSchema]) // pass the reference target to the generator so it can find it

Hope this helps
S

[frontenders-game]

@sinclairzx81 It is my first Typescript project. And first use of prisma, fastify and typebox.
Maybe i am doing something stupid.

I have it working if i use Type.Optional(Type.Number()) or Type.Any().
With Type.Optional i am getting it serialized to 0. With Type.Any() i am getting correct null. It does the job, but i would like to avoid any if possible.

Whole setup looks like this.
I am creating server like this

    const server: FastifyInstance = Fastify({
        ajv: {
            customOptions: {
                removeAdditional: true, // Refer to [ajv options](https://ajv.js.org/options.html#removeadditional)
                useDefaults: true,
                coerceTypes: true,
                allErrors: true,
                verbose: true
            },
            plugins: [
                [ajvKeywords, ['transform' ]]
            ]
        }
    }).withTypeProvider<TypeBoxTypeProvider>()

Then i define schemas. One that are used with Type.Ref i am adding to fastify:

server.addSchema(schema)

Then basically i am replying with prisma database results serialized by fastify
Whole project is here: https://github.com/frontenders-game/sever-back

About last notes i couldn't do this Prisma.Generate(T, [omittedResponseProductSchema]). It says TS2339: Property 'Generate' does not exist on type 'typeof Prisma'. Will check more later.
Without it it doesn't work. Though seems it should if other version is working?
I am doint the same

export const omittedResponseProductSchema = Type.Omit(responseProductSchema, ['categoryId'], { $id: 'omittedResponseProductSchema' })

...

 products: Type.Optional(Type.Array(Type.Ref(Type.Ref(omittedResponseProductSchema)))),

...

server.addSchema(omittedResponseProductSchema)  // server: FastifyInstance

Error:

node_modules\@sinclair\typebox\typebox.js:286
            throw Error('TypeBuilder.Ref: Referenced schema must specify an $id');
            ^

Error: TypeBuilder.Ref: Referenced schema must specify an $id
    at TypeBuilder.Ref (C:\saintcode\projects\severyanovhka-api\node_modules\@sinclair\typebox\typebox.js:286:19)

Though it it works fine the way i posted above.
But i got to say i had a lot of ref errors of ajv in simular case with null return before and i got it working now. But i don't know why.

About prisma. Seems it uses custom types (DbNull, AnyNull, JsonNull) : https://github.com/prisma/prisma/blob/df693209a7ec3eda67600b423288ae0c7633cefb/packages/client/src/generation/TSClient/common.ts#L112
Can it be the case?

[frontenders-game]

@sinclairzx81 This is what i don't understand
If i add this Nullable to my schema, i am getting ref errors:

1. if i use

export const omittedResponseProductSchema = Type.Optional(Type.Array(Type.Omit(responseProductSchema, ['categoryId'], { $id: 'omittedResponseProductSchema' })))

export const responseCategorySchema =
    Type.Object(
        {           
             something: Nullable(Type.String()),
             products: Type.Ref(omittedResponseProductSchema),
        },
        {$id: "responseCategorySchema", additionalProperties: false}
    )

server.addSchema(omittedResponseProductSchema)
server.addSchema(responseCategorySchema)

i am getting crash before launch

...\node_modules\@sinclair\typebox\typebox.js:286
            throw Error('TypeBuilder.Ref: Referenced schema must specify an $id');
            ^

Error: TypeBuilder.Ref: Referenced schema must specify an $id

2. And if i use

export const omittedResponseProductSchema = Type.Omit(responseProductSchema, ['categoryId'], { $id: 'omittedResponseProductSchema' })



export const responseCategorySchema =
    Type.Object(
        {           
             something: Nullable(Type.String()),
            products: Type.Optional(Type.Array(Type.Ref(omittedResponseProductSchema))),
        },
        {$id: "responseCategorySchema", additionalProperties: false}
    )

server.addSchema(omittedResponseProductSchema)
server.addSchema(responseCategorySchema)

Server starts and i am getting ajv error

 err: {
      "type": "MissingRefError",
      "message": "can't resolve reference omittedResponseProductSchema from id responseCategorySchema",
      "stack":
          Error: can't resolve reference omittedResponseProductSchema from id responseCategorySchema

And if i don't use Nullable, i got refs working and server returns ok.
How can this Union+Null can impact schemas references?

[sinclairzx81]

@frontenders-game It might be easier to take a step back bit and look at what Type.Ref is actually doing, consider the following.

                                      // produces:

const T = Type.String({ $id: 'T' })   // const T = { type: 'string', $id: 'T'  }

const R = Type.Ref(T)                 // const R = { $ref: 'T' } - all we know is R points to T, but we don't know what T is

// ----

new Ajv().compile(R)                  // error: can't resolve reference T from id #

new Ajv().addSchema(T).compile(R)     // ok: can resolve reference T from id #

You will need to tell Ajv where it can find omittedResponseProductSchema by calling .addSchema(omittedResponseProductSchema) in your code. Type referencing is not automatic, so you will need to come up with a strategy of adding referenced schemas to Ajv somehow. Because there are a number of ways to do this, TypeBox doesn't implement any specific approach (it's not opinionated in how end users choose to do this)

Also, just keep in mind, you don't actually need to use Type.Ref at all (it's mostly only useful when wanting to normalize schematics, usually for publishing them). If you're new to all these technologies, I would recommend removing references initially, then when you have everything setup, you can add them back + have associated infrastructure ready to register them with Ajv (as above)

For example

export const responseCategorySchema =
    Type.Object(
        {           
             something: Nullable(Type.String()),
            products: Type.Optional(Type.Array(omittedResponseProductSchema)) // < omit Ref here
        },
        {$id: "responseCategorySchema", additionalProperties: false}
    )

Validators (Ajv, TypeBox) will inline the validation logic for this case.