JSON parsing about io-ts HOT 10 CLOSED

export const JsonArray = t.recursion('JsonArray', () => t.readonlyArray(Json))

export const JsonRecord = t.recursion('JsonRecord', () => t.record(t.string, Json))

export const Json = t.union([t.boolean, t.number, t.string, t.null, JsonArray, JsonRecord], 'Json')

const PersonFromString = JSONFromString.pipe(Person)

export type Validate<T> = (value: any, context: Context) => Validation<T>

import * as t from 'io-ts'
import { tryCatch } from 'fp-ts/lib/Either'

export type JSONObject = { [key: string]: JSON }
export interface JSONArray extends Array<JSON> {}
export type JSON = null | string | number | boolean | JSONArray | JSONObject

// string -> JSON
const JSONFromString = t.prism(t.string, s => tryCatch<JSON>(() => JSON.parse(s)).toOption(), 'JSONFromString')

// JSON -> Person
const Person = t.interface({
  name: t.string
}, 'Person')

function compose<A, B>(fa: t.Type<A>, fb: t.Type<B>, name: string): t.Type<B> {
  return new t.Type<B>(
    name,
    (v, c) => fa.validate(v, c).chain(a => fb.validate(a, c))
  )
}

// string -> Person
const PersonFromString = compose(JSONFromString, Person, 'PersonFromString')


console.log(t.validate(1, PersonFromString)) // Left([{"value":1,"context":[{"key":"","type":{"name":"PersonFromString"}}]}])
console.log(t.validate('{}', PersonFromString)) // Left([{"context":[{"key":"","type":{"name":"PersonFromString"}},{"key":"name","type":{"name":"string"}}]}])
console.log(t.validate('{"name":"Giulio"}', PersonFromString)) // Right({"name":"Giulio"})

function compose<A, B>(fa: t.Type<A>, fb: t.Type<B>, name: string): t.Type<B> {
  return new t.Type<B>(
    name,
    (v, c) => fa.validate(v, c.concat({ key: 'parse', type: fa })).chain(a => fb.validate(a, c))
  )
}

import { PathReporter } from 'io-ts/lib/reporters/default'

console.log(PathReporter.report(t.validate('bad', PersonFromString))) // [ 'Invalid value "bad" supplied to : PersonFromString/parse: JSONFromString' ]
console.log(PathReporter.report(t.validate('{}', PersonFromString))) // [ 'Invalid value undefined supplied to : PersonFromString/name: string' ]

type DecodeResult<A> = Either<string, A>

function json(value: any): DecodeResult<JSON> {
  return t.validate(value, JSONFromString).mapLeft(() => 'Parsing error')
}

function type<A>(type: t.Type<A>): (value: JSON) => DecodeResult<A> {
  return value => {
    const validation = t.validate(value, type)
    return validation.mapLeft(() => PathReporter.report(validation).join('\n'))
  }
}

type Person = t.TypeOf<typeof Person>

function personFromString(value: any): DecodeResult<Person> {
  return json(value).chain(type(Person))
}

console.log(personFromString('bad')) // Left("Parsing error")
console.log(personFromString('{}')) // Left("Invalid value undefined supplied to : Person/name: string")

const JSONFromString = t.prism(t.string, s => tryCatch<JSON>(() => JSON.parse(s)).toOption(), 'JSONFromString')

export const JSONFromString = new t.Type<E.Json, string, string>(
  'JSONFromString',
  // TODO:
  (x): x is E.Json => true,
  (s, c) =>
    pipe(
      s,
      E.json((_e) => 'whatever'),
      E.fold(() => t.failure(s, c), t.success),
    ),
  JSON.stringify,
);