Parsing a numeric string

[imsergiobernal]

I think that something like this would be awesome

const numeric = '123'; // typeof string;
const number = zod.string().numeric().int().parse(numeric); // typeof number;

numeric() would convert it to a ZodNumber if it was actually a numeric value.

Or maybe, to preserve original string type:

const numeric = '123'; // typeof string;

const numericString = zod.string().numeric().int().parse(numeric); // typeof string;
const number = zod.number().stringified().int().parse(numeric); // typeof number;

What do you think?

[myywlc]

i need it

[colinhacks]

I'm not a fan of this because it introduces a new method specifically for the string->number conversion. But there are a polynomial number of pairwise conversions (number to string, number to boolean, string to boolean, etc), and introducing a new method for each will get messy.

More generally, the idea of creating "pipelines" of schemas is is discussed in depth here: #264 (comment). In fact, it's how transformers were initially implemented but I moved away from it in Zod 3 for reasons described in that thread. For now, Zod follows a simple "validate, then transform" approach. Validate the data (e.g. check that it's a "numeric string") then convert it into a number:

const numeric = z.string().regex(/^\d+$/).transform(Number);
  console.log(numeric.safeParse("1234")); // => 1234
  console.log(numeric.safeParse("12345.6")); // => ZodError: invalid_string
  console.log(numeric.safeParse("asdf")); // => ZodError: invalid_string

[scotttrinh]

@linde12

Note that I used z.string to coerce the unknown to string which is what parseInt wants, but you could decide to make a type assertion instead to lower your runtime overhead.

const schema = z.object({
  skip: z.preprocess(
    (a) => parseInt(a as string, 10),
    z.number().positive().max(100)
  )
});

[linde12]

@scotttrinh I see, thanks for the tip! I think i'll go with the typecast option. Cheers 🥇

[cyrilchapon]

@scotttrinh I'm trying to achieve the same but using .safeParse on the schema itself.

Either parseInt(z.string().parse(a), 10) (which seems legit) or parseInt(a as string, 10) can throw an Error; which is not gracefully handled by safeParse on the generated schema.

Reproduction :

const schema = z.object({
  skip: z.preprocess(
    (a) => parseInt(z.string().parse(a), 10),
    z.number().positive().max(100)
  )
})

// this throws
schema.safeParse({ skip: ['hey'] })

Is there any known elegant way to coerce string along with safe parsing ?

[kellyrmilligan]

for me, this is not letting me set a string to the value of the inferred type, am I missing something?

skip: z.ZodEffects<z.ZodNumber, number, unknown>

is the type I get back. i'm getting the value as a string, and use it in a form as a default value for a field.

[KeisukeNagakawa]

how can I validte further for transformed integer?

[lunacrafts]

import { z, ZodTypeAny } from 'zod';

export const numericString = (schema: ZodTypeAny) => z.preprocess((a) => {
  if (typeof a === 'string') {
    return parseInt(a, 10)
  } else if (typeof a === 'number') {
    return a;
  } else {
    return undefined;
  }
}, schema);


const FindMany = z.object({
  take: numericString(z.number().max(10))
});

[smeijer]

Any ideas on how to make z.infer notice take as being a number? Currently it comes back as unknown.

[smeijer]

This cast works, I'm not sure if there's a better way:

const numericString = (schema: z.ZodTypeAny) =>
  z.preprocess((a) => {
    if (typeof a === 'string') {
      return parseInt(a, 10);
    } else if (typeof a === 'number') {
      return a;
    } else {
      return undefined;
    }
  }, schema) as z.ZodEffects<z.ZodTypeAny, number, number>;

[Enteleform]

This cast works, I'm not sure if there's a better way:

A generic can be used here to allow Zod's default inference to occur:

import {z, ZodNumber, ZodOptional} from "zod"

function IntegerString
  <schema extends (ZodNumber | ZodOptional<ZodNumber>)>
  (schema:schema)
{
  return (
    z.preprocess((value) => (
      ( (typeof value === "string") ? parseInt(value, 10)
      : (typeof value === "number") ? value
      :                               undefined
    )), schema)
  )
}


type  FindMany = z.infer<typeof FindMany>
const FindMany = z.object({
  take:        IntegerString(z.number().max(10)           ),
  maybeTake:   IntegerString(z.number().max(10).optional()),
  invalidTake: IntegerString(z.string()                   ), // TypeError
})

type take      = FindMany["take"     ] // number
type maybeTake = FindMany["maybeTake"] // number | undefined

[pke]

I wonder why this is not built in like in joi? Zod is much better with TS support but I always stumble over such things when converting my schemas.

[kellyrmilligan]

joi's number will take either a string that coerces to number or a number I believe.

[P4sca1]

Given the following schema:

// A number schema, that also accepts strings as input and tries to parse them before validating.
export const numberSchema = z.preprocess((val) => {
	if (typeof val === 'string') return parseInt(val, 10)
	return val
}, z.number())

I would expect that it is possible to use number schema methods, e.g. numberSchema.gte(1). Is there any way to make this possible? I just want to validate a number, but it should be possible to also input strings (e.g. for HTTP query params).

[lgj9172]

How about this?

z.preprocess(
  Number,
  z.number()
),

[pke]

I have to try this :)

[lzehrung]

Beautiful! This style works like a charm defining numeric express route parameters in zod-express-middleware and still getting a 'number' property from req.params!

[iamadetoye]

Thank you!

[cyrilchapon]

For those coming here looking for a a safeParse-compatible solution, see my comment in #696

import { z, ZodType } from 'zod'

const stringToNumberSchema = (def: number) => (z.string().default(`${def}`).transform(Number))
const safePreprocessor = <O, Z extends ZodType<O>> (preprocessorSchema: Z) => (val: unknown): O | null => {
  const parsed = preprocessorSchema.safeParse(val)
  if (!parsed.success) {
    return null
  }
  return parsed.data
}

