Coerce bigint throws TypeError instead of ZodError

[marcus13371337]

Consider the following code:

var zod = require("zod")

const testSchema = (schema, invalidData) => {
   try {
      schema.parse(invalidData);
   } catch (e) {
       if (e instanceof zod.ZodError) {
          console.log("throws ZodError");
       } else {
          console.log(`throws other error (${e.message})`);
       }
   }
}

console.log("case 1");
testSchema(zod.object({
   foo: zod.string(),
}), {}); // throws ZodError

console.log("case 2");
testSchema(zod.object({
   foo: zod.coerce.number()
}), {
  foo: "invalid"
}); // throws ZodError

console.log("case 3");
testSchema(zod.object({
   foo: zod.coerce.bigint(),
}), {}); // throws other error (Cannot convert undefined to a BigInt)

console.log("case 4");
testSchema(zod.object({
   foo: zod.coerce.bigint(),
}), { foo: "invalid" }); // throws other error (Cannot convert invalid to a BigInt)

(Playground: https://runkit.com/embed/bk8jnwfz1tkq)

I would expect that all cases would throw a ZodError, but it seems as BigInt throws a TypeError instead.

Tested with zod 3.20.2 on node 16.18

This is a bug, right?

[JacobWeisenburger]

Everything seems to be working fine to me.

const schema = z.coerce.bigint()
console.log( schema.parse( 42 ) ) // 42n
console.log( BigInt( 42 ) ) // 42n

try {
    schema.parse( undefined )
} catch ( error ) {
    console.error( error )
    // TypeError: Cannot convert undefined to a BigInt
}

try {
    BigInt( undefined )
} catch ( error ) {
    console.error( error )
    // TypeError: Cannot convert undefined to a BigInt
}

[marcus13371337]

I might misunderstand the usage for "coerce", I'm using zod for validating the input in a REST endpoint. If the user forgets to send a value in an object (which I'm planning to check against my database which has id:s of type bigint), I want to handle that in the same way as all my other validation code, i.e throwing a ZodError with zod and catch that in an error handler. It's a bit unexpected IMO that number and bigint doesn't throw the same error-type when they can't parse the provided value (because it wasn't included in the body of the request). What's the motivation behind that?

[JacobWeisenburger]

perhaps the docs about coerce would help.
https://github.com/colinhacks/zod#coercion-for-primitives

---

Does this work for you?

const schema = z.object( {
    id: z.coerce.bigint().optional(),
} )
console.log( schema.safeParse( { id: 42 } ) )
// { success: true, data: { id: 42n } }
console.log( schema.safeParse( { id: '42' } ) )
// { success: true, data: { id: 42n } }
console.log( schema.safeParse( {} ) )
// { success: true, data: {} }

[marcus13371337]

I've read that documentation, but my interpretation of the documentation is that z.coerce.number() would validate that the provided value is something that could be converted to a number (with the javascript Number-constructor), if that's not possible it should handle the case in the normal "zod"-way.

The "zod"-way I've interpreted would be that if the validation fails (i.e the provided value, or the lack of the value for that matter, fails the validation) zod would behave exactly as if I used z.number(), i.e throw a ZodError described here:
https://github.com/colinhacks/zod#error-handling

Apparently, my mental model of zod is not in line with this package, but I can't figure out where we differ 😅

[marcus13371337]

Your suggestion wouldn't really work for my use-case (not sure that I should use zod for it), which is to validate that a property of an object can be parsed to a bigint, if not I would like to handle the error just as a normal validation-error in my application

[JacobWeisenburger]

How about this?

const schema = z.object( {
    id: z.any().transform( ( value, ctx ) => {
        try {
            return BigInt( value )
        } catch ( error ) {
            ctx.addIssue( {
                code: 'invalid_type',
                expected: 'unknown',
                received: value,
                message: `Can't be parsed to BigInt`,
            } )
        }
    } ),
} )
console.log( schema.safeParse( { id: 42 } ).success ) // true
console.log( schema.safeParse( { id: '42' } ).success ) // true
console.log( schema.safeParse( { id: 'invalid' } ).success ) // false
console.log( schema.safeParse( {} ).success ) // false

