Weird issue with 0.13.0: multiple tuple item type support

[benderTheCrime]

In an ill advised effort to use the new multitype tuple feature to allow any type in an object in any position of an Array, I think I've uncovered a weird bug:

here is my schema for an Array property "args":

        args: {
            items: [
                {
                    type: 'object',
                    patternProperties: {
                        '.*': {
                            type: 'string',
                        },
                    },
                },
                {
                    type: 'object',
                    patternProperties: {
                        '.*': {
                            type: 'number',
                        },
                    },
                },
                {
                    type: 'object',
                    patternProperties: {
                        '.*': {
                            type: 'null',
                        },
                    },
                },
                {
                    type: 'object',
                    patternProperties: {
                        '.*': {
                            type: 'boolean',
                        },
                    },
                },
            ],
            type: 'array',
        },

and then here is my object:

const obj = {
    args: [
        'foo', 
        {
            foo: 1,
            bar: 'foo',
        }
     ],
};

This is the result:

{"args":[,{"foo":"1","bar":"foo"}{"foo":1,"bar":null}{"foo":null,"bar":null}{"foo":true,"bar":true}]}

I was just attempting to use this for which it wasn't intended, but at the same time, this returns an invalid JSON string, which I don't think is desirable behavior.

[benderTheCrime]

tagging @elliotttf @delvedor

[mcollina]

You have a bug in your schema too. You are passing a string as the first object, while it's defined as type: 'object'. I don't think that's a problem, but rather on how we support patternProperties. Can you check without them if it works as expected?

[benderTheCrime]

Just to confirm, you want to see if the Object:

const obj = {
    args: [
        {
            foo: 1,
            bar: 'foo',
        }
     ],
};

prints out a valid JSON string?

[benderTheCrime]

Here is the result if that is the case:

{"args":[{"foo":"1","bar":"foo"}{"foo":1,"bar":null}{"foo":null,"bar":null}{"foo":true,"bar":true}]}

[mcollina]

There are a few bugs:

• we are missing commas if an object with patternProperties is passed in
• we are missing {} if a string is passed and we expect an object

[mcollina]

@benderTheCrime @elliotttf would any of you send a PR?

[benderTheCrime]

@mcollina I think there's also the issue with many "args" with the type of the patternProperty being created when only one "arg" (item) existed in the given Array.

[elliotttf]

allow any type in an object in any position of an Array,

I think this might be part of the problem (and wasn't immediately obvious to me when I was working on this either).

In order for the tuple to be valid you must match the types and the order of members of your array.

But yes it shouldn't be returning invalid json. I can work on a fix later today.

[benderTheCrime]

right, @elliotttf, so what I would actually expect in that case, if the first Object in the items type Array was:

                {
                    type: 'object',
                    patternProperties: {
                        '.*': {
                            type: 'string',
                        },
                    },
                },

Given the "args":

const obj = {
    args: [
        {
            foo: 1,
            bar: 'foo',
        }
     ],
};

That only the "bar" property would be be returned, or:

{"args":[{"bar":"foo"}]}

To be clear, I'm not trying to validate the way I was attempting to use it ( 😓 ), just raising an issue.