fromJSON() should initialize field values accordingly to the entity.

[m7vicente]

When created an entity instance using fromJSON() method, in some cases, the entire json object has all attributes defined as string, but these values are not ignored by fromJSON(), they just set these values in the created instance.

Since parse function in fromJSON can create BaseEntity and Dates from string types it's possible to parse Numbers and strings accordingly to the definition in the entity.

[dalssoft]

Could you give a example of a input and the desired output?

[m7vicente]

const AnEntity = entity('An entity', {
                field1: field(Number),
                field2: field(String),
                field3: field(Date),
                field4: field(Boolean)
            })

const instance = AnEntity.fromJSON({
                    "field1": "1", 
                    "field2": "1",
                    "field3": "2019-09-30T23:45:00.000Z",
                    "field4": "true"
             })

instance.field1 // should be an Number
instance.field2 // should be an String
instance.field3 // should be an Date
instance.field4 // should be an Boolean

[dalssoft]

What if there was a new options = { parseValue: true }?

[m7vicente]

I think this should be since the case doesn't whos occurs all time.

Another thing, in some cases, the parse could occur wrong, to handle those cases, let de value be the error like NaN or InvalidDate, to make these errors more visible, run isValid to inform those errors from parse in the instance .errors (only if the option its enable).

[jhomarolo]

Maybe the value parse itself, can be coupled with the isvalid() call or something related to that

I keep wondering, if the isvalid() call inside fromJson(), as a parameter would have any gain, since every time we call fromJson, we call isvalid on the next line of code.

I also believe that these parsers, can already reuse the suma checkers, which are already implemented within this gotu class, instead of creating redundant validations.

[dalssoft]

There could be a method to force parse values.

For example:

const AnEntity = entity('An entity', { field1: field(Number) })

const instance = AnEntity.fromJSON({ "field1": "1" })

instance.field1 // is a String

instance.parseFields()

instance.field1 // should be an Number

In this case we should think what would be the behavior for invalid parses.

[italojs]

I think this comportment is a little bit weird

@m7vicente in your example, why not just explicitly convert the values?

[...]
const instance = AnEntity.fromJSON({
"field1": parseInt("1"),
"field2":  parseInt("1"),
"field3": new Date("2019-09-30T23:45:00.000Z"),
"field4": myValue === 'true'
})

[dalssoft]

Another suggestion:

const AnEntity = entity('An entity', { field1: field(Number), field2: field(Date) })

const instance = AnEntity.fromJSON({ "field1": "1", "field2": "2" })
instance.field1 // is a String
instance.field2 // is a String

const instance = AnEntity.tryParse({ "field1": "1", "field2": "2" })
instance.field1 // should be an Number
instance.field2 // still a String since it could not parse to Date

[m7vicente-vortx]

If the tryParse return the instance we can execute after an fromJSON not adding a lot of complexy to use.

const values = ({ "field1": "1", "field2": "2" } const instance = AnEntity.fromJSON(values).tryParse()

[m7vicente-vortx]

Work in Progress

[dalssoft]

@m7vicente @jhomarolo @italojs please, review this commit 2efb440 (branch tryParse).

doc: herbsjs/herbsjs.github.io@8f730d4

The idea was to create a conservative tryParse, not relying completely on the messy js type/data parser. The idea is to balance the best effort of a parser and but also try to avoid surprises for the developer (ex: a field(Date) with value 1 being parsed to '1969-12-01').

Please, give me your feedback asap. I need this feature to use in a glue improvement.

[jhomarolo]

Are there any known test battery scenarios where this method will fail?
2efb440#diff-92f07723b5f0b9daa54ffc2a317a02a8a7f45e5b860a1b1b96604d1984ce0e8c