chore: upgrade to v0.3.1 - Switch to Vitest, remove nostr-tools dependency, fix type issues

Author: vveerrgg

CHANGELOG.md

@@ -0,0 +1,29 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [0.3.1] - 2024-12-30
+
+### Changed
+- Switched testing framework from Jest to Vitest
+- Removed nostr-tools dependency
+- Updated pino logger to version 8.17.2
+- Fixed TypeScript type issues and linting errors
+- Improved type safety across the codebase
+
+### Removed
+- Removed nostr-tools peer dependency
+- Removed Jest-related dependencies
+
+## [0.3.0] - 2024-12-30
+
+### Added
+- Comprehensive TypeScript type definitions
+- Enhanced WebSocket connection management
+- Improved message queue implementation
+- Better error handling and logging
+
+### Changed
+- Updated to nostr-crypto-utils 0.4.2
+- Refactored core functionality for better type safety
+- Enhanced documentation

README.md

@@ -11,13 +11,14 @@ A TypeScript library for building Nostr protocol WebSocket clients and servers.
 
 ## Features
 
-- 🚀 Full Nostr protocol support
+- 🚀 Full Nostr protocol support with nostr-crypto-utils integration
 - 🔒 Secure WebSocket connections
 - ♥️ Heartbeat mechanism for connection health
 - 🔄 Automatic reconnection handling
-- 📝 Comprehensive logging
+- 📝 Comprehensive logging with Pino v8
 - 🎯 Type-safe message handling
 - 📦 Easy to use API
+- 🧪 Vitest-powered test suite
 
 ## NIPs Support Status
 
