@peers-app/peers-sdk 0.19.14 → 0.20.1

package/dist/contracts/__tests__/contract-resolvers.test.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const user_permissions_1 = require("../../data/user-permissions");
+const user_trust_levels_1 = require("../../data/user-trust-levels");
+const users_1 = require("../../data/users");
+const socket_type_1 = require("../../device/socket.type");
+const keys_1 = require("../../keys");
+const utils_1 = require("../../utils");
+const index_1 = require("../index");
+jest.mock("../../data/user-trust-levels", () => ({
+    UserTrustLevels: jest.fn(),
+}));
+jest.mock("../../data/users", () => ({
+    Users: jest.fn(),
+}));
+const mockUserTrustLevels = user_trust_levels_1.UserTrustLevels;
+const mockUsers = users_1.Users;
+const mockTrustGet = jest.fn();
+function makeIdentity() {
+    const keys = (0, keys_1.newKeys)();
+    const userId = (0, utils_1.newid)();
+    const user = (0, user_permissions_1.signUserObject)({
+        userId,
+        name: "Remote user",
+        publicKey: keys.publicKey,
+        publicBoxKey: keys.publicBoxKey,
+    }, keys.secretKey);
+    const remoteIdentity = {
+        userId,
+        deviceId: (0, utils_1.newid)(),
+        publicKey: keys.publicKey,
+        publicBoxKey: keys.publicBoxKey,
+    };
+    return { remoteIdentity, user };
+}
+function setupUserContext(localUserId, records) {
+    const personalContext = {};
+    const groupContext = {};
+    const userContext = {
+        userId: localUserId,
+        userDataContext: personalContext,
+        groupDataContexts: new Map([["group", groupContext]]),
+        getDataContext: jest.fn(),
+    };
+    mockUsers.mockImplementation((dataContext) => ({
+        get: jest.fn().mockResolvedValue(records.get(dataContext) ?? null),
+    }));
+    mockUserTrustLevels.mockReturnValue({ get: mockTrustGet });
+    return { groupContext, personalContext, userContext: userContext };
+}
+const call = {
+    contractId: "test-contract",
+    version: 1,
+    member: "table",
+    name: "Items",
+    operation: "list",
+    args: [],
+};
+describe("Self-trusted contract caller authorization", () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it.each([
+        ["same-account", true],
+        ["explicit cross-account", false],
+    ])("allows a signed %s identity with personal Self trust", async (_label, sameAccount) => {
+        const { remoteIdentity, user } = makeIdentity();
+        const localUserId = sameAccount ? remoteIdentity.userId : (0, utils_1.newid)();
+        const records = new Map();
+        const { personalContext, userContext } = setupUserContext(localUserId, records);
+        records.set(personalContext, user);
+        mockTrustGet.mockResolvedValue({ trustLevel: socket_type_1.TrustLevel.Self });
+        await expect((0, index_1.isSelfTrustedContractCaller)(userContext, remoteIdentity)).resolves.toBe(true);
+        if (sameAccount) {
+            expect(mockTrustGet).not.toHaveBeenCalled();
+        }
+        else {
+            expect(mockUserTrustLevels).toHaveBeenCalledWith(personalContext);
+            expect(mockTrustGet).toHaveBeenCalledWith(remoteIdentity.userId);
+        }
+    });
+    it.each([
+        socket_type_1.TrustLevel.Trusted,
+        socket_type_1.TrustLevel.Unknown,
+    ])("denies a signed identity with trust level %s", async (trustLevel) => {
+        const { remoteIdentity, user } = makeIdentity();
+        const records = new Map();
+        const { personalContext, userContext } = setupUserContext((0, utils_1.newid)(), records);
+        records.set(personalContext, user);
+        mockTrustGet.mockResolvedValue({ trustLevel });
+        await expect((0, index_1.isSelfTrustedContractCaller)(userContext, remoteIdentity)).resolves.toBe(false);
+    });
+    it("accepts a matching signed identity found only in a shared group", async () => {
+        const { remoteIdentity, user } = makeIdentity();
+        const records = new Map();
+        const { groupContext, userContext } = setupUserContext((0, utils_1.newid)(), records);
+        records.set(groupContext, user);
+        mockTrustGet.mockResolvedValue({ trustLevel: socket_type_1.TrustLevel.Self });
+        await expect((0, index_1.isSelfTrustedContractCaller)(userContext, remoteIdentity)).resolves.toBe(true);
+    });
+    it("denies unsigned discovery stubs", async () => {
+        const { remoteIdentity, user } = makeIdentity();
+        const records = new Map();
+        const { personalContext, userContext } = setupUserContext((0, utils_1.newid)(), records);
+        records.set(personalContext, { ...user, signature: undefined });
+        mockTrustGet.mockResolvedValue({ trustLevel: socket_type_1.TrustLevel.Self });
+        await expect((0, index_1.isSelfTrustedContractCaller)(userContext, remoteIdentity)).resolves.toBe(false);
+        expect(mockTrustGet).not.toHaveBeenCalled();
+    });
+    it.each([
+        "publicKey",
+        "publicBoxKey",
+    ])("denies a connection whose %s differs from the signed user", async (field) => {
+        const { remoteIdentity, user } = makeIdentity();
+        const records = new Map();
+        const { personalContext, userContext } = setupUserContext((0, utils_1.newid)(), records);
+        records.set(personalContext, user);
+        const mismatchedIdentity = { ...remoteIdentity, [field]: `mismatch-${(0, utils_1.newid)()}` };
+        mockTrustGet.mockResolvedValue({ trustLevel: socket_type_1.TrustLevel.Self });
+        await expect((0, index_1.isSelfTrustedContractCaller)(userContext, mismatchedIdentity)).resolves.toBe(false);
+        expect(mockTrustGet).not.toHaveBeenCalled();
+    });
+    it("denies a malformed user signature", async () => {
+        const { remoteIdentity, user } = makeIdentity();
+        const records = new Map();
+        const { personalContext, userContext } = setupUserContext((0, utils_1.newid)(), records);
+        records.set(personalContext, { ...user, signature: `${user.signature}tampered` });
+        mockTrustGet.mockResolvedValue({ trustLevel: socket_type_1.TrustLevel.Self });
+        await expect((0, index_1.isSelfTrustedContractCaller)(userContext, remoteIdentity)).resolves.toBe(false);
+    });
+    it("ignores peer-supplied caller context when authorizing the router", async () => {
+        const { remoteIdentity, user } = makeIdentity();
+        const records = new Map();
+        const { personalContext, userContext } = setupUserContext((0, utils_1.newid)(), records);
+        records.set(personalContext, { ...user, signature: undefined });
+        mockTrustGet.mockResolvedValue({ trustLevel: socket_type_1.TrustLevel.Self });
+        const [consumerTransport, providerTransport] = (0, index_1.inProcessTransportPair)();
+        const router = (0, index_1.createUserContextContractProviderRouter)(providerTransport, {
+            userContext,
+            remoteIdentity,
+        });
+        await expect(consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, call, {
+            callerUserId: userContext.userId,
+            localUserId: userContext.userId,
+        })).rejects.toThrow("Permission denied");
+        router.dispose();
+    });
+});

