docs: mark NIP-45 as supported

Author: a-khushal

.changeset/full-donuts-allow.md

@@ -0,0 +1,5 @@
+---
+"nostream": minor
+---
+
+added NIP-45 COUNT support with end-to-end handling (validation, handler routing, DB counting, and tests).

README.md

@@ -63,6 +63,7 @@ NIPs with a relay-specific implementation are listed here.
 - [x] NIP-33: Parameterized Replaceable Events
 - [x] NIP-40: Expiration Timestamp
 - [x] NIP-44: Encrypted Payloads (Versioned)
+- [x] NIP-45: Event Counts
 
 ## Requirements
 

package.json

@@ -17,7 +17,8 @@
     28,
     33,
     40,
-    44
+    44,
+    45
   ],
   "supportedNipExtensions": [
     "11a"

src/handlers/count-message-handler.ts

@@ -5,7 +5,7 @@ import { IMessageHandler } from '../@types/message-handlers'
 import { CountMessage } from '../@types/messages'
 import { IEventRepository } from '../@types/repositories'
 import { Settings } from '../@types/settings'
-import { SubscriptionFilter } from '../@types/subscription'
+import { SubscriptionFilter, SubscriptionId } from '../@types/subscription'
 import { WebSocketAdapterEvent } from '../constants/adapter'
 import { createLogger } from '../factories/logger-factory'
 import { createClosedMessage, createCountResultMessage } from '../utils/messages'
@@ -43,12 +43,12 @@ export class CountMessageHandler implements IMessageHandler {
     }
   }
 
