applesauce-relay 0.0.0-next-20250916134023 → 0.0.0-next-20250919114711

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__/pool.test.d.ts

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

package/dist/__tests__/pool.test.js

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

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