Having the same issues here. Is there any update on this?

It's entirely reasonable that the same string produces different results when you use different array formats.

In this case, it seems like "brackets" does have a bug, whether in stringify, parse, or both.

judging from other query string libraries, it might require specifying the arrayFormat in both stringify and parse

ohhhh right, it absolutely does :-) i missed that. indices is the default arrayFormat.

@wholien what happens if you specify brackets in your first parse?

@ljharb doing it with brackets:

> metadata = [{key: "a", value: "2"}, {key: "b", value: "3"}]
[ { key: 'a', value: '2' }, { key: 'b', value: '3' } ]

> brackets = qs.stringify({"metadata": metadata}, { arrayFormat: "brackets"})
'metadata%5B%5D%5Bkey%5D=a&metadata%5B%5D%5Bvalue%5D=2&metadata%5B%5D%5Bkey%5D=b&metadata%5B%5D%5Bvalue%5D=3'

> parsed_brackets = qs.parse(brackets, { arrayFormat: "brackets"}) // <---- here
{ metadata: [ { key: [Array], value: [Array] } ] }

> parsed_brackets["metadata"]
[ { key: [ 'a', 'b' ], value: [ '2', '3' ] } ]

I was reading through the readme and some of the parse code - doesn't look like there is an option for setting arrayFormats, though I could be wrong.

Seems like we do have an issue here then.

I agree with the general premise that for any format parse accepts, or stringify produces, the other should be able to round trip (ie, stringify(parse(q)) === q modulo normalizations, and parse(stringify(q)) =~ q where =~ is a reasonable deep equal algorithm modulo normalizations).

Happy to accept a PR here, but I'm not sure concretely what it should change.

Failing test cases are probably the best place to start!

On the most recent version, an array stringified and parsed returns a string:

> qs.stringify({ foo: [ 'a', 'b' ] }, { arrayFormat: 'comma' })
'foo=a%2Cb'
> qs.parse('foo=a%2Cb', { comma: true })
{ foo: 'a,b' }

where as previously an array is returned:

> qs.parse('foo=a%2Cb', { comma: true })
{ foo: [ 'a', 'b' ] }

@nigeldunne in this case, %2c isn't a comma to be used for splitting. if you parse foo=a,b it will split properly.

I'd say the issue is that stringify needs to produce an unescaped comma when arrayFormat is "comma".

@ljharb sounds reasonable. I think the key is your point about the ability to do a "round trip".

Fixed in #361, I think?

@ljharb The "round trip" still does not work when arrayFormat is "comma":

qs.stringify({ foo: [ 'a', 'b' ] }, { arrayFormat: 'comma' })
'foo=a%2Cb'
qs.parse('foo=a%2Cb', { comma: true })
{ foo: 'a,b' } //expecting { foo: [ 'a', 'b' ]

@nigeldunne thanks, reopening

On the most recent version, an array stringified and parsed returns a string:

> qs.stringify({ foo: [ 'a', 'b' ] }, { arrayFormat: 'comma' })
'foo=a%2Cb'
> qs.parse('foo=a%2Cb', { comma: true })
{ foo: 'a,b' }

where as previously an array is returned:

> qs.parse('foo=a%2Cb', { comma: true })
{ foo: [ 'a', 'b' ] }

For now, I use this solution

qs.parse(str, {
      comma: true,
      decoder(str, defaultDecoder, charset, type) {
        const decoded = defaultDecoder(str);
        if (type === "value" && typeof decoded === "string" && decoded.includes(",")) {
          return decoded.split(",");
        }
        return decoded;
      },
    })

probably not the best solution but it is working for my case.