Design a Pastebin

// Two column lists, because this table carries the body of small pastes.
// The single-paste read needs inline_body; a listing must never select it,
// and `SELECT *` would pull it into every row of every listing query.
// (inline_body is capped at INLINE_LIMIT, 4 KB - anything larger lives in
// object storage, so the column itself is never multi-megabyte.)
const READ_COLS =
  "id, owner_id, syntax, size_bytes, inline_body, storage_key, expires_at";
const LIST_COLS =
  "id, owner_id, syntax, size_bytes, storage_key, expires_at";

async function readPaste(id) {
  const row = await db.oneOrNone(
    `SELECT ${READ_COLS} FROM pastes WHERE id = $1`, [id]
  );
  if (!row) throw new HttpError(404, "not found");

  // Expiry is enforced here, not by the cleanup job. The job may not have run.
  if (row.expires_at && row.expires_at <= new Date()) {
    throw new HttpError(404, "not found");
  }

  if (row.inline_body !== null) {
    return { ...row, body: row.inline_body };  // spread; same as
                                               // Object.assign({}, row, {...})
  }

  // Large bodies are not proxied through the app tier at all: hand the client
  // a short-lived signed URL and let object storage or the CDN send the bytes.
  const url = await getSignedUrl(
    s3,
    new GetObjectCommand({ Bucket: "pastes-prod", Key: row.storage_key }),
    { expiresIn: 300 }
  );
  return { ...row, bodyUrl: url };
}

// "My pastes" and anything else that returns many rows uses LIST_COLS, so a
// listing's cost does not depend on how big the pastes are. Expiry is applied
// here too, for the same reason as above.
async function listPastes(ownerId, limit = 50) {
  return db.manyOrNone(
    `SELECT ${LIST_COLS} FROM pastes
      WHERE owner_id = $1 AND (expires_at IS NULL OR expires_at > now())
      ORDER BY created_at DESC
      LIMIT $2`,
    [ownerId, limit]
  );
}

// Layer 1: a bucket lifecycle rule, applied once per prefix. Evaluated about
// once a day, so it is cost control, not a correctness mechanism.
const lifecycle = {
  Bucket: "pastes-prod",
  LifecycleConfiguration: {
    Rules: [{
      ID: "expire-ephemeral-pastes",
      Status: "Enabled",
      Filter: { Prefix: "pastes/ephemeral/" },
      Expiration: { Days: 30 },
    }],
  },
};

// Layer 2: a batch job for everything with an explicit expires_at. Deletes in
// bounded chunks so one long-running statement cannot lock the table.
async function reapExpired(limit = 1000) {
  const rows = await db.manyOrNone(
    `DELETE FROM pastes
      WHERE id IN (
        SELECT id FROM pastes
         WHERE expires_at IS NOT NULL AND expires_at <= now()
         ORDER BY expires_at
         LIMIT $1
      )
      RETURNING id, storage_key`,
    [limit]
  );

  const keys = rows.map(r => r.storage_key).filter(Boolean);
  // DeleteObjects takes at most 1000 keys per call.
  for (let i = 0; i < keys.length; i += 1000) {
    await s3.send(new DeleteObjectsCommand({
      Bucket: "pastes-prod",
      Delete: { Objects: keys.slice(i, i + 1000).map(Key => ({ Key })) },
    }));
  }
  return rows.length;
}

import { createHash } from "node:crypto";

const RENDERER_VERSION = "hl-3";  // bump this and every URL changes

function variantKey(body, syntax) {
  const digest = createHash("sha256").update(body).digest("hex").slice(0, 16);
  // Content-addressed: identical pastes share one rendered object.
  return `render/${RENDERER_VERSION}/${syntax}/${digest}.html`;
}

async function highlightedUrl(paste) {
  const key = variantKey(paste.body, paste.syntax);
  if (!(await objectExists("pastes-prod", key))) {
    const html = highlight(paste.body, { language: paste.syntax });
    await s3.send(new PutObjectCommand({
      Bucket: "pastes-prod",
      Key: key,
      Body: html,
      ContentType: "text/html; charset=utf-8",
      // Safe because the key changes whenever the bytes or renderer change,
      // so this object never needs a CDN purge.
      CacheControl: "public, max-age=31536000, immutable",
    }));
  }
  return `https://cdn.example.com/${key}`;
}