Improve performance for const schemas

[DanieleFedeli]

Checklist

• run npm run test and npm run benchmark
• tests and/or benchmarks are included
• documentation is changed or added
• commit message and code follows the Developer's Certification of Origin
  and the Code of conduct

As per issue #502, when using a const schema, the performance degrades. This is the continuation of #505.

Benchmark

Pre PR

Post PR

This PR supports nullable values:

test('schema with const string and no input', t => {
  t.plan(2)

  const schema = {
    type: 'object',
    properties: {
      foo: { const: 'bar' }
    }
  }

  const validate = validator(schema)
  const stringify = build(schema)
  const output = stringify({})

  t.equal(output, '{}')
  t.ok(validate(JSON.parse(output)), 'valid schema')
})

Or it coerces the value to the const property if it is required

test('schema with const string and no input but required property', t => {
  t.plan(2)

  const schema = {
    type: 'object',
    properties: {
      foo: { const: 'bar' }
    },
    required: ['foo']
  }

  const validate = validator(schema)
  const stringify = build(schema)
  const output = stringify({})

  t.equal(output, '{"foo":"bar"}')
  t.ok(validate(JSON.parse(output)), 'valid schema')
})

[mcollina]

lgtm

[ivan-tymoshenko]

This should be removed.

[ivan-tymoshenko]

const shouldn't work as a default value. If you define a schema constant property, it must const value, whatever value the user passes.

[ivan-tymoshenko]

This should work in a different way.

1. You should handle value serialization only in one place otherwise you will have code duplication and can make an error. In your case, you miss the null check here. So please handle all schema serialization logic inside buildValue function.
2. We don't need to do this check for const

   fast-json-stringify/index.js

   Line 365 in 844eba5

   if (obj[${sanitized}] !== undefined) {

   .

[DanieleFedeli]

Null checks you mean this?

const schema = {
  "type": "object",
  "properties": {
    "foo": {
      "const": "bar"
    }
  }
}


stringify({ "foo": "bar" }) // { "foo": "bar" }
stringify({ "foo": "baz" }) // { "foo": "bar" }
stringify({ "foo": 1 }) // { "foo": "bar" }
stringify({}) // { }

[DanieleFedeli]

To answer 2.
If I don't have that checks how can I handle this?

const schema = {
  "type": "object",
  "properties": {
    "foo": {
      "const": "bar"
    }
  }
}

stringify({}) // { }

[ivan-tymoshenko]

I think that the const value shouldn't work as a default value. It shouldn't have any other additional behavior.

const schema = {
  "type": "object",
  "properties": {
    "foo": {
      "const": "bar"
    }
  },
  "required": ['foo']
}

stringify({}) // throw new Error('foo is required')

[DanieleFedeli]

I am OK with that, but I remember that someone agrees on this comment.

[ivan-tymoshenko]

Yes, you are right, it should. From my point of view. But let's wait for other opinions.

[mcollina]

If you are waiting for me, I'm leaving this to you.

[ivan-tymoshenko]

I would like to hear @climba03003 opinion as it was his suggestion #505 (comment).

[climba03003]

When the schema said the property is required, and missing one from the input.
It just convenient to always put the value there since it is required.

Just like why we always put the const value regardless the input.

[climba03003]

I do not block if it turns to throw.
It consistences with the current required handling for other properties.

[Uzlopak]

I read the code. Now it is like 80% reformatting. 19% tests and 1% change. And somehow i dont see any code which is responsible for comparing const with the actual value. I guess ajv does the validation? I cant follow, lol. How i read it, it is always serializing const no matter what the actual value is.

I am not that into the codebase so i guess i am out of here.

[DanieleFedeli]

@Uzlopak Yes my bad, I don't know why I have the format changes since I don't even have the formats on save options.

[ivan-tymoshenko]

@Uzlopak yes you are right. The main idea of #505 (review), #505 (comment) was to ignore the actual value and always insert the const value. I agree with this point of view because fjs is not a validator and if we can do something without validation we don't have to do validation. If you don't agree please share your thoughts.

[ivan-tymoshenko]

@DanieleFedeli Null check.

const schema = {
  "type": "object",
  "properties": {
    "foo": {
      "nullable": true
      "const": "bar"
    }
  }
}

stringify({foo:null}) // {foo:null}

const schema = {
  "type": "object",
  "properties": {
    "foo": {
      "type": [...whatever, 'null']
      "const": "bar"
    }
  }
}

stringify({foo:null}) // {foo:null}

[ivan-tymoshenko]

@DanieleFedeli, Can you revert the formatting changes? It would be easier to review for other people.

[DanieleFedeli]

I can try

[mcollina]

lgtm

[mcollina]

@climba03003 are you ok for this to land?

[climba03003]

Yes.
LGTM