TypeScript: Push to an array of Nested JSON Object

Couple of advices when working with algorithms:

1. Recursion is actually quite hard for a human brain. Although I agree that some tasks are easier if you know how to apply recursion. Especially in case of nested recursion.
2. Naming is really important.

So for example, for me, "keys" is quite confusing. If I revisit this function later, I would probably think at first that I should add the value to all of these keys. So I would rather rename the variable into smth like "keyPath".

Now, I'll try to explain how I would solve it. This is probably not the best solution, just something from the top of my head.

So, imagine we have a nested object:

{
    key1: {
        key2: {
            key3: []
        }
    }
}

And then, let's imagine the simplest scenario, we need to insert a value all the way to key3.

In this case, obviously keyPath=["key1", "key2", "key3"]

Now, in order to reach the last key, we can start with first key of the path, and try to go down into the object until we reach the end of keyPath.

1. take first element of keyPath. const key = "key1";
2. go deeper into our object: const nestedObj = obj[key];
3. repeat, but now use nestedObj instead of obj, and "key2", and so forth

This can be a recursion, but I think it's a simple loop, isn't it?

for (const i=0; i<keyPath.length; i++) {
   const key = keyPath[i];
   const newObj = obj[key];
   obj = newObj;
}

This code is a bit too verbose though. We can simplify it like this:

for (const key of keyPath) {
    obj = obj[key];
}

And voila, we got to the final object where we can insert the element:

obj.push(value);

So the whole function would look like this:

function addNested(obj: any, keyPath: (string|number)[], value: any) {
    for (const key of keyPath)
        obj = obj[key];
    obj.push(value);
}

This will already satisfy all of the test cases you had, but as I understood your code, there is one more possibility: last key in the keyPath doesn't exist or is a primitive value (i.e. not an object and not an array).

Well, when we loop into the object, if the key doesn't exist, our obj[key] will return undefined. And we can also check if it contains a primitive value or null.

So in this case, we know that we reached the end of the object, and we simply need to assign our value.

if (typeof obj[key] === 'undefined' || obj[key] === null || obj[key] !== Object(obj[key])) {
    obj[key] = value;
    return;
}

typeof obj[key] === 'undefined' || obj[key] === null can be simplified into obj[key] == null (notice it's == and not ===).

So the function becomes something like this:

function addNested(obj: any, keyPath: (string|number)[], value: any) {
    for (const key of keyPath) {
        if (obj[key] == null || obj[key] !== Object(obj[key])) {
            obj[key] = value;
            return;
        }
        obj = obj[key];
    }
    obj.push(value);
}

This is still not ideal algorithm, because it doesn't do any error checking. For example, if more than 1 key from the keyPath doesn't exist in the object, or keyPath ends with an object, it doesn't handle that.

Still, I hope that this example will help you to improve approach to working with algorithms :)