When z.infer a Record with Brand as a key, it becomes a Partial Record.

[Hiroshiba]

When z.infer a Record with Brand as a key, it becomes a Partial Record.

With defining a Record type normally:

import { z } from "zod";
const zodKey = z.string().brand("zodKey");
type ZodKey = z.infer<typeof zodKey>;

type ZodRecord = Record<ZodKey, number>;
// type ZodRecord = {
//   [x: string & z.BRAND<"zodKey">]: number;
// }

With defining a Record type with z.infer:

import { z } from "zod";
const zodKey = z.string().brand("zodKey");
const zodRecord = z.record(zodKey, z.number());

type ZodRecord = z.infer<typeof zodRecord>;
// type ZodRecord = {
//   [x: string & z.BRAND<"zodKey">]: number | undefined;
// }

It has undefined.

[JacobWeisenburger]

Technically in TypeScript, when you use string as the key type for Record, you have a partial record, because you can have no properties at all, and there are no errors. TypeScript is just being implicit about it.

const partialRecord: Record<string, string> = {} // no errors

I'm not sure why the undefined type shows up when using a branded string as the key. But it doesn't seem to change the behavior as far as I can see.

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

[Hiroshiba]

Thank you!
The somewhat tricky part is that the behavior is different from normal TypeScript, so I get an error with the assignment.

const zodKey = z.string().brand("zodKey");

// with TypeScript
type ZodKey = z.infer<typeof zodKey>;
type ZodRecord1 = Record<ZodKey, number>;

// with Zod (will be Partial)
const zodRecord = z.record(zodKey, z.number());
type ZodRecord2 = z.infer<typeof zodRecord>;

const record2: ZodRecord2 = {};
const record1: ZodRecord1 = record2; // error

I can make ZodRecord2 also Partial or use as to work around this, I'd like to know if there is a better solution.

[Hiroshiba]

I followed the discussion.

Here Record type is now Partial.
#751

Here key=string is no longer Partial.
#992 (comment)

I thought it was more intuitive to not make it a Partial type to match vanilla TypeScript.

[JacobWeisenburger]

Is this what you are looking for?

const zodKey = z.string().brand( "zodKey" )

// with TypeScript
type ZodKey = z.infer<typeof zodKey>
type ZodRecord1 = Record<ZodKey, number | undefined>

// with Zod (will be Partial)
const zodRecord = z.record( zodKey, z.number() )
type ZodRecord2 = z.infer<typeof zodRecord>

const record2: ZodRecord2 = {}
const record1: ZodRecord1 = record2 // no error, yay!

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

[Hiroshiba]

What I want is for the elements of the Record not to be undefined.
Of course, I know this is not type safe.

I think the philosophy of zod is that certainty is more important than conformance to TypeScript, so it is designed to make the Record be Partial.
But well, I think it is a little inconvenient for the user because there are two different philosophies.

Either use as and adapt to TypeScript, or make it Partial and adapt to zod, I'll give this some more thought.

[JacobWeisenburger]

It seems the problem is caused by this code:

zod/src/types.ts

Lines 3061 to 3069 in 981af65

	export type RecordType<K extends string | number | symbol, V> = [
	string
	] extends [K]
	? Record<K, V>
	: [number] extends [K]
	? Record<K, V>
	: [symbol] extends [K]
	? Record<K, V>
	: Partial<Record<K, V>>;

If it were changed to: [K] extends [string], it might work for you.
However, I'm not sure if that will be a breaking change for other users.

[Hiroshiba]

Done! #2097

[googol]

For me this doesn't seem to fix the problem.

It seems like I can only get it to work when I replace the zod RecordType with the TS built in record. What is the reasoning behind this type anyways? I see there's a comment about the incompleteness of the TS record, but that's handled by the strictness option noUncheckedIndexedAccess .

To me it seems removing this type and replacing it with the plain Record is the best option

[EvilAlexei]

Same for me, this doesn't solve the problem.
I tried to use an enum or union as the key, but my record became Partial,
it seems a bit strange.

[googol]

I have created a pull request to simplify the z.record like I described: #2287

[wdanilo]

It doesn't seem to work for me. If I create:

function brandedStringCons<T extends symbol>() {
  const Schema = Z.string().brand<T>()
  type Out = Z.infer<typeof Schema>
  const cons = (val: string): Out => val as Out
  cons.Schema = Schema
  return cons
}

declare const IdSymbol: unique symbol
export const Id = brandedStringCons<typeof IdSymbol>()
export type Id = ReturnType<typeof Id>

And then use Z.record(Id.Schema, number), then the inferred type will be Partial<Record<...>>

[fwoelffel]

I really can't get my head around the RecordType definition:

export declare type RecordType<K extends string | number | symbol, V> = [
    string
] extends [K] ? Record<K, V> : [number] extends [K] ? Record<K, V> : [symbol] extends [K] ? Record<K, V> : [BRAND<string | number | symbol>] extends [K] ? Record<K, V> : Partial<Record<K, V>>;

Shouldn't it rather be

export declare type RecordType<K extends string | number | symbol, V> = [
    K
] extends [string] ? Record<K, V> : [K] extends [number] ? Record<K, V> : [K] extends [symbol] ? Record<K, V> : [K] extends [BRAND<string | number | symbol>] ? Record<K, V> : Partial<Record<K, V>>;

WDYT? I also don't quite get how we could have a Partial<Record<K, V>> when K extends string | number | symbol and all those cases are covered in the type ternary? Am I mistaken to think it should rather be never?