How to mark all fields in a type as optional.

[dhruv-nudge]

In zod, there was option of .deepPartial() that basically makes all the fields as optional.
I am looking for a similar solution, which will allow me to mark all fields as optional, without explicitly wrapping every field with Type.Optional.

[sinclairzx81]

@dhruv-nudge Hi,

TypeBox doesn't provide a built in deepPartial method (as there is no equivalent TS utility type). In TypeScript however, the expectation is generally to leverage the type system programmatically produce an appropriate mapped type. TypeBox follows a similar reasoning, but is a bit more complex as you will need to map both runtime and static type.

The following programmatically implements a PartialDeep type.

TypeScript Link Here

import { TypeGuard, Type, TSchema, TIntersect, TUnion, TObject, TPartial, TProperties, Evaluate } from '@sinclair/typebox'

// -------------------------------------------------------------------------------------
// TPartialDeepProperties
// -------------------------------------------------------------------------------------
export type TPartialDeepProperties<T extends TProperties> = {
  [K in keyof T]: TPartialDeep<T[K]>
}
function PartialDeepProperties<T extends TProperties>(properties: T): TPartialDeepProperties<T> {
  return Object.getOwnPropertyNames(properties).reduce((acc, key) => {
    return { ...acc, [key]: PartialDeep(properties[key]) }
  }, {}) as never
}
// -------------------------------------------------------------------------------------
// TPartialDeepRest
// -------------------------------------------------------------------------------------
export type TPartialDeepRest<T extends TSchema[], Acc extends TSchema[] = []> = (
  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
  ? TPartialDeepRest<R, [...Acc, TPartialDeep<L>]>
  : Acc
)
function PartialDeepRest<T extends TSchema[]>(rest: [...T]): TPartialDeepRest<T> {
  return rest.map(schema => PartialDeep(schema)) as never
}
// -------------------------------------------------------------------------------------
// TPartialDeep
// -------------------------------------------------------------------------------------
export type TPartialDeep<T extends TSchema> =
  T extends TIntersect<infer S> ? TIntersect<TPartialDeepRest<S>> :
  T extends TUnion<infer S> ? TUnion<TPartialDeepRest<S>> :
  T extends TObject<infer S> ? TPartial<TObject<Evaluate<TPartialDeepProperties<S>>>> :
  T
export function PartialDeep<T extends TSchema>(schema: T): TPartialDeep<T> {
  return (
    TypeGuard.IsIntersect(schema) ? Type.Intersect(PartialDeepRest(schema.allOf)) :
      TypeGuard.IsUnion(schema) ? Type.Union(PartialDeepRest(schema.anyOf)) :
        TypeGuard.IsObject(schema) ? Type.Partial(Type.Object(PartialDeepProperties(schema.properties))) :
          schema
  ) as never
}
// -------------------------------------------------------------------------------------
// Usage
// -------------------------------------------------------------------------------------
const A = PartialDeep(Type.Object({ // single depth
  x: Type.Number(),
  y: Type.Number(),
  z: Type.Number(),
}))

const B = PartialDeep(Type.Object({ // multiple depth
  a: Type.Object({
    x: Type.Number(),
    y: Type.Number(),
    z: Type.Number(),
  }),
  b: Type.Object({
    x: Type.Number(),
    y: Type.Number(),
    z: Type.Number(),
  })
}))

TypeBox tries to keep runtime and static implementations somewhat symmetric (so, taking note of the similarities between the TS types and associated mapping functions). You should be able to copy and paste the above type into your project (and modify as required) to get a deepPartial.

Hope this helps
S

[dhruv-nudge]

it definitely helps. thanks a lot.

[Dhruv-Garg79]

Hey I just tried the above method you provided, but I am not getting the same result as in the typescript snippet.

export const userSchema = PartialDeep(
	Type.Object({
		id: Type.String(),
		name: Type.String(),
		email: Type.String(),
		phone: Type.String(),
		props_int: Type.Record(Type.String(), Type.Integer()),
		props_bool: Type.Record(Type.String(), Type.Boolean()),
		props_text: Type.Record(Type.String(), Type.String()),
		props_float: Type.Record(Type.String(), Type.Number()),
		updated_at: Type.Date(),
		created_at: Type.Date(),
	}),
);

const compiledSchema = TypeCompiler.Compile(userSchema);
export type TUser = Static<typeof userSchema>;

[darthsalad]

@sinclairzx81 In the example you provided above, objects like you mentioned are converted correctly,

const TT = Type.Object({
	a: Type.Object({
		x: Type.Number(),
		y: Type.Number(),
		z: Type.Number(),
	}),
});

type:

const TTPartialDeep: TObject<{
    a: TOptional<TObject<{
        x: TOptional<TNumber>;
        y: TOptional<TNumber>;
        z: TOptional<TNumber>;
    }>>;
}>

but objects which don't have nested fields like these:

const X = Type.Object({
	c: Type.Number(),
});

are not converted correctly and give this type inference:

const XPartialDeep: TObject<{
    c: TOptional<TObject<{}>>;
}>

Can you explain why is this the case?

[sinclairzx81]

@dhruv-nudge @Dhruv-Garg79 @darthsalad Hiya,

It appears there was a bug in the DeepPartial implementation provided. The implementation was taken from the TypeBox example/prototypes/partial-deep.ts prototype (which hasn't been updated in a while). I've since updated the implementation snippet (above) to support single depth Partial (as noted by @darthsalad), have also checked in the prototype implementation at https://github.com/sinclairzx81/typebox/blob/master/example/prototypes/partial-deep.ts for future reference. You can test the implementation at the following URL

TypeScript Link Here

Let me know if this helps
S

[Dhruv-Garg79]

Hey @sinclairzx81 thanks a lot, it did help. Just one more issue is coming up for enums. The enums are becoming never

The status field was passed to deepPartial using type.enum