refactor: convert listen and splitData functions to use object parameters

Author: charleslien

backend/src/index.ts

@@ -94,7 +94,7 @@ server.listen(port, () => {
   logger.debug(`🚀 Server is running on port ${port}`)
   console.log(`🚀 Server is running on port ${port}`)
 })
-webSocketListen(server, '/ws')
+webSocketListen({ server, path: '/ws' })
 
 let shutdownInProgress = false
 // Graceful shutdown handler for both SIGTERM and SIGINT

backend/src/util/__tests__/split-data.test.ts

@@ -4,24 +4,24 @@ import { splitData } from '../split-data'
 
 describe('splitData - base cases', () => {
   it('returns primitive as-is in an array', () => {
-    expect(splitData(42)).toEqual([42])
-    expect(splitData('hello')).toEqual(['hello'])
-    expect(splitData(null)).toEqual([null])
-    expect(splitData(undefined)).toEqual([undefined])
+    expect(splitData({ data: 42 })).toEqual([42])
+    expect(splitData({ data: 'hello' })).toEqual(['hello'])
+    expect(splitData({ data: null })).toEqual([null])
+    expect(splitData({ data: undefined })).toEqual([undefined])
   })
 
   it('returns non-plain objects as-is', () => {
     const date = new Date()
     const regex = /abc/
 
-    expect(splitData(date)).toEqual([date])
-    expect(splitData(regex)).toEqual([regex])
+    expect(splitData({ data: date })).toEqual([date])
+    expect(splitData({ data: regex })).toEqual([regex])
   })
 
   it('splits short strings when maxChunkSize is small', () => {
     const input = { msg: 'abcdef'.repeat(10) } // 60 chars
 
-    const chunks = splitData(input, 30)
+    const chunks = splitData({ data: input, maxChunkSize: 30 })
 
     expect(chunks.length).toBeGreaterThan(1)
     const combined = chunks.map((c) => c.msg).join('')
@@ -32,7 +32,7 @@ describe('splitData - base cases', () => {
   it('splits deeply nested strings with small maxChunkSize', () => {
     const input = { a: { b: { c: 'xyz123'.repeat(10) } } }
 
-    const chunks = splitData(input, 50)
+    const chunks = splitData({ data: input, maxChunkSize: 50 })
 
     expect(chunks.length).toBeGreaterThan(1)
     const reconstructed = chunks.map((c) => c.a?.b?.c ?? '').join('')
@@ -41,7 +41,7 @@ describe('splitData - base cases', () => {
 
   it('handles arrays with long values', () => {
     const input = ['abcde'.repeat(5), '12345'.repeat(5)]
-    const chunks = splitData(input, 40)
+    const chunks = splitData({ data: input, maxChunkSize: 40 })
 
     const combined = chunks
       .flat()
@@ -60,7 +60,7 @@ describe('splitData - base cases', () => {
       str: 'hello world'.repeat(5),
     }
 
-    const chunks = splitData(input, 50)
+    const chunks = splitData({ data: input, maxChunkSize: 50 })
 
     expect(chunks.length).toBeGreaterThan(1)
     expect(chunks.every((c) => JSON.stringify(c).length <= 50)).toBe(true)
@@ -74,7 +74,7 @@ describe('splitData - base cases', () => {
       a: 'A'.repeat(20),
       b: 'B'.repeat(20),
     }
-    const chunks = splitData(input, 30)
+    const chunks = splitData({ data: input, maxChunkSize: 30 })
 
     expect(chunks.length).toBeGreaterThan(1)
 
@@ -89,7 +89,7 @@ describe('splitData - base cases', () => {
 describe('splitData - array and string-specific splitting', () => {
   it('splits long strings into smaller string chunks', () => {
     const input = '12345678901234567890'
-    const chunks = splitData(input, 5)
+    const chunks = splitData({ data: input, maxChunkSize: 5 })
 
     expect(Array.isArray(chunks)).toBe(true)
     chunks.forEach((chunk) => {
@@ -103,7 +103,7 @@ describe('splitData - array and string-specific splitting', () => {
   it('splits arrays into smaller arrays with sliced strings', () => {
     const input = ['1', '2', '3333333333', '4', '5']
     const maxSize = 15
-    const chunks = splitData(input, maxSize)
+    const chunks = splitData({ data: input, maxChunkSize: maxSize })
 
     expect(Array.isArray(chunks)).toBe(true)
     chunks.forEach((chunk) => {
@@ -121,7 +121,7 @@ describe('splitData - array and string-specific splitting', () => {
       b: 'bbb'.repeat(10),
     }
     const maxSize = 40
-    const chunks = splitData(input, maxSize)
+    const chunks = splitData({ data: input, maxChunkSize: maxSize })
 
     expect(Array.isArray(chunks)).toBe(true)
     chunks.forEach((chunk) => {
@@ -139,7 +139,7 @@ describe('splitData - array and string-specific splitting', () => {
     const input = ['x'.repeat(20), 123, false, 'y'.repeat(10)]
     const maxSize = 20
 
-    const chunks = splitData(input, maxSize)
+    const chunks = splitData({ data: input, maxChunkSize: maxSize })
 
     expect(Array.isArray(chunks)).toBe(true)
     chunks.forEach((chunk) => {
@@ -162,7 +162,7 @@ describe('splitData - array and string-specific splitting', () => {
     ]
     const maxSize = 30
 
-    const chunks = splitData(input, maxSize)
+    const chunks = splitData({ data: input, maxChunkSize: maxSize })
 
     expect(Array.isArray(chunks)).toBe(true)
     chunks.forEach((chunk) => {
@@ -192,7 +192,7 @@ describe('splitData - array and string-specific splitting', () => {
     ]
     const maxSize = 50
 
-    const chunks = splitData(input, maxSize)
+    const chunks = splitData({ data: input, maxChunkSize: maxSize })
 
     expect(chunks).toEqual([
       ['short', 'strings', 'that', 'can', 'fit', 'together'],
@@ -220,7 +220,7 @@ describe('splitData - array and string-specific splitting', () => {
     }
     const maxSize = 75
 
-    const chunks = splitData(input, maxSize)
+    const chunks = splitData({ data: input, maxChunkSize: maxSize })
 
     expect(chunks).toEqual([
       {
@@ -244,7 +244,7 @@ describe('splitData - array and string-specific splitting', () => {
     const input = 'testing"testing'
     const maxSize = 10
 
-    const chunks = splitData(input, maxSize)
+    const chunks = splitData({ data: input, maxChunkSize: maxSize })
 
     expect(chunks).toEqual([
       'testing', // only length 9, but testing" would be 11
@@ -269,7 +269,7 @@ describe('splitData - nested object splitting', () => {
     }
     const maxSize = 50
 
-    const chunks = splitData(input, maxSize)
+    const chunks = splitData({ data: input, maxChunkSize: maxSize })
 
     expect(chunks).toEqual([
       {

backend/src/util/logger.ts

@@ -76,7 +76,7 @@ function splitAndLog(
   const availableDataLimit = MAX_LENGTH - BUFFER - formattedMsg.length
 
   // split data recursively into chunks small enough to log
-  const processedData: any[] = splitData(data, availableDataLimit)
+  const processedData: any[] = splitData({ data, maxChunkSize: availableDataLimit })
 
   if (processedData.length === 1) {
     pinoLogger[level](processedData[0], msg, ...args)

backend/src/util/split-data.ts

@@ -21,7 +21,11 @@ function getJsonSize(data: any): number {
   return size
 }
 
-function splitString(data: string, maxSize: number): Chunk<string>[] {
+function splitString(params: {
+  data: string
+  maxSize: number
+}): Chunk<string>[] {
+  const { data, maxSize } = params
   if (data === '') {
     return [{ data: '', length: 2 }]
   }
@@ -62,7 +66,11 @@ function splitString(data: string, maxSize: number): Chunk<string>[] {
   return chunks
 }
 
-function splitObject(obj: PlainObject, maxSize: number): Chunk<PlainObject>[] {
+function splitObject(params: {
+  obj: PlainObject
+  maxSize: number
+}): Chunk<PlainObject>[] {
+  const { obj, maxSize } = params
   const chunks: Chunk<PlainObject>[] = []
 
   let currentChunk: Chunk<PlainObject> = {
@@ -79,10 +87,10 @@ function splitObject(obj: PlainObject, maxSize: number): Chunk<PlainObject>[] {
     if (standaloneEntry.length > maxSize) {
       const overhead = getJsonSize({ [key]: '' }) - 2
 
-      const items = splitDataWithLengths(
-        value,
-        maxSize - (getJsonSize({ [key]: '' }) - 2),
-      )
+      const items = splitDataWithLengths({
+        data: value,
+        maxChunkSize: maxSize - (getJsonSize({ [key]: '' }) - 2),
+      })
 
       for (const [index, item] of items.entries()) {
         const itemWithKey: Chunk<any> = {
@@ -147,7 +155,8 @@ function splitObject(obj: PlainObject, maxSize: number): Chunk<PlainObject>[] {
   return chunks
 }
 
-function splitArray(arr: any[], maxSize: number): Chunk<any[]>[] {
+function splitArray(params: { arr: any[]; maxSize: number }): Chunk<any[]>[] {
+  const { arr, maxSize } = params
   const chunks: Chunk<any[]>[] = []
   let currentChunk: Chunk<any[]> = { data: [], length: 2 }
 
@@ -163,7 +172,7 @@ function splitArray(arr: any[], maxSize: number): Chunk<any[]>[] {
         chunks.push(currentChunk)
       }
 
-      const items = splitDataWithLengths(element, maxSize - 2)
+      const items = splitDataWithLengths({ data: element, maxChunkSize: maxSize - 2 })
 
       for (const [index, item] of items.entries()) {
         if (index < items.length - 1) {
@@ -211,11 +220,15 @@ function splitArray(arr: any[], maxSize: number): Chunk<any[]>[] {
   return chunks
 }
 
-function splitDataWithLengths(data: any, maxChunkSize: number): Chunk<any>[] {
+function splitDataWithLengths(params: {
+  data: any
+  maxChunkSize: number
+}): Chunk<any>[] {
+  const { data, maxChunkSize } = params
   // Handle primitives
   if (typeof data !== 'object' || data === null) {
     if (typeof data === 'string') {
-      const result = splitString(data, maxChunkSize)
+      const result = splitString({ data, maxSize: maxChunkSize })
       return result
     }
     return [{ data, length: getJsonSize(data) }]
@@ -228,15 +241,19 @@ function splitDataWithLengths(data: any, maxChunkSize: number): Chunk<any>[] {
 
   // Arrays
   if (Array.isArray(data)) {
-    const result = splitArray(data, maxChunkSize)
+    const result = splitArray({ arr: data, maxSize: maxChunkSize })
     return result
   }
 
   // Plain objects
-  const result = splitObject(data, maxChunkSize)
+  const result = splitObject({ obj: data, maxSize: maxChunkSize })
   return result
 }
 
-export function splitData(data: any, maxChunkSize: number = 99_000): any[] {
-  return splitDataWithLengths(data, maxChunkSize).map((cwjl) => cwjl.data)
+export function splitData(params: {
+  data: any
+  maxChunkSize?: number
+}): any[] {
+  const { data, maxChunkSize = 99_000 } = params
+  return splitDataWithLengths({ data, maxChunkSize }).map((cwjl) => cwjl.data)
 }

backend/src/websockets/server.ts

@@ -80,7 +80,8 @@ async function processMessage(
   }
 }
 
-export function listen(server: HttpServer, path: string) {
+export function listen(params: { server: HttpServer; path: string }) {
+  const { server, path } = params
   const wss = new WebSocketServer({ server, path })
   let deadConnectionCleaner: NodeJS.Timeout | undefined
   wss.on('listening', () => {