Once you have your variable loaded, you should use the split filter to split that string into an array.

$ jq -n --arg inarr "${ARR}" '{ arr: $inarr | split("\n") }'

Here is a solution without loops:

json=$(jq -c ".my_key[]"  ./my-file.json)
json_without_quotes=$(echo ${json//\"/""})
declare -a all_apps_array=($(echo $json_without_quotes | tr "\n" " "))

for id in "${IDS[@]}" ; do
  echo "$id"
done | jq -nR '[ {id: inputs, names: ["bob", "sally"]} ]'

or as a one-liner:

printf "%s\n" "${IDS[@]}" | jq -nR '[{id: inputs, names: ["bob", "sally"]}]'

To correctly parse values that may have newlines (and any other arbitrary (non-NUL) characters) use jq's @sh filter to generate space-separated quoted strings, and Bash's declare -a to parse the quoted strings as array elements. (No pre-processing required)

foo.json:

{"data": ["$0", " \t\n", "*", "\"", ""]}

str=$(jq -r '.data | @sh' foo.json)
declare -a arr="($str)"   # must be quoted like this

declare -p arr
# declare -a arr=([0]="\$0" [1]=$' \t\n' [2]="*" [3]="\"" [4]="")

Update: jq 1.7 (2023-09)

As of version 1.7, jq has a --raw-output0 option, enabling it to output null-terminated strings which can be read into an array as usual:

mapfile -d '' arr < <(jq --raw-output0 '.data[]' foo.json)
wait "$!"  # use in bash-4.4+ to get exit status of the process substitution

Note on NUL characters in JSON strings

JSON strings may contain NUL characters while shell variables cannot. If your JSON input may contain NUL's, you may need to add some special handling.

• When using the @sh filter, NUL characters from JSON strings will be silently replaced with the sequence \0. Note that this makes the JSON strings "\\0" and "\u0000" indistinguishable.

• When using the --raw-output0 option, NUL characters will trigger an error and jq will terminate with an exit status of 5.

Reading multiple/nested arrays

The @sh filter can be combined with --raw-output0 to reliably read multiple arrays at once (or a single nested array) as it will produce a NUL-separated list of space-separated quoted strings.

json='[[1,2],[3,4]]' i=0
while read -r -d ''; do
    declare -a "arr$((i++))=($REPLY)"
done < <(jq --raw-output0 '.[]|@sh' <<<$json)

for ((n=0; n<i; n++)); { declare -p "arr$n"; }
# declare -a arr0=([0]="1" [1]="2")
# declare -a arr1=([0]="3" [1]="4")

The following is actually buggy:

# BAD: Output line of * is replaced with list of local files; can't deal with whitespace
arr=( $( curl -k "$url" | jq -r '.[].item2' ) )

If you have bash 4.4 or newer, a best-of-all-worlds option is available:

# BEST: Supports bash 4.4+, with failure detection and newlines in data
{ readarray -t -d '' arr && wait "$!"; } < <(
  set -o pipefail
  curl --fail -k "$url" | jq -j '.[].item2 | (., "\u0000")'
)

...whereas with bash 4.0, you can have terseness at the cost of failure detection and literal newline support:

# OK (with bash 4.0), but can't detect failure and doesn't support values with newlines
readarray -t arr < <(curl -k "$url" | jq -r '.[].item2' )

...or bash 3.x compatibility and failure detection, but without newline support:

# OK: Supports bash 3.x; no support for newlines in values, but can detect failures
IFS=$'\n' read -r -d '' -a arr < <(
  set -o pipefail
  curl --fail -k "$url" | jq -r '.[].item2' && printf '\0'
)

...or bash 3.x compatibility and newline support, but without failure detection:

# OK: Supports bash 3.x and supports newlines in values; does not detect failures
arr=( )
while IFS= read -r -d '' item; do
  arr+=( "$item" )
done < <(curl --fail -k "$url" | jq -j '.[] | (.item2, "\u0000")')

Calling jq directly from find, and then collecting the resulting data with jq to construct the final output, without any shell loops:

find ~ -maxdepth 1 -name '[[:upper:]]*' \
    -exec jq -n --arg path {} '{ name: ($path|sub(".*/"; "")), path: $path }' \; |
jq -n -s '{ items: inputs }'

The jq that is being executed via -exec creates a JSON object per found pathname. It strips off everything in the pathname up to the last slash for the name value, and uses the pathname as is for the path value.

The final jq reads the data from find into an array with -s, and simply inserts it as the items array in a new JSON object. The final jq invocation could also be written jq -n '{ items: [inputs] }.

Example result (note that I was using [[:upper:]* in place of D* for the -name pattern with find):

{
  "items": [
    {
      "name": "Documents",
      "path": "/home/myself/Documents"
    },
    {
      "name": "Mail",
      "path": "/home/myself/Mail"
    },
    {
      "name": "Work",
      "path": "/home/myself/Work"
    }
  ]
}

You can construct two arrays of names and urls, then adapt this answer to "zip" the two arrays together into the desired array of objects.

jq -n \
    --arg name1 "$server1_name" \
    --arg url1 "$server1_url" \
    --arg name2 "$server2_name" \
    --arg url2 "$server2_url" \
'[$name1, $name2] as $names |
 [$url1, $url2] as $urls |
  [([$names, $urls] | transpose[]) as [$name, $url] |{$name, $url}]'

The benefit is that as the number of name/url pairs grows, you only need to modify the first two filters that define $names and $urls; the rest of the filter stays the same. You could even separate this into separate uses of jq, to facilitate the definition of a large list of servers.

names=$(jq -n --arg v1 "$server1_name" --arg v2 "$server2_name" '[$v1, $v2]')

urls=$(jq -n --arg v1 "$server1_url" --arg v2 "$server2_url" '[$v1, $v2]')

jq -n \
   --argjson names "$names" \
   --argjson urls "$urls" \
   '[([$names, $urls] | transpose[]) as [$name, $url] | {$name, $url}]'

#!/bin/bash

list=( http://RESTURL1 http://RESTURL2 )

declare -A hypothetical_data=(
    [http://RESTURL1]='{"foo":"Tiger Nixon","bar":"Edinburgh"}'
    [http://RESTURL2]='{"foo":"Garrett Winters","bar":"Tokyo"}'
)

# create the seed file
result="result.json"
echo '{"data":[]}' > "$result"

for url in "${list[@]}"; do
    # fetch the data.
    json=${hypothetical_data[$url]}
    # would really do: json=$(curl "$url")

    # extract the name ("foo") and location ("bar") values
    name=$( jq -r '.foo' <<<"$json" )
    location=$( jq -r '.bar' <<<"$json" )

    jq --arg name "$name" \
       --arg loc "$location" \
         '.data += [[$name, $loc]]' "$result" | sponge "$result"

    # "sponge" is in the "moreutils" package that you may have to install. 
    # You can also write that line as:
    #
    # tmp=$(mktemp)
    # jq --arg name "$name" \
    #    --arg loc "$location" \
    #      '.data += [[$name, $loc]]' "$result" > "$tmp" && mv "$tmp" "$result"
    #                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
done

End result:

$ cat result.json
{
  "data": [
    [
      "Tiger Nixon",
      "Edinburgh"
    ],
    [
      "Garrett Winters",
      "Tokyo"
    ]
  ]
}