feat(upload): CSV and XLSX file parser with size validation

Author: William-Hill

codebenders-dashboard/lib/__tests__/upload-parser.test.ts

@@ -0,0 +1,72 @@
+import { describe, it, expect } from "vitest"
+import { parseFileBuffer, validateFileSize, getFileType } from "../upload-parser"
+
+describe("getFileType", () => {
+  it("returns csv for .csv files", () => {
+    expect(getFileType("data.csv")).toBe("csv")
+  })
+
+  it("returns xlsx for .xlsx files", () => {
+    expect(getFileType("data.xlsx")).toBe("xlsx")
+  })
+
+  it("returns null for unsupported extensions", () => {
+    expect(getFileType("data.pdf")).toBeNull()
+    expect(getFileType("data.json")).toBeNull()
+  })
+
+  it("handles uppercase extensions", () => {
+    expect(getFileType("DATA.CSV")).toBe("csv")
+    expect(getFileType("DATA.XLSX")).toBe("xlsx")
+  })
+})
+
+describe("validateFileSize", () => {
+  it("returns true for files under 50MB", () => {
+    expect(validateFileSize(1024 * 1024)).toBe(true)
+    expect(validateFileSize(50 * 1024 * 1024 - 1)).toBe(true)
+  })
+
+  it("returns false for files at or over 50MB", () => {
+    expect(validateFileSize(50 * 1024 * 1024)).toBe(false)
+    expect(validateFileSize(100 * 1024 * 1024)).toBe(false)
+  })
+})
+
+describe("parseFileBuffer", () => {
+  it("parses CSV content into headers and rows", async () => {
+    const csv = "Name,Age,City\nAlice,30,Mobile\nBob,25,Birmingham\n"
+    const buffer = Buffer.from(csv)
+    const result = await parseFileBuffer(buffer, "csv")
+
+    expect(result.headers).toEqual(["Name", "Age", "City"])
+    expect(result.rows).toHaveLength(2)
+    expect(result.rows[0]).toEqual({ Name: "Alice", Age: "30", City: "Mobile" })
+    expect(result.rows[1]).toEqual({ Name: "Bob", Age: "25", City: "Birmingham" })
+  })
+
+  it("handles CSV with quoted fields containing commas", async () => {
+    const csv = 'Name,Description\nAlice,"Has, commas"\n'
+    const buffer = Buffer.from(csv)
+    const result = await parseFileBuffer(buffer, "csv")
+
+    expect(result.rows[0].Description).toBe("Has, commas")
+  })
+
+  it("respects maxRows parameter", async () => {
+    const csv = "X\na\nb\nc\nd\ne\n"
+    const buffer = Buffer.from(csv)
+    const result = await parseFileBuffer(buffer, "csv", 3)
+
+    expect(result.rows).toHaveLength(3)
+    expect(result.totalRows).toBe(5)
+  })
+
+  it("trims whitespace from headers", async () => {
+    const csv = " Name , Age \nAlice,30\n"
+    const buffer = Buffer.from(csv)
+    const result = await parseFileBuffer(buffer, "csv")
+
+    expect(result.headers).toEqual(["Name", "Age"])
+  })
+})

codebenders-dashboard/lib/upload-parser.ts

@@ -0,0 +1,86 @@
+import Papa from "papaparse"
+import * as XLSX from "xlsx"
+
+const MAX_FILE_SIZE = 50 * 1024 * 1024 // 50 MB
+
+export interface ParseResult {
+  headers: string[]
+  rows: Record<string, string>[]
+  totalRows: number
+}
+
+export function getFileType(filename: string): "csv" | "xlsx" | null {
+  const ext = filename.toLowerCase().split(".").pop()
+  if (ext === "csv") return "csv"
+  if (ext === "xlsx" || ext === "xls") return "xlsx"
+  return null
+}
+
+export function validateFileSize(bytes: number): boolean {
+  return bytes < MAX_FILE_SIZE
+}
+
+export async function parseFileBuffer(
+  buffer: Buffer,
+  fileType: "csv" | "xlsx",
+  maxRows?: number
+): Promise<ParseResult> {
+  if (fileType === "xlsx") {
+    return parseXlsx(buffer, maxRows)
+  }
+  return parseCsv(buffer, maxRows)
+}
+
+function parseCsv(buffer: Buffer, maxRows?: number): Promise<ParseResult> {
+  return new Promise((resolve, reject) => {
+    const text = buffer.toString("utf-8")
+
+    const result = Papa.parse<Record<string, string>>(text, {
+      header: true,
+      skipEmptyLines: true,
+      transformHeader: (h: string) => h.trim(),
+    })
+
+    if (result.errors.length > 0 && result.data.length === 0) {
+      reject(new Error(`CSV parse error: ${result.errors[0].message}`))
+      return
+    }
+
+    const headers = result.meta.fields ?? []
+    const allRows = result.data
+    const rows = maxRows ? allRows.slice(0, maxRows) : allRows
+
+    resolve({ headers, rows, totalRows: allRows.length })
+  })
+}
+
+function parseXlsx(buffer: Buffer, maxRows?: number): Promise<ParseResult> {
+  return new Promise((resolve, reject) => {
+    try {
+      const workbook = XLSX.read(buffer, { type: "buffer" })
+      const sheetName = workbook.SheetNames[0]
+      if (!sheetName) {
+        reject(new Error("Excel file has no sheets"))
+        return
+      }
+
+      const sheet = workbook.Sheets[sheetName]
+      const jsonData = XLSX.utils.sheet_to_json<Record<string, string>>(sheet, {
+        defval: "",
+        raw: false,
+      })
+
+      if (jsonData.length === 0) {
+        resolve({ headers: [], rows: [], totalRows: 0 })
+        return
+      }
+
+      const headers = Object.keys(jsonData[0]).map((h) => h.trim())
+      const rows = maxRows ? jsonData.slice(0, maxRows) : jsonData
+
+      resolve({ headers, rows, totalRows: jsonData.length })
+    } catch (err) {
+      reject(new Error(`Excel parse error: ${(err as Error).message}`))
+    }
+  })
+}