I have been working on a simple reducer that uses an object to accumulate values, aiming to maximize TS inference. However, I am facing difficulties in achieving proper type safety with TypeScript. The issue arises when the empty object does not contain any expected types, leading to incorrect complaints. Alternatively, if I type the object, it may not complain at all, even though some keys could result in undefined values.
Consider the following code snippet:
type Session = { name: string; startDate: Date; endDate: Date };
type SessionGroup = {
name: string;
duration: number;
sessions: Session[];
};
type Grouped = { [k: string]: SessionGroup };
function selectGroupedSessions(sessions: Session[]): SessionGroup[] {
const grouped = sessions.reduce((result: Grouped, session) => {
const { name, startDate, endDate } = session;
const group = result[name] || { name, sessions: [] };
group.sessions.push(session);
result[name] = group;
return result;
}, {});
return Object.values(grouped);
}
The accumulator is typed as Grouped. Despite this, there is no error thrown at the line result[name] = group where there should be one, since a default value incompatible with the expected type of SessionGroup is being assigned. This problem stems from the Grouped type assuming that for every possible string key, there is a corresponding SessionGroup, which is not accurate.
If I adjust the Grouped type like so:
type Grouped = { [k: string]: SessionGroup | undefined };
An error emerges on the last line (returning Object.values):
Type '(SessionGroup | undefined)[]' is not assignable to type 'SessionGroup[]'
Hence, what would be the most effective way to type this scenario in order to convey to TypeScript the correctness of the underlying JavaScript code without resorting to excessive casting?