Those Apollo types... Ugh...

letEmFetch.ts

type fetchMoar<Data> =
  ({ variables: { query, page, pageSize } }:
    { variables: { query: string | null, page: number, pageSize: number } }) =>
    Promise<{ error?: ApolloError, data: Data }>

type PaginationParams = {
  query: string | null,
  page?: number,
  pageSize?: number
}

const letEmFetch = async <Data, Field>(
  fn: fetchMoar<Data>,
  accessData: (data: Data) => Field[],
  { query, pageSize = 100, page = 1 }: PaginationParams)
  : Promise<Field[]> => {

  const { error, data } = await fn({ variables: { query, page, pageSize } });

  if (error) {
    throw error;
  }
    
  // Could do even more stuff here

  return accessData(data);
}

// With letEmFetch
export const useElegantFetchMoreMeasurements = (pageSize: number = 5) => {
  const { fetchMore } = useGetMeasurementOptionsQuery({
    skip: true
  });

  const fetchMoreMeasurements = (query: string | null) =>
    letEmFetch(fetchMore, (data) => data.measurements.items, { query, pageSize });

  return fetchMoreMeasurements;
}


// Without letEmFetch
export const useNewButOldFetchMoreMeasurements = (pageSize: number = 5) => {

  const { fetchMore } = useGetMeasurementOptionsQuery({
    variables: { page: 1, pageSize: pageSize },
    skip: true
  });

  const fetchMoreMeasuremunts = async (query: string | null): Promise<MeasurementOption[]> => {
    const queryResult = await fetchMore({
      variables: {
        query: query,
      }
    })

    if (queryResult.error) {
      throw queryResult.error;
    }

    return queryResult.data.measurements.items;
  }

  return fetchMoreMeasuremunts;

}