Class Decoder<T>

constructor

• new Decoder<T>(decodeFn: (json: any) => Result<T>): Decoder<T>

  Creates a new decoder that can validate and transform JSON data into strongly typed TypeScript values.

  Type Parameters

  • T

  Parameters

  • decodeFn: (json: any) => Result<T>

    A function that takes a JSON object and returns a Result

  Returns Decoder<T>

  Example

  const myStringDecoder: JsonDecoder.Decoder<string> = new JsonDecoder.Decoder(
    (json: unknown) => {
      if (typeof json === 'string') {
        return ok(json);
      } else {
        return err('Expected a string');
      }
    }
  );
  Copy

~standard

decode

• decode(json: any): Result<T>

  Decodes a JSON object of type and returns a Result

  Parameters

  • json: any

    The JSON object to decode

  Returns Result<T>

  A Result containing either the decoded value or an error message

  Example

  JsonDecoder.string.decode('hi'); // Ok<string>({value: 'hi'})
  JsonDecoder.string.decode(5); // Err({error: '5 is not a valid string'})
  Copy

decodeToPromise

• decodeToPromise(json: any): Promise<T>

  Decodes a JSON object of type and returns a Promise

  Parameters

  • json: any

    The JSON object to decode

  Returns Promise<T>

  A Promise that resolves with the decoded value or rejects with an error message

  Example

  JsonDecoder.string.decodeToPromise('hola').then(res => console.log(res)); // 'hola'
  JsonDecoder.string.decodeToPromise(2).catch(err => console.log(err)); // '2 is not a valid string'
  Copy

fold

• fold<O>(onOk: (result: T) => O, onErr: (error: string) => O, json: any): O

  Decodes a JSON object of type and calls onOk() on success or onErr() on failure, both return

  Type Parameters

  • O

  Parameters

  • onOk: (result: T) => O

    function called when the decoder succeeds
  • onErr: (error: string) => O

    function called when the decoder fails
  • json: any

    The JSON object to decode

  Returns O

  The result of either onOk or onErr

  Example

  JsonDecoder.string.fold(
    (value: string) => parseInt(value, 10),
    (error: string) => 0,
    '000000000001'
  ); // 1
  Copy

chain

• chain<O>(fn: (value: T) => Decoder<O>): Decoder<O>

  Chain decoders that might fail

  Type Parameters

  • O

  Parameters

  • fn: (value: T) => Decoder<O>

    Function that returns a new decoder

  Returns Decoder<O>

  A new decoder that chains the current decoder with the result of fn

  Example

  const adultDecoder = JsonDecoder.number.chain(age =>
    age >= 18
      ? JsonDecoder.succeed
      : JsonDecoder.fail(`Age ${age} is less than 18`)
  );
  adultDecoder.decode(18); // Ok<number>({value: 18})
  adultDecoder.decode(17); // Err({error: 'Age 17 is less than 18'})
  Copy

map

• map<O>(fn: (value: T) => O): Decoder<O>

  If the decoder has succeeded, transforms the decoded value into something else

  Type Parameters

  • O

  Parameters

  • fn: (value: T) => O

    The transformation function

  Returns Decoder<O>

  A new decoder that applies the transformation

  Example

  // Decode a string, then transform it into a Date
  const dateDecoder = JsonDecoder.string.map(stringDate => new Date(stringDate));
  // Ok scenario
  dateDecoder.decode('2018-12-21T18:22:25.490Z'); // Ok<Date>({value: Date(......)})
  // Err scenario
  dateDecoder.decode(false); // Err({error: 'false is not a valid string'})
  Copy