chore(tables): remove extraneous comments

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/hooks/use-table.ts

@@ -31,50 +31,38 @@ interface FetchNextPageResult {
 }
 
 export interface UseTableReturn {
-  /** Table definition (name, schema, metadata, etc.). */
   tableData: TableDefinition | undefined
   isLoadingTable: boolean
-  /** Flattened rows across every fetched page. */
+  /** Flattened across every fetched infinite-query page. */
   rows: TableRow[]
   isLoadingRows: boolean
   refetchRows: () => void
   /**
-   * Fetch the next page of rows. The resolved value's `hasNextPage` reflects
-   * the post-fetch cache state — read from this rather than the parent's
-   * `hasNextPage` state, which only updates on the next React render.
+   * The resolved value's `hasNextPage` reflects the post-fetch cache state —
+   * read from this rather than the hook's `hasNextPage`, which only updates on
+   * the next React render.
    */
   fetchNextPage: () => Promise<FetchNextPageResult>
   hasNextPage: boolean
   isFetchingNextPage: boolean
-  /** Workspace-wide workflow metadata used by header chips and the column sidebar. */
   workflows: WorkflowMetadata[] | undefined
-  /** Stable reference to `tableData?.schema?.columns ?? []`. */
   columns: ColumnDefinition[]
-  /** Stable reference to `tableData?.schema?.workflowGroups ?? []`. */
   tableWorkflowGroups: WorkflowGroup[]
-  /** Pre-fetched live state for every unique workflow id used by the table. */
   workflowStates: Map<string, WorkflowState | null>
-  /** Pre-resolved icon + block-name info per output column name. Headers read
-   *  from this map instead of each subscribing to its own workflow-state query. */
+  /** Headers read from this map instead of each subscribing to its own workflow-state query. */
   columnSourceInfo: Map<string, ColumnSourceInfo>
   /**
-   * Fetches any missing row pages and returns the full flat row list directly
-   * from cache — safe to read immediately without waiting for a React re-render.
-   * Gate bulk ops that must act on the complete row set with this.
+   * Fetches any missing pages then returns the full flat row list from cache.
+   * Safe to read immediately — no React re-render required. Gate bulk ops that
+   * need the complete row set behind this.
    */
   ensureAllRowsLoaded: () => Promise<TableRow[]>
 }
 
 /**
- * Coordinator hook for the table view's data layer. Wraps row/schema/workflow
- * fetching and exposes the derived collections every consumer needs (display
- * columns, source-info map, workflow-name lookup). Mirrors the shape of
- * `use-chat`'s coordinator: one hook returning a typed bundle the surface
- * component destructures.
- *
- * Local interaction state (drag, resize, selection, editing) stays in the
- * `Table` component — moving that here would push every keystroke through a
- * single hook return and re-render the world.
+ * Local interaction state (drag, resize, selection, editing) intentionally
+ * stays in the `Table` component — moving it here would push every keystroke
+ * through this hook's return value and re-render everything.
  */
 export function useTable({ workspaceId, tableId, queryOptions }: UseTableParams): UseTableReturn {
   const queryClient = useQueryClient()
@@ -96,10 +84,8 @@ export function useTable({ workspaceId, tableId, queryOptions }: UseTableParams)
     enabled: Boolean(workspaceId && tableId),
   })
 
-  // Background drain: TanStack's prefetchInfiniteQuery is a no-op when the first page is
-  // already fresh (staleTime not exceeded). Drive the drain through fetchNextPage instead
-  // — it only fetches the *next* page (not from scratch) and fires whenever a full page
-  // is sitting in cache, chaining until getNextPageParam returns undefined.
+  // prefetchInfiniteQuery is a no-op when data is fresh (staleTime not exceeded),
+  // so drive the drain through fetchNextPage — it appends one page at a time.
   useEffect(() => {
     if (!workspaceId || !tableId || !hasNextPage || isFetchingNextPage) return
     void fetchNextPage()
@@ -125,14 +111,11 @@ export function useTable({ workspaceId, tableId, queryOptions }: UseTableParams)
       sort: queryOptions.sort,
     })
 
-    // Drain pages one at a time using the cache as the source of truth.
-    // fetchNextPage appends exactly one new page without re-fetching existing
-    // ones. getQueryData reads the live cache synchronously — bypassing React's
-    // render cycle — so updated pages are visible immediately after each await.
+    // getQueryData bypasses React's render cycle — pages added by fetchNextPage
+    // are visible synchronously after each await without waiting for a re-render.
     while (true) {
       const data = queryClient.getQueryData(opts.queryKey)
       const lastPage = data?.pages[data.pages.length - 1]
-      // A partial (or absent) last page means all available rows are in cache.
       if (!lastPage || lastPage.rows.length < TABLE_LIMITS.MAX_QUERY_LIMIT) break
       const result = await fetchNextPage()
       if (result.status === 'error') {

apps/sim/hooks/queries/tables.ts

@@ -252,7 +252,6 @@ export function tableRowsParamsKey({
   return JSON.stringify({ pageSize, filter: filter ?? null, sort: sort ?? null })
 }
 
-/** `infiniteQueryOptions` factory shared by the hook and imperative drain calls to target the same cache key. */
 export function tableRowsInfiniteOptions({
   workspaceId,
   tableId,

apps/sim/hooks/use-table-undo.ts

@@ -1,7 +1,3 @@
-/**
- * Hook that connects the table undo/redo store to React Query mutations.
- */
-
 import { useCallback, useEffect, useRef } from 'react'
 import { createLogger } from '@sim/logger'
 import { TABLE_LIMITS } from '@/lib/table/constants'
@@ -23,9 +19,6 @@ import type { TableUndoAction } from '@/stores/table/types'
 
 const logger = createLogger('useTableUndo')
 
-/**
- * Extract the row ID from a create-row API response.
- */
 export function extractCreatedRowId(response: Record<string, unknown>): string | undefined {
   const data = response?.data as Record<string, unknown> | undefined
   const row = data?.row as Record<string, unknown> | undefined