Migrating to 1.0, running into some Date related issues

[justinkwaugh]

Here are my goals (and which I believe are working in .34):

1. Create types/schemas that have properties with type Date
2. When sent as JSON, convert to iso date strings
3. Use schema checking in my apis to enforce the date strings
4. Convert from raw json w/ iso strings to my types with Date properties

In .34 I have a type defined as such:

export type Foo = Static<typeof Foo>
export const Foo = Type.Object({
    id: Type.String(),
    createdAt: Type.Optional(Type.Date())
})

I have a toAPISchema method that does this:

export const ToAPISchema= (schema: TSchema) =>
    Type.Composite([
        Type.Omit(schema, ['createdAt']),
        Type.Object({
            createdAt: Type.Optional(Type.String({ format: 'date-time' }))
        })
    ])

It's used to help generate a schema for Fastify like so:

    type FooRequest = Static<typeof FooRequest>
    const FooRequest = Type.Object(
        {
            foo: ToAPISchema(Foo)
        },
        { additionalProperties: false }
    )

Alternately I have done the following to define the request schema for other requests where I just want to pass a date as string:

type BarRequest = Static<typeof BarRequest>
const BarRequest = Type.Object(
    {
        bar: Type.Unsafe<Date>({ [Kind]: 'Date', format: 'date-time' })
    },
    { additionalProperties: false }
)

When handling a request the first way I do this:

const foo = Value.Convert(Foo, request.body.foo) as Foo

When handling a request the second way I do this:

const { bar } = Value.Convert(BarRequest, request.body) as BarRequest

And all is well, as far as I can tell.

I am trying to migrate to 1.0 and I see that Type.Date() was removed, so I added the fallback as described in the migration guide, but now using the first method Value.Convert does not actually convert the dates. Furthermore, I cannot seem to use the second way I described either, as if I replace [Kind] with ['~kind'] I get an error.

So I am wondering what would be the right way to achieve my goals using 1.0?

Thanks!

[justinkwaugh]

Well I figured out the first issue which was that I needed to implement Convert in my Base extension. Still not sure about the second

[sinclairzx81]

@justinkwaugh Heya,

This is probably good to use TB codecs. They provide bi-directional transformation for values (so you don't need to have duplicate schemas)

https://sinclairzx81.github.io/typebox/#/docs/type/codec
https://sinclairzx81.github.io/typebox/#/docs/value/decode
https://sinclairzx81.github.io/typebox/#/docs/value/encode

Reference

import Type, { StaticEncode, StaticDecode } from 'typebox'
import Value from 'typebox/value'

const DateString = Type.Codec(Type.String({ format: 'date-time' }))
  .Decode(value => new Date(value))
  .Encode(value => value.toISOString())

// ...

export type FooOutput = StaticEncode<typeof Foo>  // type FooOutput = {
                                                  //   createdAt?: string | undefined;
                                                  //   id: string;
                                                  // }

export type FooInput = StaticDecode<typeof Foo>   // type FooInput = {
                                                  //   createdAt?: Date | undefined;
                                                  //   id: string;
                                                  // }
export const Foo = Type.Object({
    id: Type.String(),
    createdAt: Type.Optional(DateString)
})

// ...

const Input = Value.Decode(Foo, { id: 'hello', createdAt: new Date().toISOString() })
const Output = Value.Encode(Foo, Input)


console.log({ Input, Output })

Just be mindful that there may be some updates to Codecs in the next version of TB (1.1) where the Encode and Decode may return unknown. (It's part of TB's optimization story), but there will be fallbacks provided and documented at that time.

Let me know if this helps
Cheers
S