readGeneric returns TypeMismatch instead of ErrorAtProperty for missing properties

[dkoontz]

I'm not sure if this is intentional but after I switch from implementing a custom read to using the readGeneric my error message for missing properties changed from

Left {
  value0:
   ErrorAtProperty {
     value0: 'y',
     value1: TypeMismatch { value0: 'Number', value1: 'Undefined' } } }

to

Left {
  value0: TypeMismatch { value0: 'Number', value1: 'Undefined' } }

I don't know if the ErrorAtProperty value is created when using readProp as I see readGeneric uses specific readXYZ functions based on the spine data. In any event, this makes parsing JS data significantly harder as you don't know where the error occurred and you're told it's a type mismatch when it's really a missing property.

Here is the test case

module Test where

import Prelude
import Data.Foreign
import Data.Foreign.Class
import Data.Foreign.Generic
import Data.Generic

parseOptions :: Options
parseOptions = defaultOptions { unwrapNewtypes = true }

data Vector2 = Vector2 { x :: Number, y :: Number }

derive instance genericVector :: Generic Vector2

-- This version produces a TypeMismatch error when one of the fields is missing
instance vector2IsForeign :: IsForeign Vector2 where
  read = readGeneric parseOptions

-- You can test this version to see a ErrorAtProperty error
-- instance vector2IsForeign :: IsForeign Vector2 where
--   read value = do
--     x <- readProp "x" value
--     y <- readProp "y" value
--     return $ Vector2 { x, y }

parseVector2 :: Foreign -> F Vector2
parseVector2 = read

"use strict";

var Test = require('Test');

console.log(Test.parseVector2({x: 0, y: 0})); // should parse fine and give Right value
console.log(Test.parseVector2({x: 0})); // should error with missing y
console.log(Test.parseVector2({y: 0})); // should error with missing x

[paf31]

Yes, looks like a bug we should fix.

[paulyoung]

I think I may be running into this but I'm honestly not sure what's going on.

It's possible I'm expecting too much here but the error is definitely cryptic.

If I leave this commented out, my tests pass:

data Expression
  = ThisExpression
    { type :: String
    }
  -- | ArrayExpression
  --   { type :: String
  --   , elements :: Array Expression
  --   }

If I uncomment it, I get things of this nature:

Error: Test 1 failed:

Actual:
  Left (Type mismatch: expected String, found Undefined)

Expected:
  Right (ESTree.Expression.ThisExpression {type: "ThisExpression"})

Input:
  "{ \"type\": \"ThisExpression\" }"

where actual = readJSON input

[paf31]

@paulyoung I'm not sure this is the same issue, but could you check what Options you are using? Single-constructor types are represented differently under the default Options, I think.

[paulyoung]

Yep, I'm using defaultOptions { unwrapNewtypes = true }.

Presumably I need to use SumEncoding. Any advice on that would be appreciated! Happy to create a new issue in the appropriate place.

[paf31]

What does the JSON look like?

[paulyoung]

For example:

{
  "type": "ThisExpression"
}

{
  "type": "ArrayExpression",
  "elements": [
    {
      "type": "ThisExpression"
    }
  ]
}

[paulyoung]

I took a look at purescript-webidl and defined IsForeign Expression in a similar fashion to the sum types there.

If there's a better way, I'd love to know how.

[paf31]

I think that is probably a reasonable way to go. Right now, the serialization only supports certain modes for sum types, so if your JSON doesn't look like one of those modes, you'll be stuck. But maybe we can make the behavior more customizable.

[paf31]

I think this is fixed in 3.0.0.