API pagination response contract (page info)

import { Connection, Edge, Keyset, encodeCursor } from "./contract";

export interface PaginationQuery {
  first: number;
  after: Keyset | null;
}

export function buildConnection<T>(
  rows: T[],
  query: PaginationQuery,
  toKeyset: (row: T) => Keyset
): Connection<T> {
  const hasNextPage = rows.length > query.first;
  const page = hasNextPage ? rows.slice(0, query.first) : rows;

  const edges: Edge<T>[] = page.map((node) => ({
    node,
    cursor: encodeCursor(toKeyset(node)),
  }));

  return {
    edges,
    pageInfo: {
      hasNextPage,
      hasPreviousPage: query.after !== null,
      startCursor: edges.length ? edges[0].cursor : null,
      endCursor: edges.length ? edges[edges.length - 1].cursor : null,
    },
  };
}

import { Pool } from "pg";
import { Keyset } from "./contract";

export interface Article {
  id: string;
  title: string;
  createdAt: string;
}

export class ArticleRepository {
  constructor(private readonly pool: Pool) {}

  async fetchPage(limit: number, after: Keyset | null): Promise<Article[]> {
    const params: unknown[] = [];
    let where = "";

    if (after) {
      params.push(after.createdAt, after.id);
      where = "WHERE (created_at, id) < ($1, $2)";
    }

    params.push(limit);
    const { rows } = await this.pool.query(
      `SELECT id, title, created_at AS "createdAt"
         FROM articles
         ${where}
         ORDER BY created_at DESC, id DESC
         LIMIT $${params.length}`,
      params
    );

    return rows as Article[];
  }
}

import { Router, Request, Response } from "express";
import { ArticleRepository, Article } from "./repository";
import { buildConnection } from "./buildConnection";
import { decodeCursor, Keyset } from "./contract";

const MAX_PAGE_SIZE = 100;
const DEFAULT_PAGE_SIZE = 20;

export function articlesRouter(repo: ArticleRepository): Router {
  const router = Router();

  router.get("/articles", async (req: Request, res: Response) => {
    const requested = Number.parseInt(String(req.query.first ?? ""), 10);
    const first = Number.isFinite(requested)
      ? Math.min(Math.max(requested, 1), MAX_PAGE_SIZE)
      : DEFAULT_PAGE_SIZE;

    let after: Keyset | null = null;
    if (typeof req.query.after === "string" && req.query.after.length) {
      try {
        after = decodeCursor(req.query.after);
      } catch {
        return res.status(400).json({ error: "invalid cursor" });
      }
    }

    const rows = await repo.fetchPage(first + 1, after);
    const connection = buildConnection<Article>(rows, { first, after }, (a) => ({
      createdAt: a.createdAt,
      id: a.id,
    }));

    return res.json(connection);
  });

  return router;
}