Function reconcileCreatedRow

apps/sim/hooks/queries/tables.ts:748–824

* Splice a server-returned new row into the paginated row cache. Bumps the * `position` of any cached row at or past the new row's position, then inserts * the row into the overlapping page (or appends to the last page when the * position lies past everything fetched). * * Scoped to the default

(
  queryClient: ReturnType<typeof useQueryClient>,
  tableId: string,
  row: TableRow
)

 * or column sort. Filtered/sorted queries are refetched by the caller.
 */
function reconcileCreatedRow(
  queryClient: ReturnType<typeof useQueryClient>,
  tableId: string,
  row: TableRow
) {
  queryClient.setQueriesData<InfiniteData<TableRowsResponse, TableRowsPageParam>>(
    {
      queryKey: tableKeys.rowsRoot(tableId),
      exact: false,
      predicate: (query) => isDefaultOrderRowsQuery(query.queryKey),
    },
    (old) => {
      if (!old) return old
      if (old.pages.some((p) => p.rows.some((r) => r.id === row.id))) return old

      // Use key-ordering only when the new row AND every cached row have an
      // `orderKey` — then no neighbor bump is needed and order is exact. If any
      // cached row is un-keyed (mid-backfill), fall back to the legacy `position`
      // path so un-keyed rows aren't yanked to the front by an empty-string sort.
      const byKey =
        row.orderKey != null && old.pages.every((p) => p.rows.every((r) => r.orderKey != null))
      // Compare order keys bytewise to match the server's `COLLATE "C"` ordering
      // and the `>=` checks in `fitsAfter` — `localeCompare` is locale-aware and
      // would place the new row in a different slot than the server (e.g. an
      // uppercase-prefixed key), leaving it visibly misordered until next reload.
      const sortRows = (rows: TableRow[]) =>
        byKey
          ? [...rows].sort((a, b) =>
              (a.orderKey as string) < (b.orderKey as string)
                ? -1
                : (a.orderKey as string) > (b.orderKey as string)
                  ? 1
                  : 0
            )
          : [...rows].sort((a, b) => a.position - b.position)
      const fitsAfter = (last: TableRow | undefined) =>
        last === undefined ||
        (byKey
          ? (last.orderKey as string) >= (row.orderKey as string)
          : last.position >= row.position)

      const pages = byKey
        ? old.pages
        : old.pages.map((page) =>
            page.rows.some((r) => r.position >= row.position)
              ? {
                  ...page,
                  rows: page.rows.map((r) =>
                    r.position >= row.position ? { ...r, position: r.position + 1 } : r
                  ),
                }
              : page
          )

      let inserted = false
      const nextPages = pages.map((page) => {
        if (inserted) return page
        if (!fitsAfter(page.rows[page.rows.length - 1])) return page