applesauce-relay 0.0.0-next-20250414120207 → 0.0.0-next-20250423145737

package/dist/__tests__/relay.test.js

@@ -3,15 +3,17 @@ import { subscribeSpyTo } from "@hirez_io/observer-spy";
 import { getSeenRelays } from "applesauce-core/helpers";
 import { WS } from "vitest-websocket-mock";
 import { Relay } from "../relay.js";
+import { filter } from "rxjs/operators";
+import { firstValueFrom } from "rxjs";
 let mockRelay;
 let relay;
 beforeEach(async () => {
-    mockRelay = new WS("wss://test");
+    mockRelay = new WS("wss://test", { jsonProtocol: true });
     relay = new Relay("wss://test");
+    relay.keepAlive = 0;
 });
+// Wait for server to close to prevent memory leaks
 afterEach(async () => {
-    mockRelay.close();
-    // Wait for server to close to prevent memory leaks
     await WS.clean();
 });
 const mockEvent = {
@@ -24,44 +26,48 @@ const mockEvent = {
     sig: "5a57b5a12bba4b7cf0121077b1421cf4df402c5c221376c076204fc4f7519e28ce6508f26ddc132c406ccfe6e62cc6db857b96c788565cdca9674fe9a0710ac2",
 };
 describe("req", () => {
+    it("should trigger connection to relay", async () => {
+        subscribeSpyTo(relay.req([{ kinds: [1] }], "sub1"));
+        // Wait for connection
+        await firstValueFrom(relay.connected$.pipe(filter(Boolean)));
+        expect(relay.connected).toBe(true);
+    });
     it("should send REQ and CLOSE messages", async () => {
         // Create subscription that completes after first EOSE
         const sub = relay.req([{ kinds: [1] }], "sub1").subscribe();
         // Verify REQ was sent
-        const reqMessage = await mockRelay.nextMessage;
-        expect(JSON.parse(reqMessage)).toEqual(["REQ", "sub1", { kinds: [1] }]);
+        expect(await mockRelay.nextMessage).toEqual(["REQ", "sub1", { kinds: [1] }]);
         // Send EOSE to complete subscription
-        mockRelay.send(JSON.stringify(["EOSE", "sub1"]));
+        mockRelay.send(["EOSE", "sub1"]);
         // Complete the subscription
         sub.unsubscribe();
         // Verify CLOSE was sent
-        const closeMessage = await mockRelay.nextMessage;
-        expect(JSON.parse(closeMessage)).toEqual(["CLOSE", "sub1"]);
+        expect(await mockRelay.nextMessage).toEqual(["CLOSE", "sub1"]);
     });
     it("should emit nostr event and EOSE", async () => {
         const spy = subscribeSpyTo(relay.req([{ kinds: [1] }], "sub1"));
         // Send EVENT message
-        mockRelay.send(JSON.stringify(["EVENT", "sub1", mockEvent]));
+        mockRelay.send(["EVENT", "sub1", mockEvent]);
         // Send EOSE message
-        mockRelay.send(JSON.stringify(["EOSE", "sub1"]));
+        mockRelay.send(["EOSE", "sub1"]);
         expect(spy.getValues()).toEqual([expect.objectContaining(mockEvent), "EOSE"]);
     });
     it("should ignore EVENT and EOSE messages that do not match subscription id", async () => {
         const spy = subscribeSpyTo(relay.req([{ kinds: [1] }], "sub1"));
         // Send EVENT message with wrong subscription id
-        mockRelay.send(JSON.stringify(["EVENT", "wrong_sub", mockEvent]));
+        mockRelay.send(["EVENT", "wrong_sub", mockEvent]);
         // Send EOSE message with wrong subscription id
-        mockRelay.send(JSON.stringify(["EOSE", "wrong_sub"]));
+        mockRelay.send(["EOSE", "wrong_sub"]);
         // Send EVENT message with correct subscription id
-        mockRelay.send(JSON.stringify(["EVENT", "sub1", mockEvent]));
+        mockRelay.send(["EVENT", "sub1", mockEvent]);
         // Send EOSE message with correct subscription id
-        mockRelay.send(JSON.stringify(["EOSE", "sub1"]));
+        mockRelay.send(["EOSE", "sub1"]);
         expect(spy.getValues()).toEqual([expect.objectContaining(mockEvent), "EOSE"]);
     });
     it("should mark events with their source relay", async () => {
         const spy = subscribeSpyTo(relay.req([{ kinds: [1] }], "sub1"));
         // Send EVENT message
-        mockRelay.send(JSON.stringify(["EVENT", "sub1", mockEvent]));
+        mockRelay.send(["EVENT", "sub1", mockEvent]);
         // Get the received event
         const receivedEvent = spy.getValues()[0];
         // Verify the event was marked as seen from this relay
@@ -70,35 +76,39 @@ describe("req", () => {
     it("should complete subscription when CLOSED message is received", async () => {
         const spy = subscribeSpyTo(relay.req([{ kinds: [1] }], "sub1"));
         // Send CLOSED message for the subscription
-        mockRelay.send(JSON.stringify(["CLOSED", "sub1", "reason"]));
+        mockRelay.send(["CLOSED", "sub1", "reason"]);
         // Verify the subscription completed
         expect(spy.receivedComplete()).toBe(true);
     });
 });
 describe("event", () => {
+    it("should trigger connection to relay", async () => {
+        subscribeSpyTo(relay.event(mockEvent));
+        // Wait for connection
+        await firstValueFrom(relay.connected$.pipe(filter(Boolean)));
+        expect(relay.connected).toBe(true);
+    });
     it("observable should complete when matching OK response received", async () => {
         const spy = subscribeSpyTo(relay.event(mockEvent));
         // Verify EVENT message was sent
-        const eventMessage = await mockRelay.nextMessage;
-        expect(JSON.parse(eventMessage)).toEqual(["EVENT", mockEvent]);
+        expect(await mockRelay.nextMessage).toEqual(["EVENT", mockEvent]);
         // Send matching OK response
-        mockRelay.send(JSON.stringify(["OK", mockEvent.id, true, ""]));
+        mockRelay.send(["OK", mockEvent.id, true, ""]);
         await spy.onComplete();
         expect(spy.receivedComplete()).toBe(true);
     });
     it("should ignore OK responses for different events", async () => {
         const spy = subscribeSpyTo(relay.event(mockEvent));
         // Send non-matching OK response
-        mockRelay.send(JSON.stringify(["OK", "different_id", true, ""]));
+        mockRelay.send(["OK", "different_id", true, ""]);
         expect(spy.receivedComplete()).toBe(false);
         // Send matching OK response
-        mockRelay.send(JSON.stringify(["OK", mockEvent.id, true, ""]));
+        mockRelay.send(["OK", mockEvent.id, true, ""]);
         expect(spy.receivedComplete()).toBe(true);
     });
     it("should send EVENT message to relay", async () => {
         relay.event(mockEvent).subscribe();
-        const eventMessage = await mockRelay.nextMessage;
-        expect(JSON.parse(eventMessage)).toEqual(["EVENT", mockEvent]);
+        expect(await mockRelay.nextMessage).toEqual(["EVENT", mockEvent]);
     });
     it("should complete with error if no OK received within 10s", async () => {
         vi.useFakeTimers();
@@ -109,37 +119,65 @@ describe("event", () => {
         expect(spy.getLastValue()).toEqual({ ok: false, from: "wss://test", message: "Timeout" });
     });
 });
-describe("notice$", () => {
+describe("notices$", () => {
+    it("should not trigger connection to relay", async () => {
+        subscribeSpyTo(relay.notices$);
+        expect(relay.connected).toBe(false);
+    });
     it("should accumulate notices in notices$ state", async () => {
         subscribeSpyTo(relay.req({ kinds: [1] }));
         // Send multiple NOTICE messages
-        mockRelay.send(JSON.stringify(["NOTICE", "Notice 1"]));
-        mockRelay.send(JSON.stringify(["NOTICE", "Notice 2"]));
-        mockRelay.send(JSON.stringify(["NOTICE", "Notice 3"]));
+        mockRelay.send(["NOTICE", "Notice 1"]);
+        mockRelay.send(["NOTICE", "Notice 2"]);
+        mockRelay.send(["NOTICE", "Notice 3"]);
         // Verify the notices state contains all messages
         expect(relay.notices$.value).toEqual(["Notice 1", "Notice 2", "Notice 3"]);
     });
     it("should ignore non-NOTICE messages", async () => {
         subscribeSpyTo(relay.req({ kinds: [1] }));
-        mockRelay.send(JSON.stringify(["NOTICE", "Important notice"]));
-        mockRelay.send(JSON.stringify(["OTHER", "other message"]));
+        mockRelay.send(["NOTICE", "Important notice"]);
+        mockRelay.send(["OTHER", "other message"]);
         // Verify only NOTICE messages are in the state
         expect(relay.notices$.value).toEqual(["Important notice"]);
     });
 });
 describe("challenge$", () => {
+    it("should not trigger connection to relay", async () => {
+        subscribeSpyTo(relay.challenge$);
+        expect(relay.connected).toBe(false);
+    });
     it("should set challenge$ when AUTH message received", async () => {
         subscribeSpyTo(relay.req({ kinds: [1] }));
         // Send AUTH message with challenge string
-        mockRelay.send(JSON.stringify(["AUTH", "challenge-string-123"]));
+        mockRelay.send(["AUTH", "challenge-string-123"]);
         // Verify challenge$ was set
         expect(relay.challenge$.value).toBe("challenge-string-123");
     });
     it("should ignore non-AUTH messages", async () => {
         subscribeSpyTo(relay.req({ kinds: [1] }));
-        mockRelay.send(JSON.stringify(["NOTICE", "Not a challenge"]));
-        mockRelay.send(JSON.stringify(["OTHER", "other message"]));
+        mockRelay.send(["NOTICE", "Not a challenge"]);
+        mockRelay.send(["OTHER", "other message"]);
         // Verify challenge$ remains null
         expect(relay.challenge$.value).toBe(null);
     });
 });
+// describe("keepAlive", () => {
+//   it("should close the socket connection after keepAlive timeout", async () => {
+//     vi.useFakeTimers();
+//     // Set a short keepAlive timeout for testing
+//     relay.keepAlive = 100; // 100ms for quick testing
+//     // Subscribe to the relay to ensure it is active
+//     const sub = subscribeSpyTo(relay.req([{ kinds: [1] }]));
+//     // Wait for connection
+//     await firstValueFrom(relay.connected$.pipe(filter(Boolean)));
+//     // Close the subscription
+//     sub.unsubscribe();
+//     // Fast-forward time by 10ms
+//     await vi.advanceTimersByTimeAsync(10);
+//     // should still be connected
+//     expect(relay.connected).toBe(true);
+//     // Wait for the keepAlive timeout to elapse
+//     await vi.advanceTimersByTimeAsync(150);
+//     expect(relay.connected).toBe(false);
+//   });
+// });

package/dist/relay.d.ts

@@ -1,7 +1,7 @@
+import { logger } from "applesauce-core";
+import { type Filter, type NostrEvent } from "nostr-tools";
 import { BehaviorSubject, Observable } from "rxjs";
 import { WebSocketSubject, WebSocketSubjectConfig } from "rxjs/webSocket";
-import { type Filter, type NostrEvent } from "nostr-tools";
-import { logger } from "applesauce-core";
 import { IRelay, PublishResponse, SubscriptionResponse } from "./types.js";
 export type RelayOptions = {
     WebSocket?: WebSocketSubjectConfig<any>["WebSocketCtor"];
@@ -26,6 +26,8 @@ export declare class Relay implements IRelay {
     eoseTimeout: number;
     /** How long to wait for an OK message from the relay */
     eventTimeout: number;
+    /** How long to keep the connection alive after nothing is subscribed */
+    keepAlive: number;
     protected authRequiredForReq: BehaviorSubject<boolean>;
     protected authRequiredForPublish: BehaviorSubject<boolean>;
     protected resetState(): void;

package/dist/relay.js

@@ -1,7 +1,7 @@
-import { BehaviorSubject, combineLatest, defer, filter, ignoreElements, map, merge, NEVER, of, scan, share, switchMap, take, takeWhile, tap, timeout, } from "rxjs";
-import { webSocket } from "rxjs/webSocket";
-import { nanoid } from "nanoid";
 import { logger } from "applesauce-core";
+import { nanoid } from "nanoid";
+import { BehaviorSubject, combineLatest, defer, filter, ignoreElements, map, merge, NEVER, of, scan, share, switchMap, take, takeWhile, tap, timeout, timer } from "rxjs";
+import { webSocket } from "rxjs/webSocket";
 import { markFromRelay } from "./operators/mark-from-relay.js";
 export class Relay {
     url;
@@ -32,6 +32,8 @@ export class Relay {
     eoseTimeout = 10_000;
     /** How long to wait for an OK message from the relay */
     eventTimeout = 10_000;
+    /** How long to keep the connection alive after nothing is subscribed */
+    keepAlive = 30_000;
     authRequiredForReq = new BehaviorSubject(false);
     authRequiredForPublish = new BehaviorSubject(false);
     resetState() {
@@ -98,7 +100,7 @@ export class Relay {
         // Never emit any values
         ignoreElements(), 
         // There should only be a single watch tower
-        share());
+        share({ resetOnRefCountZero: () => timer(this.keepAlive) }));
     }
     waitForAuth(
     // NOTE: require BehaviorSubject so it always has a value

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-relay",
-  "version": "0.0.0-next-20250414120207",
+  "version": "0.0.0-next-20250423145737",
   "description": "nostr relay communication framework built on rxjs",
   "type": "module",
   "main": "dist/index.js",
@@ -54,7 +54,7 @@
   },
   "dependencies": {
     "@noble/hashes": "^1.7.1",
-    "applesauce-core": "0.0.0-next-20250414120207",
+    "applesauce-core": "0.0.0-next-20250423145737",
     "nanoid": "^5.0.9",
     "nostr-tools": "^2.10.4",
     "rxjs": "^7.8.1"

package/dist/__tests__/faker.d.ts

@@ -1,19 +0,0 @@
-import * as Nostr from "nostr-typedef";
-export declare const faker: {
-    filter(filter?: Nostr.Filter): Nostr.Filter;
-    filters(): Nostr.Filter[];
-    event<const K extends number>(event?: Partial<Nostr.Event<K>>): Nostr.Event<K>;
-    AUTH(event?: Partial<Nostr.Event<Nostr.Kind.ClientAuthentication>>): Nostr.ToRelayMessage.AUTH;
-    CLOSE(subId: string): Nostr.ToRelayMessage.CLOSE;
-    COUNT(subId: string, filters?: Nostr.Filter[]): Nostr.ToRelayMessage.COUNT;
-    EVENT(event?: Partial<Nostr.Event>): Nostr.ToRelayMessage.EVENT;
-    REQ(subId: string, filters?: Nostr.Filter[]): Nostr.ToRelayMessage.REQ;
-    toClientMessage: {
-        AUTH(message?: string): Nostr.ToClientMessage.AUTH;
-        COUNT(subId: string, count?: number): Nostr.ToClientMessage.COUNT;
-        EOSE(subId: string): Nostr.ToClientMessage.EOSE;
-        EVENT(subId: string, event?: Partial<Nostr.Event>): Nostr.ToClientMessage.EVENT;
-        NOTICE(message?: string): Nostr.ToClientMessage.NOTICE;
-        OK(eventId: string, succeeded: boolean, message?: string): Nostr.ToClientMessage.OK;
-    };
-};

package/dist/__tests__/faker.js

@@ -1,56 +0,0 @@
-import { kinds } from "nostr-tools";
-export const faker = {
-    filter(filter) {
-        return filter ?? { kinds: [0] };
-    },
-    filters() {
-        return [faker.filter()];
-    },
-    event(event) {
-        return {
-            id: "*",
-            content: "*",
-            created_at: 0,
-            kind: 0,
-            pubkey: "*",
-            sig: "*",
-            tags: [],
-            ...event,
-        };
-    },
-    AUTH(event) {
-        return ["AUTH", { ...faker.event(event), kind: kinds.ClientAuth }];
-    },
-    CLOSE(subId) {
-        return ["CLOSE", subId];
-    },
-    COUNT(subId, filters) {
-        return ["COUNT", subId, ...(filters ?? faker.filters())];
-    },
-    EVENT(event) {
-        return ["EVENT", faker.event(event)];
-    },
-    REQ(subId, filters) {
-        return ["REQ", subId, ...(filters ?? faker.filters())];
-    },
-    toClientMessage: {
-        AUTH(message) {
-            return ["AUTH", message ?? "*"];
-        },
-        COUNT(subId, count) {
-            return ["COUNT", subId, { count: count ?? 0 }];
-        },
-        EOSE(subId) {
-            return ["EOSE", subId];
-        },
-        EVENT(subId, event) {
-            return ["EVENT", subId, faker.event(event)];
-        },
-        NOTICE(message) {
-            return ["NOTICE", message ?? "*"];
-        },
-        OK(eventId, succeeded, message) {
-            return ["OK", eventId, succeeded, message ?? "*"];
-        },
-    },
-};

package/dist/__tests__/matchers.d.ts

@@ -1,60 +0,0 @@
-import Nostr from "nostr-typedef";
-declare module "vitest" {
-    interface Assertion<T = any> extends CustomMatchers {
-    }
-    interface AsymmetricMatchersContaining extends CustomMatchers {
-    }
-}
-interface CustomMatchers {
-    beToRelayAUTH(): void;
-    beToRelayAUTH(event: Partial<Nostr.Event<Nostr.Kind.ClientAuthentication>>): void;
-    beToRelayCLOSE(): void;
-    beToRelayCLOSE(subId: string): void;
-    beToRelayCOUNT(): void;
-    beToRelayCOUNT(subId: string): void;
-    beToRelayCOUNT(expected: [subId: string, ...filters: Nostr.Filter[]]): void;
-    beToRelayEVENT(): void;
-    beToRelayEVENT(event: Partial<Nostr.Event>): void;
-    beToRelayREQ(): void;
-    beToRelayREQ(subId: string): void;
-    beToRelayREQ(expected: [subId: string, ...filters: Nostr.Filter[]]): void;
-    beToClientAUTH(): void;
-    beToClientAUTH(challengeMessage: string): void;
-    beToClientCOUNT(): void;
-    beToClientCOUNT(subId: string): void;
-    beToClientCOUNT(expected: [subId: string, count: number]): void;
-    beToClientEOSE(): void;
-    beToClientEOSE(subId: string): void;
-    beToClientEVENT(): void;
-    beToClientEVENT(subId: string): void;
-    beToClientEVENT(expected: [subId: string, event: Partial<Nostr.Event>]): void;
-    beToClientNOTICE(): void;
-    beToClientNOTICE(message: string): void;
-    beToClientOK(expected: [eventId: string, succeeded: boolean, message?: string]): void;
-    toReceiveAUTH(): Promise<void>;
-    toReceiveAUTH(event: Partial<Nostr.Event<Nostr.Kind.ClientAuthentication>>): Promise<void>;
-    toReceiveCLOSE(): Promise<void>;
-    toReceiveCLOSE(subId: string): Promise<void>;
-    toReceiveCOUNT(): Promise<void>;
-    toReceiveCOUNT(subId: string): Promise<void>;
-    toReceiveCOUNT(expected: [subId: string, ...filters: Nostr.Filter[]]): Promise<void>;
-    toReceiveEVENT(): Promise<void>;
-    toReceiveEVENT(event: Partial<Nostr.Event>): Promise<void>;
-    toReceiveREQ(): Promise<void>;
-    toReceiveREQ(subId: string): Promise<void>;
-    toReceiveREQ(expected: [subId: string, ...filters: Nostr.Filter[]]): Promise<void>;
-    toSeeAUTH(): Promise<void>;
-    toSeeAUTH(challengeMessage: string): Promise<void>;
-    toSeeCOUNT(): Promise<void>;
-    toSeeCOUNT(subId: string): Promise<void>;
-    toSeeCOUNT(expected: [subId: string, count: number]): Promise<void>;
-    toSeeEOSE(): Promise<void>;
-    toSeeEOSE(subId: string): Promise<void>;
-    toSeeEVENT(): Promise<void>;
-    toSeeEVENT(subId: string): Promise<void>;
-    toSeeEVENT(expected: [subId: string, event: Partial<Nostr.Event>]): Promise<void>;
-    toSeeNOTICE(): Promise<void>;
-    toSeeNOTICE(message: string): Promise<void>;
-    toSeeOK(expected: [eventId: string, succeeded: boolean, message?: string]): Promise<void>;
-}
-export {};

package/dist/__tests__/matchers.js

@@ -1,177 +0,0 @@
-import { expect } from "vitest";
-import { deriveToReceiveMessage } from "vitest-websocket-mock";
-import { TimeoutError, withTimeout } from "./utils.js";
-const beToRelayAUTH = function (actual, event) {
-    const pass = isNostrMessage("AUTH", actual) && (event === undefined || matchEvent(actual[1], event, this.equals.bind(this)));
-    return {
-        message: message("a to-relay-AUTH message", ["AUTH", event ?? "*"], this, actual, pass),
-        pass,
-    };
-};
-const beToRelayCLOSE = function (actual, subId) {
-    const pass = isNostrMessage("CLOSE", actual) && (subId === undefined || actual[1] === subId);
-    return {
-        message: message("a to-relay-CLOSE message", ["CLOSE", subId ?? "*"], this, actual, pass),
-        pass,
-    };
-};
-const beToRelayCOUNT = function (actual, pred) {
-    const subId = typeof pred === "string" ? pred : pred !== undefined ? pred[0] : null;
-    const filters = typeof pred === "object" && pred !== undefined ? pred.slice(1) : null;
-    const pass = isNostrMessage("COUNT", actual) &&
-        (subId === null || actual[1] === subId) &&
-        (filters === null || this.equals(actual.slice(2), filters));
-    return {
-        message: message("a to-relay-COUNT message", ["COUNT", subId ?? "*", ...(filters === null ? ["*"] : filters)], this, actual, pass),
-        pass,
-    };
-};
-const beToRelayEVENT = function (actual, event) {
-    const pass = isNostrMessage("EVENT", actual) && (event === undefined || matchEvent(actual[1], event, this.equals.bind(this)));
-    return {
-        message: message("a to-relay-EVENT message", ["EVENT", event ?? "*"], this, actual, pass),
-        pass,
-    };
-};
-const beToRelayREQ = function (actual, pred) {
-    const subId = typeof pred === "string" ? pred : pred !== undefined ? pred[0] : null;
-    const filters = typeof pred === "object" && pred !== undefined ? pred.slice(1) : null;
-    const pass = isNostrMessage("REQ", actual) &&
-        (subId === null || actual[1] === subId) &&
-        (filters === null || this.equals(actual.slice(2), filters));
-    return {
-        message: message("a to-relay-REQ message", ["REQ", subId ?? "*", ...(filters === null ? ["*"] : filters)], this, actual, pass),
-        pass,
-    };
-};
-const beToClientAUTH = function (actual, challengeMessage) {
-    const pass = isNostrMessage("AUTH", actual) && (challengeMessage === undefined || actual[1] === challengeMessage);
-    return {
-        message: message("a to-client-AUTH message", ["AUTH", challengeMessage ?? "*"], this, actual, pass),
-        pass,
-    };
-};
-const beToClientCOUNT = function (actual, pred) {
-    const subId = typeof pred === "string" ? pred : pred !== undefined ? pred[0] : null;
-    const count = typeof pred === "object" && pred !== undefined ? pred[1] : null;
-    const pass = isNostrMessage("COUNT", actual) &&
-        (subId === null || actual[1] === subId) &&
-        (count === null || this.equals(actual[2], { count }));
-    return {
-        message: message("a to-client-COUNT message", ["COUNT", subId ?? "*", count === null ? "*" : { count }], this, actual, pass),
-        pass,
-    };
-};
-const beToClientEOSE = function (actual, subId) {
-    const pass = isNostrMessage("EOSE", actual) && (subId === undefined || actual[1] === subId);
-    return {
-        message: message("a to-client-EOSE message", ["COUNT", subId ?? "*"], this, actual, pass),
-        pass,
-    };
-};
-const beToClientEVENT = function (actual, pred) {
-    const subId = typeof pred === "string" ? pred : pred !== undefined ? pred[0] : null;
-    const event = typeof pred === "object" && pred !== undefined ? pred[1] : null;
-    const pass = isNostrMessage("EVENT", actual) &&
-        (subId === null || actual[1] === subId) &&
-        (event === null || matchEvent(actual[2], event, this.equals.bind(this)));
-    return {
-        message: message("a to-client-EVENT message", ["EVENT", subId ?? "*", event ?? "*"], this, actual, pass),
-        pass,
-    };
-};
-const beToClientNOTICE = function (actual, noticeMessage) {
-    const pass = isNostrMessage("NOTICE", actual) && (noticeMessage === undefined || actual[1] === noticeMessage);
-    return {
-        message: message("a to-client-NOTICE message", ["EVENT", noticeMessage ?? "*"], this, actual, pass),
-        pass,
-    };
-};
-const beToClientOK = function (actual, expected) {
-    const pass = isNostrMessage("OK", actual) &&
-        (expected === undefined ||
-            (actual[1] === expected[0] &&
-                actual[2] === expected[1] &&
-                (expected[2] === undefined || actual[3] === expected[2])));
-    return {
-        message: message("a to-client-OK message", ["OK", ...(expected ?? ["*", "*", "*"])], this, actual, pass),
-        pass,
-    };
-};
-const toReceiveAUTH = deriveToReceiveMessage("toReceiveAUTH", beToRelayAUTH);
-const toReceiveCLOSE = deriveToReceiveMessage("toReceiveCLOSE", beToRelayCLOSE);
-const toReceiveCOUNT = deriveToReceiveMessage("toReceiveCOUNT", beToRelayCOUNT);
-const toReceiveEVENT = deriveToReceiveMessage("toReceiveEVENT", beToRelayEVENT);
-const toReceiveREQ = deriveToReceiveMessage("toReceiveREQ", beToRelayREQ);
-const toSeeAUTH = clientMathcer("toSeeAUTH", beToClientAUTH);
-const toSeeCOUNT = clientMathcer("toSeeCOUNT", beToClientCOUNT);
-const toSeeEOSE = clientMathcer("toSeeEOSE", beToClientEOSE);
-const toSeeEVENT = clientMathcer("toSeeEVENT", beToClientEVENT);
-const toSeeNOTICE = clientMathcer("toSeeNOTICE", beToClientNOTICE);
-const toSeeOK = clientMathcer("toSeeOK", beToClientOK);
-expect.extend({
-    beToRelayAUTH,
-    beToRelayCLOSE,
-    beToRelayCOUNT,
-    beToRelayEVENT,
-    beToRelayREQ,
-    beToClientAUTH,
-    beToClientCOUNT,
-    beToClientEOSE,
-    beToClientEVENT,
-    beToClientNOTICE,
-    beToClientOK,
-    toReceiveAUTH,
-    toReceiveCLOSE,
-    toReceiveCOUNT,
-    toReceiveEVENT,
-    toReceiveREQ,
-    toSeeAUTH,
-    toSeeCOUNT,
-    toSeeEOSE,
-    toSeeEVENT,
-    toSeeNOTICE,
-    toSeeOK,
-});
-function clientMathcer(name, fn) {
-    return async function (spy, pred, options) {
-        if (spy.__createClientSpy) {
-            try {
-                return await withTimeout(async () => fn.call(this, await spy.next(), pred, options));
-            }
-            catch (err) {
-                if (err instanceof TimeoutError) {
-                    return {
-                        pass: this.isNot,
-                        message: () => this.utils.matcherHint(`${this.isNot ? ".not" : ""}.${name}`, "ClientSpy", "expected") +
-                            "\n\n" +
-                            `Client spy was waiting for the next message from the relay, but timed out.`,
-                    };
-                }
-                else {
-                    throw err;
-                }
-            }
-        }
-        else {
-            return {
-                pass: this.isNot,
-                message: () => this.utils.matcherHint(`${this.isNot ? ".not" : ""}.${name}`, "ClientSpy", "expected") +
-                    "\n\n" +
-                    `Mathcer \`${name}\` must be used for ClientSpy, but now being used for:\n\n` +
-                    `${this.utils.printReceived(spy)}\n`,
-            };
-        }
-    };
-}
-function isNostrMessage(type, message) {
-    return Array.isArray(message) && message[0] === type;
-}
-function matchEvent(received, expected, equal) {
-    const eventKeys = ["id", "sig", "kind", "tags", "pubkey", "content", "created_at"];
-    const isEvent = (x) => typeof x === "object" && x !== null && eventKeys.every((key) => key in x);
-    return (isEvent(received) && eventKeys.every((key) => expected[key] === undefined || equal(received[key], expected[key])));
-}
-function message(entityName, expected, state, actual, pass) {
-    return () => `It was expected ${pass ? "not " : ""}to be ${entityName}, like this:\n\n${state.utils.printExpected(expected)}\n\nbut got:\n\n${state.utils.printReceived(actual)}\n`;
-}

package/dist/__tests__/mock.d.ts

@@ -1,84 +0,0 @@
-import { CloseOptions } from "mock-socket";
-import Nostr from "nostr-typedef";
-import { WS } from "vitest-websocket-mock";
-export interface MockServerSocket {
-    id: number;
-    send(message: unknown): void;
-    close(options?: CloseOptions): void;
-}
-export interface MockServerBehavior {
-    onOpen?(socket: MockServerSocket): void;
-    onMessage?(socket: MockServerSocket, message: string): void;
-    onClose?(socket: MockServerSocket): void;
-    onError?(socket: MockServerSocket, error: Error): void;
-}
-interface MockServer extends WS {
-    getSockets: (count: number, options?: {
-        timeout?: number;
-    }) => Promise<MockServerSocket[]>;
-    getSocket: (index: number) => Promise<MockServerSocket>;
-    getSocketsSync: () => MockServerSocket[];
-}
-export declare function createMockServer(url: string, behavior: MockServerBehavior): MockServer;
-export interface MockRelay extends MockServer {
-    /**
-     * Pop the latest message that has not yet been consumed.
-     * If such a message does not yet exist, it waits for the message
-     * until it times out.
-     *
-     * The default timeout is 1000 miliseconds.
-     */
-    next: (timeout?: number) => Promise<Nostr.ToRelayMessage.Any>;
-    /**
-     * Pop the latest `count` messages that have not yet been consumed.
-     * If such a message does not yet exist, it waits for the message
-     * until it times out.
-     *
-     * The default timeout is 1000 miliseconds.
-     */
-    nexts: (count: number, timeout?: number) => Promise<Nostr.ToRelayMessage.Any[]>;
-    /**
-     * Send messages of any format from the given socket mock.
-     * If `socket` is omitted, it will be sent from all active socket mocks.
-     *
-     * If the message is a string, as-is string will be sent,
-     * otherwise JSON strigify will be attempted.
-     *
-     * Note that the messages sent by this method are outside
-     * the management of the mock relay.
-     * This means that if, for example, you use this method to send an OK message,
-     * the mock relay will not know about it.
-     * Therefore, subsequent calls to emitOK() may send a duplicate OK message.
-     * */
-    emit(message: unknown, socket?: MockServerSocket): string;
-    /**
-     * Send COUNT messages from all socket mocks
-     * holding active COUNT subscriptions (in other words,
-     * subscriptions that have not yet responded with COUNT)
-     * with the given subId.
-     */
-    emitCOUNT(subId: string, count?: number): Nostr.ToClientMessage.COUNT;
-    /**
-     * Send EOSE messages from all socket mocks
-     * holding active REQ subscriptions (in other words,
-     * subscriptions that have not yet been CLOSE'd)
-     * with the given subId.
-     */
-    emitEOSE(subId: string): Nostr.ToClientMessage.EOSE;
-    /**
-     * Send EVENT messages from all socket mocks
-     * holding active REQ subscriptions (in other words,
-     * subscriptions that have not yet been CLOSE'd)
-     * with the given subId.
-     */
-    emitEVENT(subId: string, event?: Partial<Nostr.Event>): Nostr.ToClientMessage.EVENT;
-    /**
-     * Send OK messages from all socket mocks
-     * holding active EVENT (in other words, an EVENT
-     * that has not yet returned an OK message)
-     * with the given eventId.
-     */
-    emitOK(eventId: string, succeeded: boolean, message?: string): Nostr.ToClientMessage.OK;
-}
-export declare function createMockRelay(url: string): MockRelay;
-export {};

package/dist/__tests__/mock.js

@@ -1,181 +0,0 @@
-import { WS } from "vitest-websocket-mock";
-import { faker } from "./faker.js";
-import { withTimeout } from "./utils.js";
-export function createMockServer(url, behavior) {
-    const server = new WS(url, { jsonProtocol: true });
-    const sockets = [];
-    let resolvers = [];
-    let nextId = 1;
-    server.on("connection", (_socket) => {
-        const socket = {
-            id: nextId++,
-            send(message) {
-                if (_socket.readyState !== WebSocket.OPEN) {
-                    return;
-                }
-                _socket.send(typeof message === "string" ? message : `${JSON.stringify(message)}`);
-            },
-            close(options) {
-                _socket.close(options);
-            },
-        };
-        sockets.push(socket);
-        resolvers.filter(([count]) => count <= sockets.length).forEach(([, resolve]) => resolve([...sockets]));
-        resolvers = resolvers.filter(([count]) => count > sockets.length);
-        behavior.onOpen?.(socket);
-        _socket.on("message", (message) => {
-            if (typeof message !== "string") {
-                throw new Error("Unexpected type message");
-            }
-            behavior.onMessage?.(socket, message);
-        });
-        _socket.on("close", () => {
-            behavior.onClose?.(socket);
-        });
-        _socket.on("error", (error) => {
-            behavior.onError?.(socket, error);
-        });
-    });
-    const getSockets = async (count, options) => {
-        const promise = new Promise((resolve) => {
-            if (sockets.length >= count) {
-                resolve([...sockets]);
-            }
-            else {
-                resolvers.push([count, resolve]);
-            }
-        });
-        return withTimeout(promise, `Mock relay was waiting for ${count} connections to be established, but timed out.`, options?.timeout);
-    };
-    const getSocket = async (index) => {
-        const sockets = await getSockets(index + 1);
-        return sockets[index];
-    };
-    return Object.assign(server, {
-        getSockets,
-        getSocket,
-        getSocketsSync: () => [...sockets],
-    });
-}
-function relayBehavior() {
-    const reqs = new Map();
-    const counts = new Map();
-    const events = new Map();
-    const sockets = new Set();
-    return {
-        onOpen(socket) {
-            sockets.add(socket);
-        },
-        onMessage(socket, rawMessage) {
-            const message = JSON.parse(rawMessage);
-            switch (message[0]) {
-                case "CLOSE": {
-                    const subId = message[1];
-                    reqs.get(socket)?.delete(subId);
-                    break;
-                }
-                case "COUNT": {
-                    if (!counts.has(socket)) {
-                        counts.set(socket, new Set());
-                    }
-                    const subId = message[1];
-                    counts.get(socket)?.add(subId);
-                    break;
-                }
-                case "EVENT": {
-                    if (!events.has(socket)) {
-                        events.set(socket, new Set());
-                    }
-                    const eventId = message[1].id;
-                    events.get(socket)?.add(eventId);
-                    break;
-                }
-                case "REQ": {
-                    if (!reqs.has(socket)) {
-                        reqs.set(socket, new Set());
-                    }
-                    const subId = message[1];
-                    reqs.get(socket)?.add(subId);
-                    break;
-                }
-            }
-        },
-        onClose(socket) {
-            reqs.delete(socket);
-            counts.delete(socket);
-            events.delete(socket);
-            sockets.delete(socket);
-        },
-        emit(message, socket) {
-            const toBeSent = typeof message === "string" ? message : `${JSON.stringify(message)}`;
-            if (socket) {
-                socket.send(toBeSent);
-            }
-            else {
-                for (const socket of sockets) {
-                    socket.send(toBeSent);
-                }
-            }
-            return toBeSent;
-        },
-        emitCOUNT(subId, count) {
-            const toBeSent = faker.toClientMessage.COUNT(subId, count);
-            for (const [socket, subIds] of counts.entries()) {
-                if (subIds.has(subId)) {
-                    socket.send(toBeSent);
-                }
-                subIds.delete(subId);
-            }
-            return toBeSent;
-        },
-        emitEOSE(subId) {
-            const toBeSent = faker.toClientMessage.EOSE(subId);
-            for (const [socket, subIds] of reqs.entries()) {
-                if (subIds.has(subId)) {
-                    socket.send(toBeSent);
-                }
-            }
-            return toBeSent;
-        },
-        emitEVENT(subId, event) {
-            const toBeSent = faker.toClientMessage.EVENT(subId, event);
-            for (const [socket, subIds] of reqs.entries()) {
-                if (subIds.has(subId)) {
-                    socket.send(toBeSent);
-                }
-            }
-            return toBeSent;
-        },
-        emitOK(eventId, succeeded, message) {
-            const toBeSent = faker.toClientMessage.OK(eventId, succeeded, message);
-            for (const [socket, eventIds] of events.entries()) {
-                if (eventIds.has(eventId)) {
-                    socket.send(toBeSent);
-                }
-                eventIds.delete(eventId);
-            }
-            return toBeSent;
-        },
-    };
-}
-export function createMockRelay(url) {
-    const behavior = relayBehavior();
-    const server = createMockServer(url, behavior);
-    const { emit, emitCOUNT, emitEOSE, emitEVENT, emitOK } = behavior;
-    const timeoutMessage = "Mock relay was waiting for the next message from the client, but timed out.";
-    return Object.assign(server, {
-        next: (timeout) => withTimeout(server.nextMessage, timeoutMessage, timeout),
-        nexts: (count, timeout) => withTimeout(async () => {
-            const messages = [];
-            for (let i = 0; i < count; i++) {
-                messages.push((await server.nextMessage));
-            }
-            return messages;
-        }, timeoutMessage, timeout),
-        emit,
-        emitCOUNT,
-        emitEOSE,
-        emitEVENT,
-        emitOK,
-    });
-}

package/dist/__tests__/spy.d.ts

@@ -1,7 +0,0 @@
-import Nostr from "nostr-typedef";
-export interface ClientSpy {
-    __createClientSpy: true;
-    next: () => Promise<Nostr.ToClientMessage.Any>;
-    dispose: () => void;
-}
-export declare function createClientSpy(addOnMessageListener: (listener: (message: Nostr.ToClientMessage.Any) => void) => void): ClientSpy;

package/dist/__tests__/spy.js

@@ -1,65 +0,0 @@
-export function createClientSpy(addOnMessageListener) {
-    let queue = { type: "empty" };
-    addOnMessageListener((message) => {
-        switch (queue.type) {
-            case "empty": {
-                queue = {
-                    type: "message",
-                    items: [message],
-                };
-                break;
-            }
-            case "message": {
-                queue.items.push(message);
-                break;
-            }
-            case "resolver": {
-                const item = queue.items.shift();
-                if (item) {
-                    const resolve = item[0];
-                    resolve(message);
-                }
-                if (queue.items.length <= 0) {
-                    queue = { type: "empty" };
-                }
-            }
-        }
-    });
-    return {
-        __createClientSpy: true,
-        next: () => new Promise((resolve, reject) => {
-            switch (queue.type) {
-                case "empty": {
-                    queue = {
-                        type: "resolver",
-                        items: [[resolve, reject]],
-                    };
-                    break;
-                }
-                case "message": {
-                    const msg = queue.items.shift();
-                    if (msg) {
-                        resolve(msg);
-                    }
-                    if (queue.items.length <= 0) {
-                        queue = { type: "empty" };
-                    }
-                    break;
-                }
-                case "resolver": {
-                    queue.items.push([resolve, reject]);
-                    break;
-                }
-            }
-        }),
-        dispose: () => {
-            if (queue.type === "resolver") {
-                for (const item of queue.items) {
-                    const reject = item[1];
-                    reject(new Error());
-                }
-            }
-            queue = { type: "empty" };
-        },
-    };
-}

package/dist/__tests__/utils.d.ts

@@ -1,3 +0,0 @@
-export declare class TimeoutError extends Error {
-}
-export declare function withTimeout<T>(task: Promise<T> | (() => Promise<T>), message?: string, timeout?: number): Promise<T>;

package/dist/__tests__/utils.js

@@ -1,8 +0,0 @@
-export class TimeoutError extends Error {
-}
-export function withTimeout(task, message, timeout = 1000) {
-    return Promise.race([
-        typeof task === "function" ? task() : task,
-        new Promise((_, reject) => setTimeout(() => reject(new TimeoutError(message)), timeout)),
-    ]);
-}

package/dist/server/connection.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/server/connection.js

@@ -1,9 +0,0 @@
-import { z } from "zod";
-const IncomingREQ = z.tuple([z.literal("REQ"), z.string(), z.array(z.any())]);
-const IncomingEVENT = z.tuple([z.literal("EVENT"), z.any()]);
-const IncomingCLOSE = z.tuple([z.literal("CLOSE"), z.string()]);
-const IncomingAUTH = z.tuple([z.literal("AUTH"), z.any()]);
-const OutgoingEVENT = z.tuple([z.literal("EVENT"), z.string(), z.any()]);
-const OutgoingNOTICE = z.tuple([z.literal("NOTICE"), z.string()]);
-const OutgoingCLOSE = z.tuple([z.literal("CLOSE"), z.string()]);
-const OutgoingAUTH = z.tuple([z.literal("AUTH"), z.string()]);