Transpile TS code to JS with embedded type-safe assertions/warnings about io-ts HOT 8 CLOSED

import * as t from 'io-ts'
import { pathReporterFailure } from 'io-ts/reporters/default'

function validateEndpoint<T>(value: any, type: t.Type<T>): Promise<T> {
  if (process.env.NODE_ENV !== 'production') {
    return t.validate(value, type)
      .fold<Promise<T>>(
        errors => Promise.reject(pathReporterFailure(errors)),
        x => Promise.resolve(x)
      )
  }
  return Promise.resolve(value)
}

function validate<T>(value: any, type: t.Type<T>): T {
  if (process.env.NODE_ENV !== 'production') {
    return t.validate(value, type)
      .fold<T>(
        errors => { throw new Error(pathReporterFailure(errors).join('\n')) },
        x => x
      )
  }
  return value
}

const RTPerson = t.interface({
  name: t.string
})

// can be extracted from RTPerson
type Person = {
  name: string
}

function untrustedEndpoint(id: string): Promise<{ data: Person }> {
  return Promise.resolve({ data: {} })
}

function untrustedLibraryAPI(a: number, b: number): number {
  return a + 'wrong' as any // should be a sum
}

untrustedEndpoint('id')
  .then(res => validateEndpoint(res.data, RTPerson))
  .then(
    person => console.log(person),
    error => console.error(error) // => [ 'Invalid value undefined supplied to : { name: string }/name: string' ]
  )

validate(untrustedLibraryAPI(1, 2), t.number) // throws Invalid value "1wrong" supplied to : number

type Person = {
  name: string
}

function untrustedEndpoint(id: string): Promise<{ data: Person }> {
  return Promise.resolve(null) // <= wrong
}

untrustedEndpoint('id')

type Person = {
  name: string
}

type Endpoint = { data: Person }

function untrustedEndpoint(id: string): Promise<Endpoint> {
  return Promise.resolve(null) // <= wrong
}

function processPersonNameFromEndpoint(response : Endpoint) {
  return response.data.name
}

untrustedEndpoint('id').then(processPersonNameFromEndpoint)