Refactor EventStore to use a more Set-like interface

scripts/db.ts

@@ -39,6 +39,6 @@ async function usersToEvents() {
       created_at: Math.floor(new Date(row.inserted_at).getTime() / 1000),
     });
 
-    await eventsDB.storeEvent(event);
+    await eventsDB.add(event);
   }
 }

src/controllers/api/accounts.ts

@@ -134,7 +134,7 @@ const accountStatusesController: AppController = async (c) => {
   const { pinned, limit, exclude_replies, tagged } = accountStatusesQuerySchema.parse(c.req.query());
 
   if (pinned) {
-    const [pinEvent] = await eventsDB.getEvents([{ kinds: [10001], authors: [pubkey], limit: 1 }]);
+    const [pinEvent] = await eventsDB.filter([{ kinds: [10001], authors: [pubkey], limit: 1 }]);
     if (pinEvent) {
       const pinnedEventIds = getTagSet(pinEvent.tags, 'e');
       return renderStatuses(c, [...pinnedEventIds].reverse());
@@ -156,7 +156,7 @@ const accountStatusesController: AppController = async (c) => {
     filter['#t'] = [tagged];
   }
 
-  let events = await eventsDB.getEvents([filter]);
+  let events = await eventsDB.filter([filter]);
 
   if (exclude_replies) {
     events = events.filter((event) => !findReplyTag(event));
@@ -293,7 +293,7 @@ const favouritesController: AppController = async (c) => {
   const pubkey = c.get('pubkey')!;
   const params = paginationSchema.parse(c.req.query());
 
-  const events7 = await eventsDB.getEvents(
+  const events7 = await eventsDB.filter(
     [{ kinds: [7], authors: [pubkey], ...params }],
     { signal: AbortSignal.timeout(1000) },
   );
@@ -302,7 +302,7 @@ const favouritesController: AppController = async (c) => {
     .map((event) => event.tags.find((tag) => tag[0] === 'e')?.[1])
     .filter((id): id is string => !!id);
 
-  const events1 = await eventsDB.getEvents(
+  const events1 = await eventsDB.filter(
     [{ kinds: [1], ids, relations: ['author', 'event_stats', 'author_stats'] }],
     {
       signal: AbortSignal.timeout(1000),

src/controllers/api/admin.ts

@@ -39,9 +39,9 @@ const adminAccountsController: AppController = async (c) => {
 
   const { since, until, limit } = paginationSchema.parse(c.req.query());
 
-  const events = await eventsDB.getEvents([{ kinds: [30361], authors: [Conf.pubkey], since, until, limit }]);
+  const events = await eventsDB.filter([{ kinds: [30361], authors: [Conf.pubkey], since, until, limit }]);
   const pubkeys = events.map((event) => event.tags.find(([name]) => name === 'd')?.[1]!);
-  const authors = await eventsDB.getEvents([{ kinds: [0], authors: pubkeys }]);
+  const authors = await eventsDB.filter([{ kinds: [0], authors: pubkeys }]);
 
   for (const event of events) {
     const d = event.tags.find(([name]) => name === 'd')?.[1];

src/controllers/api/blocks.ts

@@ -7,7 +7,7 @@ import { renderAccounts } from '@/views.ts';
 const blocksController: AppController = async (c) => {
   const pubkey = c.get('pubkey')!;
 
-  const [event10000] = await eventsDB.getEvents([
+  const [event10000] = await eventsDB.filter([
     { kinds: [10000], authors: [pubkey], limit: 1 },
   ]);
 

src/controllers/api/bookmarks.ts

@@ -7,7 +7,7 @@ import { renderStatuses } from '@/views.ts';
 const bookmarksController: AppController = async (c) => {
   const pubkey = c.get('pubkey')!;
 
-  const [event10003] = await eventsDB.getEvents([
+  const [event10003] = await eventsDB.filter([
     { kinds: [10003], authors: [pubkey], limit: 1 },
   ]);
 

src/controllers/api/notifications.ts

@@ -7,7 +7,7 @@ const notificationsController: AppController = async (c) => {
   const pubkey = c.get('pubkey')!;
   const { since, until } = paginationSchema.parse(c.req.query());
 
-  const events = await eventsDB.getEvents(
+  const events = await eventsDB.filter(
     [{ kinds: [1], '#p': [pubkey], since, until }],
     { signal: AbortSignal.timeout(3000) },
   );

src/controllers/api/pleroma.ts

@@ -6,7 +6,7 @@ import { createAdminEvent } from '@/utils/api.ts';
 import { Conf } from '@/config.ts';
 
 const frontendConfigController: AppController = async (c) => {
-  const [event] = await eventsDB.getEvents([{
+  const [event] = await eventsDB.filter([{
     kinds: [30078],
     authors: [Conf.pubkey],
     '#d': ['pub.ditto.frontendConfig'],

src/controllers/api/search.ts

@@ -78,7 +78,7 @@ function searchEvents({ q, type, limit, account_id }: SearchQuery, signal: Abort
     filter.authors = [account_id];
   }
 
-  return searchStore.getEvents([filter], { signal });
+  return searchStore.filter([filter], { signal });
 }
 
 /** Get event kinds to search from `type` query param. */
@@ -96,7 +96,7 @@ function typeToKinds(type: SearchQuery['type']): number[] {
 /** Resolve a searched value into an event, if applicable. */
 async function lookupEvent(query: SearchQuery, signal: AbortSignal): Promise<Event | undefined> {
   const filters = await getLookupFilters(query);
-  const [event] = await searchStore.getEvents(filters, { limit: 1, signal });
+  const [event] = await searchStore.filter(filters, { limit: 1, signal });
   return event;
 }
 

src/controllers/api/timelines.ts

@@ -33,7 +33,7 @@ const hashtagTimelineController: AppController = (c) => {
 
 /** Render statuses for timelines. */
 async function renderStatuses(c: AppContext, filters: DittoFilter<1>[], signal = AbortSignal.timeout(1000)) {
-  const events = await eventsDB.getEvents(
+  const events = await eventsDB.filter(
     filters.map((filter) => ({ ...filter, relations: ['author', 'event_stats', 'author_stats'] })),
     { signal },
   );

src/controllers/nostr/relay.ts

@@ -63,7 +63,7 @@ function connectStream(socket: WebSocket) {
   async function handleReq([_, subId, ...rest]: ClientREQ): Promise<void> {
     const filters = prepareFilters(rest);
 
-    for (const event of await eventsDB.getEvents(filters, { limit: FILTER_LIMIT })) {
+    for (const event of await eventsDB.filter(filters, { limit: FILTER_LIMIT })) {
       send(['EVENT', subId, event]);
     }
 
@@ -96,7 +96,7 @@ function connectStream(socket: WebSocket) {
 
   /** Handle COUNT. Return the number of events matching the filters. */
   async function handleCount([_, subId, ...rest]: ClientCOUNT): Promise<void> {
-    const count = await eventsDB.countEvents(prepareFilters(rest));
+    const count = await eventsDB.count(prepareFilters(rest));
     send(['COUNT', subId, { count, approximate: false }]);
   }
 

src/db/users.ts

@@ -65,7 +65,7 @@ async function findUser(user: Partial<User>): Promise<User | undefined> {
     }
   }
 
-  const [event] = await eventsDB.getEvents([filter]);
+  const [event] = await eventsDB.filter([filter]);
 
   if (event) {
     return {

src/pipeline.ts

@@ -41,9 +41,9 @@ async function handleEvent(event: Event): Promise<void> {
 
 /** Encounter the event, and return whether it has already been encountered. */
 async function encounterEvent(event: Event): Promise<boolean> {
-  const preexisting = (await memorelay.countEvents([{ ids: [event.id] }])) > 0;
+  const preexisting = (await memorelay.count([{ ids: [event.id] }])) > 0;
-  memorelay.storeEvent(event);
+  memorelay.add(event);
-  reqmeister.storeEvent(event);
+  reqmeister.add(event);
   return preexisting;
 }
 
@@ -66,7 +66,7 @@ async function storeEvent(event: Event, data: EventData, opts: StoreEventOpts =
   const { force = false } = opts;
 
   if (force || data.user || isAdminEvent(event) || await isLocallyFollowed(event.pubkey)) {
-    const [deletion] = await eventsDB.getEvents(
+    const [deletion] = await eventsDB.filter(
       [{ kinds: [5], authors: [event.pubkey], '#e': [event.id], limit: 1 }],
       { limit: 1 },
     );
@@ -75,7 +75,7 @@ async function storeEvent(event: Event, data: EventData, opts: StoreEventOpts =
       return Promise.reject(new RelayError('blocked', 'event was deleted'));
     } else {
       await Promise.all([
-        eventsDB.storeEvent(event, { data }).catch(debug),
+        eventsDB.add(event, { data }).catch(debug),
         updateStats(event).catch(debug),
       ]);
     }
@@ -88,13 +88,13 @@ async function storeEvent(event: Event, data: EventData, opts: StoreEventOpts =
 async function processDeletions(event: Event): Promise<void> {
   if (event.kind === 5) {
     const ids = getTagSet(event.tags, 'e');
-    const events = await eventsDB.getEvents([{ ids: [...ids] }]);
+    const events = await eventsDB.filter([{ ids: [...ids] }]);
 
     const deleteIds = events
       .filter(({ pubkey, id }) => pubkey === event.pubkey && ids.has(id))
       .map((event) => event.id);
 
-    await eventsDB.deleteEvents([{ ids: deleteIds }]);
+    await eventsDB.deleteFilters([{ ids: deleteIds }]);
   }
 }
 
@@ -139,7 +139,7 @@ function fetchRelatedEvents(event: Event, data: EventData) {
     reqmeister.req({ kinds: [0], authors: [event.pubkey] }).catch(() => {});
   }
   for (const [name, id, relay] of event.tags) {
-    if (name === 'e' && !memorelay.countEvents([{ ids: [id] }])) {
+    if (name === 'e' && !memorelay.count([{ ids: [id] }])) {
       reqmeister.req({ ids: [id] }, { relays: [relay] }).catch(() => {});
     }
   }
@@ -173,7 +173,7 @@ function broadcast(event: Event, data: EventData) {
   if (!data.user || !isFresh(event)) return;
 
   if (event.kind === 5) {
-    client.storeEvent(event);
+    client.add(event);
   }
 }
 

src/queries.ts

@@ -24,7 +24,7 @@ const getEvent = async <K extends number = number>(
   const { kind, relations, signal = AbortSignal.timeout(1000) } = opts;
   const microfilter: IdMicrofilter = { ids: [id] };
 
-  const [memoryEvent] = await memorelay.getEvents([microfilter], opts) as DittoEvent<K>[];
+  const [memoryEvent] = await memorelay.filter([microfilter], opts) as DittoEvent<K>[];
 
   if (memoryEvent && !relations) {
     debug(`getEvent: ${id.slice(0, 8)} found in memory`);
@@ -36,13 +36,13 @@ const getEvent = async <K extends number = number>(
     filter.kinds = [kind];
   }
 
-  const dbEvent = await eventsDB.getEvents([filter], { limit: 1, signal })
+  const dbEvent = await eventsDB.filter([filter], { limit: 1, signal })
     .then(([event]) => event);
 
   // TODO: make this DRY-er.
 
   if (dbEvent && !dbEvent.author) {
-    const [author] = await memorelay.getEvents([{ kinds: [0], authors: [dbEvent.pubkey] }], opts);
+    const [author] = await memorelay.filter([{ kinds: [0], authors: [dbEvent.pubkey] }], opts);
     dbEvent.author = author;
   }
 
@@ -52,7 +52,7 @@ const getEvent = async <K extends number = number>(
   }
 
   if (memoryEvent && !memoryEvent.author) {
-    const [author] = await memorelay.getEvents([{ kinds: [0], authors: [memoryEvent.pubkey] }], opts);
+    const [author] = await memorelay.filter([{ kinds: [0], authors: [memoryEvent.pubkey] }], opts);
     memoryEvent.author = author;
   }
 
@@ -76,13 +76,13 @@ const getAuthor = async (pubkey: string, opts: GetEventOpts<0> = {}): Promise<Ev
   const { relations, signal = AbortSignal.timeout(1000) } = opts;
   const microfilter: AuthorMicrofilter = { kinds: [0], authors: [pubkey] };
 
-  const [memoryEvent] = await memorelay.getEvents([microfilter], opts);
+  const [memoryEvent] = await memorelay.filter([microfilter], opts);
 
   if (memoryEvent && !relations) {
     return memoryEvent;
   }
 
-  const dbEvent = await eventsDB.getEvents(
+  const dbEvent = await eventsDB.filter(
     [{ authors: [pubkey], relations, kinds: [0], limit: 1 }],
     { limit: 1, signal },
   ).then(([event]) => event);
@@ -95,7 +95,7 @@ const getAuthor = async (pubkey: string, opts: GetEventOpts<0> = {}): Promise<Ev
 
 /** Get users the given pubkey follows. */
 const getFollows = async (pubkey: string, signal?: AbortSignal): Promise<Event<3> | undefined> => {
-  const [event] = await eventsDB.getEvents([{ authors: [pubkey], kinds: [3], limit: 1 }], { limit: 1, signal });
+  const [event] = await eventsDB.filter([{ authors: [pubkey], kinds: [3], limit: 1 }], { limit: 1, signal });
   return event;
 };
 
@@ -131,7 +131,7 @@ async function getAncestors(event: Event<1>, result = [] as Event<1>[]): Promise
 }
 
 function getDescendants(eventId: string, signal = AbortSignal.timeout(2000)): Promise<Event<1>[]> {
-  return eventsDB.getEvents(
+  return eventsDB.filter(
     [{ kinds: [1], '#e': [eventId], relations: ['author', 'event_stats', 'author_stats'] }],
     { limit: 200, signal },
   );
@@ -139,7 +139,7 @@ function getDescendants(eventId: string, signal = AbortSignal.timeout(2000)): Pr
 
 /** Returns whether the pubkey is followed by a local user. */
 async function isLocallyFollowed(pubkey: string): Promise<boolean> {
-  const [event] = await eventsDB.getEvents([{ kinds: [3], '#p': [pubkey], local: true, limit: 1 }], { limit: 1 });
+  const [event] = await eventsDB.filter([{ kinds: [3], '#p': [pubkey], local: true, limit: 1 }], { limit: 1 });
   return Boolean(event);
 }
 

src/stats.ts

@@ -125,7 +125,7 @@ function eventStatsQuery(diffs: EventStatDiff[]) {
 
 /** Get the last version of the event, if any. */
 async function maybeGetPrev<K extends number>(event: Event<K>): Promise<Event<K>> {
-  const [prev] = await eventsDB.getEvents([
+  const [prev] = await eventsDB.filter([
     { kinds: [event.kind], authors: [event.pubkey], limit: 1 },
   ]);
 

src/storages/events-db.test.ts

@@ -10,37 +10,37 @@ import { EventsDB } from './events-db.ts';
 const eventsDB = new EventsDB(db);
 
 Deno.test('count filters', async () => {
-  assertEquals(await eventsDB.countEvents([{ kinds: [1] }]), 0);
+  assertEquals(await eventsDB.count([{ kinds: [1] }]), 0);
-  await eventsDB.storeEvent(event1);
+  await eventsDB.add(event1);
-  assertEquals(await eventsDB.countEvents([{ kinds: [1] }]), 1);
+  assertEquals(await eventsDB.count([{ kinds: [1] }]), 1);
 });
 
 Deno.test('insert and filter events', async () => {
-  await eventsDB.storeEvent(event1);
+  await eventsDB.add(event1);
 
-  assertEquals(await eventsDB.getEvents([{ kinds: [1] }]), [event1]);
+  assertEquals(await eventsDB.filter([{ kinds: [1] }]), [event1]);
-  assertEquals(await eventsDB.getEvents([{ kinds: [3] }]), []);
+  assertEquals(await eventsDB.filter([{ kinds: [3] }]), []);
-  assertEquals(await eventsDB.getEvents([{ since: 1691091000 }]), [event1]);
+  assertEquals(await eventsDB.filter([{ since: 1691091000 }]), [event1]);
-  assertEquals(await eventsDB.getEvents([{ until: 1691091000 }]), []);
+  assertEquals(await eventsDB.filter([{ until: 1691091000 }]), []);
   assertEquals(
-    await eventsDB.getEvents([{ '#proxy': ['https://gleasonator.com/objects/8f6fac53-4f66-4c6e-ac7d-92e5e78c3e79'] }]),
+    await eventsDB.filter([{ '#proxy': ['https://gleasonator.com/objects/8f6fac53-4f66-4c6e-ac7d-92e5e78c3e79'] }]),
     [event1],
   );
 });
 
 Deno.test('delete events', async () => {
-  await eventsDB.storeEvent(event1);
+  await eventsDB.add(event1);
-  assertEquals(await eventsDB.getEvents([{ kinds: [1] }]), [event1]);
+  assertEquals(await eventsDB.filter([{ kinds: [1] }]), [event1]);
-  await eventsDB.deleteEvents([{ kinds: [1] }]);
+  await eventsDB.deleteFilters([{ kinds: [1] }]);
-  assertEquals(await eventsDB.getEvents([{ kinds: [1] }]), []);
+  assertEquals(await eventsDB.filter([{ kinds: [1] }]), []);
 });
 
 Deno.test('query events with local filter', async () => {
-  await eventsDB.storeEvent(event1);
+  await eventsDB.add(event1);
 
-  assertEquals(await eventsDB.getEvents([{}]), [event1]);
+  assertEquals(await eventsDB.filter([{}]), [event1]);
-  assertEquals(await eventsDB.getEvents([{ local: true }]), []);
+  assertEquals(await eventsDB.filter([{ local: true }]), []);
-  assertEquals(await eventsDB.getEvents([{ local: false }]), [event1]);
+  assertEquals(await eventsDB.filter([{ local: false }]), [event1]);
 
   const userEvent = await buildUserEvent({
     username: 'alex',
@@ -48,20 +48,20 @@ Deno.test('query events with local filter', async () => {
     inserted_at: new Date(),
     admin: false,
   });
-  await eventsDB.storeEvent(userEvent);
+  await eventsDB.add(userEvent);
 
-  assertEquals(await eventsDB.getEvents([{ kinds: [1], local: true }]), [event1]);
+  assertEquals(await eventsDB.filter([{ kinds: [1], local: true }]), [event1]);
-  assertEquals(await eventsDB.getEvents([{ kinds: [1], local: false }]), []);
+  assertEquals(await eventsDB.filter([{ kinds: [1], local: false }]), []);
 });
 
 Deno.test('inserting replaceable events', async () => {
-  assertEquals(await eventsDB.countEvents([{ kinds: [0], authors: [event0.pubkey] }]), 0);
+  assertEquals(await eventsDB.count([{ kinds: [0], authors: [event0.pubkey] }]), 0);
 
-  await eventsDB.storeEvent(event0);
+  await eventsDB.add(event0);
-  await assertRejects(() => eventsDB.storeEvent(event0));
+  await assertRejects(() => eventsDB.add(event0));
-  assertEquals(await eventsDB.countEvents([{ kinds: [0], authors: [event0.pubkey] }]), 1);
+  assertEquals(await eventsDB.count([{ kinds: [0], authors: [event0.pubkey] }]), 1);
 
   const changeEvent = { ...event0, id: '123', created_at: event0.created_at + 1 };
-  await eventsDB.storeEvent(changeEvent);
+  await eventsDB.add(changeEvent);
-  assertEquals(await eventsDB.getEvents([{ kinds: [0] }]), [changeEvent]);
+  assertEquals(await eventsDB.filter([{ kinds: [0] }]), [changeEvent]);
 });

src/storages/events-db.ts

@@ -65,7 +65,7 @@ class EventsDB implements EventStore {
   }
 
   /** Insert an event (and its tags) into the database. */
-  async storeEvent(event: Event, opts: StoreEventOpts = {}): Promise<void> {
+  async add(event: Event, opts: StoreEventOpts = {}): Promise<void> {
     this.#debug('EVENT', JSON.stringify(event));
 
     if (isDittoInternalKind(event.kind) && event.pubkey !== Conf.pubkey) {
@@ -264,7 +264,7 @@ class EventsDB implements EventStore {
   }
 
   /** Get events for filters from the database. */
-  async getEvents<K extends number>(filters: DittoFilter<K>[], opts: GetEventsOpts = {}): Promise<DittoEvent<K>[]> {
+  async filter<K extends number>(filters: DittoFilter<K>[], opts: GetEventsOpts = {}): Promise<DittoEvent<K>[]> {
     filters = normalizeFilters(filters); // Improves performance of `{ kinds: [0], authors: ['...'] }` queries.
 
     if (opts.signal?.aborted) return Promise.resolve([]);
@@ -337,7 +337,7 @@ class EventsDB implements EventStore {
   }
 
   /** Delete events based on filters from the database. */
-  async deleteEvents<K extends number>(filters: DittoFilter<K>[]): Promise<void> {
+  async deleteFilters<K extends number>(filters: DittoFilter<K>[]): Promise<void> {
     if (!filters.length) return Promise.resolve();
     this.#debug('DELETE', JSON.stringify(filters));
 
@@ -345,7 +345,7 @@ class EventsDB implements EventStore {
   }
 
   /** Get number of events that would be returned by filters. */
-  async countEvents<K extends number>(filters: DittoFilter<K>[]): Promise<number> {
+  async count<K extends number>(filters: DittoFilter<K>[]): Promise<number> {
     if (!filters.length) return Promise.resolve(0);
     this.#debug('COUNT', JSON.stringify(filters));
     const query = this.getEventsQuery(filters);

src/storages/hydrate.ts

@@ -14,7 +14,7 @@ async function hydrateEvents<K extends number>(opts: HydrateEventOpts<K>): Promi
 
   if (filters.some((filter) => filter.relations?.includes('author'))) {
     const pubkeys = new Set([...events].map((event) => event.pubkey));
-    const authors = await storage.getEvents([{ kinds: [0], authors: [...pubkeys] }], { signal });
+    const authors = await storage.filter([{ kinds: [0], authors: [...pubkeys] }], { signal });
 
     for (const event of events) {
       event.author = authors.find((author) => author.pubkey === event.pubkey);

src/storages/memorelay.test.ts

@@ -11,12 +11,12 @@ const memorelay = new Memorelay({
 });
 
 Deno.test('memorelay', async () => {
-  assertEquals(await memorelay.countEvents([{ ids: [event1.id] }]), 0);
+  assertEquals(await memorelay.count([{ ids: [event1.id] }]), 0);
 
-  await memorelay.storeEvent(event1);
+  await memorelay.add(event1);
 
-  assertEquals(await memorelay.countEvents([{ ids: [event1.id] }]), 1);
+  assertEquals(await memorelay.count([{ ids: [event1.id] }]), 1);
 
-  const result = await memorelay.getEvents([{ ids: [event1.id] }]);
+  const result = await memorelay.filter([{ ids: [event1.id] }]);
   assertEquals(result[0], event1);
 });

src/storages/memorelay.ts

@@ -26,7 +26,7 @@ class Memorelay implements EventStore {
   }
 
   /** Get events from memory. */
-  getEvents<K extends number>(filters: Filter<K>[], opts: GetEventsOpts = {}): Promise<Event<K>[]> {
+  filter<K extends number>(filters: Filter<K>[], opts: GetEventsOpts = {}): Promise<Event<K>[]> {
     filters = normalizeFilters(filters);
 
     if (opts.signal?.aborted) return Promise.resolve([]);
@@ -91,20 +91,20 @@ class Memorelay implements EventStore {
   }
 
   /** Insert an event into memory. */
-  storeEvent(event: Event): Promise<void> {
+  add(event: Event): Promise<void> {
     this.#cache.set(event.id, event);
     return Promise.resolve();
   }
 
   /** Count events in memory for the filters. */
-  async countEvents(filters: Filter[]): Promise<number> {
+  async count(filters: Filter[]): Promise<number> {
-    const events = await this.getEvents(filters);
+    const events = await this.filter(filters);
     return events.length;
   }
 
   /** Delete events from memory. */
-  async deleteEvents(filters: Filter[]): Promise<void> {
+  async deleteFilters(filters: Filter[]): Promise<void> {
-    for (const event of await this.getEvents(filters)) {
+    for (const event of await this.filter(filters)) {
       this.#cache.delete(event.id);
     }
     return Promise.resolve();

src/storages/optimizer.ts

@@ -25,14 +25,14 @@ class Optimizer implements EventStore {
     this.#client = opts.client;
   }
 
-  async storeEvent(event: DittoEvent<number>, opts?: StoreEventOpts | undefined): Promise<void> {
+  async add(event: DittoEvent<number>, opts?: StoreEventOpts | undefined): Promise<void> {
     await Promise.all([
-      this.#db.storeEvent(event, opts),
+      this.#db.add(event, opts),
-      this.#cache.storeEvent(event, opts),
+      this.#cache.add(event, opts),
     ]);
   }
 
-  async getEvents<K extends number>(
+  async filter<K extends number>(
     filters: DittoFilter<K>[],
     opts: GetEventsOpts | undefined = {},
   ): Promise<DittoEvent<K>[]> {
@@ -52,7 +52,7 @@ class Optimizer implements EventStore {
       if (filter.ids) {
         this.#debug(`Filter[${i}] is an IDs filter; querying cache...`);
         const ids = new Set<string>(filter.ids);
-        for (const event of await this.#cache.getEvents([filter], opts)) {
+        for (const event of await this.#cache.filter([filter], opts)) {
           ids.delete(event.id);
           results.add(event);
           if (results.size >= limit) return getResults();
@@ -66,7 +66,7 @@ class Optimizer implements EventStore {
 
     // Query the database for events.
     this.#debug('Querying database...');
-    for (const dbEvent of await this.#db.getEvents(filters, opts)) {
+    for (const dbEvent of await this.#db.filter(filters, opts)) {
       results.add(dbEvent);
       if (results.size >= limit) return getResults();
     }
@@ -79,14 +79,14 @@ class Optimizer implements EventStore {
 
     // Query the cache again.
     this.#debug('Querying cache...');
-    for (const cacheEvent of await this.#cache.getEvents(filters, opts)) {
+    for (const cacheEvent of await this.#cache.filter(filters, opts)) {
       results.add(cacheEvent);
       if (results.size >= limit) return getResults();
     }
 
     // Finally, query the client.
     this.#debug('Querying client...');
-    for (const clientEvent of await this.#client.getEvents(filters, opts)) {
+    for (const clientEvent of await this.#client.filter(filters, opts)) {
       results.add(clientEvent);
       if (results.size >= limit) return getResults();
     }

src/storages/pool-store.ts

@@ -27,14 +27,14 @@ class PoolStore implements EventStore {
     this.#publisher = opts.publisher;
   }
 
-  storeEvent(event: Event, opts: StoreEventOpts = {}): Promise<void> {
+  add(event: Event, opts: StoreEventOpts = {}): Promise<void> {
     const { relays = this.#relays } = opts;
     this.#debug('EVENT', event);
     this.#pool.publish(event, relays);
     return Promise.resolve();
   }
 
-  getEvents<K extends number>(filters: Filter<K>[], opts: GetEventsOpts = {}): Promise<Event<K>[]> {
+  filter<K extends number>(filters: Filter<K>[], opts: GetEventsOpts = {}): Promise<Event<K>[]> {
     filters = normalizeFilters(filters);
 
     if (opts.signal?.aborted) return Promise.resolve([]);
@@ -80,11 +80,11 @@ class PoolStore implements EventStore {
     });
   }
 
-  countEvents() {
+  count() {
     return Promise.reject(new Error('COUNT not implemented'));
   }
 
-  deleteEvents() {
+  deleteFilters() {
     return Promise.reject(new Error('Cannot delete events from relays. Create a kind 5 event instead.'));
   }
 }

src/storages/reqmeister.ts

@@ -74,10 +74,10 @@ class Reqmeister extends EventEmitter<{ [filterId: string]: (event: Event) => an
 
     if (filters.length) {
       this.#debug('REQ', JSON.stringify(filters));
-      const events = await client.getEvents(filters, { signal: AbortSignal.timeout(timeout) });
+      const events = await client.filter(filters, { signal: AbortSignal.timeout(timeout) });
 
       for (const event of events) {
-        this.storeEvent(event);
+        this.add(event);
       }
     }
 
@@ -119,7 +119,7 @@ class Reqmeister extends EventEmitter<{ [filterId: string]: (event: Event) => an
     });
   }
 
-  storeEvent(event: Event): Promise<void> {
+  add(event: Event): Promise<void> {
     const filterId = getFilterId(eventToMicroFilter(event));
     this.#queue = this.#queue.filter(([id]) => id !== filterId);
     this.emit(filterId, event);
@@ -131,7 +131,7 @@ class Reqmeister extends EventEmitter<{ [filterId: string]: (event: Event) => an
     return this.#queue.some(([id]) => id === filterId);
   }
 
-  getEvents<K extends number>(filters: Filter<K>[], opts?: GetEventsOpts | undefined): Promise<Event<K>[]> {
+  filter<K extends number>(filters: Filter<K>[], opts?: GetEventsOpts | undefined): Promise<Event<K>[]> {
     if (opts?.signal?.aborted) return Promise.resolve([]);
     if (!filters.length) return Promise.resolve([]);
 
@@ -145,11 +145,11 @@ class Reqmeister extends EventEmitter<{ [filterId: string]: (event: Event) => an
     return Promise.all(promises);
   }
 
-  countEvents(_filters: Filter[]): Promise<number> {
+  count(_filters: Filter[]): Promise<number> {
     throw new Error('COUNT not implemented.');
   }
 
-  deleteEvents(_filters: Filter[]): Promise<void> {
+  deleteFilters(_filters: Filter[]): Promise<void> {
     throw new Error('DELETE not implemented.');
   }
 }

src/storages/search-store.ts

@@ -30,11 +30,11 @@ class SearchStore implements EventStore {
     }
   }
 
-  storeEvent(_event: Event, _opts?: StoreEventOpts | undefined): Promise<void> {
+  add(_event: Event, _opts?: StoreEventOpts | undefined): Promise<void> {
     throw new Error('EVENT not implemented.');
   }
 
-  async getEvents<K extends number>(
+  async filter<K extends number>(
     filters: DittoFilter<K>[],
     opts?: GetEventsOpts | undefined,
   ): Promise<DittoEvent<K>[]> {
@@ -69,15 +69,15 @@ class SearchStore implements EventStore {
       return hydrateEvents({ events: [...events], filters, storage: this.#hydrator, signal: opts?.signal });
     } else {
       this.#debug(`Searching for "${query}" locally...`);
-      return this.#fallback.getEvents(filters, opts);
+      return this.#fallback.filter(filters, opts);
     }
   }
 
-  countEvents<K extends number>(_filters: Filter<K>[]): Promise<number> {
+  count<K extends number>(_filters: Filter<K>[]): Promise<number> {
     throw new Error('COUNT not implemented.');
   }
 
-  deleteEvents<K extends number>(_filters: Filter<K>[]): Promise<void> {
+  deleteFilters<K extends number>(_filters: Filter<K>[]): Promise<void> {
     throw new Error('DELETE not implemented.');
   }
 }

src/storages/types.ts

@@ -38,13 +38,13 @@ interface EventStore {
   /** Indicates NIPs supported by this data store, similar to NIP-11. For example, `50` would indicate support for `search` filters. */
   supportedNips: readonly number[];
   /** Add an event to the store. */
-  storeEvent(event: Event, opts?: StoreEventOpts): Promise<void>;
+  add(event: Event, opts?: StoreEventOpts): Promise<void>;
   /** Get events from filters. */
-  getEvents<K extends number>(filters: DittoFilter<K>[], opts?: GetEventsOpts): Promise<DittoEvent<K>[]>;
+  filter<K extends number>(filters: DittoFilter<K>[], opts?: GetEventsOpts): Promise<DittoEvent<K>[]>;
   /** Get the number of events from filters. */
-  countEvents<K extends number>(filters: DittoFilter<K>[]): Promise<number>;
+  count?<K extends number>(filters: DittoFilter<K>[]): Promise<number>;
   /** Delete events from filters. */
-  deleteEvents<K extends number>(filters: DittoFilter<K>[]): Promise<void>;
+  deleteFilters?<K extends number>(filters: DittoFilter<K>[]): Promise<void>;
 }
 
 export type { DittoEvent, EventStore, GetEventsOpts, StoreEventOpts };

src/utils/api.ts

@@ -51,7 +51,7 @@ async function updateEvent<K extends number, E extends EventStub<K>>(
   fn: (prev: Event<K> | undefined) => E,
   c: AppContext,
 ): Promise<Event<K>> {
-  const [prev] = await eventsDB.getEvents([filter], { limit: 1 });
+  const [prev] = await eventsDB.filter([filter], { limit: 1 });
   return createEvent(fn(prev), c);
 }
 

src/views.ts

@@ -11,14 +11,14 @@ async function renderEventAccounts(c: AppContext, filters: Filter[], signal = Ab
     return c.json([]);
   }
 
-  const events = await eventsDB.getEvents(filters, { signal });
+  const events = await eventsDB.filter(filters, { signal });
   const pubkeys = new Set(events.map(({ pubkey }) => pubkey));
 
   if (!pubkeys.size) {
     return c.json([]);
   }
 
-  const authors = await eventsDB.getEvents(
+  const authors = await eventsDB.filter(
     [{ kinds: [0], authors: [...pubkeys], relations: ['author_stats'] }],
     { signal },
   );
@@ -33,7 +33,7 @@ async function renderEventAccounts(c: AppContext, filters: Filter[], signal = Ab
 async function renderAccounts(c: AppContext, authors: string[], signal = AbortSignal.timeout(1000)) {
   const { since, until, limit } = paginationSchema.parse(c.req.query());
 
-  const events = await eventsDB.getEvents(
+  const events = await eventsDB.filter(
     [{ kinds: [0], authors, relations: ['author_stats'], since, until, limit }],
     { signal },
   );
@@ -53,7 +53,7 @@ async function renderStatuses(c: AppContext, ids: string[], signal = AbortSignal
 
   const { limit } = paginationSchema.parse(c.req.query());
 
-  const events = await eventsDB.getEvents(
+  const events = await eventsDB.filter(
     [{ kinds: [1], ids, relations: ['author', 'event_stats', 'author_stats'], limit }],
     { signal },
   );

src/views/mastodon/relationships.ts

@@ -2,7 +2,7 @@ import { eventsDB } from '@/storages.ts';
 import { hasTag } from '@/tags.ts';
 
 async function renderRelationship(sourcePubkey: string, targetPubkey: string) {
-  const events = await eventsDB.getEvents([
+  const events = await eventsDB.filter([
     { kinds: [3], authors: [sourcePubkey], limit: 1 },
     { kinds: [3], authors: [targetPubkey], limit: 1 },
     { kinds: [10000], authors: [sourcePubkey], limit: 1 },

src/views/mastodon/statuses.ts

@@ -35,7 +35,7 @@ async function renderStatus(event: DittoEvent<1>, viewerPubkey?: string) {
       Promise.all(mentionedPubkeys.map(toMention)),
       firstUrl ? unfurlCardCached(firstUrl) : null,
       viewerPubkey
-        ? await eventsDB.getEvents([
+        ? await eventsDB.filter([
           { kinds: [6], '#e': [event.id], authors: [viewerPubkey], limit: 1 },
           { kinds: [7], '#e': [event.id], authors: [viewerPubkey], limit: 1 },
           { kinds: [10001], '#e': [event.id], authors: [viewerPubkey], limit: 1 },