holosphere 2.0.0-alpha11 → 2.0.0-alpha13

package/src/federation/card-storage.js

@@ -0,0 +1,376 @@
+/**
+ * @fileoverview Federation Card Storage
+ *
+ * Persists federation card state to prevent cards from reappearing
+ * after deletion. Manages card lifecycle (pending, sent, accepted,
+ * rejected, dismissed).
+ *
+ * @module federation/card-storage
+ */
+
+import { writeGlobal, readGlobal, getAllGlobal } from '../storage/global-tables.js';
+import { serializeCard, deserializeCard, shouldDisplayCard } from './request-card.js';
+
+const FEDERATION_CARDS_TABLE = '_federation-cards';
+const DISMISSED_REQUESTS_TABLE = '_dismissed-federation-requests';
+const PROCESSED_RESPONSES_TABLE = '_processed-federation-responses';
+const DM_STATE_TABLE = '_federation-dm-state';
+const PROCESSED_DMS_TABLE = '_processed-federation-dms';
+
+/**
+ * Save a federation card
+ * @param {Object} client - NostrClient instance
+ * @param {string} appname - Application namespace
+ * @param {Object} card - Federation card configuration
+ * @returns {Promise<boolean>} Success indicator
+ */
+export async function saveCard(client, appname, card) {
+  const serialized = serializeCard(card);
+  serialized.id = card.id;
+  return writeGlobal(client, appname, FEDERATION_CARDS_TABLE, serialized);
+}
+
+/**
+ * Get a specific federation card
+ * @param {Object} client - NostrClient instance
+ * @param {string} appname - Application namespace
+ * @param {string} cardId - Card ID
+ * @returns {Promise<Object|null>} Card or null
+ */
+export async function getCard(client, appname, cardId) {
+  const data = await readGlobal(client, appname, FEDERATION_CARDS_TABLE, cardId);
+  return data ? deserializeCard(data) : null;
+}
+
+/**
+ * Get all federation cards
+ * @param {Object} client - NostrClient instance
+ * @param {string} appname - Application namespace
+ * @returns {Promise<Object[]>} Array of cards
+ */
+export async function getAllCards(client, appname) {
+  const data = await getAllGlobal(client, appname, FEDERATION_CARDS_TABLE);
+  return (data || [])
+    .filter(d => d && !d._deleted)
+    .map(d => deserializeCard(d));
+}
+
+/**
+ * Get cards that should be displayed
+ * @param {Object} client - NostrClient instance
+ * @param {string} appname - Application namespace
+ * @returns {Promise<Object[]>} Array of displayable cards
+ */
+export async function getDisplayableCards(client, appname) {
+  const cards = await getAllCards(client, appname);
+  return cards.filter(shouldDisplayCard);
+}
+
+/**
+ * Get card by partner public key
+ * @param {Object} client - NostrClient instance
+ * @param {string} appname - Application namespace
+ * @param {string} partnerPubKey - Partner's public key
+ * @returns {Promise<Object|null>} Card or null
+ */
+export async function getCardByPartner(client, appname, partnerPubKey) {
+  const cards = await getAllCards(client, appname);
+  return cards.find(c => c.partnerPubKey === partnerPubKey) || null;
+}
+
+/**
+ * Delete a federation card
+ * @param {Object} client - NostrClient instance
+ * @param {string} appname - Application namespace
+ * @param {string} cardId - Card ID
+ * @returns {Promise<boolean>} Success indicator
+ */
+export async function deleteCard(client, appname, cardId) {
+  const card = await getCard(client, appname, cardId);
+  if (!card) return false;
+
+  // Mark as deleted
+  const deleted = {
+    ...card,
+    id: cardId,
+    _deleted: true,
+    deletedAt: Date.now(),
+  };
+
+  return writeGlobal(client, appname, FEDERATION_CARDS_TABLE, deleted);
+}
+
+/**
+ * Dismiss a card (mark as dismissed so it won't reappear)
+ * @param {Object} client - NostrClient instance
+ * @param {string} appname - Application namespace
+ * @param {string} cardId - Card ID
+ * @returns {Promise<boolean>} Success indicator
+ */
+export async function dismissCard(client, appname, cardId) {
+  const card = await getCard(client, appname, cardId);
+  if (!card) return false;
+
+  card.status = 'dismissed';
+  card.dismissedAt = Date.now();
+
+  return saveCard(client, appname, card);
+}
+
+/**
+ * Mark a federation request as dismissed (by request ID)
+ * This prevents the request from showing up again as a card
+ * @param {Object} client - NostrClient instance
+ * @param {string} appname - Application namespace
+ * @param {string} requestId - Request ID from federation request
+ * @returns {Promise<boolean>} Success indicator
+ */
+export async function dismissRequest(client, appname, requestId) {
+  const entry = {
+    id: requestId,
+    dismissedAt: Date.now(),
+  };
+  return writeGlobal(client, appname, DISMISSED_REQUESTS_TABLE, entry);
+}
+
+/**
+ * Check if a request has been dismissed
+ * @param {Object} client - NostrClient instance
+ * @param {string} appname - Application namespace
+ * @param {string} requestId - Request ID
+ * @returns {Promise<boolean>} True if dismissed
+ */
+export async function isRequestDismissed(client, appname, requestId) {
+  const entry = await readGlobal(client, appname, DISMISSED_REQUESTS_TABLE, requestId);
+  return !!entry;
+}
+
+/**
+ * Get all dismissed request IDs
+ * @param {Object} client - NostrClient instance
+ * @param {string} appname - Application namespace
+ * @returns {Promise<Set<string>>} Set of dismissed request IDs
+ */
+export async function getDismissedRequestIds(client, appname) {
+  const entries = await getAllGlobal(client, appname, DISMISSED_REQUESTS_TABLE);
+  return new Set((entries || []).map(e => e.id));
+}
+
+/**
+ * Mark a federation response as processed
+ * This prevents duplicate "federation accepted" messages
+ * @param {Object} client - NostrClient instance
+ * @param {string} appname - Application namespace
+ * @param {string} requestId - Original request ID
+ * @param {string} responderPubKey - Responder's public key
+ * @returns {Promise<boolean>} Success indicator
+ */
+export async function markResponseProcessed(client, appname, requestId, responderPubKey) {
+  const entry = {
+    id: `${requestId}_${responderPubKey}`,
+    requestId,
+    responderPubKey,
+    processedAt: Date.now(),
+  };
+  return writeGlobal(client, appname, PROCESSED_RESPONSES_TABLE, entry);
+}
+
+/**
+ * Check if a response has already been processed
+ * @param {Object} client - NostrClient instance
+ * @param {string} appname - Application namespace
+ * @param {string} requestId - Original request ID
+ * @param {string} responderPubKey - Responder's public key
+ * @returns {Promise<boolean>} True if already processed
+ */
+export async function isResponseProcessed(client, appname, requestId, responderPubKey) {
+  const id = `${requestId}_${responderPubKey}`;
+  const entry = await readGlobal(client, appname, PROCESSED_RESPONSES_TABLE, id);
+  return !!entry;
+}
+
+/**
+ * Get all processed response IDs
+ * @param {Object} client - NostrClient instance
+ * @param {string} appname - Application namespace
+ * @returns {Promise<Set<string>>} Set of processed response IDs
+ */
+export async function getProcessedResponseIds(client, appname) {
+  const entries = await getAllGlobal(client, appname, PROCESSED_RESPONSES_TABLE);
+  return new Set((entries || []).map(e => e.id));
+}
+
+/**
+ * Update card status
+ * @param {Object} client - NostrClient instance
+ * @param {string} appname - Application namespace
+ * @param {string} cardId - Card ID
+ * @param {string} status - New status
+ * @returns {Promise<boolean>} Success indicator
+ */
+export async function updateCardStatus(client, appname, cardId, status) {
+  const card = await getCard(client, appname, cardId);
+  if (!card) return false;
+
+  card.status = status;
+  card.statusUpdatedAt = Date.now();
+
+  return saveCard(client, appname, card);
+}
+
+/**
+ * Find pending cards for a partner
+ * @param {Object} client - NostrClient instance
+ * @param {string} appname - Application namespace
+ * @param {string} partnerPubKey - Partner's public key
+ * @returns {Promise<Object[]>} Array of pending cards
+ */
+export async function findPendingCardsForPartner(client, appname, partnerPubKey) {
+  const cards = await getAllCards(client, appname);
+  return cards.filter(c =>
+    c.partnerPubKey === partnerPubKey &&
+    c.status === 'pending'
+  );
+}
+
+/**
+ * Clean up old dismissed entries (older than maxAge)
+ * @param {Object} client - NostrClient instance
+ * @param {string} appname - Application namespace
+ * @param {number} maxAge - Maximum age in milliseconds (default: 30 days)
+ * @returns {Promise<Object>} Cleanup result
+ */
+export async function cleanupOldEntries(client, appname, maxAge = 30 * 24 * 60 * 60 * 1000) {
+  const result = {
+    dismissedCleaned: 0,
+    responsesCleaned: 0,
+    cardsCleaned: 0,
+  };
+
+  const now = Date.now();
+  const cutoff = now - maxAge;
+
+  // Cleanup old dismissed requests
+  const dismissed = await getAllGlobal(client, appname, DISMISSED_REQUESTS_TABLE);
+  for (const entry of (dismissed || [])) {
+    if (entry.dismissedAt && entry.dismissedAt < cutoff) {
+      await writeGlobal(client, appname, DISMISSED_REQUESTS_TABLE, {
+        id: entry.id,
+        _deleted: true,
+      });
+      result.dismissedCleaned++;
+    }
+  }
+
+  // Cleanup old processed responses
+  const responses = await getAllGlobal(client, appname, PROCESSED_RESPONSES_TABLE);
+  for (const entry of (responses || [])) {
+    if (entry.processedAt && entry.processedAt < cutoff) {
+      await writeGlobal(client, appname, PROCESSED_RESPONSES_TABLE, {
+        id: entry.id,
+        _deleted: true,
+      });
+      result.responsesCleaned++;
+    }
+  }
+
+  // Cleanup old dismissed cards
+  const cards = await getAllCards(client, appname);
+  for (const card of cards) {
+    if (card.status === 'dismissed' && card.dismissedAt && card.dismissedAt < cutoff) {
+      await deleteCard(client, appname, card.id);
+      result.cardsCleaned++;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Get the last DM fetch timestamp
+ * @param {Object} client - NostrClient instance
+ * @param {string} appname - Application namespace
+ * @returns {Promise<number>} Unix timestamp (seconds) of last fetch, or 0 if never fetched
+ */
+export async function getLastDMFetchTime(client, appname) {
+  const entry = await readGlobal(client, appname, DM_STATE_TABLE, 'lastFetch');
+  return entry?.timestamp || 0;
+}
+
+/**
+ * Set the last DM fetch timestamp
+ * @param {Object} client - NostrClient instance
+ * @param {string} appname - Application namespace
+ * @param {number} timestamp - Unix timestamp (seconds)
+ * @returns {Promise<boolean>} Success indicator
+ */
+export async function setLastDMFetchTime(client, appname, timestamp) {
+  return writeGlobal(client, appname, DM_STATE_TABLE, {
+    id: 'lastFetch',
+    timestamp,
+    updatedAt: Date.now(),
+  });
+}
+
+/**
+ * Mark a DM as processed by its Nostr event ID
+ * @param {Object} client - NostrClient instance
+ * @param {string} appname - Application namespace
+ * @param {string} eventId - Nostr event ID
+ * @param {string} type - DM type (request/response)
+ * @returns {Promise<boolean>} Success indicator
+ */
+export async function markDMProcessed(client, appname, eventId, type = 'unknown') {
+  return writeGlobal(client, appname, PROCESSED_DMS_TABLE, {
+    id: eventId,
+    type,
+    processedAt: Date.now(),
+  });
+}
+
+/**
+ * Check if a DM has been processed
+ * @param {Object} client - NostrClient instance
+ * @param {string} appname - Application namespace
+ * @param {string} eventId - Nostr event ID
+ * @returns {Promise<boolean>} True if already processed
+ */
+export async function isDMProcessed(client, appname, eventId) {
+  const entry = await readGlobal(client, appname, PROCESSED_DMS_TABLE, eventId);
+  return !!entry;
+}
+
+/**
+ * Get all processed DM event IDs
+ * @param {Object} client - NostrClient instance
+ * @param {string} appname - Application namespace
+ * @returns {Promise<Set<string>>} Set of processed event IDs
+ */
+export async function getProcessedDMIds(client, appname) {
+  const entries = await getAllGlobal(client, appname, PROCESSED_DMS_TABLE);
+  return new Set((entries || []).map(e => e.id));
+}
+
+export default {
+  saveCard,
+  getCard,
+  getAllCards,
+  getDisplayableCards,
+  getCardByPartner,
+  deleteCard,
+  dismissCard,
+  dismissRequest,
+  isRequestDismissed,
+  getDismissedRequestIds,
+  markResponseProcessed,
+  isResponseProcessed,
+  getProcessedResponseIds,
+  updateCardStatus,
+  findPendingCardsForPartner,
+  cleanupOldEntries,
+  getLastDMFetchTime,
+  setLastDMFetchTime,
+  markDMProcessed,
+  isDMProcessed,
+  getProcessedDMIds,
+};