Object key/value order changes after parsing

[andrewrjohn]

This seems like an odd behavior, and I don't know if this is intended or not. When using z.object the parsed return value matches the same key/value order as defined in the schema (not according to the original data).

Example:

const Schema = z.object({
  one: z.number(),
  two: z.number(),
  three: z.number(),
})

const data = { three: 3, two: 2, one: 1 };

Schema.parse(data) // returns { one: 1, two: 2, three: 3 }

Is there a workaround for this? In my case the order of the key/values is very important because we are using the data object as a signature message, and if the order changes at all, then the signature will be different.

[JacobWeisenburger]

It seems that the order of the keys is determined by the schema not the value passed to parse.

Does this help?

const schema = z.object( {
    three: z.number(),
    two: z.number(),
    one: z.number(),
} )

console.log( schema.parse( {
    one: 1,
    three: 3,
    two: 2,
} ) )
// { three: 3, two: 2, one: 1 }

[andrewrjohn]

Yeah I'm aware of what the current behavior is, I just think it's an unintended side-effect and could create issues like it is for our project. Without knowing the details of how the library is implemented, I don't know why it would have to modify the order of the keys at all.

[JacobWeisenburger]

zod loops thru each child schema and checks the passed value against it. zod can only know with certainty that the keys exist in the schema, so that is why it uses the schema keys and not the passed value. also, by default it removes unknown keys, so that's why it doesn't just return the original passed value if it passes validation.

[JacobWeisenburger]

I took another look at it and found that you could do this potentially. This way preserves the order of keys from the passed value.

const schema = z.record( z.enum( [ 'one', 'two', 'three' ] ), z.number() )

console.log( schema.parse( {
    three: 3,
    two: 2,
    one: 1,
} ) )
// { three: 3, two: 2, one: 1 }

[bconnorwhite]

This still doesn't work I think if you have a more complex object that can't be represented with record

schema.parse({ three: "string", two: 2, one: true });

[JacobWeisenburger]

const schema = z.record(
    z.enum( [ 'one', 'two', 'three' ] ),
    z.union( [
        z.string(),
        z.number(),
        z.boolean(),
    ] )
)

console.log( schema.parse( {
    three: 'string',
    two: 2,
    one: true,
} ) )
// { three: 'string', two: 2, one: true }

[bconnorwhite]

The problem is you can also do this:

console.log( schema.parse( {
    three: 3,
    two: true,
    one: "string",
} ) )

I want to be able to parse an object where each key is a different type without changing the order.

Here's what I'm doing at the moment:

function parse(value: unknown) {
  return schema.safeParse(value).success ? value : undefined;
}

[andrewrjohn]

@bconnorwhite this is a workaround I was considering doing, so if the library won't be updated then I guess this is what we'll have to do.

[andrewrjohn]

It is a bummer though, because by doing this you lose your type safety.

[JacobWeisenburger]

How about this?

const schema = z.custom( value =>
    z.object( {
        one: z.number(),
        two: z.number(),
        three: z.number(),
    } ).safeParse( value ).success
)

console.log( schema.parse( {
    three: 3,
    two: 2,
    one: 1,
} ) )
// { three: 3, two: 2, one: 1 }

[JacobWeisenburger]

This way keeps the type safety. Does this work for you?

function returnDataInSameOrderAsPassed<Schema extends z.ZodObject<z.ZodRawShape>> (
    schema: Schema
) {
    return z.custom( value => schema.safeParse( value ).success ) as Schema
    // return z.custom<z.infer<Schema>>( value => schema.safeParse( value ).success )
    // this could also work ^^^^^^
}

const objSchema = z.object( {
    one: z.number(),
    two: z.number(),
    three: z.number(),
} )

console.log( objSchema.parse( {
    three: 3,
    two: 2,
    one: 1,
} ) )
// { one: 1, two: 2, three: 3 }

const sameOrderAsPassedSchema = returnDataInSameOrderAsPassed( objSchema )
type SameOrderAsPassedSchema = z.infer<typeof sameOrderAsPassedSchema>
// type SameOrderAsPassedSchema = {
//     one: number
//     two: number
//     three: number
// }

console.log( sameOrderAsPassedSchema.parse( {
    three: 3,
    two: 2,
    one: 1,
} ) )
// { three: 3, two: 2, one: 1 }

[king-of-poppk]

What about transforms?