const _paginationSchema = z.object({
  skip: z.preprocess(
    safePreprocessor(stringToNumberSchema(0)),
    z.number().min(0)
  ),
  limit: z.preprocess(
    safePreprocessor(stringToNumberSchema(20)),
    z.number().min(0).max(100)
  )
}).strict()

export type PaginationQuery = z.infer<typeof _paginationSchema>

The default value can also be undefined or null for various use cases, and it behaves correctly.
I've been using this for several weeks, it seems to do the job

[Danzo7]

They should add the support for numericString I think

[JacobWeisenburger]

v3.20 just released with coerce. I think this is what you are looking for.

[prscoelho]

Nevermind, I read some relevant issues and this seems to be out of scope. Sorry for the noise.

[cellulosa]

Can you give me an example of how you would want to use it with enum?

Mhh something like

z.coerce.boolean().parse("hello").nativeEnum(MyEnum); // => false
z.coerce.boolean().parse("hi").nativeEnum(MyEnum); // => true

[JacobWeisenburger]

Is this what you are looking for?

enum MyEnum { hi = 'hi' }
console.log( z.nativeEnum( MyEnum ).safeParse( 'hi' ).success ) // true
console.log( z.nativeEnum( MyEnum ).safeParse( 'hello' ).success ) // false

[cellulosa]

Is this what you are looking for?

it is! Thanks Jacob 🙏

so perhaps I’m not fully grasping the use of coerce

[JacobWeisenburger]

If you found my answer satisfactory, please consider supporting me. Even a small amount is greatly appreciated. Thanks friend! 🙏
https://github.com/sponsors/JacobWeisenburger

[JLarky]

I think this would be the answer, zod has it's own utility to quickly coerce the type:

console.log(z.coerce.string().parse(1));   // "1"
console.log(z.coerce.string().parse('1')); // "1"
console.log(z.coerce.number().parse(1));   //  1
console.log(z.coerce.number().parse('1')); //  1

If you want a bit more control you should look into preprocess

console.log(z.preprocess((x) => '' + x, z.string()).parse(1));      // "1"
console.log(z.preprocess((x) => Number(x), z.number()).parse('1')); //  1

or transform and pipe

console.log(z.union([z.string(), z.number()]).transform((x) => '' + x).pipe(z.string()).parse(1));      // "1"
console.log(z.union([z.string(), z.number()]).transform((x) => Number(x)).pipe(z.number()).parse('1')); //  1

added by @JacobWeisenburger

or pipe and coerce

console.log(z.union([z.string(), z.number()]).pipe(z.coerce.string()).parse(1));    // "1"
console.log(z.union([z.string(), z.number()]).pipe(z.coerce.number()).parse('1') ); //  1

• https://zod.dev/?id=coercion-for-primitives
• https://zod.dev/?id=preprocess
• https://zod.dev/?id=pipe
• https://twitter.com/colinhacks/status/1602238724120924160?lang=en

[shimon-technonext]

this does not validate if the incoming value is really a number or not. heres my version of it -

z.string().refine(v => { let n = Number(v); return !isNaN(n) && v?.length > 0}, {message: "Invalid number"})

[kellyrmilligan]

There are a lot of powerful solutions on the parsing side, that being said, if you have a form that starts with strings(aka all forms basically?), but need to validate a field is valid for some sort of number situation, i'm not seeing any answer besides a refine based solution ,is that right? otherwise the inferred type will be a number. maybe i'm missing something?

[merojosa]

In case anyone is interested in a different approach:

z.custom<number>()
  .refine((value) => value ?? false, "Required")
  .refine((value) => Number.isFinite(Number(value)), "Invalid number")
  .transform((value) => Number(value));

[zhe]

My case differs when passing an empty '' string, expecting undefined in safeParse's data and type is number | undefined

z.coerce.number().optional(); // ❌ get '0' 

z.preprocess((val) => (val ? val : undefined), z.coerce.number().optional()); // ✅ get 'undefined'

[JacobWeisenburger]

how about?

z.coerce.number().nullish().transform( x => x ? x : undefined )

[zhe]

thanks Jacob, much better. my original answer was causing unknown..

null is not needed in my case, so i will just use optional() instead.

z.coerce.number().optional().transform( x => x ? x : undefined )

[zhe]

just a follow-up:

if narrowing the number down to int 1 - 12, seems preprocess only works...

// "" -> undefined
// "2" -> pass
// "13" -> fail

// ❌
z.coerce
  .number()
  .int()
  .min(1)
  .max(12)
  .optional()
  .transform((x) => (x ? x : undefined));

// ❌
z.coerce
  .number()
  .optional() // ❌
  .int()
  .min(1)
  .max(12)
  .transform((x) => (x ? x : undefined));

✅
z.preprocess((x) => (x ? x : undefined), z.coerce.number().int().min(1).max(31).optional());

[fallmo]

Now we can simply do:

z.number({ coerce: true })

[pke]

with a new release?

[patlux]

This results into 0 when the string is empty.

[markedwards]

It still seems like having a way to indicate a decimal string, with precision, would be very useful. It's very common to return decimal values as strings, like "10.3". As it stands, if I'm describing an output schema, for example, all I can here is z.string() I think (?). And in reality the output is highly constrained.

Am I missing something?

[sahiljain11]

I just spent a few hours stuck on an downstream issue due to default value of x being 0. The full form of the preprocess should be the following since x ? x : undefined will resolve to undefined when x = 0:

z.preprocess(x => (x || x === 0 ? x : undefined))

If anyone else faces a similar issue, hopefully this will resolve it for you :)