[JacobWeisenburger]

it really comes down to there not being a standard way to do this for everyone's use cases. So it was decided it would be best to just do coerce in the most basic of terms. That way it is on the ECMA script standard to figure out the best way to coerce. So under the hood, zod just passes the value to the corresponding constructor. In this case, the BigInt constructor only works with bigints and numbers and everything else throws. At least, that's my understanding of it.

I think there are just too many different ways to handle something like this, so it's best, for now, if the user of zod decides how to do more advanced coercion. Perhaps in the future a better standard will be figured out.

[marcus13371337]

I understand what you mean, but from a simple user of zod (me) perspective, it would be really nice to do:

app.use((err, req, res, next) => {
   if (err instanceof z.ZodError) {
       return res.status(400).send(`Invalid parameters: ${err.message}`);
   }

  return res.status(500).send('Something broke!')
})

req.post('/api/person', (req) => {
   const PersonSchema = z.object({
     firstName: z.string().min(2).max(150),
     lastName: z.string(),
     age: z.coerce.number().min(0).max(300),
     parentId: z.coerce.bigint()
  })

   const person = PersonSchema.parse(req.body);

   return personRepository.save(person);
})

without having the developer know the fact that if something breaks with age / firstName / lastName it will get picked up by the error handler (as zod will throw a ZodError) compared to with parentId which will throw a TypeError which will be reflected as an internal server error for the consumer of my api

[JacobWeisenburger]

Does this work for you?

const coerceBigInt = z.object( {
    id: z.any().transform( ( value, ctx ) => {
        try {
            return BigInt( value )
        } catch ( error ) {
            ctx.addIssue( {
                code: 'invalid_type',
                expected: 'unknown',
                received: value,
                message: `Can't be parsed to BigInt`,
            } )
        }
    } ),
} )
console.log( coerceBigInt.safeParse( { id: 42 } ).success ) // true
console.log( coerceBigInt.safeParse( { id: '42' } ).success ) // true
console.log( coerceBigInt.safeParse( { id: 'invalid' } ).success ) // false
console.log( coerceBigInt.safeParse( {} ).success ) // false

const PersonSchema = z.object( {
    firstName: z.string().min( 2 ).max( 150 ),
    lastName: z.string(),
    age: z.coerce.number().min( 0 ).max( 300 ),
    parentId: coerceBigInt
} )

[marcus13371337]

Yes that would work, thanks for the suggestion! Just wanted to point out from my, new to zod, perspective that this was an inconsistency according to my understanding. But thanks for the explanation, I understand your reasons better now. Thanks for this great library btw! ❤️

[JacobWeisenburger]

You're welcome. Always happy to help. But by the way, I didn't really have much to do with making this a great library. :D @colinhacks mostly did that. I'm just trying to help people learn it.

[JacobWeisenburger]

I added an easier way to work with coerce to my utilz library. Perhaps this will help you.

https://github.com/JacobWeisenburger/zod_utilz#coerce

import { zu } from 'zod_utilz'
const schema = z.object( {
    foo: zu.coerce( z.bigint() ),
} )

console.log( zu.SPR( schema.safeParse( {} ) ).error?.issues )
// [
//     {
//         code: 'invalid_type',
//         expected: 'bigint',
//         received: 'undefined',
//         path: [ 'foo' ],
//         message: 'Required'
//     }
// ]

console.log( zu.SPR( schema.safeParse( { foo: 'invalid' } ) ).error?.issues )
// [
//     {
//         code: 'invalid_type',
//         expected: 'bigint',
//         received: 'string',
//         path: [ 'foo' ],
//         message: 'Expected bigint, received string'
//     }
// ]