@seedprotocol/feed 0.4.7

package/dist/index.js

@@ -0,0 +1,1163 @@
+import { client as $, getFeedItemsBySchemaName as _ } from "@seedprotocol/sdk";
+import F from "pluralize";
+import { generateRssFeed as L, generateJsonFeed as z, generateAtomFeed as R } from "feedsmith";
+import { gql as x } from "graphql-request";
+import { createHash as j } from "crypto";
+import { promises as p } from "fs";
+import { join as D } from "path";
+import S from "image-size";
+function k(d) {
+  return `"${j("md5").update(d).digest("hex").substring(0, 16)}"`;
+}
+function B(d, e, t, r) {
+  const n = `${d}-${e}-${t}-${r}`;
+  return k(n);
+}
+function O(d, e, t, r) {
+  const n = `${d}-${e}-${t}-${r}`;
+  return k(n);
+}
+function W(d, e) {
+  const t = (r) => r.replace(/^"|"$/g, "");
+  return t(d) === t(e);
+}
+function H(d) {
+  return d ? d.split(",").map((e) => e.trim()).filter((e) => e.length > 0) : [];
+}
+function G(d, e) {
+  const t = H(d);
+  return t.length === 0 ? !1 : t.includes("*") ? !0 : t.some((r) => W(r, e));
+}
+class X {
+  feedDataCache = /* @__PURE__ */ new Map();
+  feedContentCache = /* @__PURE__ */ new Map();
+  imageMetadataCache = /* @__PURE__ */ new Map();
+  config;
+  refreshLocks = /* @__PURE__ */ new Map();
+  constructor(e) {
+    this.config = e;
+  }
+  /**
+   * Get cached feed data for a schema
+   */
+  getFeedData(e) {
+    const t = this.feedDataCache.get(e);
+    return t ? Math.floor(Date.now() / 1e3) - t.lastUpdated > this.config.ttl ? (this.feedDataCache.delete(e), this.clearContentCache(e), null) : t : null;
+  }
+  /**
+   * Set cached feed data for a schema
+   */
+  setFeedData(e, t) {
+    const r = Math.floor(Date.now() / 1e3);
+    let n = 0, s = "";
+    for (const h of t) {
+      const f = h.timeCreated;
+      f && f > n && (n = f, s = h.id || h.seedUid || h.SeedUid || "");
+    }
+    n === 0 && (n = r);
+    const o = B(e, "data", n, t.length), l = {
+      items: [...t],
+      // Create a copy
+      lastProcessedTimestamp: n,
+      lastProcessedItemId: s,
+      lastUpdated: r,
+      etag: o
+    };
+    this.feedDataCache.set(e, l);
+  }
+  /**
+   * Get cached feed content for a schema and format
+   */
+  getFeedContent(e, t) {
+    const r = `${e}:${t}`, n = this.feedContentCache.get(r);
+    return n ? Math.floor(Date.now() / 1e3) > n.expiresAt ? (this.feedContentCache.delete(r), null) : n : null;
+  }
+  /**
+   * Set cached feed content for a schema and format
+   */
+  setFeedContent(e, t, r, n) {
+    const s = `${e}:${t}`, o = Math.floor(Date.now() / 1e3), l = o + this.config.ttl, h = O(e, t, o, r.length), f = {
+      content: r,
+      contentType: n,
+      etag: h,
+      lastModified: o,
+      expiresAt: l
+    };
+    this.feedContentCache.set(s, f);
+  }
+  /**
+   * Clear feed data cache for a schema
+   */
+  clearFeedData(e) {
+    this.feedDataCache.delete(e);
+  }
+  /**
+   * Clear content cache for a schema (all formats)
+   */
+  clearContentCache(e) {
+    const t = [];
+    for (const r of this.feedContentCache.keys())
+      r.startsWith(`${e}:`) && t.push(r);
+    t.forEach((r) => this.feedContentCache.delete(r));
+  }
+  /**
+   * Get cached image metadata for a transaction ID
+   */
+  getImageMetadata(e) {
+    const t = this.imageMetadataCache.get(e);
+    return t ? Math.floor(Date.now() / 1e3) > t.expiresAt ? (this.imageMetadataCache.delete(e), null) : t.metadata : null;
+  }
+  /**
+   * Set cached image metadata for a transaction ID
+   */
+  setImageMetadata(e, t) {
+    const r = Math.floor(Date.now() / 1e3), n = this.config.imageMetadata?.ttl || 604800, s = r + n, o = {
+      metadata: t,
+      cachedAt: r,
+      expiresAt: s
+    };
+    this.imageMetadataCache.set(e, o);
+  }
+  /**
+   * Clear all caches
+   */
+  clearAll() {
+    this.feedDataCache.clear(), this.feedContentCache.clear(), this.imageMetadataCache.clear();
+  }
+  /**
+   * Get or create a refresh lock for a schema
+   * Prevents concurrent fetches for the same schema
+   */
+  async withRefreshLock(e, t) {
+    const r = this.refreshLocks.get(e);
+    r && (await r, this.getFeedData(e));
+    const n = (async () => {
+      try {
+        return await t();
+      } finally {
+        this.refreshLocks.delete(e);
+      }
+    })();
+    return this.refreshLocks.set(e, n), n;
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(e) {
+    this.config = { ...this.config, ...e };
+  }
+  /**
+   * Get cache statistics
+   */
+  getStats() {
+    return {
+      feedDataCount: this.feedDataCache.size,
+      feedContentCount: this.feedContentCache.size,
+      imageMetadataCount: this.imageMetadataCache.size,
+      activeLocks: this.refreshLocks.size
+    };
+  }
+}
+class J {
+  cacheDir;
+  config;
+  constructor(e) {
+    this.cacheDir = e.cacheDir, this.config = e, this.ensureCacheDir().catch((t) => {
+      console.error("Failed to create cache directory:", t);
+    });
+  }
+  /**
+   * Ensure cache directory exists
+   */
+  async ensureCacheDir() {
+    try {
+      await p.mkdir(this.cacheDir, { recursive: !0 });
+    } catch (e) {
+      if (e.code !== "EEXIST")
+        throw e;
+    }
+  }
+  /**
+   * Get file path for feed data
+   */
+  getFeedDataPath(e) {
+    return D(this.cacheDir, `${e}.json`);
+  }
+  /**
+   * Get file path for feed content
+   */
+  getFeedContentPath(e, t) {
+    return D(this.cacheDir, `${e}-${t}.json`);
+  }
+  /**
+   * Get file path for image metadata
+   */
+  getImageMetadataPath(e) {
+    const t = D(this.cacheDir, "image-metadata");
+    return D(t, `${e}.json`);
+  }
+  /**
+   * Ensure image metadata directory exists
+   */
+  async ensureImageMetadataDir() {
+    try {
+      const e = D(this.cacheDir, "image-metadata");
+      await p.mkdir(e, { recursive: !0 });
+    } catch (e) {
+      if (e.code !== "EEXIST")
+        throw e;
+    }
+  }
+  /**
+   * Get cached feed data for a schema
+   */
+  async getFeedData(e) {
+    try {
+      const t = this.getFeedDataPath(e), r = await p.readFile(t, "utf-8"), n = JSON.parse(r);
+      return Math.floor(Date.now() / 1e3) - n.lastUpdated > this.config.ttl ? (await this.clearFeedData(e), null) : n;
+    } catch (t) {
+      return t.code === "ENOENT" || console.error(`Error reading feed data cache for ${e}:`, t), null;
+    }
+  }
+  /**
+   * Set cached feed data for a schema
+   */
+  async setFeedData(e, t) {
+    try {
+      await this.ensureCacheDir();
+      const r = this.getFeedDataPath(e);
+      await p.writeFile(r, JSON.stringify(t, null, 2), "utf-8");
+    } catch (r) {
+      console.error(`Error writing feed data cache for ${e}:`, r);
+    }
+  }
+  /**
+   * Get cached feed content for a schema and format
+   */
+  async getFeedContent(e, t) {
+    try {
+      const r = this.getFeedContentPath(e, t), n = await p.readFile(r, "utf-8"), s = JSON.parse(n);
+      return Math.floor(Date.now() / 1e3) > s.expiresAt ? (await this.clearFeedContent(e, t), null) : s;
+    } catch (r) {
+      return r.code === "ENOENT" || console.error(
+        `Error reading feed content cache for ${e}:${t}:`,
+        r
+      ), null;
+    }
+  }
+  /**
+   * Set cached feed content for a schema and format
+   */
+  async setFeedContent(e, t, r) {
+    try {
+      await this.ensureCacheDir();
+      const n = this.getFeedContentPath(e, t);
+      await p.writeFile(n, JSON.stringify(r, null, 2), "utf-8");
+    } catch (n) {
+      console.error(
+        `Error writing feed content cache for ${e}:${t}:`,
+        n
+      );
+    }
+  }
+  /**
+   * Clear feed data cache for a schema
+   */
+  async clearFeedData(e) {
+    try {
+      const t = this.getFeedDataPath(e);
+      await p.unlink(t);
+    } catch (t) {
+      t.code !== "ENOENT" && console.error(`Error clearing feed data cache for ${e}:`, t);
+    }
+  }
+  /**
+   * Clear content cache for a schema and format
+   */
+  async clearFeedContent(e, t) {
+    try {
+      const r = this.getFeedContentPath(e, t);
+      await p.unlink(r);
+    } catch (r) {
+      r.code !== "ENOENT" && console.error(
+        `Error clearing feed content cache for ${e}:${t}:`,
+        r
+      );
+    }
+  }
+  /**
+   * Clear all content cache for a schema (all formats)
+   */
+  async clearAllContentCache(e) {
+    try {
+      const t = await p.readdir(this.cacheDir), r = `${e}-`, n = ".json";
+      for (const s of t)
+        s.startsWith(r) && s.endsWith(n) && s !== `${e}.json` && await p.unlink(D(this.cacheDir, s));
+    } catch (t) {
+      console.error(`Error clearing all content cache for ${e}:`, t);
+    }
+  }
+  /**
+   * Get cached image metadata for a transaction ID
+   */
+  async getImageMetadata(e) {
+    try {
+      const t = this.getImageMetadataPath(e), r = await p.readFile(t, "utf-8"), n = JSON.parse(r);
+      return Math.floor(Date.now() / 1e3) > n.expiresAt ? (await this.clearImageMetadata(e), null) : n.metadata;
+    } catch (t) {
+      return t.code === "ENOENT" || console.error(`Error reading image metadata cache for ${e}:`, t), null;
+    }
+  }
+  /**
+   * Set cached image metadata for a transaction ID
+   */
+  async setImageMetadata(e, t) {
+    try {
+      await this.ensureImageMetadataDir();
+      const r = this.getImageMetadataPath(e), n = Math.floor(Date.now() / 1e3), s = this.config.imageMetadata?.ttl || 604800, o = n + s, l = {
+        metadata: t,
+        cachedAt: n,
+        expiresAt: o
+      };
+      await p.writeFile(r, JSON.stringify(l, null, 2), "utf-8");
+    } catch (r) {
+      console.error(`Error writing image metadata cache for ${e}:`, r);
+    }
+  }
+  /**
+   * Clear image metadata cache for a transaction ID
+   */
+  async clearImageMetadata(e) {
+    try {
+      const t = this.getImageMetadataPath(e);
+      await p.unlink(t);
+    } catch (t) {
+      t.code !== "ENOENT" && console.error(`Error clearing image metadata cache for ${e}:`, t);
+    }
+  }
+  /**
+   * Clear all caches
+   */
+  async clearAll() {
+    try {
+      const e = await p.readdir(this.cacheDir);
+      for (const r of e)
+        r.endsWith(".json") && await p.unlink(D(this.cacheDir, r));
+      const t = D(this.cacheDir, "image-metadata");
+      try {
+        const r = await p.readdir(t);
+        for (const n of r)
+          n.endsWith(".json") && await p.unlink(D(t, n));
+      } catch {
+      }
+    } catch (e) {
+      console.error("Error clearing all caches:", e);
+    }
+  }
+}
+class N {
+  memoryCache;
+  fileCache;
+  config;
+  stats = {
+    hits: 0,
+    misses: 0,
+    refreshes: 0,
+    errors: 0
+  };
+  constructor(e) {
+    this.config = e, this.memoryCache = new X(e), this.fileCache = new J(e);
+  }
+  /**
+   * Get cached feed data for a schema
+   * Checks memory cache first, then file cache
+   */
+  async getFeedData(e) {
+    if (!this.config.enabled)
+      return null;
+    try {
+      let t = this.memoryCache.getFeedData(e);
+      return t ? (this.stats.hits++, t) : (t = await this.fileCache.getFeedData(e), t ? (this.memoryCache.setFeedData(e, t.items), this.stats.hits++, t) : (this.stats.misses++, null));
+    } catch (t) {
+      return console.error(`Error getting feed data cache for ${e}:`, t), this.stats.errors++, null;
+    }
+  }
+  /**
+   * Set cached feed data for a schema
+   * Updates both memory and file cache
+   */
+  async setFeedData(e, t) {
+    if (this.config.enabled)
+      try {
+        this.memoryCache.setFeedData(e, t);
+        const r = this.memoryCache.getFeedData(e);
+        r && await this.fileCache.setFeedData(e, r);
+      } catch (r) {
+        console.error(`Error setting feed data cache for ${e}:`, r), this.stats.errors++;
+      }
+  }
+  /**
+   * Get cached feed content for a schema and format
+   * Checks memory cache first, then file cache
+   */
+  async getFeedContent(e, t) {
+    if (!this.config.enabled)
+      return null;
+    try {
+      let r = this.memoryCache.getFeedContent(e, t);
+      return r ? (this.stats.hits++, r) : (r = await this.fileCache.getFeedContent(e, t), r ? (this.memoryCache.setFeedContent(
+        e,
+        t,
+        r.content,
+        r.contentType
+      ), this.stats.hits++, r) : (this.stats.misses++, null));
+    } catch (r) {
+      return console.error(
+        `Error getting feed content cache for ${e}:${t}:`,
+        r
+      ), this.stats.errors++, null;
+    }
+  }
+  /**
+   * Set cached feed content for a schema and format
+   * Updates both memory and file cache
+   */
+  async setFeedContent(e, t, r, n) {
+    if (this.config.enabled)
+      try {
+        this.memoryCache.setFeedContent(e, t, r, n);
+        const s = this.memoryCache.getFeedContent(e, t);
+        s && await this.fileCache.setFeedContent(e, t, s);
+      } catch (s) {
+        console.error(
+          `Error setting feed content cache for ${e}:${t}:`,
+          s
+        ), this.stats.errors++;
+      }
+  }
+  /**
+   * Clear feed data cache for a schema
+   */
+  async clearFeedData(e) {
+    this.memoryCache.clearFeedData(e), await this.fileCache.clearFeedData(e), this.memoryCache.clearContentCache(e), await this.fileCache.clearAllContentCache(e);
+  }
+  /**
+   * Clear all caches
+   */
+  async clearAll() {
+    this.memoryCache.clearAll(), await this.fileCache.clearAll();
+  }
+  /**
+   * Get or create a refresh lock for a schema
+   * Prevents concurrent fetches for the same schema
+   */
+  async withRefreshLock(e, t) {
+    return this.memoryCache.withRefreshLock(e, t);
+  }
+  /**
+   * Merge new items with cached items
+   * Deduplicates by item ID and sorts by timeCreated (descending)
+   */
+  mergeItems(e, t) {
+    const r = /* @__PURE__ */ new Map();
+    for (const s of e) {
+      const o = s.id || s.seedUid || s.SeedUid || "";
+      o && r.set(o, s);
+    }
+    for (const s of t) {
+      const o = s.id || s.seedUid || s.SeedUid || "";
+      o ? r.set(o, s) : r.set(`temp-${Date.now()}-${Math.random()}`, s);
+    }
+    const n = Array.from(r.values());
+    return n.sort((s, o) => {
+      const l = s.timeCreated || 0;
+      return (o.timeCreated || 0) - l;
+    }), n;
+  }
+  /**
+   * Filter items to only include those newer than the given timestamp
+   */
+  filterNewItems(e, t) {
+    return e.filter((r) => {
+      const n = r.timeCreated;
+      return n && n > t;
+    });
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(e) {
+    this.config = { ...this.config, ...e }, this.memoryCache.updateConfig(this.config);
+  }
+  /**
+   * Get cache statistics
+   */
+  getStats() {
+    return {
+      ...this.stats,
+      memoryStats: this.memoryCache.getStats()
+    };
+  }
+  /**
+   * Get cached image metadata for a transaction ID
+   * Checks memory cache first, then file cache
+   */
+  async getImageMetadata(e) {
+    if (!this.config.enabled || !this.config.imageMetadata?.enabled)
+      return null;
+    try {
+      let t = this.memoryCache.getImageMetadata(e);
+      return t ? (this.stats.hits++, t) : (t = await this.fileCache.getImageMetadata(e), t ? (this.memoryCache.setImageMetadata(e, t), this.stats.hits++, t) : (this.stats.misses++, null));
+    } catch (t) {
+      return console.error(`Error getting image metadata cache for ${e}:`, t), this.stats.errors++, null;
+    }
+  }
+  /**
+   * Set cached image metadata for a transaction ID
+   * Updates both memory and file cache
+   */
+  async setImageMetadata(e, t) {
+    if (!(!this.config.enabled || !this.config.imageMetadata?.enabled))
+      try {
+        this.memoryCache.setImageMetadata(e, t), await this.fileCache.setImageMetadata(e, t);
+      } catch (r) {
+        console.error(`Error setting image metadata cache for ${e}:`, r), this.stats.errors++;
+      }
+  }
+  /**
+   * Reset statistics
+   */
+  resetStats() {
+    this.stats = {
+      hits: 0,
+      misses: 0,
+      refreshes: 0,
+      errors: 0
+    };
+  }
+}
+function P() {
+  const d = parseInt(process.env.CACHE_TTL || "3600", 10), e = process.env.CACHE_DIR || "./cache", t = !(process.env.CACHE_ENABLED === "false" || process.env.CACHE_ENABLED === "0" || process.env.CACHE_ENABLED === "no" || process.env.CACHE_ENABLED === "off"), r = process.env.CACHE_BACKGROUND_REFRESH === "true", n = parseInt(
+    process.env.CACHE_REFRESH_INTERVAL || "300",
+    10
+  );
+  t || console.log("⚠️  Cache is DISABLED (CACHE_ENABLED=false)");
+  const s = process.env.IMAGE_METADATA_ENABLED !== "false", o = parseInt(process.env.IMAGE_METADATA_TTL || "604800", 10), l = process.env.IMAGE_METADATA_GATEWAYS ? process.env.IMAGE_METADATA_GATEWAYS.split(",").map((m) => m.trim()) : ["arweave.net", "ar-io.net"], h = parseInt(process.env.IMAGE_METADATA_TIMEOUT || "5000", 10);
+  return {
+    ttl: d,
+    cacheDir: e,
+    enabled: t,
+    backgroundRefresh: r,
+    refreshInterval: n,
+    imageMetadata: {
+      enabled: s,
+      ttl: o,
+      gateways: l,
+      timeout: h
+    }
+  };
+}
+function q() {
+  const d = process.env.FEED_ITEM_URL_BASE?.trim() || void 0, e = process.env.FEED_ITEM_URL_PATH?.trim() || "attestation/view";
+  return { itemUrlBase: d, itemUrlPath: e };
+}
+class b {
+  config;
+  constructor(e) {
+    this.config = e;
+  }
+  /**
+   * Detect if an Arweave transaction ID links to an image and extract metadata
+   */
+  async detectImage(e) {
+    const t = this.config.gateways || ["arweave.net"];
+    for (const r of t)
+      try {
+        const n = `https://${r}/${e}`, s = await this.getImageMetadata(n);
+        if (s.isImage)
+          return s;
+      } catch (n) {
+        console.warn(`Failed to fetch from gateway ${r} for transaction ${e}:`, n);
+        continue;
+      }
+    return {
+      isImage: !1,
+      url: `https://${t[0]}/${e}`
+    };
+  }
+  /**
+   * Get image metadata from a URL
+   */
+  async getImageMetadata(e) {
+    try {
+      const t = await this.fetchWithTimeout(e, { method: "HEAD" });
+      if (!t.ok)
+        return { isImage: !1, url: e };
+      const r = t.headers.get("content-type") || "", n = t.headers.get("content-length");
+      if (!this.isImageContentType(r))
+        return {
+          isImage: !1,
+          url: e,
+          mimeType: r || void 0,
+          size: n ? parseInt(n, 10) : void 0
+        };
+      const s = await this.fetchWithTimeout(e, {
+        headers: {
+          Range: "bytes=0-8192"
+          // First 8KB should be enough for most image headers
+        }
+      });
+      if (!s.ok)
+        return await this.getImageMetadataFromFullRequest(e, r, n);
+      const o = Buffer.from(await s.arrayBuffer()), l = this.extractImageDimensions(o, r), h = this.getImageFormat(r, o);
+      return {
+        isImage: !0,
+        url: e,
+        mimeType: r,
+        width: l.width,
+        height: l.height,
+        size: n ? parseInt(n, 10) : void 0,
+        format: h
+      };
+    } catch (t) {
+      return console.warn(`Error fetching image metadata from ${e}:`, t), { isImage: !1, url: e };
+    }
+  }
+  /**
+   * Fetch image metadata from full request (fallback when range requests fail)
+   */
+  async getImageMetadataFromFullRequest(e, t, r) {
+    try {
+      const n = await this.fetchWithTimeout(e);
+      if (!n.ok)
+        return { isImage: !1, url: e };
+      const s = Buffer.from(await n.arrayBuffer()), o = this.extractImageDimensions(s, t), l = this.getImageFormat(t, s);
+      return {
+        isImage: !0,
+        url: e,
+        mimeType: t,
+        width: o.width,
+        height: o.height,
+        size: s.length,
+        format: l
+      };
+    } catch (n) {
+      return console.warn(`Error in full request for ${e}:`, n), { isImage: !1, url: e };
+    }
+  }
+  /**
+   * Validate if Content-Type indicates an image
+   */
+  isImageContentType(e) {
+    return e ? (e.toLowerCase().split(";")[0] ?? "").trim().startsWith("image/") : !1;
+  }
+  /**
+   * Extract image dimensions from buffer
+   */
+  extractImageDimensions(e, t) {
+    try {
+      const r = S(e);
+      if (r.width && r.height)
+        return {
+          width: r.width,
+          height: r.height
+        };
+    } catch (r) {
+      console.warn("Failed to extract dimensions:", r);
+    }
+    return { width: 0, height: 0 };
+  }
+  /**
+   * Get image format from Content-Type or buffer analysis
+   */
+  getImageFormat(e, t) {
+    if (e) {
+      const r = e.toLowerCase().match(/image\/([^;]+)/);
+      if (r && r[1]) {
+        const n = r[1].toLowerCase();
+        return n === "jpeg" ? "jpeg" : n === "png" ? "png" : n === "gif" ? "gif" : n === "webp" ? "webp" : n === "svg+xml" ? "svg" : n;
+      }
+    }
+    try {
+      const r = S(t);
+      if (r.type)
+        return r.type.toLowerCase();
+    } catch {
+    }
+  }
+  /**
+   * Fetch with timeout
+   */
+  async fetchWithTimeout(e, t = {}) {
+    const r = new AbortController(), n = setTimeout(() => r.abort(), this.config.timeout);
+    try {
+      const s = await fetch(e, {
+        ...t,
+        signal: r.signal
+      });
+      return clearTimeout(n), s;
+    } catch (s) {
+      throw clearTimeout(n), s instanceof Error && s.name === "AbortError" ? new Error(`Request timeout after ${this.config.timeout}ms`) : s;
+    }
+  }
+}
+let I, M = null, E = null;
+function V() {
+  if (!E) {
+    const d = P();
+    E = new N(d);
+  }
+  return E;
+}
+function de() {
+  E = null;
+}
+const Y = async () => {
+  if (M)
+    return M;
+  if (!I)
+    return M = (async () => {
+      try {
+        console.log("Initializing Seed Protocol client..."), await $.init({ config: {
+          endpoints: {
+            filePaths: "app-files",
+            files: "/app-files"
+          },
+          arweaveDomain: "arweave.net"
+        }, addresses: [] }), console.log("✅ Seed Protocol client initialized successfully"), I = $, M = null;
+      } catch (d) {
+        throw console.error("❌ Failed to initialize Seed Protocol client:", d), M = null, d;
+      }
+    })(), M;
+}, U = async () => I || (M ? (await M, I) : (await Y(), I)), he = async () => {
+  try {
+    console.log("Tearing down Seed Protocol client..."), typeof $.stop == "function" && (await $.stop(), console.log("✅ Seed Protocol client stopped")), typeof $.unload == "function" && (await $.unload(), console.log("✅ Seed Protocol client unloaded")), console.log("✅ Seed Protocol client teardown complete");
+  } catch (d) {
+    console.error("❌ Failed to teardown Seed Protocol client:", d);
+  }
+}, u = {
+  title: "Seed Protocol",
+  description: "Content published via Seed Protocol",
+  siteUrl: "https://seedprotocol.io",
+  language: "en",
+  copyright: `© ${(/* @__PURE__ */ new Date()).getFullYear()} All rights reserved`,
+  author: {
+    name: "Seed Protocol",
+    email: "info@seedprotocol.io",
+    link: "https://seedprotocol.io"
+  }
+}, ge = x`
+  query GetSeeds($where: AttestationWhereInput!) {
+    itemSeeds: attestations(where: $where, orderBy: [{ timeCreated: desc }]) {
+      id
+      decodedDataJson
+      attester
+      schema {
+        schemaNames {
+          name
+        }
+      }
+      refUID
+      revoked
+      schemaId
+      timeCreated
+      isOffchain
+    }
+  }
+`;
+async function v(d, e, t) {
+  const r = d.filter(
+    (l) => l.storageTransactionId || l.storage_transaction_id
+  );
+  if (r.length === 0)
+    return d;
+  console.log(`Enriching ${r.length} items with image metadata`);
+  const n = r.map(async (l) => {
+    const h = l.storageTransactionId || l.storage_transaction_id;
+    if (!h) return l;
+    try {
+      let f = await t.getImageMetadata(h);
+      return f || (console.log(`Detecting image for transaction ${h}`), f = await e.detectImage(h), await t.setImageMetadata(h, f)), f.isImage && (l._imageMetadata = f, l._hasImage = !0), l;
+    } catch (f) {
+      return console.warn(`Error enriching item with transaction ${h}:`, f), l;
+    }
+  }), s = await Promise.all(n), o = /* @__PURE__ */ new Map();
+  return s.forEach((l) => {
+    const h = l.id || l.seedUid || l.SeedUid || "";
+    h && o.set(h, l);
+  }), d.map((l) => {
+    const h = l.id || l.seedUid || l.SeedUid || "";
+    return o.get(h) || l;
+  });
+}
+function K(d, e) {
+  const { schemaName: t, siteUrl: r, itemUrlBase: n, itemUrlPath: s } = e;
+  return d.map((o) => {
+    const l = o.id || o.seedUid || o.SeedUid || o.storageTransactionId || o.storage_transaction_id, h = n != null ? `${n.replace(/\/$/, "")}/${(s ?? "attestation/view").replace(/^\//, "")}/${l}` : `${r}/${F(t)}/${l}`, f = o.link || o.Link || o.import_url || o.importUrl || h;
+    let m;
+    if (o.pubDate || o.PubDate) {
+      const a = o.pubDate || o.PubDate;
+      m = new Date(a);
+    } else if (o.timeCreated)
+      m = new Date(o.timeCreated * 1e3);
+    else if (o.publishedAt || o.createdAt || o.updatedAt) {
+      const a = o.publishedAt || o.createdAt || o.updatedAt;
+      m = a && typeof a == "object" && a.constructor === Date ? a : new Date(a);
+    } else
+      m = /* @__PURE__ */ new Date();
+    const w = {
+      ...o,
+      // Preserve all dynamic properties first
+      // Map to standard feed fields
+      id: l,
+      title: o.title || o.Title || "Untitled",
+      link: f,
+      description: o.summary || o.description || "",
+      content: o.html || o.content || o.summary || "",
+      pubDate: m,
+      date: m,
+      // Map guid - use full URL when available for proper permalink
+      guid: o.guid || o.Guid || o.link || o.Link || f
+    };
+    if (o._imageMetadata && o._hasImage) {
+      const a = o._imageMetadata;
+      w._imageMetadata = a, w._hasImage = !0;
+    }
+    return Object.keys(w).forEach((a) => {
+      const i = w[a];
+      if (typeof i == "string" && /date|time|published|created|updated/i.test(a) && a !== "pubDate" && a !== "date") {
+        const c = new Date(i);
+        isNaN(c.getTime()) || (w[a] = c);
+      }
+    }), w;
+  });
+}
+const Q = (d, e, t, r) => {
+  const n = F(e), s = `${u.siteUrl}/${n}/${t}`, o = r ? `${s}?v=${r}` : s, l = `${u.title} - ${te(n)}`, h = /* @__PURE__ */ new Date(), f = q(), m = K(d, {
+    schemaName: e,
+    siteUrl: u.siteUrl,
+    itemUrlBase: f.itemUrlBase,
+    itemUrlPath: f.itemUrlPath
+  });
+  switch (t) {
+    case "atom": {
+      const w = {
+        id: o,
+        title: l,
+        updated: h,
+        links: [
+          { href: o, rel: "self" },
+          { href: u.siteUrl }
+        ],
+        subtitle: u.description,
+        rights: u.copyright,
+        author: u.author ? {
+          name: u.author.name,
+          email: u.author.email,
+          uri: u.author.link
+        } : void 0,
+        entries: m.map((a) => {
+          const i = {
+            id: a.id || a.link,
+            title: a.title || "Untitled",
+            updated: a.date || a.pubDate || h,
+            links: a.link ? [{ href: a.link }] : [],
+            ...a
+            // Preserve all dynamic properties
+          };
+          if (a.content && (i.content = a.content), a.description && (i.summary = a.description), a._imageMetadata && a._hasImage) {
+            const c = a._imageMetadata;
+            if (i.links || (i.links = []), i.links.push({
+              href: c.url,
+              rel: "enclosure",
+              type: c.mimeType || "image/jpeg",
+              length: c.size
+            }), c.url && i.content && !i.content.includes(c.url)) {
+              const g = `<img src="${c.url}" alt="${a.title || ""}"${c.width ? ` width="${c.width}"` : ""}${c.height ? ` height="${c.height}"` : ""} />`;
+              i.content = typeof i.content == "string" ? `${g}
+${i.content}` : { type: "html", value: `${g}
+${i.content.value || i.content}` };
+            }
+          }
+          return i;
+        })
+      };
+      return Promise.resolve(R(w));
+    }
+    case "json": {
+      const w = {
+        title: l,
+        home_page_url: u.siteUrl,
+        feed_url: o,
+        description: u.description,
+        author: u.author ? {
+          name: u.author.name,
+          url: u.author.link
+        } : void 0,
+        items: m.map((i) => {
+          const c = {
+            id: i.id || i.link,
+            ...i
+            // Preserve all dynamic properties
+          };
+          if (i.title && (c.title = i.title), i.link && (c.url = i.link), i.content && (c.content_html = i.content), i.description && (c.summary = i.description), (i.date || i.pubDate) && (c.date_published = i.date || i.pubDate), i._imageMetadata && i._hasImage) {
+            const g = i._imageMetadata;
+            if (c.image = g.url, c.attachments || (c.attachments = []), c.attachments.push({
+              url: g.url,
+              mime_type: g.mimeType || "image/jpeg",
+              size_in_bytes: g.size,
+              title: i.title || "Image"
+            }), g.url && c.content_html && !c.content_html.includes(g.url)) {
+              const C = `<img src="${g.url}" alt="${i.title || ""}"${g.width ? ` width="${g.width}"` : ""}${g.height ? ` height="${g.height}"` : ""} />`;
+              c.content_html = `${C}
+${c.content_html}`;
+            }
+          }
+          return c;
+        })
+      }, a = z(w);
+      return Promise.resolve(typeof a == "string" ? a : JSON.stringify(a));
+    }
+    case "rss":
+    default: {
+      const w = {
+        title: l,
+        link: u.siteUrl,
+        description: u.description,
+        language: u.language,
+        copyright: u.copyright,
+        webMaster: u.author?.email,
+        pubDate: h,
+        lastBuildDate: h,
+        items: m.map((a) => {
+          const i = {
+            ...a
+            // Preserve all dynamic properties
+          };
+          if (a.title && (i.title = a.title), a.link && (i.link = a.link), a.description && (i.description = a.description), (a.date || a.pubDate) && (i.pubDate = a.date || a.pubDate), a.guid ? i.guid = {
+            value: a.guid,
+            isPermaLink: typeof a.guid == "string" && (a.guid.startsWith("http://") || a.guid.startsWith("https://"))
+          } : a.id && (i.guid = {
+            value: a.id,
+            isPermaLink: typeof a.id == "string" && (a.id.startsWith("http://") || a.id.startsWith("https://"))
+          }), a._imageMetadata && a._hasImage) {
+            const c = a._imageMetadata;
+            i.enclosures = [{
+              url: c.url,
+              type: c.mimeType || "image/jpeg",
+              length: c.size
+            }];
+            const g = {
+              url: c.url,
+              type: c.mimeType || "image/jpeg",
+              medium: "image"
+              // image, video, audio, document
+            };
+            c.width && (g.width = c.width), c.height && (g.height = c.height), c.size && (g.fileSize = c.size), c.format && (g.format = c.format), i["media:content"] = [g];
+            const C = {
+              url: c.url
+            };
+            c.width && (C.width = c.width), c.height && (C.height = c.height), i["media:thumbnail"] = [C], a.title && (i["media:title"] = a.title);
+            const T = a.description || a.summary || a.title || "";
+            if (T && (i["media:description"] = T), a.title) {
+              const y = [];
+              a.title && y.push(...a.title.toLowerCase().split(/\s+/).filter((A) => A.length > 3)), a.description && y.push(...a.description.toLowerCase().split(/\s+/).filter((A) => A.length > 3)), y.length > 0 && (i["media:keywords"] = [...new Set(y)].slice(0, 10).join(", "));
+            }
+            if (a.authors && Array.isArray(a.authors) && a.authors.length > 0 ? i["media:credit"] = a.authors.map((y) => ({
+              value: y.name || y.displayName || "Unknown",
+              role: "author"
+            })) : u.author && (i["media:credit"] = [{
+              value: u.author.name,
+              role: "author"
+            }]), u.copyright && (i["media:copyright"] = u.copyright), e && (i["media:category"] = [{
+              value: e,
+              scheme: "http://www.schema.org/"
+            }]), i["media:group"] = [{
+              "media:content": [g],
+              "media:thumbnail": [C],
+              "media:title": a.title || "Untitled",
+              "media:description": T
+            }], c.url && a.content && !a.content.includes(c.url)) {
+              const y = `<img src="${c.url}" alt="${a.title || ""}"${c.width ? ` width="${c.width}"` : ""}${c.height ? ` height="${c.height}"` : ""} />`;
+              i["content:encoded"] = `${y}
+${a.content}`;
+            }
+          }
+          if (!i.enclosures && (a.feature_image || a.featureImage)) {
+            const c = a.feature_image || a.featureImage, g = typeof c == "string" && c.startsWith("http") ? c : `https://arweave.net/${c}`;
+            i.enclosures = [{
+              url: g,
+              type: "image/jpeg"
+              // Default, could be determined from URL or metadata
+            }];
+          }
+          if (i.dc = {}, (a.date || a.pubDate) && (i.dc.date = a.date || a.pubDate), a.timeCreated) {
+            const c = new Date(a.timeCreated * 1e3);
+            i.dc.dates || (i.dc.dates = []), i.dc.dates.push(c);
+          }
+          return (a.seedUid || a.SeedUid) && (i.dc.identifier || (i.dc.identifier = []), i.dc.identifier.push(a.seedUid || a.SeedUid)), (a.storageTransactionId || a.storage_transaction_id) && (i.dc.identifier || (i.dc.identifier = []), i.dc.identifier.push(a.storageTransactionId || a.storage_transaction_id)), (a.import_url || a.importUrl) && (i.dc.source = a.import_url || a.importUrl), (a.seedUid || a.SeedUid) && (i.seedUid = a.seedUid || a.SeedUid), (a.storageTransactionId || a.storage_transaction_id) && (i.storageTransactionId = a.storageTransactionId || a.storage_transaction_id), a.timeCreated && (i.timeCreated = a.timeCreated), i;
+        })
+      };
+      return Promise.resolve(L(w));
+    }
+  }
+};
+function Z(d) {
+  switch (d) {
+    case "atom":
+      return "application/atom+xml; charset=utf-8";
+    case "json":
+      return "application/feed+json; charset=utf-8";
+    case "rss":
+    default:
+      return "application/rss+xml; charset=utf-8";
+  }
+}
+function ee(d) {
+  const e = d.toLowerCase();
+  return ["rss", "atom", "json"].includes(e) ? e : null;
+}
+function te(d) {
+  return d.charAt(0).toUpperCase() + d.slice(1);
+}
+async function fe(d, e, t, r) {
+  const n = ee(e);
+  if (!n)
+    return new Response(
+      JSON.stringify({ error: `Invalid feed format: ${e}` }),
+      {
+        status: 400,
+        headers: { "Content-Type": "application/json" }
+      }
+    );
+  const s = F.singular(d.toLowerCase()), o = F(s);
+  console.log(`Schema name: ${s}`), console.log(`Collection name: ${o}`);
+  const l = V(), h = P();
+  try {
+    if (h.enabled) {
+      const a = await l.getFeedContent(s, n);
+      if (a)
+        return t && G(t, a.etag) ? (console.log(`Cache hit with ETag match for ${s}:${n} - returning 304`), new Response(null, {
+          status: 304,
+          headers: {
+            ETag: a.etag,
+            "Last-Modified": new Date(a.lastModified * 1e3).toUTCString(),
+            "Cache-Control": "public, max-age=3600, s-maxage=3600, must-revalidate"
+          }
+        })) : (console.log(`Cache hit for ${s}:${n}`), new Response(a.content, {
+          status: 200,
+          headers: {
+            "Content-Type": a.contentType,
+            ETag: a.etag,
+            "Last-Modified": new Date(a.lastModified * 1e3).toUTCString(),
+            "Cache-Control": "public, max-age=3600, s-maxage=3600, must-revalidate",
+            "X-Feed-Schema": s,
+            "X-Feed-Format": n,
+            "X-Cache": "HIT"
+          }
+        }));
+    }
+    console.log(`Cache miss for ${s}:${n} - fetching items`);
+    const f = h.enabled ? await l.withRefreshLock(s, async () => {
+      const a = await l.getFeedData(s);
+      let i;
+      if (a) {
+        console.log(`Incremental fetch: last processed timestamp: ${a.lastProcessedTimestamp}`);
+        const g = await _(s);
+        console.log(`First item: ${JSON.stringify(g[0])}`);
+        const C = l.filterNewItems(g, a.lastProcessedTimestamp);
+        C.length > 0 ? (console.log(`Found ${C.length} new items, merging with ${a.items.length} cached items`), i = l.mergeItems(a.items, C)) : (console.log("No new items found, using cached items"), i = a.items);
+      } else {
+        console.log("Cold cache - fetching all items");
+        const g = await U();
+        g && console.log(`Client initialized: ${g.isInitialized()}`), i = await _(s), console.log(`Found ${i.length} feed items for schema ${s}`);
+      }
+      let c = i;
+      if (h.imageMetadata?.enabled) {
+        const g = new b({
+          gateways: h.imageMetadata.gateways,
+          timeout: h.imageMetadata.timeout
+        });
+        c = await v(i, g, l);
+      }
+      return await l.setFeedData(s, i), c;
+    }) : await (async () => {
+      console.log("Cache disabled - fetching all items directly");
+      const a = await U();
+      a && console.log(`Client initialized: ${a.isInitialized()}`);
+      const i = await _(s);
+      console.log(`Found ${i.length} feed items for schema ${s}`);
+      let c = i;
+      if (h.imageMetadata?.enabled) {
+        const g = new b({
+          gateways: h.imageMetadata.gateways,
+          timeout: h.imageMetadata.timeout
+        });
+        c = await v(i, g, l);
+      }
+      return c;
+    })(), m = await Q(f, s, n, r), w = Z(n);
+    if (h.enabled) {
+      await l.setFeedContent(s, n, m, w);
+      const a = await l.getFeedContent(s, n), i = a?.etag || "", c = a?.lastModified || Math.floor(Date.now() / 1e3);
+      return new Response(m, {
+        status: 200,
+        headers: {
+          "Content-Type": w,
+          ETag: i,
+          "Last-Modified": new Date(c * 1e3).toUTCString(),
+          "Cache-Control": "public, max-age=3600, s-maxage=3600, must-revalidate",
+          "X-Feed-Schema": s,
+          "X-Feed-Format": n,
+          "X-Cache": "MISS"
+        }
+      });
+    }
+    return new Response(m, {
+      status: 200,
+      headers: {
+        "Content-Type": w,
+        "Cache-Control": "public, max-age=3600, s-maxage=3600",
+        "X-Feed-Schema": s,
+        "X-Feed-Format": n
+      }
+    });
+  } catch (f) {
+    if (console.error("Feed generation error:", f), h.enabled) {
+      const m = await l.getFeedContent(s, n);
+      if (m)
+        return console.log("Serving stale cache due to error"), new Response(m.content, {
+          status: 200,
+          headers: {
+            "Content-Type": m.contentType,
+            ETag: m.etag,
+            "Cache-Control": "public, max-age=3600, s-maxage=3600, must-revalidate",
+            "X-Feed-Schema": s,
+            "X-Feed-Format": n,
+            "X-Cache": "STALE",
+            Warning: '299 - "Cache is stale"'
+          }
+        });
+    }
+    return new Response(
+      JSON.stringify({
+        error: "Failed to generate feed",
+        message: f instanceof Error ? f.message : "Unknown error"
+      }),
+      {
+        status: 500,
+        headers: { "Content-Type": "application/json" }
+      }
+    );
+  }
+}
+export {
+  ge as GET_SEEDS,
+  Q as createFeed,
+  U as getClient,
+  fe as handleFeedRequest,
+  Y as initializeSeedClient,
+  de as resetCacheManager,
+  he as teardownSeedClient
+};
+//# sourceMappingURL=index.js.map