@peers-app/peers-sdk 0.19.13 → 0.20.0

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

@@ -0,0 +1,193 @@
+"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("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("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();
+    });
+});

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

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

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

@@ -0,0 +1,424 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const decorators_1 = require("../../data/orm/decorators");
+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");
+const CONTRACT_ID = (0, utils_1.newid)();
+const cleanups = [];
+afterEach(() => {
+    for (const cleanup of cleanups.splice(0).reverse()) {
+        cleanup();
+    }
+    jest.restoreAllMocks();
+});
+/** A small contract with one table, one tool, and one observable. */
+function makeContract(opts = {}) {
+    return {
+        contractId: CONTRACT_ID,
+        version: 1,
+        devTag: "dev",
+        name: "Test Contract",
+        description: "For proxy tests",
+        tables: [
+            {
+                name: "Widgets",
+                description: "Widget table",
+                primaryKeyName: "widgetId",
+                fields: [{ name: "widgetId", type: field_type_1.FieldType.id, description: "PK" }],
+            },
+        ],
+        tools: [
+            {
+                name: "make-widget",
+                usageDescription: "Makes a widget",
+                inputFields: [{ name: "color", type: field_type_1.FieldType.string, description: "Color" }],
+                outputFields: [{ name: "widgetId", type: field_type_1.FieldType.id, description: "ID" }],
+            },
+        ],
+        observables: opts.observable
+            ? [
+                {
+                    name: "widgetCount",
+                    description: "Count",
+                    valueType: field_type_1.FieldType.number,
+                    writable: true,
+                },
+            ]
+            : [],
+    };
+}
+/**
+ * A fake resolution with an in-memory table (list/get/save), a tool fn, and an observable.
+ * Tables in a real resolution are `Table` instances; for dispatch the provider only needs
+ * indexable methods, so a plain object cast to the resolution type is sufficient here.
+ */
+function makeResolution() {
+    const rows = [];
+    const table = {
+        list: jest.fn(async (filter = {}) => rows.filter((r) => Object.entries(filter).every(([k, v]) => r[k] === v))),
+        get: jest.fn(async (id) => rows.find((r) => r.widgetId === id)),
+        save: jest.fn(async (record) => {
+            rows.push(record);
+            return record;
+        }),
+    };
+    const makeWidget = jest.fn(async ({ color }) => ({
+        widgetId: (0, utils_1.newid)(),
+        color,
+    }));
+    const widgetCount = (0, observable_1.observable)(0);
+    const resolution = {
+        contractId: CONTRACT_ID,
+        version: 1,
+        tables: { Widgets: table },
+        tools: {
+            "make-widget": {
+                tool: { toolId: (0, utils_1.newid)(), name: "make-widget" },
+                toolFn: makeWidget,
+            },
+        },
+        observables: { widgetCount },
+        observableWritability: { widgetCount: true },
+    };
+    return { resolution, table, makeWidget, widgetCount, rows };
+}
+/**
+ * Build a consumer wired to a provider dispatch fn over an in-process transport pair:
+ * the provider handler is registered on the provider end's request channel, and the
+ * consumer is built on the other end.
+ */
+function consumerVia(contract, provider, context = {}) {
+    const [consumerTransport, providerTransport] = (0, contract_transport_1.inProcessTransportPair)();
+    const offRequest = providerTransport.on(contract_transport_1.CONTRACT_REQUEST_CHANNEL, (call) => provider(call, context));
+    const consumer = (0, contract_proxy_1.createContractConsumer)(contract, consumerTransport);
+    cleanups.push(() => {
+        consumer.dispose();
+        offRequest();
+    });
+    return consumer;
+}
+/** Wire a request/response-only consumer directly to a stateless provider. */
+function wire(opts = {}) {
+    const contract = makeContract();
+    const { resolution, ...rest } = makeResolution();
+    const provider = (0, contract_proxy_1.createContractProvider)(resolution, { permissionCheck: opts.permissionCheck });
+    const consumer = consumerVia(contract, provider, opts.context ?? {});
+    return { consumer, provider, contract, ...rest };
+}
+/** Wire an observable-bearing consumer to a stateful provider session. */
+function wireSession(opts = {}) {
+    const contract = makeContract({ observable: true });
+    const { resolution, ...rest } = makeResolution();
+    const [consumerTransport, providerTransport] = (0, contract_transport_1.inProcessTransportPair)();
+    const session = (0, contract_proxy_1.createContractProviderSession)(resolution, providerTransport, {
+        permissionCheck: opts.permissionCheck,
+        context: opts.context,
+    });
+    const consumer = (0, contract_proxy_1.createContractConsumer)(contract, consumerTransport);
+    cleanups.push(() => {
+        consumer.dispose();
+        session.dispose();
+    });
+    return { consumer, session, contract, ...rest };
+}
+describe("contract proxy — consumer/provider round-trip", () => {
+    it("proxies a table method (save then list) through to the live table", async () => {
+        const { consumer, table } = wire();
+        const saved = await consumer.tables.Widgets.save({ widgetId: "w1", color: "red" });
+        expect(saved).toEqual({ widgetId: "w1", color: "red" });
+        expect(table.save).toHaveBeenCalledWith({ widgetId: "w1", color: "red" });
+        const listed = await consumer.tables.Widgets.list({ color: "red" });
+        expect(listed).toEqual([{ widgetId: "w1", color: "red" }]);
+        expect(table.list).toHaveBeenCalledWith({ color: "red" });
+    });
+    it("passes multiple positional args to a table method", async () => {
+        const { consumer, table } = wire();
+        const filter = { color: "blue" };
+        const opts = { pageSize: 10 };
+        await consumer.tables.Widgets.list(filter, opts);
+        expect(table.list).toHaveBeenCalledWith(filter, opts);
+    });
+    it("proxies a tool call", async () => {
+        const { consumer, makeWidget } = wire();
+        const result = await consumer.tools["make-widget"]({ color: "blue" });
+        expect(makeWidget).toHaveBeenCalledWith({ color: "blue" });
+        expect(result.color).toBe("blue");
+    });
+    it("forwards dataContextId on methods, tools, observables, and subscriptions", async () => {
+        const dataContextId = (0, utils_1.newid)();
+        const calls = [];
+        const transport = {
+            emit: jest.fn(async (channel, call) => {
+                expect(channel).toBe(contract_transport_1.CONTRACT_REQUEST_CHANNEL);
+                calls.push(call);
+                return call.member === "observable" && call.operation === "get" ? 0 : undefined;
+            }),
+            on: () => () => { },
+        };
+        const contract = {
+            ...makeContract({ observable: true }),
+            events: [
+                {
+                    name: "changed",
+                    description: "Changed",
+                    payloadFields: [],
+                },
+            ],
+        };
+        const consumer = (0, contract_proxy_1.createContractConsumer)(contract, transport, { dataContextId });
+        cleanups.push(() => consumer.dispose());
+        await consumer.loadingPromise;
+        await consumer.tables.Widgets.list();
+        await consumer.tools["make-widget"]({ color: "blue" });
+        consumer.events.changed.subscribe(() => { });
+        consumer.tables.Widgets.dataChanged.subscribe(() => { });
+        consumer.observables.widgetCount(2);
+        await consumer.loadingPromise;
+        expect(calls).toEqual(expect.arrayContaining([
+            expect.objectContaining({ member: "table", operation: "list" }),
+            expect.objectContaining({ member: "tool", operation: "run" }),
+            expect.objectContaining({ member: "observable", operation: "subscribe" }),
+            expect.objectContaining({ member: "observable", operation: "get" }),
+            expect.objectContaining({ member: "observable", operation: "set" }),
+            expect.objectContaining({ member: "event", operation: "subscribe" }),
+            expect.objectContaining({
+                member: "table",
+                operation: "subscribe",
+                event: "dataChanged",
+            }),
+        ]));
+        expect(calls.every((call) => call.dataContextId === dataContextId)).toBe(true);
+    });
+    it("mirrors an observable snapshot and provider pushes through a session", async () => {
+        const { consumer, widgetCount } = wireSession();
+        await consumer.loadingPromise;
+        expect(consumer.observables.widgetCount()).toBe(0);
+        const pushed = new Promise((resolve) => {
+            const sub = consumer.observables.widgetCount.subscribe((value) => {
+                if (value === 4) {
+                    sub.dispose();
+                    resolve();
+                }
+            });
+        });
+        widgetCount(4);
+        await pushed;
+        expect(consumer.observables.widgetCount()).toBe(4);
+    });
+    it("forwards writable observable writes through a session", async () => {
+        const { consumer, widgetCount } = wireSession();
+        await consumer.loadingPromise;
+        consumer.observables.widgetCount(7);
+        await consumer.loadingPromise;
+        expect(widgetCount()).toBe(7);
+        expect(consumer.observables.widgetCount()).toBe(7);
+    });
+    it("dispatches stateless observable get and set calls directly", async () => {
+        const { resolution, widgetCount } = makeResolution();
+        const provider = (0, contract_proxy_1.createContractProvider)(resolution);
+        await expect(provider({
+            contractId: CONTRACT_ID,
+            version: 1,
+            member: "observable",
+            name: "widgetCount",
+            operation: "get",
+            args: [],
+        })).resolves.toBe(0);
+        await expect(provider({
+            contractId: CONTRACT_ID,
+            version: 1,
+            member: "observable",
+            name: "widgetCount",
+            operation: "set",
+            args: [8],
+        })).resolves.toBe(8);
+        expect(widgetCount()).toBe(8);
+    });
+    it("unwraps a client-proxy (__original) table method", async () => {
+        const contract = makeContract();
+        const original = jest.fn(async () => "original-result");
+        (0, decorators_1.ProxyClientTableMethodCalls)()(original, { kind: "method", name: "deleteOldLogs" });
+        const proxied = jest.fn(async () => "proxied-result");
+        proxied.__original = original;
+        const resolution = {
+            contractId: CONTRACT_ID,
+            version: 1,
+            tables: { Widgets: { deleteOldLogs: proxied } },
+        };
+        const provider = (0, contract_proxy_1.createContractProvider)(resolution);
+        const consumer = consumerVia(contract, provider);
+        const result = await consumer.tables.Widgets.deleteOldLogs();
+        expect(result).toBe("original-result");
+        expect(original).toHaveBeenCalled();
+        expect(proxied).not.toHaveBeenCalled();
+    });
+});
+describe("contract proxy — error handling", () => {
+    it("rejects an unknown table method", async () => {
+        const { consumer } = wire();
+        await expect(consumer.tables.Widgets.nope()).rejects.toThrow(/no method 'nope'/);
+    });
+    it.each([
+        "getRecordId",
+        "cursor",
+        "initDoc",
+    ])("rejects unmarked internal or non-serializable table method %s", async (operation) => {
+        const contract = makeContract();
+        const method = jest.fn();
+        const resolution = {
+            contractId: CONTRACT_ID,
+            version: 1,
+            tables: { Widgets: { [operation]: method } },
+        };
+        const provider = (0, contract_proxy_1.createContractProvider)(resolution);
+        const consumer = consumerVia(contract, provider);
+        await expect(consumer.tables.Widgets[operation]()).rejects.toThrow(/not remotely callable/);
+        expect(method).not.toHaveBeenCalled();
+    });
+    it.each([
+        "constructor",
+        "__proto__",
+        "dataChanged",
+        "then",
+    ])("rejects dangerous table property %s before reading it", async (operation) => {
+        const table = Object.create(null);
+        const getter = jest.fn();
+        Object.defineProperty(table, operation, { get: getter });
+        const provider = (0, contract_proxy_1.createContractProvider)({
+            contractId: CONTRACT_ID,
+            version: 1,
+            tables: { Widgets: table },
+        });
+        await expect(provider({
+            contractId: CONTRACT_ID,
+            version: 1,
+            member: "table",
+            name: "Widgets",
+            operation,
+            args: [],
+        })).rejects.toThrow(/not remotely callable/);
+        expect(getter).not.toHaveBeenCalled();
+    });
+    it("rejects a call for a table not in the resolution", async () => {
+        const contract = makeContract();
+        const resolution = { contractId: CONTRACT_ID, version: 1, tables: {} };
+        const provider = (0, contract_proxy_1.createContractProvider)(resolution);
+        const consumer = consumerVia(contract, provider);
+        await expect(consumer.tables.Widgets.list()).rejects.toThrow(/does not provide table 'Widgets'/);
+    });
+    it.each([
+        ["tool", "missingTool"],
+        ["observable", "missingObservable"],
+    ])("rejects an unknown %s", async (member, name) => {
+        const { resolution } = makeResolution();
+        const provider = (0, contract_proxy_1.createContractProvider)(resolution);
+        await expect(provider({
+            contractId: CONTRACT_ID,
+            version: 1,
+            member,
+            name,
+            operation: member === "tool" ? "run" : "get",
+            args: [],
+        })).rejects.toThrow(new RegExp(`does not provide ${member} '${name}'`));
+    });
+    it("rejects a contract id/version mismatch", async () => {
+        const { provider } = wire();
+        const badCall = {
+            contractId: (0, utils_1.newid)(),
+            version: 1,
+            member: "table",
+            name: "Widgets",
+            operation: "list",
+            args: [],
+        };
+        await expect(provider(badCall)).rejects.toThrow(/Contract mismatch/);
+    });
+    it("rejects a version-only contract mismatch", async () => {
+        const { provider } = wire();
+        await expect(provider({
+            contractId: CONTRACT_ID,
+            version: 2,
+            member: "table",
+            name: "Widgets",
+            operation: "list",
+            args: [],
+        })).rejects.toThrow(/Contract mismatch/);
+    });
+    it("rejects an unsupported observable operation", async () => {
+        const { provider } = wire();
+        const call = {
+            contractId: CONTRACT_ID,
+            version: 1,
+            member: "observable",
+            name: "widgetCount",
+            operation: "increment",
+            args: [],
+        };
+        await expect(provider(call)).rejects.toThrow(/Unsupported observable operation/);
+    });
+    it("rejects an unsupported tool operation without invoking the tool", async () => {
+        const { provider, makeWidget } = wire();
+        await expect(provider({
+            contractId: CONTRACT_ID,
+            version: 1,
+            member: "tool",
+            name: "make-widget",
+            operation: "get",
+            args: [],
+        })).rejects.toThrow(/Unsupported tool operation/);
+        expect(makeWidget).not.toHaveBeenCalled();
+    });
+});
+describe("contract proxy — permission checks", () => {
+    it("allows same-user calls and denies cross-user calls (stub)", async () => {
+        const localUserId = (0, utils_1.newid)();
+        const allowed = wire({
+            permissionCheck: contract_proxy_1.sameUserContractPermissionCheck,
+            context: { localUserId, callerUserId: localUserId },
+        });
+        await expect(allowed.consumer.tables.Widgets.list()).resolves.toEqual([]);
+        const denied = wire({
+            permissionCheck: contract_proxy_1.sameUserContractPermissionCheck,
+            context: { localUserId, callerUserId: (0, utils_1.newid)() },
+        });
+        await expect(denied.consumer.tables.Widgets.list()).rejects.toThrow(/Permission denied/);
+    });
+    it("denies when the caller identity is unknown", async () => {
+        const denied = wire({
+            permissionCheck: contract_proxy_1.sameUserContractPermissionCheck,
+            context: { localUserId: (0, utils_1.newid)() },
+        });
+        await expect(denied.consumer.tools["make-widget"]({ color: "x" })).rejects.toThrow(/Permission denied/);
+    });
+    it("does not dispatch to the table when permission is denied", async () => {
+        const localUserId = (0, utils_1.newid)();
+        const denied = wire({
+            permissionCheck: contract_proxy_1.sameUserContractPermissionCheck,
+            context: { localUserId, callerUserId: (0, utils_1.newid)() },
+        });
+        await expect(denied.consumer.tables.Widgets.save({ widgetId: "z" })).rejects.toThrow(/Permission denied/);
+        expect(denied.table.save).not.toHaveBeenCalled();
+    });
+});
+describe("connectionContractTransport", () => {
+    it("emits on the request channel with the call and returns the response", async () => {
+        const emit = jest.fn(async (_event, _call) => ["ok"]);
+        const emitter = { emit, on: jest.fn() };
+        const contract = makeContract();
+        const consumer = (0, contract_proxy_1.createContractConsumer)(contract, (0, contract_transport_1.connectionContractTransport)(emitter));
+        cleanups.push(() => consumer.dispose());
+        const result = await consumer.tables.Widgets.list({ color: "red" });
+        expect(result).toEqual(["ok"]);
+        expect(emit).toHaveBeenCalledWith("contractCall", expect.objectContaining({
+            contractId: CONTRACT_ID,
+            version: 1,
+            member: "table",
+            name: "Widgets",
+            operation: "list",
+            args: [{ color: "red" }],
+        }));
+    });
+});

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

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