Paginação, filtros e ordenação

import { Pool } from "pg";

const pool = new Pool({ connectionString: process.env.DATABASE_URL });

type Cursor = { criadoEm: string; id: string };

// Cursor opaco: o cliente devolve sem interpretar
const codificar = (c: Cursor) => Buffer.from(JSON.stringify(c)).toString("base64url");
const decodificar = (texto: string): Cursor => JSON.parse(Buffer.from(texto, "base64url").toString());

export async function listarPedidos(limiteSolicitado = 20, cursor?: string) {
  const limite = Math.min(Math.max(limiteSolicitado, 1), 100);
  const apos = cursor ? decodificar(cursor) : null;

  // criado_em::text preserva os microssegundos; o Date do JavaScript não
  const { rows } = await pool.query(
    `SELECT id, criado_em::text AS criado_em, total
       FROM pedidos
      WHERE $1::timestamptz IS NULL OR (criado_em, id) < ($1::timestamptz, $2::bigint)
      ORDER BY criado_em DESC, id DESC
      LIMIT $3`,
    [apos?.criadoEm ?? null, apos?.id ?? null, limite + 1],
  );

  const temMais = rows.length > limite;
  const itens = rows.slice(0, limite);
  const ultimo = itens.at(-1);
  return {
    itens,
    proximoCursor: temMais && ultimo
      ? codificar({ criadoEm: ultimo.criado_em, id: String(ultimo.id) })
      : null,
  };
}

import base64
import json

import psycopg


def codificar(cursor: dict) -> str:
    return base64.urlsafe_b64encode(json.dumps(cursor).encode()).decode()


def decodificar(texto: str) -> dict:
    return json.loads(base64.urlsafe_b64decode(texto))


def listar_pedidos(conexao: psycopg.Connection, limite: int = 20, cursor: str | None = None) -> dict:
    limite = min(max(limite, 1), 100)
    apos = decodificar(cursor) if cursor else {"criadoEm": None, "id": None}

    linhas = conexao.execute(
        """SELECT id, criado_em::text, total
             FROM pedidos
            WHERE %(c)s::timestamptz IS NULL
               OR (criado_em, id) < (%(c)s::timestamptz, %(i)s::bigint)
            ORDER BY criado_em DESC, id DESC
            LIMIT %(l)s""",
        {"c": apos["criadoEm"], "i": apos["id"], "l": limite + 1},
    ).fetchall()

    tem_mais = len(linhas) > limite
    itens = linhas[:limite]
    proximo = codificar({"criadoEm": itens[-1][1], "id": itens[-1][0]}) if tem_mais else None
    return {
        "itens": [{"id": str(i), "criadoEm": c, "total": t} for i, c, t in itens],
        "proximoCursor": proximo,
    }

package pedidos

import (
	"context"
	"database/sql"
	"encoding/base64"
	"encoding/json"
)

type Cursor struct {
	CriadoEm string `json:"criadoEm"`
	ID       int64  `json:"id"`
}

type Pedido struct {
	ID       int64  `json:"id"`
	CriadoEm string `json:"criadoEm"`
	Total    int    `json:"total"`
}

func codificar(c Cursor) string {
	dados, _ := json.Marshal(c)
	return base64.RawURLEncoding.EncodeToString(dados)
}

func decodificar(texto string) (*Cursor, error) {
	dados, err := base64.RawURLEncoding.DecodeString(texto)
	if err != nil {
		return nil, err
	}
	var c Cursor
	return &c, json.Unmarshal(dados, &c)
}

func ListarPedidos(ctx context.Context, db *sql.DB, limite int, cursor string) ([]Pedido, string, error) {
	limite = min(max(limite, 1), 100)
	var criadoEm, id any // nulos na primeira página
	if cursor != "" {
		c, err := decodificar(cursor)
		if err != nil {
			return nil, "", err // cursor inválido: responda 400
		}
		criadoEm, id = c.CriadoEm, c.ID
	}

	linhas, err := db.QueryContext(ctx,
		`SELECT id, criado_em::text, total
		   FROM pedidos
		  WHERE $1::timestamptz IS NULL OR (criado_em, id) < ($1::timestamptz, $2::bigint)
		  ORDER BY criado_em DESC, id DESC
		  LIMIT $3`,
		criadoEm, id, limite+1)
	if err != nil {
		return nil, "", err
	}
	defer linhas.Close()

	var itens []Pedido
	for linhas.Next() {
		var p Pedido
		if err := linhas.Scan(&p.ID, &p.CriadoEm, &p.Total); err != nil {
			return nil, "", err
		}
		itens = append(itens, p)
	}

	proximo := ""
	if len(itens) > limite {
		itens = itens[:limite]
		ultimo := itens[len(itens)-1]
		proximo = codificar(Cursor{CriadoEm: ultimo.CriadoEm, ID: ultimo.ID})
	}
	return itens, proximo, linhas.Err()
}