package/dist/contracts/__tests__/contract-subscription-lifecycle.test.d.ts

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

package/dist/contracts/__tests__/contract-subscription-lifecycle.test.js

@@ -0,0 +1,353 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const observable_1 = require("../../observable");
+const field_type_1 = require("../../types/field-type");
+const utils_1 = require("../../utils");
+const contract_proxy_1 = require("../contract-proxy");
+const contract_transport_1 = require("../contract-transport");
+function deferred() {
+    let resolve;
+    const promise = new Promise((resolvePromise) => {
+        resolve = resolvePromise;
+    });
+    return { promise, resolve };
+}
+function trackedEvent() {
+    const handlers = new Set();
+    const event = {
+        subscribe: jest.fn((handler) => {
+            handlers.add(handler);
+            let active = true;
+            return {
+                unsubscribe: () => {
+                    if (!active) {
+                        return false;
+                    }
+                    active = false;
+                    return handlers.delete(handler);
+                },
+            };
+        }),
+    };
+    return {
+        event,
+        activeCount: () => handlers.size,
+        emit: async (value) => {
+            for (const handler of [...handlers]) {
+                await handler(value);
+            }
+        },
+    };
+}
+function trackedObservable(initialValue) {
+    const source = (0, observable_1.observable)(initialValue);
+    const subscribe = source.subscribe;
+    let activeCount = 0;
+    source.subscribe = (handler) => {
+        activeCount += 1;
+        const subscription = subscribe(handler);
+        let active = true;
+        return {
+            dispose: () => {
+                if (!active) {
+                    return;
+                }
+                active = false;
+                activeCount -= 1;
+                subscription.dispose();
+            },
+        };
+    };
+    return { source, activeCount: () => activeCount };
+}
+async function settleTransport(emitSpy) {
+    let previousCount = -1;
+    while (previousCount !== emitSpy.mock.results.length) {
+        previousCount = emitSpy.mock.results.length;
+        const pending = emitSpy.mock.results
+            .map((result) => result.value)
+            .filter((value) => value instanceof Promise);
+        await Promise.allSettled(pending);
+        await Promise.resolve();
+    }
+}
+const cleanups = [];
+afterEach(() => {
+    for (const cleanup of cleanups.splice(0).reverse()) {
+        cleanup();
+    }
+    jest.restoreAllMocks();
+});
+function makeHarness(opts = {}) {
+    const contractId = (0, utils_1.newid)();
+    const generic = trackedEvent();
+    const tableChanged = trackedEvent();
+    const count = trackedObservable(0);
+    const list = jest.fn(async () => []);
+    const run = jest.fn(async () => "ok");
+    const contract = {
+        contractId,
+        version: 1,
+        devTag: "dev",
+        name: "Lifecycle Contract",
+        description: "Exercises every subscription surface",
+        tables: [
+            {
+                name: "Widgets",
+                description: "Widgets",
+                primaryKeyName: "id",
+                fields: [{ name: "id", type: field_type_1.FieldType.id }],
+            },
+        ],
+        tools: [
+            {
+                name: "run",
+                usageDescription: "Run",
+                inputFields: [],
+                outputFields: [],
+            },
+        ],
+        observables: [
+            {
+                name: "count",
+                description: "Count",
+                valueType: field_type_1.FieldType.number,
+                writable: true,
+            },
+        ],
+        events: [
+            {
+                name: "changed",
+                description: "Changed",
+                payloadFields: [{ name: "id", type: field_type_1.FieldType.id }],
+            },
+        ],
+    };
+    const resolution = {
+        contractId,
+        version: 1,
+        tables: {
+            Widgets: { dataChanged: tableChanged.event, list },
+        },
+        tools: {
+            run: {
+                tool: { toolId: (0, utils_1.newid)(), name: "run" },
+                toolFn: run,
+            },
+        },
+        observables: { count: count.source },
+        observableWritability: { count: true },
+        events: { changed: generic.event },
+    };
+    const [consumerTransport, providerTransport] = (0, contract_transport_1.inProcessTransportPair)();
+    const emitSpy = jest.spyOn(consumerTransport, "emit");
+    const session = (0, contract_proxy_1.createContractProviderSession)(resolution, providerTransport, {
+        permissionCheck: opts.permissionCheck,
+    });
+    const consumer = (0, contract_proxy_1.createContractConsumer)(contract, consumerTransport);
+    cleanups.push(() => {
+        consumer.dispose();
+        session.dispose();
+    });
+    return {
+        consumer,
+        session,
+        generic,
+        tableChanged,
+        count,
+        emitSpy,
+        consumerTransport,
+        providerTransport,
+        contractId,
+    };
+}
+describe("contract subscription lifecycle — consumer teardown", () => {
+    it("detaches generic, table, and observable provider subscriptions", async () => {
+        const { consumer, generic, tableChanged, count, emitSpy } = makeHarness();
+        consumer.events.changed.subscribe(() => { });
+        consumer.tables.Widgets.dataChanged.subscribe(() => { });
+        await consumer.loadingPromise;
+        expect(generic.activeCount()).toBe(1);
+        expect(tableChanged.activeCount()).toBe(1);
+        expect(count.activeCount()).toBe(1);
+        consumer.dispose();
+        await settleTransport(emitSpy);
+        expect(generic.activeCount()).toBe(0);
+        expect(tableChanged.activeCount()).toBe(0);
+        expect(count.activeCount()).toBe(0);
+    });
+    it("is idempotent and sends each wire unsubscribe at most once", async () => {
+        const { consumer, emitSpy } = makeHarness();
+        consumer.events.changed.subscribe(() => { });
+        await consumer.loadingPromise;
+        consumer.dispose();
+        consumer.dispose();
+        await settleTransport(emitSpy);
+        const unsubscribeCalls = emitSpy.mock.calls.filter(([channel, call]) => channel === contract_transport_1.CONTRACT_REQUEST_CHANNEL && call.operation === "unsubscribe");
+        expect(unsubscribeCalls).toHaveLength(2);
+    });
+    it("returns false and emits nothing for a repeated event unsubscribe", async () => {
+        const { consumer, emitSpy } = makeHarness();
+        const subscription = consumer.events.changed.subscribe(() => { });
+        await settleTransport(emitSpy);
+        emitSpy.mockClear();
+        expect(subscription.unsubscribe()).toBe(true);
+        expect(subscription.unsubscribe()).toBe(false);
+        await settleTransport(emitSpy);
+        const unsubscribeCalls = emitSpy.mock.calls
+            .map(([, call]) => call)
+            .filter((call) => call.name === "changed" && call.operation === "unsubscribe");
+        expect(unsubscribeCalls).toHaveLength(1);
+    });
+    it("rejects new remote operations and writes after disposal without emitting", async () => {
+        const { consumer, emitSpy } = makeHarness();
+        await consumer.loadingPromise;
+        expect(consumer.observables.count()).toBe(0);
+        consumer.dispose();
+        await settleTransport(emitSpy);
+        emitSpy.mockClear();
+        await expect(consumer.tables.Widgets.list()).rejects.toThrow(/consumer .* disposed/i);
+        await expect(consumer.tools.run()).rejects.toThrow(/consumer .* disposed/i);
+        expect(() => consumer.events.changed.subscribe(() => { })).toThrow(/consumer .* disposed/i);
+        expect(() => consumer.tables.Widgets.dataChanged.subscribe(() => { })).toThrow(/consumer .* disposed/i);
+        expect(() => consumer.observables.count(1)).toThrow(/consumer .* disposed/i);
+        expect(consumer.observables.count()).toBe(0);
+        expect(emitSpy).not.toHaveBeenCalled();
+    });
+});
+describe("contract subscription lifecycle — ordering and failures", () => {
+    it("queues immediate unsubscribe behind a delayed subscribe acknowledgement", async () => {
+        const permissionStarted = deferred();
+        const permissionResult = deferred();
+        const permissionCheck = async (call) => {
+            if (call.operation === "subscribe") {
+                permissionStarted.resolve();
+                return permissionResult.promise;
+            }
+            return true;
+        };
+        const { consumer, generic, emitSpy } = makeHarness({ permissionCheck });
+        const subscription = consumer.events.changed.subscribe(() => { });
+        await permissionStarted.promise;
+        expect(subscription.unsubscribe()).toBe(true);
+        expect(generic.activeCount()).toBe(0);
+        permissionResult.resolve(true);
+        await settleTransport(emitSpy);
+        expect(generic.activeCount()).toBe(0);
+        const operations = emitSpy.mock.calls
+            .filter(([channel]) => channel === contract_transport_1.CONTRACT_REQUEST_CHANNEL)
+            .map(([, call]) => call.operation)
+            .filter((operation) => operation === "subscribe" || operation === "unsubscribe");
+        expect(operations).toEqual(["subscribe", "subscribe", "unsubscribe"]);
+    });
+    it("does not unsubscribe after a failed subscribe", async () => {
+        const consoleError = jest.spyOn(console, "error").mockImplementation();
+        const permissionStarted = deferred();
+        const permissionResult = deferred();
+        const permissionCheck = async (call) => {
+            if (call.operation === "subscribe") {
+                permissionStarted.resolve();
+                return permissionResult.promise;
+            }
+            return true;
+        };
+        const { consumer, generic, emitSpy } = makeHarness({ permissionCheck });
+        const subscription = consumer.events.changed.subscribe(() => { });
+        await permissionStarted.promise;
+        subscription.unsubscribe();
+        consumer.dispose();
+        permissionResult.resolve(false);
+        await settleTransport(emitSpy);
+        expect(generic.activeCount()).toBe(0);
+        const changedCalls = emitSpy.mock.calls
+            .map(([, call]) => call)
+            .filter((call) => call.name === "changed");
+        expect(changedCalls.map((call) => call.operation)).toEqual(["subscribe"]);
+        expect(consoleError).toHaveBeenCalledWith("Contract subscribe failed", expect.objectContaining({ message: expect.stringMatching(/Permission denied/) }));
+    });
+});
+describe("contract subscription lifecycle — provider protocol", () => {
+    it("rejects duplicate subscription ids without corrupting the existing refcount", async () => {
+        const { generic, consumerTransport, contractId } = makeHarness();
+        const subscriptionId = (0, utils_1.newid)();
+        const call = {
+            contractId,
+            version: 1,
+            member: "event",
+            name: "changed",
+            operation: "subscribe",
+            subscriptionId,
+            args: [],
+        };
+        await consumerTransport.emit(contract_transport_1.CONTRACT_REQUEST_CHANNEL, call);
+        await expect(consumerTransport.emit(contract_transport_1.CONTRACT_REQUEST_CHANNEL, call)).rejects.toThrow(/Duplicate contract subscriptionId/);
+        expect(generic.activeCount()).toBe(1);
+        await consumerTransport.emit(contract_transport_1.CONTRACT_REQUEST_CHANNEL, {
+            ...call,
+            operation: "unsubscribe",
+            subscriptionId: (0, utils_1.newid)(),
+        });
+        expect(generic.activeCount()).toBe(1);
+        await consumerTransport.emit(contract_transport_1.CONTRACT_REQUEST_CHANNEL, {
+            ...call,
+            operation: "unsubscribe",
+        });
+        expect(generic.activeCount()).toBe(0);
+    });
+    it("rejects missing ids and unsupported member/operation combinations", async () => {
+        const { consumerTransport, contractId } = makeHarness();
+        const base = {
+            contractId,
+            version: 1,
+            name: "changed",
+            args: [],
+        };
+        await expect(consumerTransport.emit(contract_transport_1.CONTRACT_REQUEST_CHANNEL, {
+            ...base,
+            member: "event",
+            operation: "subscribe",
+        })).rejects.toThrow(/requires a subscriptionId/);
+        await expect(consumerTransport.emit(contract_transport_1.CONTRACT_REQUEST_CHANNEL, {
+            ...base,
+            member: "tool",
+            operation: "subscribe",
+            subscriptionId: (0, utils_1.newid)(),
+        })).rejects.toThrow(/does not support subscriptions/);
+        await expect(consumerTransport.emit(contract_transport_1.CONTRACT_REQUEST_CHANNEL, {
+            ...base,
+            member: "event",
+            operation: "get",
+            subscriptionId: (0, utils_1.newid)(),
+        })).rejects.toThrow(/Unsupported subscription operation/);
+        await expect(consumerTransport.emit(contract_transport_1.CONTRACT_REQUEST_CHANNEL, {
+            ...base,
+            member: "table",
+            name: "Widgets",
+            operation: "subscribe",
+            event: "privateEvent",
+            subscriptionId: (0, utils_1.newid)(),
+        })).rejects.toThrow(/Unsupported table event/);
+    });
+    it("isolates a rejected notify so later subscribers still receive the payload", async () => {
+        const consoleError = jest.spyOn(console, "error").mockImplementation();
+        const { consumer, generic, emitSpy } = makeHarness();
+        consumer.events.changed.subscribe(() => {
+            throw new Error("first handler failed");
+        });
+        const received = [];
+        consumer.events.changed.subscribe((value) => received.push(value));
+        await settleTransport(emitSpy);
+        await generic.emit({ id: "w1" });
+        await Promise.resolve();
+        expect(received).toEqual([{ id: "w1" }]);
+        expect(consoleError).toHaveBeenCalledWith(expect.stringMatching(/Contract notify failed/), expect.objectContaining({ message: "first handler failed" }));
+    });
+    it("allows provider session disposal more than once", () => {
+        const { session, generic } = makeHarness();
+        expect(() => {
+            session.dispose();
+            session.dispose();
+        }).not.toThrow();
+        expect(generic.activeCount()).toBe(0);
+    });
+});

package/dist/contracts/__tests__/contract-table-events.test.d.ts

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