Is it possible to use Transform for Recursive type?

[joshuaavalon]

As title. Is it possible to use Type.Recursive with Type.Transform?

For example, I want to replacenull with undefined during Decode.

const date = Type.Transform(
  Type.Union([Type.Date(), Type.Null(), Type.Undefined()])
)
  .Decode(v => v ?? undefined)
  .Encode(v => v);

const dateList = Type.Transform(
  Type.Union([Type.Array(Type.Date()), Type.Null(), Type.Undefined()])
)
  .Decode(v => v ?? undefined)
  .Encode(v => v);

const schema = Type.Recursive(self =>
  Type.Object({
    equals: Type.Optional(date),
    in: Type.Optional(dateList),
    notIn: Type.Optional(dateList),
    lt: Type.Optional(date),
    lte: Type.Optional(date),
    gt: Type.Optional(date),
    gte: Type.Optional(date),
    not: Type.Optional(Type.Union([self, Type.Null()]))
  })
);

However, not is not decoded recursively

const transform = Type.Transform(schema)
  .Decode(v => {
    const { not, ...others } = v;
    return { ...others, not: not ?? undefined }; // <- It is not decoded recursively
  })
  .Encode(v => v);

[sinclairzx81]

@joshuaavalon Hi,

The Decode function will infer as the return type, however in your implementation, you have only applied the ?? operator to the top level not. The top level not infers correctly, but all sub level properties will remain as null | undefined (as these haven't been remapped)

const transform = Type.Transform(schema)
  .Decode(v => {
    const { not, ...others } = v;
    return { ...others, not: not ?? undefined }; // <- nullish only applied for top-level not
  })
  .Encode(v => v);

type T = StaticDecode<typeof transform> // type T = {
                                        //   not: {                               // <- correctly mapped
                                        //       not?: ... | null | undefined;    // <- not recursively mapped
                                        //       equals?: Date | undefined;
                                        //       in?: Date[] | undefined;
                                        //       notIn?: Date[] | undefined;
                                        //       lt?: Date | undefined;
                                        //       lte?: Date | undefined;
                                        //       gt?: Date | undefined;
                                        //       gte?: Date | undefined;
                                        //   } | undefined;
                                        //   ... 6 more ...;
                                        //   gte?: Date | undefined;
                                        // }

To map for this type, I would recommend extracting the decode logic from the callback, and implement as separate function which returns the type or interface you expect. Given the recursive nature of this type, you may need to explicitly define return type as an explicit TS interface (as there is no trivial way to automatically remap recursive alias types using TB inference)

Hope this helps
S

[joshuaavalon]

Yes, I understand I it only decode the top level. However, I believe Decode handle itself recursively.

For example, ...others seems to be decoded already in Type.Transform(schema).
If I handle not separately, do you mean I have to call the decode for fields in not?

[sinclairzx81]

@joshuaavalon Hi,

Yeah, you will need to explicitly return a correctly typed value from the Decode callback (which would be inclusive of recursively (and manually) re-mapping the not field). The Decode function infers from what ever value you return. It doesn't perform any recursive mapping internally, it just looks at the return value and uses that for the inference.

Because of this, you may wish to extract the decode logic into it's own function and have it return an explicit return type. The following is a very high level implementation of how you might approach that. Below you would need to replace the explicit RecursiveType TS type below with your own recursive type (with not fixed up).

import { Type } from '@sinclair/typebox'
import { Value } from '@sinclair/typebox/value'

interface RecursiveType {  // <- You will need an explicit TS type to decode into
  id: string,
  nodes: this[]
}
function DecodeRecursiveType(value: string): RecursiveType {
  // todo: implement logic to decode the value into RecursiveType
   return { id: '', nodes: [] }
}
function EncodeRecursiveType(value: RecursiveType) {
  // todo: implement logic to encode the RecursiveType into string
  return ''
}

// This is the transform type.
const T = Type.Transform(Type.String())
   .Decode(DecodeRecursiveType)                 // <- Infers as RecursiveType
   .Encode(EncodeRecursiveType)                 // <- Infers as string

const V1 = Value.Decode(T, null)                 // <- V1 is RecursiveType
const V2 = Value.Encode(T, null)                 // <- V2 is string

The re-declaration (duplication) of the TS type + the schema type is largely unavoidable in this scenario, as TS cannot (afaik) derive a potentially infinite data structure from the return type instantiation expression.