highperfocused/grimoire
1
0
Fork 0
mirror of https://github.com/purrgrammer/grimoire.git synced 2026-04-09 06:57:07 +02:00
Code Issues Packages Projects Releases Wiki Activity

Display user's blossom servers in menu (#90)

Browse Source 
* feat: Display blossom servers in user menu with caching

Implements caching and display of user's blossom server lists (kind 10063) in the user menu dropdown.

**Key Changes:**

1. **Database Schema (db.ts)**:
   - Added `CachedBlossomServerList` interface
   - Added `blossomServers` table to Dexie v15
   - Indexed by pubkey and updatedAt for efficient querying

2. **Caching Service (blossom-server-cache.ts)**:
   - Dual-layer caching: LRU memory cache (100 entries) + Dexie persistent cache
   - 24-hour TTL to reduce network requests
   - Auto-caches kind:10063 events from EventStore
   - Mirrors relay-list-cache pattern for consistency

3. **Sync Hooks**:
   - `useBlossomServerCacheSync`: Subscribes to EventStore for auto-caching kind:10063 events
   - `useAccountSync`: Extended to fetch and watch active account's blossom servers

4. **State Management**:
   - Added `blossomServers` field to `activeAccount` in GrimoireState
   - Created `setActiveAccountBlossomServers` pure function and callback
   - Reactive updates when user's server list changes

5. **User Menu UI (user-menu.tsx)**:
   - Added blossom servers section with HardDrive icon
   - Shows server count badge (e.g., "3 servers")
   - Clickable links open servers in new tabs
   - Displays only when user has configured servers

**Architecture:**
- Follows existing relay list caching pattern for consistency
- Reactive: UI auto-updates when kind:10063 events arrive
- Incremental sync: Fetches on login, caches for 24h
- Performance: Memory cache for <1ms lookups, Dexie for persistence

**Testing:**
- Build: ✓ No TypeScript errors
- Tests: ✓ All 838 tests passing

* feat: Open blossom server file lists directly from menus

**User Menu & Profile Viewer Improvements:**

1. **Enhanced Click Behavior**:
   - Clicking a blossom server now opens the file list for that server
   - Shows blobs uploaded by the user (user menu) or profile owner (profile viewer)
   - Pre-selects the clicked server in the dropdown

2. **UX Improvements**:
   - Removed server count from user menu label (cleaner UI)
   - Added `cursor-crosshair` to blossom server items (consistent with other clickable items)
   - Removed external link icon (not opening external URL anymore)

3. **Technical Changes**:
   - Updated `ListBlobsView` to accept optional `serverUrl` prop for pre-selection
   - User menu: Opens `blossom list` with `serverUrl` for active user
   - Profile viewer: Opens `blossom list` with both `pubkey` and `serverUrl`

**Flow:**
- User menu → Click server → Opens files for active user on that server
- Profile viewer → Click server → Opens files for viewed user on that server

* fix: Properly fetch blossom servers for any profile view

**Problem:**
Blossom servers were only visible for the logged-in user's profile,
not for other users' profiles being viewed.

**Solution:**
Enhanced ProfileViewer blossom server fetching with multi-layer approach:

1. **Cache-first loading**: Check blossomServerCache for instant display
2. **EventStore check**: Use existing cached event if available
3. **Reactive subscription**: Subscribe to EventStore for real-time updates
4. **Network fetch**: Use addressLoader to fetch latest from relays
5. **Auto-caching**: Update cache when new events arrive

**Benefits:**
- Blossom servers now display for ANY user's profile
- Instant display from cache (< 1ms)
- Reactive updates when data changes
- Proper cache hydration for future visits
- Consistent with relay list fetching pattern

**Technical:**
- Imported and integrated blossomServerCache service
- Added cache check before network fetch
- Separated EventStore subscription from network fetch
- Added cache updates on event arrival

---------

Co-authored-by: Claude <noreply@anthropic.com>
This commit is contained in:
Alejandro
2026-01-14 14:52:16 +01:00
committed by GitHub
parent 998944fdf7
commit 16764e1aca
11 changed files with 510 additions and 32 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
src/components/BlossomViewer.tsx
View File

