Implement filter_by_role API function

package.json

@@ -2,6 +2,7 @@
   "name": "trcc",
   "version": "0.1.0",
   "private": true,
+  "type": "module",
   "scripts": {
     "dev": "next dev --turbopack",
     "build": "next build --turbopack",

src/app/volunteers/filter_by_role/route.ts

@@ -0,0 +1,38 @@
+import { NextRequest, NextResponse } from "next/server";
+import {
+  getVolunteersByRoles,
+  isAllStrings,
+  isValidOperator,
+} from "@/lib/api/getVolunteersByRoles";
+
+export async function GET(request: NextRequest) {
+  const { searchParams } = request.nextUrl;
+  const operator = searchParams.get("operator");
+  const roleParams = searchParams.get("roles");
+
+  if (!operator || !roleParams) {
+    return NextResponse.json({
+      status: 400,
+      error: "Missing operator or role filter values",
+    });
+  }
+
+  const roles = roleParams.split(",");
+
+  if (!isValidOperator(operator)) {
+    return { status: 400, error: "Operator is not AND or OR" };
+  }
+
+  if (!isAllStrings(roles)) {
+    return {
+      status: 400,
+      error: "Roles to filter by are not all strings",
+    };
+  }
+
+  const response = await getVolunteersByRoles(operator as "OR" | "AND", roles);
+
+  return NextResponse.json(response, {
+    status: response.status,
+  });
+}

src/lib/api/getVolunteersByRoles.ts

@@ -0,0 +1,108 @@
+import { createClient } from "../client/supabase/server";
+
+type Volunteer = {
+  id: number;
+  created_at: string;
+  updated_at: string;
+  email: string | null;
+  phone: string | null;
+  name_org: string;
+  notes: string | null;
+  opt_in_communication: boolean | null;
+  position: string | null;
+  pronouns: string | null;
+  pseudonym: string | null;
+};
+
+type Operator = "OR" | "AND";
+
+export function isAllStrings(arr: unknown[]): arr is string[] {
+  return arr.every((item) => typeof item === "string");
+}
+
+export function isValidOperator(operator: string) {
+  return (
+    typeof operator === "string" &&
+    ["OR", "AND"].includes(operator.toUpperCase())
+  );
+}
+
+export async function getVolunteersByRoles(
+  operator: Operator,
+  filters: string[]
+) {
+  if (!isValidOperator(operator)) {
+    return { status: 400, error: "Operator is not AND or OR" };
+  }
+
+  if (!isAllStrings(filters)) {
+    return {
+      status: 400,
+      error: "Roles to filter by are not all strings",
+    };
+  }
+
+  const client = await createClient();
+  const { data: allRows, error } = await client
+    .from("VolunteerRoles")
+    .select(
+      `
+      Roles!inner (name),
+      Volunteers!inner (*)
+    `
+    )
+    .in("Roles.name", filters);
+
+  if (error) {
+    // console.error("Supabase error:", error.message);
+    // console.error("Details:", error.details);
+    // console.error("Hint:", error.hint);
+
+    return {
+      status: 500,
+      error: `Failed to query Supabase database: ${error.message}`,
+    };
+  }
+
+  const volunteerRoleMap = new Map<
+    number,
+    {
+      row: Volunteer;
+      roleNames: Set<string>;
+    }
+  >();
+
+  for (const row of allRows) {
+    const volunteerId = row.Volunteers.id;
+    const roleName = row.Roles.name;
+
+    let volunteerData = volunteerRoleMap.get(volunteerId);
+    if (!volunteerData) {
+      volunteerData = { row: row.Volunteers, roleNames: new Set<string>() };
+      volunteerRoleMap.set(volunteerId, volunteerData);
+    }
+
+    volunteerData.roleNames.add(roleName);
+  }
+
+  const filteredVolunteers = [];
+  if (operator.toUpperCase() == "OR") {
+    for (const volunteer of volunteerRoleMap.values()) {
+      filteredVolunteers.push({
+        ...volunteer.row,
+        filtered_roles: Array.from(volunteer.roleNames),
+      });
+    }
+  } else {
+    for (const volunteer of volunteerRoleMap.values()) {
+      if (volunteer.roleNames.size == filters.length) {
+        filteredVolunteers.push({
+          ...volunteer.row,
+          filtered_roles: Array.from(volunteer.roleNames),
+        });
+      }
+    }
+  }
+
+  return { data: filteredVolunteers, status: 200 };
+}

src/lib/api/index.ts

@@ -1,3 +1,8 @@
 // Add any exports from your API files here
 
 export { getExample } from "./getExample";
+export {
+  getVolunteersByRoles,
+  isAllStrings,
+  isValidOperator,
+} from "./getVolunteersByRoles";

tests/lib/api/getVolunteersByRoles.test.ts

@@ -0,0 +1,103 @@
+// Example test for getExample function
+// This test is not meaningful as is, but serves as a template
+// You should modify it to fit your actual implementation and testing needs
+
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { getVolunteersByRoles } from "@/lib/api/getVolunteersByRoles";
+import { createClient } from "@/lib/client/supabase/server";
+
+const Roles1 = [
+  {
+    Roles: { name: "Role 1" },
+    Volunteers: {
+      id: 1,
+    },
+  },
+  {
+    Roles: { name: "Role 1" },
+    Volunteers: {
+      id: 3,
+    },
+  },
+];
+
+const Roles2 = [
+  {
+    Roles: { name: "Role 2" },
+    Volunteers: {
+      id: 2,
+    },
+  },
+  {
+    Roles: { name: "Role 2" },
+    Volunteers: {
+      id: 3,
+    },
+  },
+];
+
+// Mock the Supabase client
+vi.mock("@/lib/client/supabase/server", () => ({
+  createClient: vi.fn(),
+}));
+
+describe("getVolunteersByRoles", () => {
+  const mockIn = vi.fn();
+  const mockSelect = vi.fn(() => ({ in: mockIn }));
+  const mockFrom = vi.fn(() => ({ select: mockSelect }));
+  const mockClient = { from: mockFrom };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // @ts-expect-error - Partial mock of SupabaseClient for testing
+    vi.mocked(createClient).mockResolvedValue(mockClient);
+  });
+
+  it("returns error response for an invalid operator", async () => {
+    const result = await getVolunteersByRoles("INVALID", ["Role 1"]);
+    expect(result.status).toBe(400);
+    expect(result).toEqual({ status: 400, error: "Operator is not AND or OR" });
+  });
+
+  it("returns error response if the filters array is malformed", async () => {
+    const result = await getVolunteersByRoles("OR", [1]);
+    expect(result.status).toBe(400);
+    expect(result).toEqual({
+      status: 400,
+      error: "Roles to filter by are not all strings",
+    });
+  });
+
+  it("returns all volunteers with Role 1 or Role 2", async () => {
+    mockIn.mockResolvedValueOnce({ data: [...Roles1, ...Roles2], error: null });
+
+    const result = await getVolunteersByRoles("OR", ["Role 1", "Role 2"]);
+    expect(result.status).toBe(200);
+    expect(result).toHaveProperty("data");
+
+    const ids = result.data?.map((volunteer) => volunteer.id).sort();
+    expect(ids).toEqual([1, 2, 3]);
+  });
+
+  it("returns all volunteers with Role 1", async () => {
+    mockIn.mockResolvedValueOnce({ data: Roles1, error: null });
+
+    const result = await getVolunteersByRoles("OR", ["Role 1"]);
+    expect(result.status).toBe(200);
+    expect(result).toHaveProperty("data");
+
+    const ids = result.data?.map((volunteer) => volunteer.id).sort();
+    expect(ids).toEqual([1, 3]);
+  });
+
+  it("returns all volunteers with Role 1 AND Role2", async () => {
+    mockIn.mockResolvedValueOnce({ data: [...Roles1, ...Roles2], error: null });
+
+    const result = await getVolunteersByRoles("AND", ["Role 1", "Role 2"]);
+    expect(result.status).toBe(200);
+    expect(result).toHaveProperty("data");
+
+    const ids = result.data?.map((volunteer) => volunteer.id).sort();
+    expect(ids).toEqual([3]);
+  });
+});