typescript-aggregate-null-set-member

Answer

Root cause: teacherIds.add(cls.teacherId) inserted null (a falsy, non-undefined value) into the JS Set. Sets dedupe by value equality, and null is a valid member, so 1172/1188 unassigned classes contributed a phantom "teacher" — inflating totalTeachers from 1 to 2.

The fix: guard before Set.add so null/undefined teacher_id never enters the distinct set.

// admin/dashboard/stats.ts
export interface ClassRow {
  id: number;
  name: string;
  teacherId: number | null; // null when unassigned
}

export interface TeacherStats {
  totalClasses: number;
  totalTeachers: number;
}

export function computeTeacherStats(classes: ClassRow[]): TeacherStats {
  const teacherIds = new Set<number>();
  let totalClasses = 0;

  for (const cls of classes) {
    totalClasses++;
    // FIX: skip unassigned classes — null/undefined must not count as a distinct teacher
    if (cls.teacherId != null) {
      teacherIds.add(cls.teacherId);
    }
  }

  return { totalClasses, totalTeachers: teacherIds.size };
}

The problem statement's canonical guard is if (cls.teacherId) (truthiness) — sufficient here because auto-increment teacher IDs are positive integers ≥ 1. I use != null in the solution because it's the stricter fix: it also excludes undefined (e.g., a row missing the field after a partial projection) while still counting a hypothetical teacherId === 0. For ID columns either guard is correct; != null is the more defensive one.

Call-site usage (admin dashboard aggregate):

const stats = computeTeacherStats(await db.fetchClasses());
// previously: totalTeachers 2 (real teacher + NULL phantom)
// now:        totalTeachers 1

Regression test (vitest):

// admin/dashboard/stats.test.ts
import { describe, expect, it } from 'vitest';
import { computeTeacherStats, type ClassRow } from './stats';

describe('computeTeacherStats', () => {
  it('does not count unassigned classes as distinct teachers', () => {
    const classes: ClassRow[] = [
      { id: 1, name: 'A', teacherId: 7 },
      { id: 2, name: 'B', teacherId: null },      // unassigned — must NOT count
      { id: 3, name: 'C', teacherId: null },      // unassigned — must NOT count
      { id: 4, name: 'D', teacherId: 7 },         // duplicate — deduped by Set
      { id: 5, name: 'E', teacherId: undefined }, // missing — must NOT count
    ];
    const stats = computeTeacherStats(classes);
    expect(stats.totalTeachers).toBe(1);
    expect(stats.totalClasses).toBe(5);
  });

  it('matches SQL COUNT(DISTINCT ...) IS NOT NULL against seeded data', async () => {
    const classes = await fetchClasses(); // seeded: 1188 classes, 1172 with NULL teacher_id
    const stats = computeTeacherStats(classes);
    const { rows } = await db.query(
      `SELECT COUNT(DISTINCT teacher_id) AS n FROM classes WHERE teacher_id IS NOT NULL`,
    );
    expect(stats.totalTeachers).toBe(Number(rows[0].n));
  });

  it('handles degenerate inputs', () => {
    expect(computeTeacherStats([])).toEqual({ totalClasses: 0, totalTeachers: 0 });
    const allUnassigned: ClassRow[] = [
      { id: 1, name: 'x', teacherId: null },
      { id: 2, name: 'y', teacherId: null },
    ];
    expect(computeTeacherStats(allUnassigned).totalTeachers).toBe(0); // not 1 or 2
  });
});