How to build a type-safe multiple property groupBy in typescript

I'm going to assume you care more about type safety from the caller's side, especially since your existing groupBy() function has at least one as any type assertion inside its implementation.

Let's say that the call signature of groupByMulti() should look like:

<T extends Record<K[number], {}>, K extends readonly (keyof T)[]>(
  arr: readonly T[], 
  keys: readonly [...K],
  propIndex?: number
) => GroupByMulti<T, K>

for some appropriate definition of GroupByMulti.

Before we get to GroupByMulti, let me explain the rest of that call signature:

We want K to be a tuple type of keys, and we want T to be an object type with properties at K whose values at those properties are assignable to {}, the so-called empty object type which (despite the name) accepts all primitives (like string or number) and only rejects null and undefined. I did this because you call .toString() on those properties, and we don't want possibly-undefined or null properties to be in there.

If you're wondering about readonly XXX[], it's because readonly arrays and readonly tuples are less restrictive than "normal" arrays. (The names are deceptive; readonly here means "can definitely be read, but may or may not be written", while regular arrays are "can definitely be read, and can definitely be written").

And finally the fact that keys is [...K] instead of just K is using variadic tuple types to give the compiler a hint that we want it to keep track of the exact length of that array, since it makes a big difference.

Okay, now let's define GroupByMulti:

type GroupByMulti<T, K extends readonly any[]> =
    K extends readonly [any, ...infer KR] ?
    Record<string, GroupByMulti<T, KR>> : readonly T[];

That's a recursive conditional type that walks through the K tuple. If K is empty, we just want readonly T[], that is, grouping by no keys just gives you an array. Otherwise, we want Record<string, GroupByMulti<T, KR>> where KR is an array that's shorter by one than K. (It's the Rest of the K array so I call it KR. ‍♂️).

The implementation is full of type assertions I won't spend time explaining:

const groupByMulti = <
    T extends Record<K[number], {}>,
    K extends readonly (keyof T)[]
>(arr: readonly T[], keys: readonly [...K], propIndex = 0) => {
    var grouppedObj: any = groupBy(arr, keys[propIndex]);
    Object.keys(grouppedObj).forEach((key) => {
        if (propIndex < keys.length - 1) {
            grouppedObj[key] = groupByMulti<any, any[]>(
                grouppedObj[key], keys, propIndex + 1);
        } else {
            grouppedObj[key] = grouppedObj[key]
        }
    });
    return grouppedObj as GroupByMulti<T, K>;
}

The only important bit is that we are returning a value of type GroupByMulti<T, K>. Let's test it out:

const result = groupByMulti(cars, ['car', 'year', 'model']);
/* const result: Record<string, Record<string, Record<string, readonly {
    car: string;
    model: string;
    style: string;
    year: string;
}[]>>> */

Object.keys(result).forEach(k =>
    Object.keys(result[k]).forEach(l =>
        Object.keys(result[k][l]).forEach(m => {
            result[k][l][m].forEach(c => console.log(c.car));
        })
    )
)

Looks good. The type of result is a triply-nested object with string keys, whose deep object type is the an of T objects. That allows us to process the result with some type safety (the compiler knows that result[k][l][m] is an array).

Playground link to code