feat(core): prevent caching of ephemeral events

Ephemeral events (kind 20000-29999) are not meant to be stored. This change prevents them from being saved to the cache.

A test case has been added to ensure that ephemeral events are not passed to the cache adapter.

Author: google-labs-jules[bot]

core/src/subscription.test.ts

@@ -1,6 +1,14 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { EventGenerator, RelayPoolMock } from "../test";
-import NDK, { type NDKEvent, type NDKFilter, NDKKind, type NDKRelay, NDKRelaySet, NDKSubscription } from "./index";
+import NDK, {
+    NDKSubscriptionCacheUsage,
+    type NDKEvent,
+    type NDKFilter,
+    NDKKind,
+    type NDKRelay,
+    NDKRelaySet,
+    NDKSubscription,
+} from "./index";
 
 describe("NDKSubscription", () => {
     let ndk: NDK;
@@ -120,4 +128,48 @@ describe("NDKSubscription", () => {
         expect(eoseReceived).toBe(true);
         expect(closedReceived).toBe(true);
     });
+
+    it("should not cache ephemeral events", async () => {
+        // Mock cache adapter
+        const mockCacheAdapter = {
+            setEvent: vi.fn(),
+            query: vi.fn().mockResolvedValue([]),
+        };
+        // @ts-expect-error - We're intentionally replacing the cache for testing
+        ndk.cacheAdapter = mockCacheAdapter;
+
+        // Create replaceable and ephemeral events
+        const replaceableEvent = EventGenerator.createEvent(10002, "replaceable");
+        await replaceableEvent.sign();
+        const ephemeralEvent = EventGenerator.createEvent(20000, "ephemeral");
+        await ephemeralEvent.sign();
+
+        // Get the first relay
+        const relaysArray = Array.from(pool.relays);
+        const mockRelay = relaysArray[0];
+        const relaySet = new NDKRelaySet(new Set([mockRelay as unknown as NDKRelay]), ndk);
+        const filter: NDKFilter = {
+            kinds: [replaceableEvent.kind as number, ephemeralEvent.kind as number],
+        };
+        const sub = new NDKSubscription(ndk, filter, {
+            subId: "test-subscription-cache",
+            skipVerification: true,
+            skipValidation: true,
+            relaySet,
+            cacheUsage: NDKSubscriptionCacheUsage.ONLY_RELAY,
+        });
+
+        // Start subscription and simulate events
+        sub.start();
+        await mockRelay.simulateEvent(replaceableEvent, sub.subId!);
+        await mockRelay.simulateEvent(ephemeralEvent, sub.subId!);
+        mockRelay.simulateEOSE(sub.subId!);
+        // Verify cache adapter was only called for the replaceable event
+        expect(mockCacheAdapter.setEvent).toHaveBeenCalledTimes(1);
+        expect(mockCacheAdapter.setEvent).toHaveBeenCalledWith(
+            expect.objectContaining({ id: replaceableEvent.id }),
+            expect.any(Array),
+            expect.any(Object)
+        );
+    });
 });

core/src/subscription/index.ts

@@ -823,7 +823,7 @@ export class NDKSubscription extends EventEmitter<{
                     }
                 }
 
-                if (this.ndk.cacheAdapter && !this.opts.dontSaveToCache) {
+                if (this.ndk.cacheAdapter && !this.opts.dontSaveToCache && !kindIsEphemeral(ndkEvent.kind as NDKKind)) {
                     this.ndk.cacheAdapter.setEvent(ndkEvent, this.filters, relay);
                 }
             }