Unable to validate nested arrays of objects

[logonv]

Support plan

• is this issue currently blocking your project? (yes/no): yes
• is this issue affecting a production system? (yes/no): yes

Context

We are trying to use JOI with a nextJs 13.4.4 app with node 18.6.0. ​ The same issue can be reproduced on https://npm.runkit.com/joi and that's what's described below.

• node version: 18.11.0
• module version with issue: 17.9.2
• last module version without issue: n/a
• environment (e.g. node, browser, native): node
• used with (e.g. hapi application, another framework, standalone, ...): n/a
• any other relevant information: n/a

What are you trying to achieve or the steps to reproduce?

• We are trying to carry out nested 2 level validation of an object where one of the values is an arrays of objects.
• Reproducible example described below concerns movies and series
• The root object has the keys id, format, status and seasons . format is either movie or series while status is either pass or fail. seasons is an array of season objects.
• Each season object has the keys id, seasonNumber and episodes. episodes is an array of episode objects.
• Each episode object has the keys id and name.
• Whenever the format is notseriesthen theseasons` key of the root object is forbidden.
• When the format is series and the status is pass there should be a minimum of 2 season objects and 5 episodes.

Reproduction can be found here https://runkit.com/logan-runkit/joi-bug ​

var Joi = require('joi')
​
// episodes
const episodeSchema = Joi.object({
  id: Joi.string().required(),
  name: Joi.string(),
})
​
// seasons
const seasonSchema = Joi.object({
  id: Joi.string().required(),
  seasonNumber: Joi.number(),
  episodes: Joi.array().items(episodeSchema).required(),
})
​
const schema = Joi.object({
  id: Joi.string().required(),
  format: Joi.string().equal(...['movie', 'series']).required(),
  status: Joi.string().equal(...['fail', 'pass']).required(),
  seasons: Joi.when('format', {
    is: 'series',
    then: Joi.array().items(seasonSchema),
    otherwise: Joi.forbidden(),
  }),
})
  .when(Joi.object({
    format: 'series',
    status: 'pass',
  }),
  {
    then: Joi.object({
      seasons: Joi.array().items(
        seasonSchema.keys(
          { episodes: Joi.array().items(episodeSchema).required().min(5) },
        ),
      ).min(2).required(),
    }),
  })
​
const { value, error } = schema.validate({
  id: 'a', format: 'series', status: 'pass', seasons: [{ id: 'b', episodes: [] }],
})
​
// Above should result in an error as the format is 'series', the status is 'pass' but episodes is an array with length 0 and there is only 1 season
​
console.log('value', value)
console.log('error', error)

What was the result you got?

Validation passes

What result did you expect?

Validation should fail

[Marsup]

Hi,

Thanks for the detailed example. I can see 2 "mistakes" in this schema:

• when with a schema as 1st parameter must completely match, a match on a partial object needs .unknown() to validate that object, if you were to validate this in isolation, it would report excess keys as errors
• when merges then/otherwise schemas based on the conditions, what you might not have considered is that arrays can't be deterministically merged, there is no unique way of knowing if by items(A) + items(B) you meant items(A, B) or items(A+B), and the current way joi does this is by adding your new schema to the list of possibilities, it won't merge it into seasonSchema

Knowing all of this, I would write your schema like that: https://runkit.com/embed/m8hwqfjgjg5c I think it passes all your scenarios, or at least it's a good starting point.

[logonv]

Apologies for the late reply, thanks for your help!