Moodboard & collection builder

const base = process.env.EPOCHAL_API_BASE ?? "https://epochalstock.com/api/v1";
const apiKey = process.env.EPOCHAL_API_KEY;

/** @param {string[]} pinIds from your DB */
async function hydratePins(pinIds) {
  const unique = [...new Set(pinIds)];
  const images = [];
  let requested = 0;
  let found = 0;

  for (let i = 0; i < unique.length; i += 100) {
    const ids = unique.slice(i, i + 100);
    const res = await fetch(\`${base}/images/batch\`, {
      method: "POST",
      headers: {
        Authorization: \`Bearer ${apiKey}\`,
        "Content-Type": "application/json",
        Accept: "application/json",
      },
      body: JSON.stringify({ ids }),
    });
    if (res.status === 429) {
      const wait = Number(res.headers.get("Retry-After") || "2");
      await new Promise((r) => setTimeout(r, wait * 1000));
      i -= 100;
      continue;
    }
    if (!res.ok) throw new Error(await res.text());
    const { data } = await res.json();
    images.push(...data.images);
    requested += data.requested;
    found += data.found;
  }

  const byId = new Map(images.map((img) => [img.id, img]));
  return {
    requested,
    found,
    cards: unique.map((id) => ({
      imageId: id,
      catalog: byId.get(id) ?? null, // null → show unavailable placeholder
    })),
  };
}

// Example route: GET /api/boards/:boardId
// 1) assert membership
// 2) const pinIds = await db.listPinIds(boardId)
// 3) return { pins: await hydratePins(pinIds) }

<?php
declare(strict_types=1);

function epochal_batch(string $base, string $apiKey, array $ids): array
{
    $ch = curl_init(rtrim($base, '/') . '/images/batch');
    curl_setopt_array($ch, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_POST => true,
        CURLOPT_HTTPHEADER => [
            'Authorization: Bearer ' . $apiKey,
            'Content-Type: application/json',
            'Accept: application/json',
        ],
        CURLOPT_POSTFIELDS => json_encode(['ids' => array_values($ids)], JSON_THROW_ON_ERROR),
        CURLOPT_TIMEOUT => 20,
    ]);
    $raw = curl_exec($ch);
    $status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    if ($status === 429) {
        sleep(2);
        return epochal_batch($base, $apiKey, $ids);
    }
    if ($status !== 200) {
        throw new RuntimeException((string) $raw);
    }
    return json_decode((string) $raw, true, 512, JSON_THROW_ON_ERROR)['data'];
}

/**
 * @param list<string> $pinIds
 * @return list<array{imageId: string, catalog: ?array}>
 */
function hydrate_pins(array $pinIds): array
{
    $base = getenv('EPOCHAL_API_BASE') ?: 'https://epochalstock.com/api/v1';
    $apiKey = getenv('EPOCHAL_API_KEY') ?: '';
    $unique = array_values(array_unique($pinIds));
    $images = [];

    foreach (array_chunk($unique, 100) as $chunk) {
        $data = epochal_batch($base, $apiKey, $chunk);
        foreach ($data['images'] as $img) {
            $images[$img['id']] = $img;
        }
    }

    $cards = [];
    foreach ($unique as $id) {
        $cards[] = [
            'imageId' => $id,
            'catalog' => $images[$id] ?? null,
        ];
    }
    return $cards;
}

import os
from typing import Any

import requests

BASE = os.environ.get("EPOCHAL_API_BASE", "https://epochalstock.com/api/v1").rstrip("/")
API_KEY = os.environ["EPOCHAL_API_KEY"]


def hydrate_pins(pin_ids: list[str]) -> list[dict[str, Any]]:
    unique = list(dict.fromkeys(pin_ids))  # stable dedupe
    by_id: dict[str, dict] = {}

    for i in range(0, len(unique), 100):
        chunk = unique[i : i + 100]
        r = requests.post(
            f"{BASE}/images/batch",
            json={"ids": chunk},
            headers={
                "Authorization": f"Bearer {API_KEY}",
                "Accept": "application/json",
            },
            timeout=20,
        )
        if r.status_code == 429:
            import time

            time.sleep(float(r.headers.get("Retry-After", "2")))
            # simple retry of same chunk
            r = requests.post(
                f"{BASE}/images/batch",
                json={"ids": chunk},
                headers={
                    "Authorization": f"Bearer {API_KEY}",
                    "Accept": "application/json",
                },
                timeout=20,
            )
        r.raise_for_status()
        for img in r.json()["data"]["images"]:
            by_id[img["id"]] = img

    return [
        {"imageId": i, "catalog": by_id.get(i)}  # None → unavailable
        for i in unique
    ]

// POST /api/boards/:boardId/pins  { "imageId": "es_001_example", "note": "hero option" }
app.post("/api/boards/:boardId/pins", async (req, res) => {
  await assertCanEdit(req.user, req.params.boardId);
  const imageId = String(req.body.imageId || "");
  if (!imageId) return res.status(400).json({ error: "imageId_required" });

  // Optional: verify still exists (1 rate unit)
  const check = await fetch(
    \`${base}/images/${encodeURIComponent(imageId)}\`,
    { headers: { Authorization: \`Bearer ${apiKey}\`, Accept: "application/json" } }
  );
  if (check.status === 404) return res.status(404).json({ error: "image_not_found" });
  if (!check.ok) return res.status(502).json({ error: "catalog_error" });

  await db.insertPin({
    boardId: req.params.boardId,
    imageId,
    note: String(req.body.note || "").slice(0, 500),
    addedBy: req.user.id,
  });
  res.status(201).json({ ok: true });
});

// Pseudocode: pin after optional detail check
$imageId = (string) ($body['imageId'] ?? '');
// ... ACL on $boardId ...
$ch = curl_init(rtrim($base, '/') . '/images/' . rawurlencode($imageId));
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer ' . $apiKey,
        'Accept: application/json',
    ],
]);
curl_exec($ch);
$status = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);
if ($status === 404) {
    http_response_code(404);
    exit;
}
// INSERT INTO board_pins (board_id, image_id, note, added_by) VALUES (...)

# FastAPI: pin image_id into YOUR database only
@app.post("/api/boards/{board_id}/pins")
async def add_pin(board_id: str, image_id: str, note: str = ""):
    await assert_can_edit(board_id)
    async with httpx.AsyncClient(timeout=20.0) as client:
        r = await client.get(
            f"{BASE}/images/{image_id}",
            headers={"Authorization": f"Bearer {API_KEY}", "Accept": "application/json"},
        )
    if r.status_code == 404:
        raise HTTPException(404, "image_not_found")
    if r.status_code != 200:
        raise HTTPException(502, "catalog_error")
    await db.insert_pin(board_id, image_id, note[:500])
    return {"ok": True}