transform object property encoding about typebox HOT 4 CLOSED

import {type StringOptions, type NumberOptions, Type, type StaticEncode} from '@sinclair/typebox';

/** Date encoded as an ISO8601-compliant string */
export const DateTimeStringTransform = (_options: StringOptions = {}) =>
  Type.Transform(
    Type.String({
      ..._options,
      format: 'date-time'
    })
  )
    .Decode(v => new Date(v))
    .Encode(v => v.toISOString());

/** Date encoded as a millisecond timestamp number */
export const DateTimeNumberTransform = (_options: NumberOptions = {}) =>
  Type.Transform(Type.Integer(_options))
    .Decode(v => new Date(v))
    .Encode(v => v.getTime());

/** Compound date codec that accepts both string and number representation */
export const DateTimeTransform = (
  _options: {string?: StringOptions; number?: NumberOptions} = {string: {}, number: {}}
) => Type.Union([DateTimeStringTransform(_options.string), DateTimeNumberTransform(_options.number)]);

/* inferred as string|number */
type DateTimeTransformEncode = StaticEncode<ReturnType<typeof DateTimeTransform>>;

export default DateTimeTransform;

// Bad Decode (lost information about source type)
string  -> Date
number  -> Date

// Good Decode (union information retained for later Encode)
string -> Date & { type: 'string' }
number -> Date & { type: 'number' }

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

// ---------------------------------------------------------
// DiscriminatedDate
// ---------------------------------------------------------
export type DiscriminatedDate = Date & { kind: 'string' | 'number' | ({} & string) }

const DecodeDiscriminatedDate = (value: string | number) => (
  Object.defineProperty(new Date(value), 'kind', { value: typeof value }) 
) as DiscriminatedDate

const EncodeDiscriminatedDate = (value: DiscriminatedDate) => (
  value.kind === 'string' ? value.toISOString() :
  value.kind === 'number' ? value.getTime() :
  value.getTime()
)
const DiscriminatedDate = Type.Transform(Type.Union([Type.Number(),Type.String()]))
  .Decode(DecodeDiscriminatedDate)
  .Encode(EncodeDiscriminatedDate)

// ---------------------------------------------------------
// String
// ---------------------------------------------------------
{
  const D = Value.Decode(DiscriminatedDate, '1970-01-01T00:00:12.345Z')
  const E = Value.Encode(DiscriminatedDate, D)
  console.log('string:')
  console.log('  decode:', D)
  console.log('  encode:', E)
}
// ---------------------------------------------------------
// Number
// ---------------------------------------------------------
{
  const D = Value.Decode(DiscriminatedDate, 12345)
  const E = Value.Encode(DiscriminatedDate, D) 
  console.log('number:')
  console.log('  decode:', D)
  console.log('  encode:', E)
}
// ---------------------------------------------------------
// Embedded
// ---------------------------------------------------------
{
  const User = Type.Transform(Type.Object({ created_at: DiscriminatedDate }))
    .Decode(value => ({ createdAt: value.created_at }))
    .Encode(value => ({ created_at: value.createdAt }))

  const D = Value.Decode(User, { created_at: '1970-01-01T00:00:12.345Z' })
  const E = Value.Encode(User, D)
  console.log('embedded:')
  console.log('  decode:', D)
  console.log('  encode:', E)
}