-  private canCount(queryId: string, filters: SubscriptionFilter[]): string | undefined {
+  private canCount(queryId: SubscriptionId, filters: SubscriptionFilter[]): string | undefined {
     const subscriptionLimits = this.settings().limits?.client?.subscription
     const maxFilters = subscriptionLimits?.maxFilters ?? 0
 
     if (maxFilters > 0 && filters.length > maxFilters) {
-      return `Too many filters: Number of filters per count query must be less then or equal to ${maxFilters}`
+      return `Too many filters: Number of filters per count query must be less than or equal to ${maxFilters}`
     }
 
     if (

test/unit/handlers/count-message-handler.spec.ts

@@ -1,6 +1,6 @@
 import chai from 'chai'
 import EventEmitter from 'events'
-import sinon from 'sinon'
+import Sinon from 'sinon'
 import sinonChai from 'sinon-chai'
 
 import { IWebSocketAdapter } from '../../../src/@types/adapters'
@@ -17,18 +17,16 @@ describe('CountMessageHandler', () => {
   let webSocket: IWebSocketAdapter
   let handler: CountMessageHandler
   let eventRepository: IEventRepository
-  let onMessageStub: sinon.SinonStub
-  let sandbox: sinon.SinonSandbox
+  let sandbox: Sinon.SinonSandbox
 
   beforeEach(() => {
-    sandbox = sinon.createSandbox()
+    sandbox = Sinon.createSandbox()
+
     eventRepository = {
       countByFilters: sandbox.stub().resolves(7),
     } as any
 
     webSocket = new EventEmitter() as any
-    onMessageStub = sandbox.stub()
-    webSocket.on(WebSocketAdapterEvent.Message, onMessageStub)
 
     handler = new CountMessageHandler(webSocket, eventRepository, () => ({
       limits: {
@@ -47,47 +45,89 @@ describe('CountMessageHandler', () => {
     sandbox.restore()
   })
 
-  it('emits COUNT message with count on success', async () => {
-    const message = [MessageType.COUNT, 'q1', {}] as any
+  describe('handleMessage()', () => {
+    let webSocketOnMessageStub: Sinon.SinonStub
 
-    await handler.handleMessage(message)
+    beforeEach(() => {
+      webSocketOnMessageStub = sandbox.stub()
+      webSocket.on(WebSocketAdapterEvent.Message, webSocketOnMessageStub)
+    })
 
-    expect(eventRepository.countByFilters).to.have.been.calledOnceWithExactly([{}])
-    expect(onMessageStub).to.have.been.calledOnceWithExactly([MessageType.COUNT, 'q1', { count: 7 }])
-  })
+    it('returns COUNT with the result when counting works', async () => {
+      const message = [MessageType.COUNT, 'q1', {}] as any
 
-  it('emits CLOSED message when request is rejected', async () => {
-    handler = new CountMessageHandler(webSocket, eventRepository, () => ({
-      limits: {
-        client: {
-          subscription: {
-            maxFilters: 1,
-            maxSubscriptionIdLength: 256,
+      await handler.handleMessage(message)
+
+      expect(eventRepository.countByFilters).to.have.been.calledOnceWithExactly([{}])
+      expect(webSocketOnMessageStub).to.have.been.calledOnceWithExactly([MessageType.COUNT, 'q1', { count: 7 }])
+    })
+
+    it('drops duplicate filters before querying the repository', async () => {
+      const repeatedFilter = { kinds: [1] }
+      const message = [MessageType.COUNT, 'q1', repeatedFilter, repeatedFilter] as any
+
+      await handler.handleMessage(message)
+
+      expect(eventRepository.countByFilters).to.have.been.calledOnceWithExactly([repeatedFilter])
+      expect(webSocketOnMessageStub).to.have.been.calledOnceWithExactly([MessageType.COUNT, 'q1', { count: 7 }])
+    })
+
+    it('returns CLOSED when the request has too many filters', async () => {
+      handler = new CountMessageHandler(webSocket, eventRepository, () => ({
+        limits: {
+          client: {
+            subscription: {
+              maxFilters: 1,
+              maxSubscriptionIdLength: 256,
+            },
           },
         },
-      },
-    }) as Settings)
+      }) as Settings)
+
+      const message = [MessageType.COUNT, 'q1', { kinds: [1] }, { kinds: [2] }] as any
+
+      await handler.handleMessage(message)
+
+      expect(eventRepository.countByFilters).to.not.have.been.called
+      expect(webSocketOnMessageStub).to.have.been.calledOnce
+      expect(webSocketOnMessageStub.firstCall.args[0][0]).to.equal(MessageType.CLOSED)
+      expect(webSocketOnMessageStub.firstCall.args[0][1]).to.equal('q1')
+    })
+
+    it('returns CLOSED when the query ID is too long', async () => {
+      handler = new CountMessageHandler(webSocket, eventRepository, () => ({
+        limits: {
+          client: {
+            subscription: {
+              maxFilters: 10,
+              maxSubscriptionIdLength: 2,
+            },
+          },
+        },
+      }) as Settings)
 
-    const message = [MessageType.COUNT, 'q1', { kinds: [1] }, { kinds: [2] }] as any
+      const message = [MessageType.COUNT, 'q123', {}] as any
 
-    await handler.handleMessage(message)
+      await handler.handleMessage(message)
 
-    expect(eventRepository.countByFilters).to.not.have.been.called
-    expect(onMessageStub).to.have.been.calledOnce
-    expect(onMessageStub.firstCall.args[0][0]).to.equal(MessageType.CLOSED)
-    expect(onMessageStub.firstCall.args[0][1]).to.equal('q1')
-  })
+      expect(eventRepository.countByFilters).to.not.have.been.called
+      expect(webSocketOnMessageStub).to.have.been.calledOnce
+      expect(webSocketOnMessageStub.firstCall.args[0][0]).to.equal(MessageType.CLOSED)
+      expect(webSocketOnMessageStub.firstCall.args[0][1]).to.equal('q123')
+    })
 
-  it('emits CLOSED message when repository fails', async () => {
-    (eventRepository.countByFilters as sinon.SinonStub).rejects(new Error('boom'))
-    const message = [MessageType.COUNT, 'q1', {}] as any
+    it('returns CLOSED when counting fails in the repository', async () => {
+      const countByFiltersStub = eventRepository.countByFilters as Sinon.SinonStub
+      countByFiltersStub.rejects(new Error('boom'))
+      const message = [MessageType.COUNT, 'q1', {}] as any
 
-    await handler.handleMessage(message)
+      await handler.handleMessage(message)
 
-    expect(onMessageStub).to.have.been.calledOnceWithExactly([
-      MessageType.CLOSED,
-      'q1',
-      'error: unable to count events',
-    ])
+      expect(webSocketOnMessageStub).to.have.been.calledOnceWithExactly([
+        MessageType.CLOSED,
+        'q1',
+        'error: unable to count events',
+      ])
+    })
   })
 })

test/unit/repositories/event-repository.spec.ts

@@ -439,6 +439,18 @@ describe('EventRepository', () => {
       expect(result).to.equal(42)
     })
 
+    it('uses countDistinct on event_id to avoid duplicate counts', async () => {
+      const countDistinctStub = sandbox.stub().returns({
+        first: async () => ({ count: '1' }),
+      })
+
+      sandbox.stub(rrDbClient, 'from').returns({ countDistinct: countDistinctStub } as any)
+
+      await repository.countByFilters([{ '#e': ['aaaaaa'] } as any])
+
+      expect(countDistinctStub).to.have.been.calledOnceWithExactly({ count: 'event_id' })
+    })
+
     it('builds union query when there are multiple filters', async () => {
       const fromStub = sandbox.stub(rrDbClient, 'from').returns({
         countDistinct: () => ({
@@ -464,6 +476,20 @@ describe('EventRepository', () => {
       const sql = fromStub.firstCall.args[0].toString()
       expect(sql).to.include('left join "event_tags"')
       expect(sql).to.include('event_tags.tag_name')
+      expect(sql).to.include('event_tags.tag_value')
+    })
+
+    it('applies limit ordering when a filter includes limit', async () => {
+      const fromStub = sandbox.stub(rrDbClient, 'from').returns({
+        countDistinct: () => ({
+          first: async () => ({ count: '1' }),
+        }),
+      } as any)
+
+      await repository.countByFilters([{ limit: 3 }])
+
+      const sql = fromStub.firstCall.args[0].toString()
+      expect(sql).to.include('order by "event_created_at" DESC, "event_id" asc limit 3')
     })
 
     it('filters out deleted and expired events', async () => {

test/unit/schemas/message-schema.spec.ts

@@ -152,6 +152,13 @@ describe('NIP-01', () => {
         expect(result).to.have.property('error').that.is.not.undefined
       })
 
+      it('returns error if filter is not an object', () => {
+        message[2] = null
+
+        const result = validateSchema(messageSchema)(message)
+        expect(result).to.have.property('error').that.is.not.undefined
+      })
+
       it('returns error if there are too many filters', () => {
         ;(message as any[]).splice(2, 1)
         ;(message as any[]).push(...range(0, 11).map(() => ({})))