refactor: improve type safety by replacing any with unknown and proper types

- error.ts: use unknown instead of any for error parameters
- promise.ts: use unknown for error callbacks with proper type narrowing
- object.ts: use Record<string, unknown> and proper generic types
- split-data.ts: add JsonValue type, use unknown for public API
- org-billing.ts: document WithSerializableTransactionFn any usage

Author: brandonkachen

common/src/util/__tests__/promise.test.ts

@@ -299,7 +299,7 @@ describe('withRetry', () => {
 
       const result = await withRetry(operation, {
         maxRetries: 3,
-        retryIf: (error) => error?.code === 'RETRY_ME',
+        retryIf: (error) => (error as { code?: string })?.code === 'RETRY_ME',
       })
 
       expect(result).toBe('success')
@@ -315,7 +315,7 @@ describe('withRetry', () => {
       await expect(
         withRetry(operation, {
           maxRetries: 3,
-          retryIf: (err) => err?.code === 'RETRY_ME',
+          retryIf: (err) => (err as { code?: string })?.code === 'RETRY_ME',
         }),
       ).rejects.toMatchObject({ code: 'DO_NOT_RETRY' })
 

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

@@ -21,7 +21,7 @@ describe('splitData - base cases', () => {
   it('splits short strings when maxChunkSize is small', () => {
     const input = { msg: 'abcdef'.repeat(10) } // 60 chars
 
-    const chunks = splitData({ data: input, maxChunkSize: 30 })
+    const chunks = splitData({ data: input, maxChunkSize: 30 }) as { msg?: string }[]
 
     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({ data: input, maxChunkSize: 50 })
+    const chunks = splitData({ data: input, maxChunkSize: 50 }) as { a?: { b?: { c?: string } } }[]
 
     expect(chunks.length).toBeGreaterThan(1)
     const reconstructed = chunks.map((c) => c.a?.b?.c ?? '').join('')
@@ -60,7 +60,7 @@ describe('splitData - base cases', () => {
       str: 'hello world'.repeat(5),
     }
 
-    const chunks = splitData({ data: input, maxChunkSize: 50 })
+    const chunks = splitData({ data: input, maxChunkSize: 50 }) as { flag?: boolean; num?: number; str?: string }[]
 
     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({ data: input, maxChunkSize: 30 })
+    const chunks = splitData({ data: input, maxChunkSize: 30 }) as { a?: string; b?: string }[]
 
     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({ data: input, maxChunkSize: 5 })
+    const chunks = splitData({ data: input, maxChunkSize: 5 }) as string[]
 
     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({ data: input, maxChunkSize: maxSize })
+    const chunks = splitData({ data: input, maxChunkSize: maxSize }) as { a?: string; b?: string }[]
 
     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({ data: input, maxChunkSize: maxSize })
+    const chunks = splitData({ data: input, maxChunkSize: maxSize }) as { msg?: string; val?: number }[][]
 
     expect(Array.isArray(chunks)).toBe(true)
     chunks.forEach((chunk) => {

common/src/util/error.ts

@@ -33,29 +33,29 @@ export function success<T>(value: T): Success<T> {
   }
 }
 
-export function failure(error: any): Failure<ErrorObject> {
+export function failure(error: unknown): Failure<ErrorObject> {
   return {
     success: false,
     error: getErrorObject(error),
   }
 }
 
 export function getErrorObject(
-  error: any,
+  error: unknown,
   options: { includeRawError?: boolean } = {},
 ): ErrorObject {
   if (error instanceof Error) {
-    const anyError = error as any
+    const errorWithExtras = error as { status?: unknown; statusCode?: unknown; code?: unknown }
     return {
       name: error.name,
       message: error.message,
       stack: error.stack,
-      status: typeof anyError.status === 'number' ? anyError.status : undefined,
+      status: typeof errorWithExtras.status === 'number' ? errorWithExtras.status : undefined,
       statusCode:
-        typeof anyError.statusCode === 'number'
-          ? anyError.statusCode
+        typeof errorWithExtras.statusCode === 'number'
+          ? errorWithExtras.statusCode
           : undefined,
-      code: typeof anyError.code === 'string' ? anyError.code : undefined,
+      code: typeof errorWithExtras.code === 'string' ? errorWithExtras.code : undefined,
       rawError: options.includeRawError
         ? JSON.stringify(error, null, 2)
         : undefined,

common/src/util/object.ts

@@ -1,41 +1,45 @@
 import { isEqual, mapValues, union } from 'lodash'
 
+type RemoveUndefined<T extends object> = {
+  [K in keyof T as T[K] extends undefined ? never : K]: Exclude<T[K], undefined>
+}
+
 export const removeUndefinedProps = <T extends object>(
   obj: T,
-): {
-  [K in keyof T as T[K] extends undefined ? never : K]: Exclude<T[K], undefined>
-} => {
-  const newObj: any = {}
+): RemoveUndefined<T> => {
+  const newObj: Record<string, unknown> = {}
 
   for (const key of Object.keys(obj)) {
-    if ((obj as any)[key] !== undefined) newObj[key] = (obj as any)[key]
+    const value = obj[key as keyof T]
+    if (value !== undefined) newObj[key] = value
   }
 
-  return newObj
+  return newObj as RemoveUndefined<T>
 }
 
 export const removeNullOrUndefinedProps = <T extends object>(
   obj: T,
   exceptions?: string[],
 ): T => {
-  const newObj: any = {}
+  const newObj: Record<string, unknown> = {}
 
   for (const key of Object.keys(obj)) {
+    const value = obj[key as keyof T]
     if (
-      ((obj as any)[key] !== undefined && (obj as any)[key] !== null) ||
+      (value !== undefined && value !== null) ||
       (exceptions ?? []).includes(key)
     )
-      newObj[key] = (obj as any)[key]
+      newObj[key] = value
   }
-  return newObj
+  return newObj as T
 }
 
 export const addObjects = <T extends { [key: string]: number }>(
   obj1: T,
   obj2: T,
 ) => {
   const keys = union(Object.keys(obj1), Object.keys(obj2))
-  const newObj = {} as any
+  const newObj: Record<string, number> = {}
 
   for (const key of keys) {
     newObj[key] = (obj1[key] ?? 0) + (obj2[key] ?? 0)
@@ -49,7 +53,7 @@ export const subtractObjects = <T extends { [key: string]: number }>(
   obj2: T,
 ) => {
   const keys = union(Object.keys(obj1), Object.keys(obj2))
-  const newObj = {} as any
+  const newObj: Record<string, number> = {}
 
   for (const key of keys) {
     newObj[key] = (obj1[key] ?? 0) - (obj2[key] ?? 0)
@@ -68,14 +72,19 @@ export const hasSignificantDeepChanges = <T extends object>(
   partial: Partial<T>,
   epsilonForNumbers: number,
 ): boolean => {
-  const compareValues = (currValue: any, partialValue: any): boolean => {
+  const compareValues = (currValue: unknown, partialValue: unknown): boolean => {
     if (typeof currValue === 'number' && typeof partialValue === 'number') {
       return Math.abs(currValue - partialValue) > epsilonForNumbers
     }
-    if (typeof currValue === 'object' && typeof partialValue === 'object') {
+    if (
+      typeof currValue === 'object' &&
+      currValue !== null &&
+      typeof partialValue === 'object' &&
+      partialValue !== null
+    ) {
       return hasSignificantDeepChanges(
-        currValue,
-        partialValue,
+        currValue as Record<string, unknown>,
+        partialValue as Partial<Record<string, unknown>>,
         epsilonForNumbers,
       )
     }
@@ -95,7 +104,7 @@ export const hasSignificantDeepChanges = <T extends object>(
 
 export const filterObject = <T extends object>(
   obj: T,
-  predicate: (value: any, key: keyof T) => boolean,
+  predicate: (value: T[keyof T], key: keyof T) => boolean,
 ): { [P in keyof T]: T[P] } => {
   const result = {} as { [P in keyof T]: T[P] }
   for (const key in obj) {

common/src/util/promise.ts

@@ -4,19 +4,22 @@ export async function withRetry<T>(
   operation: () => Promise<T>,
   options: {
     maxRetries?: number
-    retryIf?: (error: any) => boolean
-    onRetry?: (error: any, attempt: number) => void
+    retryIf?: (error: unknown) => boolean
+    onRetry?: (error: unknown, attempt: number) => void
     retryDelayMs?: number
   } = {},
 ): Promise<T> {
   const {
     maxRetries = 3,
-    retryIf = (error) => error?.type === 'APIConnectionError',
+    retryIf = (error) => {
+      const errorObj = error as { type?: string } | null | undefined
+      return errorObj?.type === 'APIConnectionError'
+    },
     onRetry = () => {},
     retryDelayMs = INITIAL_RETRY_DELAY,
   } = options
 
-  let lastError: any = null
+  let lastError: unknown = null
 
   for (let attempt = 0; attempt < maxRetries; attempt++) {
     try {

common/src/util/split-data.ts

@@ -1,19 +1,32 @@
-type PlainObject = Record<string, any>
+/**
+ * Represents any JSON-serializable value (primitives, arrays, or objects).
+ * Used internally for type-safe JSON splitting operations.
+ */
+type JsonValue =
+  | string
+  | number
+  | boolean
+  | null
+  | undefined
+  | JsonValue[]
+  | { [key: string]: JsonValue }
+
+type PlainObject = Record<string, JsonValue>
 
 interface Chunk<T> {
   data: T
   length: number
 }
 
-function isPlainObject(val: any): val is PlainObject {
+function isPlainObject(val: unknown): val is PlainObject {
   return (
     typeof val === 'object' &&
     val !== null &&
     Object.getPrototypeOf(val) === Object.prototype
   )
 }
 
-function getJsonSize(data: any): number {
+function getJsonSize(data: unknown): number {
   if (data === undefined) {
     return 'undefined'.length
   }
@@ -93,7 +106,7 @@ function splitObject(params: {
       })
 
       for (const [index, item] of items.entries()) {
-        const itemWithKey: Chunk<any> = {
+        const itemWithKey: Chunk<PlainObject> = {
           data: { [key]: item.data },
           length: item.length + overhead,
         }
@@ -155,14 +168,14 @@ function splitObject(params: {
   return chunks
 }
 
-function splitArray(params: { arr: any[]; maxSize: number }): Chunk<any[]>[] {
+function splitArray(params: { arr: JsonValue[]; maxSize: number }): Chunk<JsonValue[]>[] {
   const { arr, maxSize } = params
-  const chunks: Chunk<any[]>[] = []
-  let currentChunk: Chunk<any[]> = { data: [], length: 2 }
+  const chunks: Chunk<JsonValue[]>[] = []
+  let currentChunk: Chunk<JsonValue[]> = { data: [], length: 2 }
 
   for (const element of arr) {
-    const entryArr = [element]
-    const standaloneEntry: Chunk<any[]> = {
+    const entryArr: JsonValue[] = [element]
+    const standaloneEntry: Chunk<JsonValue[]> = {
       data: entryArr,
       length: getJsonSize(entryArr),
     }
@@ -224,27 +237,29 @@ function splitArray(params: { arr: any[]; maxSize: number }): Chunk<any[]>[] {
 }
 
 function splitDataWithLengths(params: {
-  data: any
+  data: unknown
   maxChunkSize: number
-}): Chunk<any>[] {
+}): Chunk<JsonValue>[] {
   const { data, maxChunkSize } = params
   // Handle primitives
   if (typeof data !== 'object' || data === null) {
     if (typeof data === 'string') {
       const result = splitString({ data, maxSize: maxChunkSize })
       return result
     }
-    return [{ data, length: getJsonSize(data) }]
+    // Primitives (number, boolean, null, undefined) are valid JsonValues
+    return [{ data: data as JsonValue, length: getJsonSize(data) }]
   }
 
-  // Non-plain objects (Date, RegExp, etc.)
+  // Non-plain objects (Date, RegExp, etc.) - pass through as-is
+  // These will be serialized by JSON.stringify when needed
   if (!Array.isArray(data) && !isPlainObject(data)) {
-    return [{ data, length: getJsonSize(data) }]
+    return [{ data: data as JsonValue, length: getJsonSize(data) }]
   }
 
   // Arrays
   if (Array.isArray(data)) {
-    const result = splitArray({ arr: data, maxSize: maxChunkSize })
+    const result = splitArray({ arr: data as JsonValue[], maxSize: maxChunkSize })
     return result
   }
 
@@ -253,7 +268,15 @@ function splitDataWithLengths(params: {
   return result
 }
 
-export function splitData(params: { data: any; maxChunkSize?: number }): any[] {
+/**
+ * Splits JSON-serializable data into smaller chunks that fit within the specified size limit.
+ * Preserves the structure of objects and arrays while splitting long strings and nested values.
+ *
+ * @param params.data - The data to split (can be any JSON-serializable value)
+ * @param params.maxChunkSize - Maximum size in characters for each chunk (default: 99,000)
+ * @returns An array of chunks, each fitting within the size limit
+ */
+export function splitData(params: { data: unknown; maxChunkSize?: number }): unknown[] {
   const { data, maxChunkSize = 99_000 } = params
   return splitDataWithLengths({ data, maxChunkSize }).map((cwjl) => cwjl.data)
 }

packages/billing/src/org-billing.ts

@@ -277,8 +277,16 @@ export async function calculateOrganizationUsageAndBalance(
 
 /**
  * Type for the withSerializableTransaction dependency.
+ * 
+ * The callback parameter uses `any` for the same reason as `BillingTransactionFn`:
+ * Drizzle's `PgTransaction` type has method signatures incompatible with our
+ * simplified `BillingDbConnection` interface. Using `any` allows both real
+ * Drizzle transactions and mock implementations to work.
+ * 
+ * @see BillingTransactionFn in `@codebuff/common/types/contracts/billing` for details
  */
 type WithSerializableTransactionFn = <T>(params: {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   callback: (tx: any) => Promise<T>
   context: Record<string, unknown>
   logger: Logger