Correctly infer type with transform and composite?

[m1212e]

I try to use transform and composite together:

const SerializedCompactSchema = 
Type.Transform(
  Type.Object(
    {
      k: KindCompactSchema,
    },
    { additionalProperties: true }
  )
)
  .Decode((value) => ({ compactKind: value.k }))
  .Encode((value) => ({ k: value.compactKind }));


export const SerSchema = 
Type.Composite([
  SerializedCompactSchema
]);
type Ser = Static<typeof SerSchema>;

which results in type Ser = {}. If I either remove the transform or the composite the type infer works correctly again. Do you know what I'm doing wrong?

Thanks for you awesome work!

[sinclairzx81]

@m1212e Hi,

You can try the following.

The Composite type may prove to be an issue here as Composite needs to rebuild an Object type and may discard interior Transforms. The reason is because compositing objects may invalidate the transform logic applied to the interior type. The constraints additionalProperties would also be discarded via Composite.

Instead you can try use a Intersect (but you will want to remove the additionalProperties constraint from Object and apply a unevaluatedProperties to the Intersect)

TypeScript Link

import { Type, Static, StaticEncode, StaticDecode } from '@sinclair/typebox'

const KindCompactSchema = Type.Object({
  k: Type.String()
})

const SerializedCompactSchema = Type.Transform(Type.Object({
  k: KindCompactSchema,
}))
  .Decode((value) => ({ compactKind: value.k }))
  .Encode((value) => ({ k: value.compactKind }))


// Use Intersect (Composite discards Transforms as it needs to rebuild a new Object)
export const SerSchema = Type.Intersect([
  SerializedCompactSchema
], { unevaluatedProperties: false })

// Use StaticEncode / StaticDecode to infer either Transform state. 
type Ser = StaticDecode<typeof SerializedCompactSchema>;
type Ser = StaticEncode<typeof SerializedCompactSchema>;

Also, you can use StaticEncode and StaticDecode to give you the correct inference.

Hope this helps
S

[m1212e]

Hey, this does kinda work but fails at runtime. Since I actually want to merge two schemas into one I added two transform types to intersect and receive Exception during run: Error: Cannot intersect transform types

[sinclairzx81]

@m1212e Hiya,

Since I actually want to merge two schemas into one I added two transform types to intersect and receive

Ah right. I think the only way to really achieve this to apply the Transform to the composited type. The issue is that Composite only merges the properties of each sub type, and ignores the transform and other constraints applied for each sub type. The return type for Composite is a brand new Object, so any constraints and transforms need to be re-applied.

A refactor of the types is probably the best way forward.

import { Type, StaticDecode, StaticEncode} from '@sinclair/typebox'

const A = Type.Object({ a: Type.Number() })
const B = Type.Object({ b: Type.Number() })
const C = Type.Composite([A, B], {
  additionalProperties: false
})

// Apply Transform to Composited A + B
const TransformC = Type.Transform(C)
  .Decode((value) => [value.a, value.b] as const)
  .Encode((value) => ({ a: value[0], b: value[1] }))

type DecodedC = StaticDecode<typeof TransformC>;
type EncodedC = StaticEncode<typeof TransformC>;

Unfortunately, this doesn't make Transforms applied for A and B reusable in C, but I think this is correct because any logic applied to A may not be applicable in C. Internally, the Composite function applies some type normalization to each property, and non compatible properties will transform to TNever for mismatched property types. It's because of this, attempting to re-use a Transform (i.e nesting them) probably wouldn't work in a general sense.

Does this help?

[m1212e]

I see, thank you very much!