@@ -72,7 +72,7 @@ export function BlossomViewer({
case "upload":
return <UploadView />;
case "list":
return <ListBlobsView pubkey={pubkey} />;
return <ListBlobsView pubkey={pubkey} serverUrl={serverUrl} />;
case "blob":
return <BlobDetailView sha256={sha256!} serverUrl={serverUrl} />;
case "mirror":
@@ -753,7 +753,13 @@ function formatSize(bytes: number): string {
/**
* ListBlobsView - List blobs for a user
*/
function ListBlobsView({ pubkey }: { pubkey?: string }) {
function ListBlobsView({
pubkey,
serverUrl,
}: {
pubkey?: string;
serverUrl?: string;
}) {
const { state } = useGrimoire();
const eventStore = useEventStore();
const accountPubkey = state.activeAccount?.pubkey;
@@ -762,7 +768,9 @@ function ListBlobsView({ pubkey }: { pubkey?: string }) {
const [servers, setServers] = useState<string[]>([]);
const [blobs, setBlobs] = useState<BlobDescriptor[]>([]);
const [loading, setLoading] = useState(true);
const [selectedServer, setSelectedServer] = useState<string | null>(null);
const [selectedServer, setSelectedServer] = useState<string | null>(
serverUrl || null,
);
const [selectedBlob, setSelectedBlob] = useState<BlobDescriptor | null>(null);
// Fetch servers for the target pubkey
@@ -780,7 +788,8 @@ function ListBlobsView({ pubkey }: { pubkey?: string }) {
if (event) {
const s = getServersFromEvent(event);
setServers(s);
if (s.length > 0 && !selectedServer) {
// Only set default server if no serverUrl was provided and no server is selected
if (s.length > 0 && !selectedServer && !serverUrl) {
setSelectedServer(s[0]);
}
}
@@ -799,7 +808,8 @@ function ListBlobsView({ pubkey }: { pubkey?: string }) {
if (e) {
const s = getServersFromEvent(e);
setServers(s);
if (s.length > 0 && !selectedServer) {
// Only set default server if no serverUrl was provided and no server is selected
if (s.length > 0 && !selectedServer && !serverUrl) {
setSelectedServer(s[0]);
}
}

74
src/components/ProfileViewer.tsx
View File

@@ -10,7 +10,6 @@ import {
Send,
Wifi,
HardDrive,
ExternalLink,
} from "lucide-react";
import { kinds, nip19 } from "nostr-tools";
import { useEventStore, use$ } from "applesauce-react/hooks";
@@ -33,6 +32,7 @@ import { useEffect, useState } from "react";
import type { Subscription } from "rxjs";
import { useGrimoire } from "@/core/state";
import { USER_SERVER_LIST_KIND, getServersFromEvent } from "@/services/blossom";
import blossomServerCache from "@/services/blossom-server-cache";
export interface ProfileViewerProps {
pubkey: string;
@@ -43,7 +43,7 @@ export interface ProfileViewerProps {
* Shows profile metadata, inbox/outbox relays, and raw JSON
*/
export function ProfileViewer({ pubkey }: ProfileViewerProps) {
const { state } = useGrimoire();
const { state, addWindow } = useGrimoire();
const accountPubkey = state.activeAccount?.pubkey;
// Resolve $me alias
@@ -129,40 +129,55 @@ export function ProfileViewer({ pubkey }: ProfileViewerProps) {
// Fetch Blossom server list (kind 10063)
useEffect(() => {
if (!resolvedPubkey) return;
if (!resolvedPubkey) {
setBlossomServers([]);
return;
}
let subscription: Subscription | null = null;
// First, check cache for instant display
blossomServerCache.getServers(resolvedPubkey).then((cachedServers) => {
if (cachedServers && cachedServers.length > 0) {
setBlossomServers(cachedServers);
}
});
// Check if we already have the event in store
// Check if we already have the event in EventStore
const existingEvent = eventStore.getReplaceable(
USER_SERVER_LIST_KIND,
resolvedPubkey,
"",
);
if (existingEvent) {
setBlossomServers(getServersFromEvent(existingEvent));
const servers = getServersFromEvent(existingEvent);
setBlossomServers(servers);
// Also update cache
blossomServerCache.set(existingEvent);
}
// Also fetch from network
subscription = addressLoader({
// Subscribe to EventStore for reactive updates
const storeSubscription = eventStore
.replaceable(USER_SERVER_LIST_KIND, resolvedPubkey, "")
.subscribe((event) => {
if (event) {
const servers = getServersFromEvent(event);
setBlossomServers(servers);
// Also update cache
blossomServerCache.set(event);
} else {
setBlossomServers([]);
}
});
// Also fetch from network to get latest data
const networkSubscription = addressLoader({
kind: USER_SERVER_LIST_KIND,
pubkey: resolvedPubkey,
identifier: "",
}).subscribe({
next: () => {
const event = eventStore.getReplaceable(
USER_SERVER_LIST_KIND,
resolvedPubkey,
"",
);
if (event) {
setBlossomServers(getServersFromEvent(event));
}
},
});
}).subscribe();
return () => {
subscription?.unsubscribe();
storeSubscription.unsubscribe();
networkSubscription.unsubscribe();
};
}, [resolvedPubkey, eventStore]);
@@ -336,14 +351,25 @@ export function ProfileViewer({ pubkey }: ProfileViewerProps) {
{blossomServers.map((url) => (
<DropdownMenuItem
key={url}
className="flex items-center justify-between gap-2"
onClick={() => window.open(url, "_blank")}
className="flex items-center justify-between gap-2 cursor-crosshair"
onClick={() => {
if (resolvedPubkey) {
addWindow(
"blossom",
{
subcommand: "list",
pubkey: resolvedPubkey,
serverUrl: url,
},
`Files on ${url}`,
);
}
}}
>
<div className="flex items-center gap-1.5 flex-1 min-w-0">
<HardDrive className="size-3 text-muted-foreground flex-shrink-0" />
<span className="font-mono text-xs truncate">{url}</span>
</div>
<ExternalLink className="size-3 text-muted-foreground flex-shrink-0" />
</DropdownMenuItem>
))}
</DropdownMenuContent>

4
src/components/layouts/AppShell.tsx
View File

@@ -2,6 +2,7 @@ import { useState, useEffect, ReactNode } from "react";
import { Terminal } from "lucide-react";
import { useAccountSync } from "@/hooks/useAccountSync";
import { useRelayListCacheSync } from "@/hooks/useRelayListCacheSync";
import { useBlossomServerCacheSync } from "@/hooks/useBlossomServerCacheSync";
import { useRelayState } from "@/hooks/useRelayState";
import relayStateManager from "@/services/relay-state-manager";
import { TabBar } from "../TabBar";
@@ -25,6 +26,9 @@ export function AppShell({ children, hideBottomBar = false }: AppShellProps) {
// Auto-cache kind:10002 relay lists from EventStore to Dexie
useRelayListCacheSync();
// Auto-cache kind:10063 blossom server lists from EventStore to Dexie
useBlossomServerCacheSync();
// Initialize global relay state manager
useEffect(() => {
relayStateManager.initialize().catch((err) => {

31
src/components/nostr/user-menu.tsx
View File

@@ -1,4 +1,4 @@
import { User } from "lucide-react";
import { User, HardDrive } from "lucide-react";
import accounts from "@/services/accounts";
import { useProfile } from "@/hooks/useProfile";
import { use$ } from "applesauce-react/hooks";
@@ -54,6 +54,7 @@ export default function UserMenu() {
const account = use$(accounts.active$);
const { state, addWindow } = useGrimoire();
const relays = state.activeAccount?.relays;
const blossomServers = state.activeAccount?.blossomServers;
const [showSettings, setShowSettings] = useState(false);
const [showLogin, setShowLogin] = useState(false);
@@ -123,6 +124,34 @@ export default function UserMenu() {
</>
)}
{blossomServers && blossomServers.length > 0 && (
<>
<DropdownMenuSeparator />
<DropdownMenuGroup>
<DropdownMenuLabel className="text-xs text-muted-foreground font-normal flex items-center gap-1.5">
<HardDrive className="size-3.5" />
<span>Blossom Servers</span>
</DropdownMenuLabel>
{blossomServers.map((server) => (
<DropdownMenuItem
key={server}
className="cursor-crosshair"
onClick={() => {
addWindow(
"blossom",
{ subcommand: "list", serverUrl: server },
`Files on ${server}`,
);
}}
>
<HardDrive className="size-4 text-muted-foreground mr-2" />
<span className="text-sm truncate">{server}</span>
</DropdownMenuItem>
))}
</DropdownMenuGroup>
</>
)}
<DropdownMenuSeparator />
{/* <DropdownMenuItem
onClick={() => setShowSettings(true)}

25
src/core/logic.ts
View File

@@ -295,6 +295,31 @@ export const setActiveAccountRelays = (
};
};
/**
* Updates the blossom server list for the active account.
*/
export const setActiveAccountBlossomServers = (
state: GrimoireState,
blossomServers: string[],
): GrimoireState => {
if (!state.activeAccount) {
return state;
}
// If blossom servers reference hasn't changed, return state unchanged
if (state.activeAccount.blossomServers === blossomServers) {
return state;
}
return {
...state,
activeAccount: {
...state.activeAccount,
blossomServers,
},
};
};
/**
* Deletes a workspace by ID.
* Cannot delete the last remaining workspace.

10
src/core/state.ts
View File

@@ -275,6 +275,15 @@ export const useGrimoire = () => {
[setState],
);
const setActiveAccountBlossomServers = useCallback(
(blossomServers: string[]) => {
setState((prev) =>
Logic.setActiveAccountBlossomServers(prev, blossomServers),
);
},
[setState],
);
const updateLayoutConfig = useCallback(
(layoutConfig: Partial<LayoutConfig>) => {
setState((prev) => Logic.updateLayoutConfig(prev, layoutConfig));
@@ -351,6 +360,7 @@ export const useGrimoire = () => {
setActiveWorkspace,
setActiveAccount,
setActiveAccountRelays,
setActiveAccountBlossomServers,
updateLayoutConfig,
applyPresetLayout,
updateWorkspaceLabel,

46
src/hooks/useAccountSync.ts
View File

@@ -5,12 +5,17 @@ import { useGrimoire } from "@/core/state";
import { addressLoader } from "@/services/loaders";
import type { RelayInfo } from "@/types/app";
import { normalizeRelayURL } from "@/lib/relay-url";
import { getServersFromEvent } from "@/services/blossom";
/**
* Hook that syncs active account with Grimoire state and fetches relay lists
* Hook that syncs active account with Grimoire state and fetches relay lists and blossom servers
*/
export function useAccountSync() {
const { setActiveAccount, setActiveAccountRelays } = useGrimoire();
const {
setActiveAccount,
setActiveAccountRelays,
setActiveAccountBlossomServers,
} = useGrimoire();
const eventStore = useEventStore();
// Watch active account from accounts service
@@ -83,4 +88,41 @@ export function useAccountSync() {
storeSubscription.unsubscribe();
};
}, [activeAccount?.pubkey, eventStore, setActiveAccountRelays]);
// Fetch and watch blossom server list (kind 10063) when account changes
useEffect(() => {
if (!activeAccount?.pubkey) {
return;
}
const pubkey = activeAccount.pubkey;
let lastBlossomEventId: string | undefined;
// Subscribe to kind 10063 (blossom server list)
const subscription = addressLoader({
kind: 10063,
pubkey,
identifier: "",
}).subscribe();
// Watch for blossom server list event in store
const storeSubscription = eventStore
.replaceable(10063, pubkey, "")
.subscribe((blossomListEvent) => {
if (!blossomListEvent) return;
// Only process if this is a new event
if (blossomListEvent.id === lastBlossomEventId) return;
lastBlossomEventId = blossomListEvent.id;
// Parse servers from event
const servers = getServersFromEvent(blossomListEvent);
setActiveAccountBlossomServers(servers);
});
return () => {
subscription.unsubscribe();
storeSubscription.unsubscribe();
};
}, [activeAccount?.pubkey, eventStore, setActiveAccountBlossomServers]);
}

24
src/hooks/useBlossomServerCacheSync.ts Normal file
View File

@@ -0,0 +1,24 @@
/**
* Hook to keep blossom server cache in sync with EventStore
*
* Subscribes to kind:10063 events and automatically caches them in Dexie.
* Should be used once at app root level.
*/
import { useEffect } from "react";
import { useEventStore } from "applesauce-react/hooks";
import blossomServerCache from "@/services/blossom-server-cache";
export function useBlossomServerCacheSync() {
const eventStore = useEventStore();
useEffect(() => {
// Subscribe to EventStore for auto-caching
blossomServerCache.subscribeToEventStore(eventStore);
// Cleanup on unmount
return () => {
blossomServerCache.unsubscribe();
};
}, [eventStore]);
}

285
src/services/blossom-server-cache.ts Normal file
View File

@@ -0,0 +1,285 @@
/**
* Blossom Server Cache Service
*
* Caches BUD-03 blossom server lists (kind:10063) in Dexie for fast access.
* Reduces network requests and improves cold start performance.
*
* Auto-caches kind:10063 events from EventStore when subscribed.
*/
import type { NostrEvent } from "@/types/nostr";
import { getServersFromEvent } from "./blossom";
import db, { CachedBlossomServerList } from "./db";
import type { IEventStore } from "applesauce-core/event-store";
import type { Subscription } from "rxjs";
const CACHE_TTL = 24 * 60 * 60 * 1000; // 24 hours
const MAX_MEMORY_CACHE = 100; // LRU cache size
class BlossomServerCache {
private eventStoreSubscription: Subscription | null = null;
private memoryCache = new Map<string, CachedBlossomServerList>();
private cacheOrder: string[] = [];
/**
* Subscribe to EventStore to auto-cache kind:10063 events
*/
subscribeToEventStore(eventStore: IEventStore): void {
if (this.eventStoreSubscription) {
console.warn("[BlossomServerCache] Already subscribed to EventStore");
return;
}
// Subscribe to kind:10063 events
this.eventStoreSubscription = eventStore
.filters({ kinds: [10063] })
.subscribe((event: NostrEvent) => {
// Cache each kind:10063 event as it arrives
this.set(event);
});
console.log(
"[BlossomServerCache] Subscribed to EventStore for kind:10063 events",
);
}
/**
* Unsubscribe from EventStore
*/
unsubscribe(): void {
if (this.eventStoreSubscription) {
this.eventStoreSubscription.unsubscribe();
this.eventStoreSubscription = null;
console.log("[BlossomServerCache] Unsubscribed from EventStore");
}
}
/**
* Get cached blossom server list for a pubkey
* Returns undefined if not cached or stale
*/
async get(pubkey: string): Promise<CachedBlossomServerList | undefined> {
try {
const cached = await db.blossomServers.get(pubkey);
// Check if stale (>24 hours)
if (cached && Date.now() - cached.updatedAt < CACHE_TTL) {
return cached;
}
// Stale or not found
if (cached) {
console.debug(
`[BlossomServerCache] Cached server list for ${pubkey.slice(0, 8)} is stale (${Math.floor((Date.now() - cached.updatedAt) / 1000 / 60)}min old)`,
);
}
return undefined;
} catch (error) {
console.error(
`[BlossomServerCache] Error reading cache for ${pubkey.slice(0, 8)}:`,
error,
);
return undefined;
}
}
/**
* Store blossom server list event in cache
*/
async set(event: NostrEvent): Promise<void> {
try {
if (event.kind !== 10063) {
console.warn(
`[BlossomServerCache] Attempted to cache non-10063 event (kind ${event.kind})`,
);
return;
}
// Parse servers from event
const servers = getServersFromEvent(event);
// Store in Dexie and memory cache
const cachedEntry: CachedBlossomServerList = {
pubkey: event.pubkey,
event,
servers,
updatedAt: Date.now(),
};
await db.blossomServers.put(cachedEntry);
// Also populate memory cache
this.memoryCache.set(event.pubkey, cachedEntry);
this.cacheOrder.push(event.pubkey);
this.evictOldest();
console.debug(
`[BlossomServerCache] Cached ${servers.length} server(s) for ${event.pubkey.slice(0, 8)}`,
);
} catch (error) {
console.error(
`[BlossomServerCache] Error caching server list for ${event.pubkey.slice(0, 8)}:`,
error,
);
}
}
/**
* Update LRU order for a pubkey
*/
private updateLRU(pubkey: string): void {
const index = this.cacheOrder.indexOf(pubkey);
if (index > -1) {
this.cacheOrder.splice(index, 1);
}
this.cacheOrder.push(pubkey);
}
/**
* Evict oldest entries from memory cache if over limit
*/
private evictOldest(): void {
while (this.cacheOrder.length > MAX_MEMORY_CACHE) {
const oldest = this.cacheOrder.shift();
if (oldest) {
this.memoryCache.delete(oldest);
}
}
}
/**
* Get blossom servers from memory cache only (synchronous, fast)
* Used for real-time operations where async Dexie lookup would be too slow
* Returns null if not in memory cache
*/
getServersSync(pubkey: string): string[] | null {
const memCached = this.memoryCache.get(pubkey);
if (memCached && Date.now() - memCached.updatedAt < CACHE_TTL) {
this.updateLRU(pubkey);
return memCached.servers;
}
return null;
}
/**
* Get blossom servers for a pubkey from cache
*/
async getServers(pubkey: string): Promise<string[] | null> {
// Check memory cache first (< 1ms)
const memCached = this.memoryCache.get(pubkey);
if (memCached && Date.now() - memCached.updatedAt < CACHE_TTL) {
this.updateLRU(pubkey);
return memCached.servers;
}
// Then check Dexie (5-10ms)
const cached = await this.get(pubkey);
if (cached) {
// Populate memory cache for next time
this.memoryCache.set(pubkey, cached);
this.cacheOrder.push(pubkey);
this.evictOldest();
return cached.servers;
}
return null;
}
/**
* Check if we have a valid cache entry for a pubkey
*/
async has(pubkey: string): Promise<boolean> {
const cached = await this.get(pubkey);
return cached !== undefined;
}
/**
* Invalidate (delete) cache entry for a pubkey
*/
async invalidate(pubkey: string): Promise<void> {
try {
await db.blossomServers.delete(pubkey);
// Also remove from memory cache
this.memoryCache.delete(pubkey);
const index = this.cacheOrder.indexOf(pubkey);
if (index > -1) {
this.cacheOrder.splice(index, 1);
}
console.debug(
`[BlossomServerCache] Invalidated cache for ${pubkey.slice(0, 8)}`,
);
} catch (error) {
console.error(
`[BlossomServerCache] Error invalidating cache for ${pubkey.slice(0, 8)}:`,
error,
);
}
}
/**
* Clear all cached blossom server lists
*/
async clear(): Promise<void> {
try {
await db.blossomServers.clear();
// Also clear memory cache
this.memoryCache.clear();
this.cacheOrder = [];
console.log("[BlossomServerCache] Cleared all cached server lists");
} catch (error) {
console.error("[BlossomServerCache] Error clearing cache:", error);
}
}
/**
* Get cache statistics
*/
async getStats(): Promise<{
count: number;
oldestEntry: number | null;
newestEntry: number | null;
memoryCacheSize: number;
memoryCacheLimit: number;
}> {
try {
const count = await db.blossomServers.count();
const all = await db.blossomServers.toArray();
if (all.length === 0) {
return {
count: 0,
oldestEntry: null,
newestEntry: null,
memoryCacheSize: this.memoryCache.size,
memoryCacheLimit: MAX_MEMORY_CACHE,
};
}
const timestamps = all.map((entry) => entry.updatedAt);
const oldest = Math.min(...timestamps);
const newest = Math.max(...timestamps);
return {
count,
oldestEntry: oldest,
newestEntry: newest,
memoryCacheSize: this.memoryCache.size,
memoryCacheLimit: MAX_MEMORY_CACHE,
};
} catch (error) {
console.error("[BlossomServerCache] Error getting stats:", error);
return {
count: 0,
oldestEntry: null,
newestEntry: null,
memoryCacheSize: this.memoryCache.size,
memoryCacheLimit: MAX_MEMORY_CACHE,
};
}
}
}
// Singleton instance
export const blossomServerCache = new BlossomServerCache();
export default blossomServerCache;

22
src/services/db.ts
View File

@@ -54,6 +54,13 @@ export interface RelayLivenessEntry {
backoffUntil?: number;
}
export interface CachedBlossomServerList {
pubkey: string;
event: NostrEvent;
servers: string[];
updatedAt: number;
}
export interface LocalSpell {
id: string; // UUID for local-only spells, or event ID for published spells
alias?: string; // Optional local-only quick name (e.g., "btc")
@@ -88,6 +95,7 @@ class GrimoireDb extends Dexie {
relayAuthPreferences!: Table<RelayAuthPreference>;
relayLists!: Table<CachedRelayList>;
relayLiveness!: Table<RelayLivenessEntry>;
blossomServers!: Table<CachedBlossomServerList>;
spells!: Table<LocalSpell>;
spellbooks!: Table<LocalSpellbook>;
@@ -311,6 +319,20 @@ class GrimoireDb extends Dexie {
spells: "&id, alias, createdAt, isPublished, deletedAt",
spellbooks: "&id, slug, title, createdAt, isPublished, deletedAt",
});
// Version 15: Add blossom server list caching
this.version(15).stores({
profiles: "&pubkey",
nip05: "&nip05",
nips: "&id",
relayInfo: "&url",
relayAuthPreferences: "&url",
relayLists: "&pubkey, updatedAt",
relayLiveness: "&url",
blossomServers: "&pubkey, updatedAt",
spells: "&id, alias, createdAt, isPublished, deletedAt",
spellbooks: "&id, slug, title, createdAt, isPublished, deletedAt",
});
}
}

1
src/types/app.ts
View File

@@ -87,6 +87,7 @@ export interface GrimoireState {
activeAccount?: {
pubkey: string;
relays?: RelayInfo[];
blossomServers?: string[];
};
compactModeKinds?: number[];
locale?: {