@peers-app/peers-sdk 0.27.3 → 0.27.4

package/dist/contracts/__tests__/contract-provider-router.test.js

@@ -1,315 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const utils_1 = require("../../utils");
-const index_1 = require("../index");
-const makeCall = (overrides = {}) => ({
-    contractId: "contract-a",
-    version: 1,
-    member: "table",
-    name: "Items",
-    operation: "list",
-    args: [],
-    ...overrides,
-});
-const makeEndpoint = (label) => ({
-    handleCall: jest.fn(async (call) => `${label}:${call.operation}`),
-    dispose: jest.fn(),
-});
-describe("contract provider router", () => {
-    it("refreshes a retired cached endpoint once and shares the new route across concurrent calls", async () => {
-        const [consumerTransport, providerTransport] = (0, index_1.inProcessTransportPair)();
-        const old = makeEndpoint("old");
-        const current = makeEndpoint("current");
-        const resolveEndpoint = jest.fn().mockResolvedValueOnce(old).mockResolvedValue(current);
-        const router = (0, index_1.createContractProviderRouter)(providerTransport, {
-            authorizeCall: () => ({}),
-            resolveEndpoint,
-        });
-        try {
-            expect(await consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, makeCall())).toBe("old:list");
-            old.handleCall.mockRejectedValue(new index_1.RetiredContractProviderEndpointError(old));
-            expect(await Promise.all([
-                consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, makeCall()),
-                consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, makeCall()),
-            ])).toEqual(["current:list", "current:list"]);
-            expect(resolveEndpoint).toHaveBeenCalledTimes(2);
-            expect(old.dispose).toHaveBeenCalledTimes(1);
-            // Another replacement in the same call fails closed instead of looping.
-            current.handleCall.mockRejectedValue(new index_1.RetiredContractProviderEndpointError(current));
-            await expect(consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, makeCall())).rejects.toThrow(/retired/);
-            expect(resolveEndpoint).toHaveBeenCalledTimes(3);
-        }
-        finally {
-            router.dispose();
-        }
-    });
-    it("does not replay provider code when a downstream endpoint retires", async () => {
-        const [consumerTransport, providerTransport] = (0, index_1.inProcessTransportPair)();
-        const downstream = makeEndpoint("downstream");
-        const endpoint = makeEndpoint("caller");
-        const effects = jest.fn();
-        const failure = new index_1.RetiredContractProviderEndpointError(downstream);
-        endpoint.handleCall.mockImplementation(async () => {
-            effects();
-            throw failure;
-        });
-        const resolveEndpoint = jest.fn().mockResolvedValue(endpoint);
-        const router = (0, index_1.createContractProviderRouter)(providerTransport, {
-            authorizeCall: () => ({}),
-            resolveEndpoint,
-        });
-        try {
-            await expect(consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, makeCall())).rejects.toBe(failure);
-            expect(resolveEndpoint).toHaveBeenCalledTimes(1);
-            expect(effects).toHaveBeenCalledTimes(1);
-        }
-        finally {
-            router.dispose();
-        }
-    });
-    it("multiplexes routes and caches normalized contract/version/data-context endpoints", async () => {
-        const [consumerTransport, providerTransport] = (0, index_1.inProcessTransportPair)();
-        const endpoints = new Map();
-        const resolveEndpoint = jest.fn((request) => {
-            const key = JSON.stringify([request.contractId, request.version, request.dataContextId]);
-            const endpoint = makeEndpoint(key);
-            endpoints.set(key, endpoint);
-            return endpoint;
-        });
-        const router = (0, index_1.createContractProviderRouter)(providerTransport, {
-            authorizeCall: (call) => ({
-                dataContextId: call.dataContextId || "personal-context",
-            }),
-            resolveEndpoint,
-        });
-        await consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, makeCall());
-        await consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, makeCall({ dataContextId: "personal-context", operation: "count" }));
-        await consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, makeCall({ dataContextId: "group-context" }));
-        await consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, makeCall({ contractId: "contract-b" }));
-        expect(resolveEndpoint).toHaveBeenCalledTimes(3);
-        expect(resolveEndpoint.mock.calls.map(([request]) => [
-            request.contractId,
-            request.version,
-            request.dataContextId,
-        ])).toEqual([
-            ["contract-a", 1, "personal-context"],
-            ["contract-a", 1, "group-context"],
-            ["contract-b", 1, "personal-context"],
-        ]);
-        expect((endpoints.get('["contract-a",1,"personal-context"]')?.handleCall).mock.calls).toHaveLength(2);
-        router.dispose();
-        for (const endpoint of endpoints.values()) {
-            expect(endpoint.dispose).toHaveBeenCalledTimes(1);
-        }
-    });
-    it("denies before invoking the endpoint resolver", async () => {
-        const [consumerTransport, providerTransport] = (0, index_1.inProcessTransportPair)();
-        const resolveEndpoint = jest.fn(() => makeEndpoint("denied"));
-        const router = (0, index_1.createContractProviderRouter)(providerTransport, {
-            authorizeCall: async () => {
-                throw new Error("Permission denied by host");
-            },
-            resolveEndpoint,
-        });
-        await expect(consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, makeCall())).rejects.toThrow("Permission denied by host");
-        expect(resolveEndpoint).not.toHaveBeenCalled();
-        router.dispose();
-    });
-    it("keys endpoints by provider and invalidates one provider without trusting call payload", async () => {
-        const [consumerTransport, providerTransport] = (0, index_1.inProcessTransportPair)();
-        let activeProvider = "provider-a";
-        const created = [];
-        const router = (0, index_1.createContractProviderRouter)(providerTransport, {
-            authorizeCall: () => ({ dataContextId: "personal-context" }),
-            resolveProviderPackageId: () => activeProvider,
-            resolveEndpoint: (request) => {
-                const providerPackageId = request.providerPackageId ?? "missing";
-                const endpoint = makeEndpoint(providerPackageId);
-                created.push({ providerPackageId, endpoint });
-                return endpoint;
-            },
-        });
-        await expect(consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, makeCall())).resolves.toBe("provider-a:list");
-        activeProvider = "provider-b";
-        await expect(consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, makeCall())).resolves.toBe("provider-b:list");
-        expect(created).toHaveLength(2);
-        router.invalidateProvider("provider-a");
-        expect(created[0].endpoint.dispose).toHaveBeenCalledTimes(1);
-        expect(created[1].endpoint.dispose).not.toHaveBeenCalled();
-        activeProvider = "provider-a";
-        await expect(consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, makeCall())).resolves.toBe("provider-a:list");
-        expect(created).toHaveLength(3);
-        router.dispose();
-    });
-    it("ignores peer-supplied context in favor of trusted host context", async () => {
-        const [consumerTransport, providerTransport] = (0, index_1.inProcessTransportPair)();
-        const trustedContext = {
-            callerUserId: "trusted-caller",
-            localUserId: "trusted-local",
-        };
-        const endpoint = makeEndpoint("trusted");
-        const authorizeCall = jest.fn((_call, context) => ({
-            dataContextId: "personal-context",
-            context,
-        }));
-        const resolveEndpoint = jest.fn(() => endpoint);
-        const router = (0, index_1.createContractProviderRouter)(providerTransport, {
-            context: trustedContext,
-            authorizeCall,
-            resolveEndpoint,
-        });
-        await consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, makeCall(), {
-            callerUserId: "spoofed-caller",
-            localUserId: "spoofed-local",
-        });
-        expect(authorizeCall).toHaveBeenCalledWith(expect.anything(), trustedContext);
-        expect(resolveEndpoint).toHaveBeenCalledWith(expect.objectContaining({ context: trustedContext }));
-        expect(endpoint.handleCall).toHaveBeenCalledWith(expect.anything(), trustedContext);
-        router.dispose();
-    });
-    it("routes independent subscriptions and skips authorization for idempotent unsubscribe", async () => {
-        const [consumerTransport, providerTransport] = (0, index_1.inProcessTransportPair)();
-        const endpoint = makeEndpoint("subscriptions");
-        const authorizeCall = jest.fn((call) => ({
-            dataContextId: call.dataContextId || "personal-context",
-        }));
-        const resolveEndpoint = jest.fn(() => endpoint);
-        const router = (0, index_1.createContractProviderRouter)(providerTransport, {
-            authorizeCall,
-            resolveEndpoint,
-        });
-        const firstId = (0, utils_1.newid)();
-        const secondId = (0, utils_1.newid)();
-        await consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, makeCall({
-            member: "event",
-            name: "changed",
-            operation: "subscribe",
-            subscriptionId: firstId,
-        }));
-        await consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, makeCall({
-            member: "event",
-            name: "changed",
-            operation: "subscribe",
-            subscriptionId: secondId,
-        }));
-        await consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, makeCall({
-            member: "event",
-            name: "ignored-by-router",
-            operation: "unsubscribe",
-            subscriptionId: firstId,
-        }));
-        await consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, makeCall({
-            member: "event",
-            name: "changed",
-            operation: "unsubscribe",
-            subscriptionId: (0, utils_1.newid)(),
-        }));
-        expect(authorizeCall).toHaveBeenCalledTimes(2);
-        expect(resolveEndpoint).toHaveBeenCalledTimes(1);
-        expect(endpoint.handleCall).toHaveBeenCalledTimes(3);
-        expect(endpoint.handleCall).toHaveBeenLastCalledWith(expect.objectContaining({
-            name: "changed",
-            operation: "unsubscribe",
-            subscriptionId: firstId,
-        }), {});
-        router.dispose();
-    });
-    it("tears down a subscription cancelled while authorization is pending", async () => {
-        const [consumerTransport, providerTransport] = (0, index_1.inProcessTransportPair)();
-        const endpoint = makeEndpoint("pending");
-        let finishAuthorization;
-        const authorizationReady = new Promise((resolve) => {
-            finishAuthorization = resolve;
-        });
-        const router = (0, index_1.createContractProviderRouter)(providerTransport, {
-            authorizeCall: async () => {
-                await authorizationReady;
-                return { dataContextId: "personal-context" };
-            },
-            resolveEndpoint: () => endpoint,
-        });
-        const subscriptionId = (0, utils_1.newid)();
-        const subscribeCall = makeCall({
-            member: "event",
-            name: "changed",
-            operation: "subscribe",
-            subscriptionId,
-        });
-        const subscribePromise = consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, subscribeCall);
-        await expect(consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, {
-            ...subscribeCall,
-            operation: "unsubscribe",
-        })).resolves.toBeUndefined();
-        finishAuthorization();
-        await expect(subscribePromise).resolves.toBe("pending:subscribe");
-        expect(endpoint.handleCall.mock.calls.map(([call]) => call.operation)).toEqual(["subscribe", "unsubscribe"]);
-        router.dispose();
-    });
-    it("disposes an endpoint whose asynchronous resolution finishes during teardown", async () => {
-        const [consumerTransport, providerTransport] = (0, index_1.inProcessTransportPair)();
-        const endpoint = makeEndpoint("late");
-        let resolveEndpointPromise;
-        const endpointPromise = new Promise((resolve) => {
-            resolveEndpointPromise = resolve;
-        });
-        const resolveEndpoint = jest.fn(() => endpointPromise);
-        const router = (0, index_1.createContractProviderRouter)(providerTransport, {
-            authorizeCall: () => ({ dataContextId: "personal-context" }),
-            resolveEndpoint,
-        });
-        const callPromise = consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, makeCall());
-        await Promise.resolve();
-        await Promise.resolve();
-        expect(resolveEndpoint).toHaveBeenCalledTimes(1);
-        router.dispose();
-        resolveEndpointPromise(endpoint);
-        await expect(callPromise).rejects.toThrow("Contract provider router is disposed");
-        expect(endpoint.dispose).toHaveBeenCalledTimes(1);
-        expect(await consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, makeCall())).toBeUndefined();
-    });
-    it("routes device-targeted tool calls by target without selecting a local provider", async () => {
-        const [consumerTransport, providerTransport] = (0, index_1.inProcessTransportPair)();
-        const resolveProviderPackageId = jest.fn(async () => "local-provider");
-        const resolveEndpoint = jest.fn((request) => makeEndpoint(`${request.providerPackageId ?? "none"}@${request.targetDeviceId ?? "local"}`));
-        const router = (0, index_1.createContractProviderRouter)(providerTransport, {
-            authorizeCall: () => ({ dataContextId: "group-context" }),
-            resolveProviderPackageId,
-            resolveEndpoint,
-        });
-        const toolCall = makeCall({ member: "tool", name: "ping", operation: "run", args: [{}] });
-        await expect(consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, { ...toolCall, targetDeviceId: "device-b" })).resolves.toBe("none@device-b:run");
-        await consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, {
-            ...toolCall,
-            targetDeviceId: "device-b",
-        });
-        await expect(consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, { ...toolCall, targetDeviceId: "device-c" })).resolves.toBe("none@device-c:run");
-        await expect(consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, toolCall)).resolves.toBe("local-provider@local:run");
-        // One endpoint per target device plus one local; provider selection only ran locally.
-        expect(resolveEndpoint).toHaveBeenCalledTimes(3);
-        expect(resolveProviderPackageId).toHaveBeenCalledTimes(1);
-        expect(resolveEndpoint.mock.calls[0][0]).toMatchObject({
-            targetDeviceId: "device-b",
-            dataContextId: "group-context",
-            providerPackageId: undefined,
-        });
-        router.dispose();
-    });
-    it("rejects device-targeted calls that are not tool runs", async () => {
-        const [consumerTransport, providerTransport] = (0, index_1.inProcessTransportPair)();
-        const resolveEndpoint = jest.fn(() => makeEndpoint("never"));
-        const router = (0, index_1.createContractProviderRouter)(providerTransport, {
-            authorizeCall: () => ({ dataContextId: "group-context" }),
-            resolveEndpoint,
-        });
-        await expect(consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, makeCall({ targetDeviceId: "device-b" }))).rejects.toThrow("only tool runs are remotely callable");
-        await expect(consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, makeCall({
-            member: "event",
-            name: "changed",
-            operation: "subscribe",
-            subscriptionId: (0, utils_1.newid)(),
-            targetDeviceId: "device-b",
-        }))).rejects.toThrow("only tool runs are remotely callable");
-        expect(resolveEndpoint).not.toHaveBeenCalled();
-        router.dispose();
-    });
-});

package/dist/contracts/__tests__/contract-proxy.test.d.ts

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