Use [] to access a dynamic key on the object

json.users[username] = {a: 1, b: 2}

Be careful naming your variable like that tho because json the way you're using it is not JSON. JSON is a string, not an object with keys.

See the below demo for distinction

var json = '{"users":{"test1":{},"test2":{}}}';
var obj  = JSON.parse(json);
var newuser = 'test3';
obj.users[newuser] = {};
console.log(JSON.stringify(obj));
//=> {"users":{"test1":{},"test2":{},"test3":{}}}

Your code works but is really not optimized. You can use dictionnaries (Map in javascript) to improve it.

Try this:

function getStorage(incs) {
  const mapIncoming = new Map();
  const storage = {};

  // Create map with status as keys and object of products as values
  incs.forEach(({productStatus, productName, productId}) => {
    if (mapIncoming.has(productStatus)) {
        const objNames = mapIncoming.get(productStatus)
      if (objNames[productName]) {
        objNames[productName].productId.push(productId)
      } else {
        objNames[productName] = {productName, productId: [productId]}
      }
    } else {
        mapIncoming.set(productStatus, {[productName]: {productName, productId: [productId]}})
    }
  })
  
  // Convert objects stored in map into array
  for(const [status, products] of mapIncoming){
    storage[status] = Object.values(products)
  }
  
  return storage
}

console.log(getStorage(incoming))

JSON stands for JavaScript Object Notation. A JSON object is really a string that has yet to be turned into the object it represents.

To add a property to an existing object in JS you could do the following.

object["property"] = value;

or

object.property = value;

If you provide some extra info like exactly what you need to do in context you might get a more tailored answer.

json might not be the best choice for on-disk formats; The trouble it has with appending data is a good example of why this might be. Specifically, json objects have a syntax that means the whole object must be read and parsed in order to understand any part of it.

Fortunately, there are lots of other options. A particularly simple one is CSV; which is supported well by python's standard library. The biggest downside is that it only works well for text; it requires additional action on the part of the programmer to convert the values to numbers or other formats, if needed.

Another option which does not have this limitation is to use a sqlite database, which also has built-in support in python. This would probably be a bigger departure from the code you already have, but it more naturally supports the 'modify a little bit' model you are apparently trying to build.

The result that you expect to get is a set type, not a dict. Here is an example how you could do that using list.

In [7]: not_a_json_just_a_python_dict =     {
   ...:         "text": "test text",
   ...:         "created_at": "some date",
   ...:         "entity": "most_common_entity",
   ...:         "username": "someuser",
   ...:         "tweet_id": "coolid",
   ...:         "hashtags": "#coolndat"
   ...:     }

In [8]: list_of_dicts = [not_a_json_just_a_python_dict]

In [9]: list_of_dicts.append({
   ...:             "text": "test text",
   ...:             "created_at": "some date",
   ...:             "entity": "most_common_entity",
   ...:             "username": "someuser",
   ...:             "tweet_id": "coolid",
   ...:             "hashtags": "#coolndat"
   ...:         })

In [10]: list_of_dicts
Out[10]:
[{'text': 'test text',
  'created_at': 'some date',
  'entity': 'most_common_entity',
  'username': 'someuser',
  'tweet_id': 'coolid',
  'hashtags': '#coolndat'},
 {'text': 'test text',
  'created_at': 'some date',
  'entity': 'most_common_entity',
  'username': 'someuser',
  'tweet_id': 'coolid',
  'hashtags': '#coolndat'}]

If you use json.NET you can simply deserialize and serialize the json.

var list = JsonConvert.DeserializeObject<List<Person>>(myJsonString);
list.Add(new Person(1234,"carl2");
var convertedJson = JsonConvert.SerializeObject(list, Formatting.Indented);

I found the solution, thanks to the comments by other users and to a "retired" answer, not present here anymore. Maybe it was my fault not being clear.

public void addEntryToJsonFile(Context ctx, String id, String name, String size) {

    // parse existing/init new JSON 
    File jsonFile = new File(ctx.getDir("my_data_dir", 0), "my_json_file.json");
    String previousJson = null;
    if (jsonFile.exists()) {
        try {
            previousJson = Utils.readFromFile(jsonFile);
        } catch (IOException e) {
            e.printStackTrace();
        }
    } else {
        previousJson = "{}";
    }

    // create new "complex" object
    JSONObject mO = null;
    JSONObject jO = new JSONObject();

    try {
        mO = new JSONObject(previousJson);
        jO.put("completed", true);
        jO.put("name", name);
        jO.put("size", size);
        mO.put(id, jO); //thanks "retired" answer
    } catch (JSONException e) {
        e.printStackTrace();
    }

    // generate string from the object
    String jsonString = null;
    try {
        jsonString = mO.toString(4);
    } catch (JSONException e) {
        e.printStackTrace();
    }

    // write back JSON file
    Utils.writeToFile(jsonFile, jsonString);

}