@@ -118,11 +119,11 @@ const server = await createNostrServer(8080, {
 
 ## Dependencies
 
-This package relies on:
-- [nostr-crypto-utils](https://github.com/HumanjavaEnterprises/nostr-crypto-utils) - For all cryptographic operations
-- [ws](https://github.com/websockets/ws) - For WebSocket functionality
-- [pino](https://github.com/pinojs/pino) - For logging
-- [uuid](https://github.com/uuidjs/uuid) - For unique identifiers
+This package uses:
+- nostr-crypto-utils (^0.4.2) for cryptographic operations
+- pino (^8.17.2) for logging
+- ws (^8.16.0) for WebSocket functionality
+- uuid (^9.0.0) for unique identifiers
 
 ## Documentation
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "nostr-websocket-utils",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Robust WebSocket utilities for Nostr applications with automatic reconnection, channel-based messaging, and type-safe handlers. Features heartbeat monitoring, message queueing, and comprehensive error handling.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

src/__mocks__/extendedWsMock.ts

@@ -1,6 +1,29 @@
 import { vi } from 'vitest';
 import { EventEmitter } from 'events';
 
+// WebSocket event interfaces
+interface WebSocketEventBase {
+  type: string;
+  target: WebSocket;
+  currentTarget: WebSocket;
+}
+
+interface WebSocketMessageEvent extends WebSocketEventBase {
+  data: string | Buffer;
+  isBinary: boolean;
+}
+
+interface WebSocketCloseEvent extends WebSocketEventBase {
+  code: number;
+  reason: string;
+  wasClean: boolean;
+}
+
+interface WebSocketErrorEvent extends WebSocketEventBase {
+  error: Error;
+  message: string;
+}
+
 export class ExtendedWsMock extends EventEmitter {
   // WebSocket state constants
   public readonly CONNECTING = 0 as const;
@@ -18,10 +41,10 @@ export class ExtendedWsMock extends EventEmitter {
   public isPaused = false;
 
   // Event handlers
-  onopen: ((event: any) => void) | null = null;
-  onclose: ((event: any) => void) | null = null;
-  onerror: ((event: any) => void) | null = null;
-  onmessage: ((event: any) => void) | null = null;
+  onopen: ((event: WebSocketEventBase) => void) | null = null;
+  onclose: ((event: WebSocketCloseEvent) => void) | null = null;
+  onerror: ((event: WebSocketErrorEvent) => void) | null = null;
+  onmessage: ((event: WebSocketMessageEvent) => void) | null = null;
 
   constructor() {
     super();
@@ -39,36 +62,36 @@ export class ExtendedWsMock extends EventEmitter {
     this.resume = this.resume.bind(this);
   }
 
-  private createWsEvent(type: string, data: any): any {
-    const event = {
+  private createWsEvent<T extends WebSocketEventBase>(type: string, data: Partial<T>): T {
+    return {
       type,
-      target: this,
-      currentTarget: this,
+      target: this as unknown as WebSocket,
+      currentTarget: this as unknown as WebSocket,
       ...data
-    };
-    return event;
+    } as T;
   }
 
-  addEventListener(type: string, listener: (event: any) => void): void {
-    const boundListener = ((event: any) => {
+  addEventListener(type: string, listener: (event: WebSocketEventBase) => void): void {
+    const boundListener = ((event: WebSocketEventBase) => {
       listener.apply(this, [event]);
     });
     this.on(type, boundListener);
   }
 
-  removeEventListener(type: string, listener: (event: any) => void): void {
+  removeEventListener(type: string, listener: (event: WebSocketEventBase) => void): void {
     this.removeListener(type, listener);
   }
 
-  public send = vi.fn((data: any): this => {
+  public send = vi.fn((data: string | Buffer): this => {
     if (this.isPaused) return this;
 
     const isBinary = !(typeof data === 'string');
-    const event = this.createWsEvent('message', {
-      data: data
+    const event = this.createWsEvent<WebSocketMessageEvent>('message', {
+      data: data,
+      isBinary: isBinary
     });
 
-    this.emit('message', data, isBinary);
+    this.emit('message', event);
     this.onmessage?.apply(this, [event]);
 
     return this;
@@ -90,27 +113,27 @@ export class ExtendedWsMock extends EventEmitter {
 
   public close = vi.fn((code?: number, reason?: string): this => {
     this.readyState = this.CLOSED;
-    const event = this.createWsEvent('close', {
+    const event = this.createWsEvent<WebSocketCloseEvent>('close', {
       code,
       reason,
       wasClean: true
     });
 
-    this.emit('close', code, Buffer.from(reason || ''));
+    this.emit('close', event);
     this.onclose?.apply(this, [event]);
 
     return this;
   });
 
   public terminate = vi.fn((): this => {
     this.readyState = this.CLOSED;
-    const event = this.createWsEvent('close', {
+    const event = this.createWsEvent<WebSocketCloseEvent>('close', {
       code: 1006,
       reason: 'Connection terminated',
       wasClean: false
     });
 
-    this.emit('close', 1006, Buffer.from('Connection terminated'));
+    this.emit('close', event);
     this.onclose?.apply(this, [event]);
 
     return this;
@@ -134,64 +157,64 @@ export class ExtendedWsMock extends EventEmitter {
 }
 
 // Create mock event classes for Node.js environment
-class MockEvent {
+class MockEvent implements WebSocketEventBase {
   readonly type: string;
-  readonly target: any;
-  readonly currentTarget: any;
+  readonly target: WebSocket;
+  readonly currentTarget: WebSocket;
 
-  constructor(type: string, target?: any) {
+  constructor(type: string, target?: WebSocket) {
     this.type = type;
-    this.target = target || (mockWebSocket as any);
+    this.target = target || (mockWebSocket as unknown as WebSocket);
     this.currentTarget = this.target;
   }
 }
 
-class MockMessageEvent extends MockEvent {
-  readonly data: any;
+class MockMessageEvent extends MockEvent implements WebSocketMessageEvent {
+  readonly data: string | Buffer;
   readonly isBinary: boolean;
 
-  constructor(type: string, init?: { data?: any; isBinary?: boolean; target?: any }) {
+  constructor(type: string, init?: { data?: string | Buffer; isBinary?: boolean; target?: WebSocket }) {
     super(type, init?.target);
     this.data = init?.data ?? '';
     this.isBinary = init?.isBinary ?? false;
   }
 }
 
-class MockCloseEvent extends MockEvent {
+class MockCloseEvent extends MockEvent implements WebSocketCloseEvent {
   readonly code: number;
   readonly reason: string;
   readonly wasClean: boolean;
 
-  constructor(type: string, init?: { code?: number; reason?: string; wasClean?: boolean; target?: any }) {
+  constructor(type: string, init?: { code?: number; reason?: string; wasClean?: boolean; target?: WebSocket }) {
     super(type, init?.target);
     this.code = init?.code ?? 1000;
     this.reason = init?.reason ?? '';
     this.wasClean = init?.wasClean ?? true;
   }
 }
 
-class MockErrorEvent extends MockEvent {
+class MockErrorEvent extends MockEvent implements WebSocketErrorEvent {
   readonly error: Error;
   readonly message: string;
 
-  constructor(type: string, init?: { error?: Error; message?: string; target?: any }) {
+  constructor(type: string, init?: { error?: Error; message?: string; target?: WebSocket }) {
     super(type, init?.target);
     this.error = init?.error ?? new Error('WebSocket Error');
     this.message = init?.message ?? 'WebSocket Error';
   }
 }
 
 if (typeof Event === 'undefined') {
-  (global as { Event?: typeof MockEvent }).Event = MockEvent;
+  (global as any).Event = MockEvent;
 }
 if (typeof MessageEvent === 'undefined') {
-  (global as unknown as { MessageEvent: typeof MockMessageEvent }).MessageEvent = MockMessageEvent;
+  (global as any).MessageEvent = MockMessageEvent;
 }
 if (typeof CloseEvent === 'undefined') {
-  (global as { CloseEvent?: typeof MockCloseEvent }).CloseEvent = MockCloseEvent;
+  (global as any).CloseEvent = MockCloseEvent;
 }
 if (typeof ErrorEvent === 'undefined') {
-  (global as { ErrorEvent?: typeof MockErrorEvent }).ErrorEvent = MockErrorEvent;
+  (global as any).ErrorEvent = MockErrorEvent;
 }
 
 // Export a singleton instance

src/__tests__/client.test.ts

@@ -77,7 +77,7 @@ describe('NostrWSClient', () => {
       const messageHandler = vi.fn();
       client.on('message', messageHandler);
 
-      const testMessage: NostrWSMessage = { type: 'EVENT', content: { id: 'test' } };
+      const testMessage: NostrWSMessage = ['EVENT', { id: 'test' }];
       client.send(testMessage);
 
       await vi.waitFor(() => expect(messageHandler).toHaveBeenCalledWith(testMessage));

src/__tests__/nostr-types.test.ts

@@ -1,11 +1,11 @@
 import { describe, it, expect } from 'vitest';
-import { NostrWSEvent, NostrWSFilter, NostrWSMessage } from '../types/messages';
+import { NostrEvent, NostrWSFilter, NostrWSMessage } from '../types/messages';
 import { MESSAGE_TYPES } from '../types/messages';
 
 describe('Nostr WebSocket Types', () => {
-  describe('NostrWSEvent', () => {
+  describe('NostrEvent', () => {
     it('should validate a valid event', () => {
-      const event: NostrWSEvent = {
+      const event: NostrEvent = {
         id: 'test-id',
         pubkey: 'test-pubkey',
         created_at: Date.now(),
@@ -30,8 +30,10 @@ describe('Nostr WebSocket Types', () => {
         ids: ['test-id-1', 'test-id-2'],
         authors: ['test-pubkey-1', 'test-pubkey-2'],
         kinds: [1, 2, 3],
-        '#e': ['test-event-1', 'test-event-2'],
-        '#p': ['test-pubkey-1', 'test-pubkey-2'],
+        tags: {
+          'e': ['test-event-1', 'test-event-2'],
+          'p': ['test-pubkey-1', 'test-pubkey-2']
+        },
         since: now - 3600, // 1 hour ago
         until: now,
         limit: 100,
@@ -40,8 +42,8 @@ describe('Nostr WebSocket Types', () => {
       expect(filter.ids).toBeInstanceOf(Array);
       expect(filter.authors).toBeInstanceOf(Array);
       expect(filter.kinds).toBeInstanceOf(Array);
-      expect(filter['#e']).toBeInstanceOf(Array);
-      expect(filter['#p']).toBeInstanceOf(Array);
+      expect(filter.tags?.e).toBeInstanceOf(Array);
+      expect(filter.tags?.p).toBeInstanceOf(Array);
       expect(typeof filter.since).toBe('number');
       expect(typeof filter.until).toBe('number');
       expect(typeof filter.limit).toBe('number');
@@ -50,18 +52,17 @@ describe('Nostr WebSocket Types', () => {
 
   describe('NostrWSMessage', () => {
     it('should validate a valid message', () => {
-      const message: NostrWSMessage = {
-        type: MESSAGE_TYPES.EVENT,
-        content: {
-          id: 'test-id',
-          pubkey: 'test-pubkey',
-          created_at: Date.now(),
-          kind: 1,
-          tags: [],
-          content: 'test content'
-        }
+      const event: NostrEvent = {
+        id: 'test-id',
+        pubkey: 'test-pubkey',
+        created_at: Date.now(),
+        kind: 1,
+        tags: [],
+        content: 'test content'
       };
-      expect(message).toBeDefined();
+      const message: NostrWSMessage = [MESSAGE_TYPES.EVENT, event];
+      expect(message[0]).toBe(MESSAGE_TYPES.EVENT);
+      expect(message[1]).toEqual(event);
     });
   });