@canopy-iiif/app 1.10.5 → 1.10.6

package/lib/build/build.js

@@ -174,9 +174,13 @@ async function build(options = {}) {
     } catch (_) {}
     if (!skipIiif && hasIiifSources && currentManifestIds.length) {
       try {
+        const featuredKeepIds = Array.isArray(CONFIG?.featured)
+          ? CONFIG.featured
+          : [];
         await iiif.cleanupIiifCache({
           allowedManifestIds: currentManifestIds,
           allowedCollectionIds: currentCollectionIds,
+          keepManifestIds: featuredKeepIds,
         });
       } catch (_) {}
     }

package/lib/build/iiif.js

@@ -82,6 +82,7 @@ const IIIF_CACHE_INDEX_MANIFESTS = path.join(
 const DEFAULT_THUMBNAIL_SIZE = 400;
 const DEFAULT_CHUNK_SIZE = 10;
 const DEFAULT_FETCH_CONCURRENCY = 1;
+const DEFAULT_FEATURED_FETCH_TIMEOUT_MS = 15000;
 const HERO_THUMBNAIL_SIZE = 800;
 const HERO_IMAGE_SIZES_ATTR = "(min-width: 1024px) 1280px, 100vw";
 const OG_IMAGE_WIDTH = 1200;
@@ -873,13 +874,27 @@ function extractCollectionEntries(collection) {
 }
 
 async function readJsonFromUri(uri, options = {log: false}) {
+  const opts = options && typeof options === "object" ? options : {};
+  const shouldLog = Boolean(opts.log);
+  const fetchSignal = opts.signal;
   try {
     if (/^https?:\/\//i.test(uri)) {
       if (typeof fetch !== "function") return null;
-      const res = await fetch(uri, {
-        headers: {Accept: "application/json"},
-      }).catch(() => null);
-      if (options && options.log) {
+      let res = null;
+      try {
+        const fetchOptions = {headers: {Accept: "application/json"}};
+        if (fetchSignal) fetchOptions.signal = fetchSignal;
+        res = await fetch(uri, fetchOptions);
+      } catch (error) {
+        if (shouldLog) {
+          try {
+            const code = error && error.name === "AbortError" ? "ABORT" : "ERR";
+            logLine(`⊘ ${String(uri)} → ${code}`, "red", {bright: true});
+          } catch (_) {}
+        }
+        return null;
+      }
+      if (shouldLog) {
         try {
           if (res && res.ok) {
             logLine(`↓ ${String(uri)} → ${res.status}`, "yellow", {
@@ -1235,14 +1250,53 @@ async function ensureFeaturedInCache(cfg) {
     if (!featured.length) return;
     const {size: thumbSize, unsafe: unsafeThumbs} =
       resolveThumbnailPreferences();
+    const fetchTimeoutMs = resolvePositiveInteger(
+      process.env.CANOPY_FEATURED_FETCH_TIMEOUT_MS,
+      DEFAULT_FEATURED_FETCH_TIMEOUT_MS,
+      {allowZero: true},
+    );
+    const canAbortFetches =
+      typeof AbortController === "function" && Number(fetchTimeoutMs) > 0;
     for (const rawId of featured) {
       const id = normalizeIiifId(String(rawId || ""));
       if (!id) continue;
       let manifest = await loadCachedManifestById(id);
       if (!manifest) {
-        const m = await readJsonFromUri(id).catch(() => null);
-        if (!m) continue;
-        const upgraded = await upgradeIiifResource(m);
+        let controller = null;
+        let timeoutId = null;
+        let fetched = null;
+        try {
+          if (canAbortFetches) {
+            controller = new AbortController();
+            timeoutId = setTimeout(
+              () => controller.abort(),
+              Math.max(1, fetchTimeoutMs),
+            );
+          }
+          fetched = await readJsonFromUri(id, {
+            log: true,
+            signal: controller ? controller.signal : undefined,
+          });
+        } catch (_) {
+          fetched = null;
+        } finally {
+          if (timeoutId) clearTimeout(timeoutId);
+        }
+        if (!fetched) {
+          if (controller && controller.signal && controller.signal.aborted) {
+            try {
+              logLine(
+                `[iiif] Featured manifest timed out after ${formatDurationMs(
+                  fetchTimeoutMs,
+                )}: ${id}`,
+                "red",
+                {dim: true},
+              );
+            } catch (_) {}
+          }
+          continue;
+        }
+        const upgraded = await upgradeIiifResource(fetched);
         if (!upgraded || !upgraded.id) continue;
         manifest = (await saveCachedManifest(upgraded, id, "")) || upgraded;
         manifest = (await loadCachedManifestById(id)) || manifest;
@@ -1522,11 +1576,18 @@ async function cleanupIiifCache(options = {}) {
   const allowedCollectionIds = Array.isArray(options.allowedCollectionIds)
     ? options.allowedCollectionIds
     : [];
+  const keepManifestIds = Array.isArray(options.keepManifestIds)
+    ? options.keepManifestIds
+    : [];
   const manifestSet = new Set(
     allowedManifestIds
       .map((id) => normalizeIiifId(String(id || "")))
       .filter(Boolean),
   );
+  for (const keepId of keepManifestIds) {
+    const normalized = normalizeIiifId(String(keepId || ""));
+    if (normalized) manifestSet.add(normalized);
+  }
   const collectionSet = new Set(
     allowedCollectionIds
       .map((id) => normalizeIiifId(String(id || "")))

package/lib/components/featured.js

@@ -4,6 +4,9 @@ const yaml = require('js-yaml');
 const { rootRelativeHref } = require('../common');
 const { resolveCanopyConfigPath } = require('../config-path');
 
+const IIIF_MANIFESTS_DIR = path.resolve('.cache/iiif/manifests');
+const SLUG_MEMO = new Map();
+
 function firstLabelString(label) {
   if (!label) return 'Untitled';
   if (typeof label === 'string') return label;
@@ -67,12 +70,11 @@ function readJson(p) {
 
 function findSlugByIdFromDiskSync(nid) {
   try {
-    const dir = path.resolve('.cache/iiif/manifests');
-    if (!fs.existsSync(dir)) return null;
-    const names = fs.readdirSync(dir);
+    if (!fs.existsSync(IIIF_MANIFESTS_DIR)) return null;
+    const names = fs.readdirSync(IIIF_MANIFESTS_DIR);
     for (const name of names) {
       if (!name || !name.toLowerCase().endsWith('.json')) continue;
-      const fp = path.join(dir, name);
+      const fp = path.join(IIIF_MANIFESTS_DIR, name);
       try {
         const obj = readJson(fp);
         const mid = normalizeIiifId(String((obj && (obj.id || obj['@id'])) || ''));
@@ -83,6 +85,75 @@ function findSlugByIdFromDiskSync(nid) {
   return null;
 }
 
+function manifestPathFromSlug(slug) {
+  try {
+    const normalized = String(slug || '').trim();
+    if (!normalized || /[\\/]/.test(normalized)) return '';
+    return path.resolve(IIIF_MANIFESTS_DIR, `${normalized}.json`);
+  } catch (_) {
+    return '';
+  }
+}
+
+function manifestExistsForSlug(slug) {
+  const fp = manifestPathFromSlug(slug);
+  if (!fp) return false;
+  try {
+    return fs.existsSync(fp);
+  } catch (_) {
+    return false;
+  }
+}
+
+function readManifestBySlug(slug) {
+  const fp = manifestPathFromSlug(slug);
+  if (!fp) return null;
+  return readJson(fp);
+}
+
+function resolveSlugForFeaturedEntry(rawId, byId) {
+  if (rawId == null) return null;
+  const rawValue = String(rawId).trim();
+  if (!rawValue) return null;
+  if (!/^https?:\/\//i.test(rawValue) && manifestExistsForSlug(rawValue)) {
+    const entry = Array.isArray(byId)
+      ? byId.find((candidate) => candidate && candidate.slug === rawValue)
+      : null;
+    return {slug: rawValue, entry};
+  }
+  const normalizedId = normalizeIiifId(rawValue);
+  if (!normalizedId) return null;
+  const memoSlug = SLUG_MEMO.get(normalizedId);
+  if (memoSlug && manifestExistsForSlug(memoSlug)) {
+    const memoEntry = Array.isArray(byId)
+      ? byId.find((candidate) => candidate && candidate.slug === memoSlug)
+      : null;
+    return {slug: memoSlug, entry: memoEntry};
+  }
+  const entry = byId.find(
+    (candidate) =>
+      candidate && candidate.type === 'Manifest' && equalIiifId(candidate.id, normalizedId)
+  );
+  if (entry && entry.slug && manifestExistsForSlug(entry.slug)) {
+    SLUG_MEMO.set(normalizedId, entry.slug);
+    return {slug: entry.slug, entry};
+  }
+  const fallbackSlug = findSlugByIdFromDiskSync(normalizedId);
+  if (fallbackSlug && manifestExistsForSlug(fallbackSlug)) {
+    SLUG_MEMO.set(normalizedId, fallbackSlug);
+    const fallbackEntry = Array.isArray(byId)
+      ? byId.find(
+          (candidate) =>
+            candidate &&
+            candidate.type === 'Manifest' &&
+            (candidate.slug === fallbackSlug || equalIiifId(candidate.id, normalizedId))
+        )
+      : null;
+    return {slug: fallbackSlug, entry: fallbackEntry};
+  }
+  return null;
+}
+
 function readFeaturedFromCacheSync() {
   try {
     const debug = !!process.env.CANOPY_DEBUG_FEATURED;
@@ -93,13 +164,13 @@ function readFeaturedFromCacheSync() {
     const byId = Array.isArray(idx && idx.byId) ? idx.byId : [];
     const out = [];
     for (const id of featured) {
-      const nid = normalizeIiifId(id);
       if (debug) { try { console.log('[featured] id:', id); } catch (_) {} }
-      const entry = byId.find((e) => e && e.type === 'Manifest' && equalIiifId(e.id, nid));
-      const slug = entry && entry.slug ? String(entry.slug) : findSlugByIdFromDiskSync(nid);
+      const resolved = resolveSlugForFeaturedEntry(id, byId);
+      const slug = resolved && resolved.slug ? resolved.slug : '';
+      const entry = resolved && resolved.entry ? resolved.entry : null;
       if (debug) { try { console.log('[featured]  - slug:', slug || '(none)'); } catch (_) {} }
       if (!slug) continue;
-      const m = readJson(path.resolve('.cache/iiif/manifests', slug + '.json'));
+      const m = readManifestBySlug(slug);
       if (!m) continue;
       const rec = {
         title: firstLabelString(m && m.label),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canopy-iiif/app",
-  "version": "1.10.5",
+  "version": "1.10.6",
   "private": false,
   "license": "MIT",
   "author": "Mat Jordan <mat@northwestern.edu>",