The following script produces the desired result, and should be fairly robust:

#!/bin/bash

environments=('development' 'stage' 'production')
regions=('us-east-1' 'us-west-2')

jq -n --slurpfile e <(for e in "${environments[@]}" ; do echo "\"$e\""; done) \
   --slurpfile r <(for r in "${regions[@]}" ; do echo "\"$r\"" ; done) \
   '(regions
     | [{(regions}] | add'

The main point to note here is that in order to construct an object with a dynamically determined key, one has to use parentheses, as in {(KEY): VALUE}

Of course, if the values for the "environments" and "regions" were available in a more convenient form, the above could be simplified.

Output

{
  "development": {
    "us-east-1": {},
    "us-west-2": {}
  },
  "stage": {
    "us-east-1": {},
    "us-west-2": {}
  },
  "production": {
    "us-east-1": {},
    "us-west-2": {}
  }
}

You need to use square parens [..] instead of (..) as reported in the error message. Just do

jq --arg key "foo" --arg value "bar" '.[value]'

This error line is quite verbose to recommend you the right syntax to use. The emphasis with # is mine

jq: error: try .["field"] instead of .field for unusually named fields at <top-level>, line 1
#              ^^^^^^^^^^^^^  

This was actually relatively straight forward:

.things | .[] | {name: .name, category: .params | .[] | select(.key=="category") | .value }

You can accomplish this by wrapping $n in parenthesis to tell jq to evaluate the expression:

n="foo"; echo "{}" | jq --arg n "$n" '. += { (n }'

Or probably better suited for this task would be jo(1):

$ jo "$n"="$n"
{"foo":"foo"}

I'm not sure if the documentation is just wrong or if my ability to comprehend is not at a high enough level but it does seem to say that your example should work:

Key expressions other than constant literals, identifiers, or variable references, need to be parenthesized, e.g., {("a"+"b"):59}.

And one might assume that is referring to a jq native variable rather than one injected by the shell as they are slightly different, but alas both need to be parenthesized:

$ echo '{}' | jq 'def myvar: "foo"; {myvar: myvar}'
{
  "myvar": "foo"
}
$ echo '{}' | jq 'def myvar: "foo"; {(myvar): myvar}'
{
  "foo": "foo"
}

Use parentheses to evaluate $key early as in:

 jq --null-input --arg key foobar '{($key): "value"}'

See also: Parentheses in JQ for .key

Elements of a stream are processed independently. So we have to change the input.

We could group the stream elements into an array. For an input stream, this can be achieved using --slurp/-s.^[1]

jq -s '
   ( .[0].Columns[0] | map_values( tostring ) ) as $map |
   (
      .[0],
      (
         .[1:][] |
         .Users[] |= with_entries(
            .key = $map[ .key ]
         )
      )
   )
'

Demo on jqplay

Alternatively, we could use --null-input/-n in conjunction with input and/or inputs to read the input.

jq -n '
   input |
   ( .Columns[0] | map_values( tostring ) ) as $map |
   (
      .,
      (
         inputs |
         .Users[] |= with_entries(
            .key = $map[ .key ]
         )
      )
   )
'

Demo on jqplay

Note that your desired output isn't valid JSON. Object keys must be strings. So the above produces a slightly different document than requested.

Note that I assumed that .Columns is always an array of one exactly one element. This is a nonsense assumption, but it's the only way the question makes sense.

1. For a stream the code generates, you could place the stream generator in an array constructor ([]). reduce can also be used to collect from a stream. For example, map( ... ) can be written as [ .[] | ... ] and as reduce .[] as $_ ( []; . + [ $_ | ... ] ).

The main problem seems to be in your json data because you have:

{'a': 'apple', 'b', 'bananna'}

As far as I know using single quotes is not valid (use double quotes): json format.
The another problem I see is that you have a comma , between 'b' and 'bannana' (I assume you didn't notice that and you typed , instead of :)

So Your json data should be like this:

{"a": "apple", "b": "bananna"}

What is the proper syntax to get a key?

I usually see that the syntax '.key' is more used. However I think you should use any which works. For example, I see in your case that you are using a variable $key to get specific value from a json key. So, you should use something like ".$key" or maybe ."$key", .$key (I'm not sure if these are recommended):

Solution 1

FRUIT=$(echo $ALIASES | jq ".$key" -r)
#or
FRUIT=$(echo $ALIASES | jq ."$key" -r)
#or
FRUIT=$(echo $ALIASES | jq .$key -r)

If you use or want to use single quotes then you will not be able to pass any variable value to jq command. According to man bash:

Enclosing characters in single quotes (') preserves the literal value of each character within the quotes. A single quote may not occur between single quotes, even when preceded by a backslash

Therefore If you want to use single quotes to a json value by specifying some key you should use:

FRUIT=$(echo $ALIASES | jq '.somekey' -r)
#e.g.
FRUIT=$(echo $ALIASES | jq '.a' -r)
echo $FRUIT
#Output:
apple

You can check these answers for a better understanding about single quotes and double quotes

Solution 2 (using jq --arg)
I'm not sure why the code above doesn't work for you (using the double quotes). However there is another possible solution to pass variables to jq, you can try:

val="a"
echo $ALIASES | jq --arg key "$val" '.[$key]' -r

As you are using python to get the json then you should use the method json.dumps(your_json), for example:

python3 -c 'import json;aliases = json.load(open("file"));print(json.dumps(aliases))'

$ jq -n '.a.x = 3 | .b.y = 4'
{
  "a": {
    "x": 3
  },
  "b": {
    "y": 4
  }
}

The jq expression first sets the x key beneath a to 3, and the resulting object is passed on via the pipe to another similar assignment, setting the y key of b to 4 in the same object.

However, this uses the static paths .a.x and .b.y.

Would you want to work with data given from the shell, then you could do the following for your two values:

jq -n --argjson value 3 'setpath($ARGS.positional; $value)' --args a x |
jq    --argjson value 4 'setpath($ARGS.positional; $value)' --args b y

This uses setpath() to set the path given by the list at the end of the command line (a and x in the first instance) to the value given to the $value variable. The result is then passed on to a similar jq invocation that adds a second value at another path (note the lack of -n here, though!) If the value should be added as a string (not a number), then use --arg in place of --argjson when you give the value.

The result of this pipeline would be

{
  "a": {
    "x": 3
  },
  "b": {
    "y": 4
  }
}

Depending on what form you have the path on in the shell, you might find it useful to pass a fully constructed path array to jq:

jq -n --argjson path '["a","x"]' --argjson value 3 'setpath($path; $value)' |
jq    --argjson path '["b","y"]' --argjson value 4 'setpath($path; $value)'

If you have the paths in the form .a.x and .b.y, then you can split these up with split() to form path arrays for setpath():

jq -n --arg path .a.x --argjson value 3 'setpath($path|split(".")[1:]; $value)' |
jq    --arg path .b.y --argjson value 4 'setpath($path|split(".")[1:]; $value)'

The [1:] on the result of split() is needed only if your path strings start with a dot. Note that this is the first variation of this solution that doesn't allow dots in key names.

With your clarified input taken into consideration, you may use

jq -n --argjson path '[".a.x", ".b.y"]' --argjson value '[3,4]' '[ ([$path,$value]|transpose[]) as [$p,$v] | setpath($p|split(".")[1:];$v) ] | add'

This first creates a single $p ("path") and $v ("value") pair from each combined element of the two arrays $path and $value. The $p string is then split in a similar manner as before, and the value $v is assigned to it with setpath().

The only "magic" here is the initial [$path,$value] | transpose[], which generates the two arrays

[".a.x",3]
[".b.y",4]

... and the fact that the whole operation takes place within an array constructor, forming the array

[
  {
    "a": {
      "x": 3
    }
  },
  {
    "b": {
      "y": 4
    }
  }
]

... which add then combines into our final product:

{
  "a": {
    "x": 3
  },
  "b": {
    "y": 4
  }
}

Again, dots are not allowed in key strings, and we also assume that the input arrays' length will always be the same.

You could tweak your attempt as follows:

jq -s 'map({ (.id) : . }) | add' <data

However, it would be more efficient to use inputs and reduce with the -n command-line option instead of -s.

Of course, using this approach runs the risk of collisions.

You might also want to add del(.id)

Like this:

$ jq '.compilerOptions.skipLibCheck=true' file.json
{
  "compileOnSave": false,
  "compilerOptions": {
    "baseUrl": "./",
    "skipLibCheck": true
  }
}