import java.nio.charset.StandardCharsets;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Types;
import java.util.ArrayList;
import java.util.Base64;
import java.util.List;

public class ListaDePedidos {
    public record Pedido(long id, String criadoEm, int total) {}
    public record Pagina(List<Pedido> itens, String proximoCursor) {}

    // Cursor opaco: "criadoEm|id" em base64
    static String codificar(String criadoEm, long id) {
        var texto = criadoEm + "|" + id;
        return Base64.getUrlEncoder().withoutPadding().encodeToString(texto.getBytes(StandardCharsets.UTF_8));
    }

    public static Pagina listar(Connection conexao, int limiteSolicitado, String cursor) throws SQLException {
        int limite = Math.min(Math.max(limiteSolicitado, 1), 100);
        String criadoEm = null;
        Long id = null;
        if (cursor != null) {
            var partes = new String(Base64.getUrlDecoder().decode(cursor), StandardCharsets.UTF_8).split("\\|");
            criadoEm = partes[0];
            id = Long.parseLong(partes[1]);
        }

        var sql = """
            SELECT id, criado_em::text, total
              FROM pedidos
             WHERE ?::timestamptz IS NULL OR (criado_em, id) < (?::timestamptz, ?::bigint)
             ORDER BY criado_em DESC, id DESC
             LIMIT ?""";
        try (var consulta = conexao.prepareStatement(sql)) {
            consulta.setString(1, criadoEm);
            consulta.setString(2, criadoEm);
            if (id == null) consulta.setNull(3, Types.BIGINT); else consulta.setLong(3, id);
            consulta.setInt(4, limite + 1);

            var itens = new ArrayList<Pedido>();
            try (var linhas = consulta.executeQuery()) {
                while (linhas.next()) {
                    itens.add(new Pedido(linhas.getLong(1), linhas.getString(2), linhas.getInt(3)));
                }
            }
            if (itens.size() <= limite) return new Pagina(itens, null);
            var pagina = itens.subList(0, limite);
            var ultimo = pagina.get(limite - 1);
            return new Pagina(pagina, codificar(ultimo.criadoEm(), ultimo.id()));
        }
    }
}

using System.Text;
using System.Text.Json;
using Npgsql;

public record Pedido(long Id, string CriadoEm, int Total);
public record Pagina(List<Pedido> Itens, string? ProximoCursor);
record Cursor(string CriadoEm, long Id);

public class ListaDePedidos(NpgsqlDataSource dados)
{
    static string Codificar(Cursor c) =>
        Convert.ToBase64String(JsonSerializer.SerializeToUtf8Bytes(c)).TrimEnd('=').Replace('+', '-').Replace('/', '_');

    static Cursor Decodificar(string texto)
    {
        var base64 = texto.Replace('-', '+').Replace('_', '/');
        base64 = base64.PadRight(base64.Length + (4 - base64.Length % 4) % 4, '=');
        return JsonSerializer.Deserialize<Cursor>(Convert.FromBase64String(base64))!;
    }

    public async Task<Pagina> Listar(int limiteSolicitado = 20, string? cursor = null)
    {
        var limite = Math.Clamp(limiteSolicitado, 1, 100);
        var apos = cursor is null ? null : Decodificar(cursor);

        await using var comando = dados.CreateCommand("""
            SELECT id, criado_em::text, total
              FROM pedidos
             WHERE $1::timestamptz IS NULL OR (criado_em, id) < ($1::timestamptz, $2::bigint)
             ORDER BY criado_em DESC, id DESC
             LIMIT $3
            """);
        comando.Parameters.Add(new() { Value = (object?)apos?.CriadoEm ?? DBNull.Value, NpgsqlDbType = NpgsqlTypes.NpgsqlDbType.Text });
        comando.Parameters.Add(new() { Value = (object?)apos?.Id ?? DBNull.Value, NpgsqlDbType = NpgsqlTypes.NpgsqlDbType.Bigint });
        comando.Parameters.Add(new() { Value = limite + 1 });

        var itens = new List<Pedido>();
        await using var linhas = await comando.ExecuteReaderAsync();
        while (await linhas.ReadAsync())
            itens.Add(new Pedido(linhas.GetInt64(0), linhas.GetString(1), linhas.GetInt32(2)));

        if (itens.Count <= limite) return new Pagina(itens, null);
        itens.RemoveAt(limite);
        var ultimo = itens[^1];
        return new Pagina(itens, Codificar(new Cursor(ultimo.CriadoEm, ultimo.Id)));
    }
}