The |= .+ part in the filter adds a new element to the existing array. You can use jq with filter like:

jq '.data.messages[3] |= . + {
      "date": "2010-01-07T19:55:99.999Z", 
      "xml": "xml_samplesheet_2017_01_07_run_09.xml", 
      "status": "OKKK", 
      "message": "metadata loaded into iRODS successfullyyyyy"
}' inputJson

To avoid using the hardcoded length value 3 and dynamically add a new element, use . | length which returns the length, which can be used as the next array index, i.e.,

jq '.data.messages[.data.messages| length] |= . + {
      "date": "2010-01-07T19:55:99.999Z", 
      "xml": "xml_samplesheet_2017_01_07_run_09.xml", 
      "status": "OKKK", 
      "message": "metadata loaded into iRODS successfullyyyyy"
}' inputJson

(or) as per peak's suggestion in the comments, using the += operator alone

jq '.data.messages += [{
     "date": "2010-01-07T19:55:99.999Z",
     "xml": "xml_samplesheet_2017_01_07_run_09.xml", 
     "status": "OKKK", 
     "message": "metadata loaded into iRODS successfullyyyyy"
}]'

which produces the output you need:

{
  "report": "1.0",
  "data": {
    "date": "2010-01-07",
    "messages": [
      {
        "date": "2010-01-07T19:58:42.949Z",
        "xml": "xml_samplesheet_2017_01_07_run_09.xml",
        "status": "OK",
        "message": "metadata loaded into iRODS successfully"
      },
      {
        "date": "2010-01-07T20:22:46.949Z",
        "xml": "xml_samplesheet_2017_01_07_run_09.xml",
        "status": "NOK",
        "message": "metadata duplicated into iRODS"
      },
      {
        "date": "2010-01-07T22:11:55.949Z",
        "xml": "xml_samplesheet_2017_01_07_run_09.xml",
        "status": "NOK",
        "message": "metadata was not validated by XSD schema"
      },
      {
        "date": "2010-01-07T19:55:99.999Z",
        "xml": "xml_samplesheet_2017_01_07_run_09.xml",
        "status": "OKKK",
        "message": "metadata loaded into iRODS successfullyyyyy"
      }
    ]
  }
}

Use jq-play to dry-run your jq-filter and optimize any way you want.

jq has a flag for feeding actual JSON contents with its --argjson flag. What you need to do is, store the content of the first JSON file in a variable in jq's context and update it in the second JSON

jq --argjson groupInfo "$(<input.json)" '.[].groups += [$groupInfo]' orig.json

The part "$(<input.json)" is shell re-direction construct to output the contents of the file given and with the argument to --argjson it is stored in the variable groupInfo. Now you add it to the groups array in the actual filter part.

Putting it in another way, the above solution is equivalent of doing this

jq --argjson groupInfo '{"id": 9,"version": 0,"lastUpdTs": 1532371267968,"name": "Training" }' \
   '.[].groups += [$groupInfo]' orig.json

Do not try to parse JSON text with standard text processing tools like awk, sed or without JSON modules in perl, as they are non JSON syntax aware. jq is a lightweight JSON processor that allows you manipulate content on the fly.

For e.g. your requirement could be simply written as

jq --arg new "arn:aws:iam::xxxxxxx:role/3" \
  '.Statement[].Principal.AWS? += [$new]' json

If there is more than one element to be appended, create the arg as a JSON blob

jq --argjson new \
  '["arn:aws:iam::xxxxxxx:role/3", "arn:aws:iam::xxxxxxx:role/4"]' \
  '.Statement[].Principal.AWS? += $new'

Instructions for downloading and using the tool are at Download jq and usage tutorial at jq Manual

If the contents are in a file and you want to modify this file permanently, use a in-place edit tool like sponge available from GNU moreutils package which you can do

jq --arg new "arn:aws:iam::xxxxxxx:role/3" \
  '.Statement[].Principal.AWS? += [$new]' json | sponge json

or use a POSIX tool like mktemp

temp="$(mktemp)"
jq --arg new "arn:aws:iam::xxxxxxx:role/3" \
  '.Statement[].Principal.AWS? += [$new]' json > "$temp" && mv "$temp" json

Assuming that you mean you want to append to the JSON that you show and that the JSON document is well-formed,

$ cat file.json
{
  "access": {
    "allowed_users": [
      "admin",
      "test"
    ]
  }
}

you can do

$ jq '.access.allowed_users += ["test32"]' file.json
{
  "access": {
    "allowed_users": [
      "admin",
      "test",
      "test32"
    ]
  }
}

It uses the += to add to the array by assigning a new element to it.

With a new value in a shell variable:

$ data='My "awesome" data'
$ jq --arg value "$data" '.access.allowed_users += [$value]' file.json
{
  "access": {
    "allowed_users": [
      "admin",
      "test",
      "My \"awesome\" data"
    ]
  }
}

To add many entries in one go, it's easiest to add them with --args:

$ jq '.access.allowed_users += $ARGS.positional' file.json --args Bilbo Frodo Sam Merry Pippin
{
  "access": {
    "allowed_users": [
      "admin",
      "test",
      "Bilbo",
      "Frodo",
      "Sam",
      "Merry",
      "Pippin"
    ]
  }
}

Note that --args and the subsequent arguments to that option must be the last thing on the command line.

To make these changes to your file, use a temporary file:

jq ...one-of-the-above-approaches... >tmp.json &&
mv tmp.json file.json

The && prevents the original file from being overwritten if jq for some reason fails.

You can concatenate arrays with + so you can add your new object inside an array and concat the rest:

.examples |= [{example: "1"}] + .

https://jqplay.org/s/XIsoZ4GvOa

Well, does something like this work for you?

jq '.[0].array += ["string3"]' test.json

I see this response, which looks pretty much like what I would want:

[
  {
    "array": [
      "string1",
      "string2",
      "string3"
    ]
  },
  {
    "object1": {
      "subobject1": {},
      "subobject2": {}
    }
  },
  {
    "object2": {}
  }
]

EDIT 1: I like the more general solutions provided by @peak particularly the first one:

map( if .array then .array += ["string3"] else . end)

Here's a snippet you can experiment with. It's easy to see how you could insert the new string into the second contained array rather than the first with:

 map( if .array2 then .array2 += ["string3"] else . end)

You need to use the update assignment operator |=:

jq '(.Details[]|={entry_date:"\(.entry_day) \(.entry_month)"})' input.json

There are several issues with your script. Generally, this should work (but still needs improvement on certain levels):

JSON='[{"name": "Jon", "class": "senior"}]'
echo "$JSON" | jq '. += [{"new_key": "new_value"}]'

[
  {
    "name": "Jon",
    "class": "senior"
  },
  {
    "new_key": "new_value"
  }
]

[THIS IS NOT WORKING. READ BELOW.]

There are many ways to do this.

Assuming elements of the array are supposed to be unique, which your use case strongly implies, you can just pass the resulting array after the addition through the unique filter.

$ cat foo.json | jq '.widgets[] | select(.name=="foo").properties |= (.+ ["cat"] | unique)'

There are a few problems here.

One is that the resulting output is partial as it is missing the container object.

Another one is that the edited array looses the commas separating the objects thus becoming illegal JSON.

The actual result from the above command is:

{
  "name": "foo",
  "properties": [
    "baz",
    "cat"
  ]
}
{
  "name": "bar"
}