applesauce-relay 0.0.0-next-20250808173123 → 0.0.0-next-20250815164532

package/dist/__tests__/mock.d.ts

@@ -0,0 +1,84 @@
+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

@@ -0,0 +1,181 @@
+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__/pool.test.d.ts

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

package/dist/__tests__/pool.test.js

@@ -0,0 +1,96 @@
+import { expect, beforeEach, afterEach, describe, it } from "vitest";
+import { subscribeSpyTo } from "@hirez_io/observer-spy";
+import { WS } from "vitest-websocket-mock";
+import { RelayPool } from "../pool.js";
+let pool;
+let mockServer1;
+let mockServer2;
+let mockEvent;
+beforeEach(async () => {
+    // Create mock WebSocket servers
+    mockServer1 = new WS("wss://relay1.example.com");
+    mockServer2 = new WS("wss://relay2.example.com");
+    pool = new RelayPool();
+    mockEvent = {
+        kind: 1,
+        id: "test-id",
+        pubkey: "test-pubkey",
+        created_at: 1743712795,
+        tags: [],
+        content: "test content",
+        sig: "test-sig",
+    };
+});
+afterEach(async () => {
+    mockServer1.close();
+    mockServer2.close();
+    // Clean up WebSocket mocks
+    await WS.clean();
+});
+describe("relay", () => {
+    it("should create a new relay", () => {
+        const url = "wss://relay1.example.com/";
+        const relay = pool.relay(url);
+        expect(relay).toBeDefined();
+        expect(pool.relays.get(url)).toBe(relay);
+    });
+    it("should return existing relay connection if already exists", () => {
+        const url = "wss://relay1.example.com";
+        const relay1 = pool.relay(url);
+        const relay2 = pool.relay(url);
+        expect(relay1).toBe(relay2);
+        expect(pool.relays.size).toBe(1);
+    });
+    it("should normalize relay urls", () => {
+        expect(pool.relay("wss://relay.example.com")).toBe(pool.relay("wss://relay.example.com/"));
+        expect(pool.relay("wss://relay.example.com:443")).toBe(pool.relay("wss://relay.example.com/"));
+        expect(pool.relay("ws://relay.example.com:80")).toBe(pool.relay("ws://relay.example.com/"));
+    });
+});
+describe("group", () => {
+    it("should create a relay group", () => {
+        const urls = ["wss://relay1.example.com/", "wss://relay2.example.com/"];
+        const group = pool.group(urls);
+        expect(group).toBeDefined();
+        expect(pool.groups.get(urls.sort().join(","))).toBe(group);
+    });
+});
+describe("req", () => {
+    it("should send subscription to multiple relays", async () => {
+        const urls = ["wss://relay1.example.com", "wss://relay2.example.com"];
+        const filters = { kinds: [1] };
+        const spy = subscribeSpyTo(pool.req(urls, filters));
+        // Verify REQ was sent to both relays
+        const req1 = await mockServer1.nextMessage;
+        const req2 = await mockServer2.nextMessage;
+        // Both messages should be REQ messages with the same filter
+        expect(JSON.parse(req1)[0]).toBe("REQ");
+        expect(JSON.parse(req2)[0]).toBe("REQ");
+        expect(JSON.parse(req1)[2]).toEqual(filters);
+        expect(JSON.parse(req2)[2]).toEqual(filters);
+        // Send EVENT from first relay
+        mockServer1.send(JSON.stringify(["EVENT", JSON.parse(req1)[1], mockEvent]));
+        // Send EOSE from both relays
+        mockServer1.send(JSON.stringify(["EOSE", JSON.parse(req1)[1]]));
+        mockServer2.send(JSON.stringify(["EOSE", JSON.parse(req2)[1]]));
+        expect(spy.getValues()).toContainEqual(expect.objectContaining(mockEvent));
+    });
+});
+describe("event", () => {
+    it("should publish to multiple relays", async () => {
+        const urls = ["wss://relay1.example.com/", "wss://relay2.example.com/"];
+        const spy = subscribeSpyTo(pool.event(urls, mockEvent));
+        // Verify EVENT was sent to both relays
+        const event1 = await mockServer1.nextMessage;
+        const event2 = await mockServer2.nextMessage;
+        expect(JSON.parse(event1)).toEqual(["EVENT", mockEvent]);
+        expect(JSON.parse(event2)).toEqual(["EVENT", mockEvent]);
+        // Send OK responses from both relays
+        mockServer1.send(JSON.stringify(["OK", mockEvent.id, true, ""]));
+        mockServer2.send(JSON.stringify(["OK", mockEvent.id, true, ""]));
+        expect(spy.getValues()).toEqual([
+            { ok: true, from: "wss://relay1.example.com/", message: "" },
+            { ok: true, from: "wss://relay2.example.com/", message: "" },
+        ]);
+    });
+});

package/dist/__tests__/relay.test.d.ts

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