Using a pared-down sample JSON object with just the relevant key:

$ cat test.json
{
    "drop_reasons": ["a","b","c"]
}
$ jq '.drop_reasons |= join(",")' test.json
{
  "drop_reasons": "a,b,c"
}

Your sample with an empty array would change to an empty string.

x |= y is essentially shorthand for x = (x | y). The parens are what you were missing in your attempt; they're needed because of jq precedence rules.

Assuming that the input is given on stdin, the following command solves the problem:

jq -Rn '[inputs]'

The flag -R reads the input as "raw" (i.e. unquoted strings) and -n hands over stdin to inputs (slurping with -s doesn't work because when combined with -R, it reads the whole input a single string). Add -c to print the JSON on one line like in the question.

Any empty lines (like a trailing newline) may be skipped by adding a little filter:

jq -Rn '[inputs|select(length>0)]'

If the strings are separated by other characters like ,, the string may be split with

jq -R 'split(",")'

This could be used to split on \n as well for solving the above case, but my (unverified) assumption is that the above solution is more portable with systems using other line terminators.

In general, the elements of an array may be converted to a single space-delimited string using join(" ") in jq. In your case, the .source array may be converted into a space-delimited string using .source | join(" ").

I'm assuming that your input document contains an array of objects of the type that you show in the question.

Instead of calling jq multiple times in each iteration, consider using jq to get the data into a form that is usable as a single stream:

jq -r '.[] | [ .name, (.source | join(" ")) ] | @tsv' file.json |
while IFS=$'\t' read -r name source; do
    __test "$name" "$source"
done

This provides two tab-delimited fields to the loop. The first field is simply the .name value from the JSON document, while the second field is a space-delimited string made by concatenating the elements from the .source array. The concatenation of array elements into a singe string is done with join() in jq, and the tab-delimited output is produced by providing @tsv with an array.

If you feel brave, you could even use

eval "$( jq -r '.[] | [ "__test", .name, (.source | join(" ")) ] | @sh' file.json )"

This uses jq to actually create the shell commands that you aim to execute. The calling shell then gets this script as a string and runs it with eval. In the jq expression, @sh is used to provide proper quoting for the command name and its arguments. The jq expression here expects an array of objects of the type shown in the question.

jq solution:

jq '[.[] | [(.Authors | split(", ")), (.Affiliation | split(", "))] 
         | transpose | { authors: map({ Name:.[0], Affiliation:.[1] }) }]' input.json

The output:

[
  {
    "authors": [
      {
        "Name": "Author1",
        "Affiliation": "Here"
      },
      {
        "Name": "Author2",
        "Affiliation": "There"
      },
      {
        "Name": "Author3",
        "Affiliation": "Everywhere"
      }
    ]
  },
  {
    "authors": [
      {
        "Name": "Author4",
        "Affiliation": "Nirvana"
      },
      {
        "Name": "Author5",
        "Affiliation": "Utopia"
      }
    ]
  }
]

I forgot the closing parenthesis:

aws ecs list-services --cluster splat-dev --profile mfa |
  jq -r '.serviceArns[] | select(contains("edp-api-dev"))'
#                                                       ^

You're making it a lot more complicated than it is. Just use map() and |=:

jq 'map(.tags |= split(" "))' file.json

Edit:

If you want to handle entries without tags:

jq 'map(try(.tags |= split(" ")))' file.json

Alternatively, if you want to keep unchanged all entries without tags:

jq 'map(try(.tags |= split(" ")) // .)' file.json

Result:

[
  {
    "tags": [
      "tagA",
      "tag-B",
      "tagC"
    ],
    "title": "Some Title"
  },
  {
    "tags": [
      "tagA",
      "tagC"
    ],
    "title": "Some Title 2"
  }
]

This should work:

[
    .ClassIdentifier,
    .StateMode // "null",
    (.StateGroups
        | map(select(.Status=="active").StateGroupName)
        | sort
        | join("|")
        | if .=="" then "null" else . end
    )
] | @csv

Which produces:

"consumer-leads","txt-2300","null"
"main","null","brown-space|default|txt-hosts"
"paid-media","txt-2300","null"
"reports","null","default|grey-space|txt-hosts"

Note that since you're using 1.3, join/1 won't be available to you. But it shouldn't be difficult to implement yourself.

def join(sep): sep as $sep
    | reduce .[1:][] as $item (.[0]|tostring; . + $sep + $item)
    ;