Paginação

async function* paginarTodos(client, path, params = {}) {
  let pagina = 0
  const limite = params.limite || 100

  while (true) {
    const data = await client.fetch(
      `${path}?${new URLSearchParams({ ...params, pagina, limite })}`,
    )

    yield* data.resultados

    const totalProcessado = (pagina + 1) * limite
    if (totalProcessado >= data.totalRegistros) return
    pagina++
  }
}

// Uso — async iterator (memory-efficient)
const pontua = new PontuaClient({ token: process.env.PONTUA_API_TOKEN })
for await (const colaborador of paginarTodos(pontua, '/colaborador', { status: 'ATIVO' })) {
  await processar(colaborador)
}

from typing import Iterator, Dict, Any

def paginar_todos(client, path: str, **params) -> Iterator[Dict[str, Any]]:
    pagina = 0
    limite = params.pop('limite', 100)

    while True:
        data = client.request('GET', path, params={**params, 'pagina': pagina, 'limite': limite})

        yield from data['resultados']

        total_processado = (pagina + 1) * limite
        if total_processado >= data['totalRegistros']:
            return
        pagina += 1

# Uso — generator (memory-efficient)
pontua = PontuaClient()
for colaborador in paginar_todos(pontua, '/colaborador', status='ATIVO'):
    processar(colaborador)

type PaginatedResponse[T any] struct {
    Pagina         int `json:"pagina"`
    Limite         int `json:"limite"`
    TotalRegistros int `json:"totalRegistros"`
    Resultados     []T `json:"resultados"`
}

func PaginarTodos[T any](client *Client, path string, params url.Values) (<-chan T, <-chan error) {
    out := make(chan T)
    errc := make(chan error, 1)

    go func() {
        defer close(out)
        defer close(errc)

        pagina := 0
        limite := 100

        for {
            params.Set("pagina", strconv.Itoa(pagina))
            params.Set("limite", strconv.Itoa(limite))

            var data PaginatedResponse[T]
            req, _ := http.NewRequest("GET", path+"?"+params.Encode(), nil)
            if err := client.Do(req, &data); err != nil {
                errc <- err
                return
            }

            for _, item := range data.Resultados {
                out <- item
            }

            if (pagina+1)*limite >= data.TotalRegistros {
                return
            }
            pagina++
        }
    }()

    return out, errc
}

<?php
function paginarTodos(PontuaClient $client, string $path, array $params = []): Generator {
    $pagina = 0;
    $limite = $params['limite'] ?? 100;

    while (true) {
        $data = $client->request('GET', $path, [
            'query' => array_merge($params, ['pagina' => $pagina, 'limite' => $limite]),
        ]);

        foreach ($data['resultados'] as $item) {
            yield $item;
        }

        $totalProcessado = ($pagina + 1) * $limite;
        if ($totalProcessado >= $data['totalRegistros']) return;
        $pagina++;
    }
}

// Uso — generator (memory-efficient)
$pontua = new PontuaClient();
foreach (paginarTodos($pontua, '/colaborador', ['status' => 'ATIVO']) as $colaborador) {
    processar($colaborador);
}

def paginar_todos(client, path, **params)
  return enum_for(:paginar_todos, client, path, **params) unless block_given?

  pagina = 0
  limite = params.delete(:limite) || 100

  loop do
    data = client.request(:get, path, params: { **params, pagina: pagina, limite: limite })

    data['resultados'].each { |item| yield item }

    total_processado = (pagina + 1) * limite
    break if total_processado >= data['totalRegistros']
    pagina += 1
  end
end

# Uso — Enumerator (lazy)
pontua = PontuaClient.new
paginar_todos(pontua, '/colaborador', status: 'ATIVO').each do |colaborador|
  processar(colaborador)
end