@peers-app/peers-sdk 0.27.2 → 0.27.4

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

@@ -1,657 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const groupPermissions = require("../../data/group-permissions");
-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", accessLevel: 0 },
-                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("allows a classified tool when the provider data context grants access", async () => {
-        const getUserAccessLevel = jest
-            .spyOn(groupPermissions, "getUserAccessLevel")
-            .mockResolvedValue(100);
-        const contract = makeContract();
-        const { resolution, makeWidget } = makeResolution();
-        const makeWidgetTool = resolution.tools?.["make-widget"];
-        if (!makeWidgetTool) {
-            throw new Error("expected make-widget tool");
-        }
-        makeWidgetTool.tool.accessLevel = 80;
-        const provider = (0, contract_proxy_1.createContractProvider)(resolution);
-        const dataContext = { userContext: { userId: "u1" } };
-        const consumer = consumerVia(contract, provider, {
-            callerUserId: "u1",
-            localUserId: "u1",
-            dataContext,
-        });
-        await expect(consumer.tools["make-widget"]({ color: "blue" })).resolves.toEqual(expect.objectContaining({ color: "blue" }));
-        expect(makeWidget).toHaveBeenCalledWith({ color: "blue" });
-        expect(getUserAccessLevel).toHaveBeenCalledWith(dataContext, "u1");
-    });
-    it("fails closed quickly when a classified tool has no user context", async () => {
-        const contract = makeContract();
-        const { resolution } = makeResolution();
-        const makeWidgetTool = resolution.tools?.["make-widget"];
-        if (!makeWidgetTool) {
-            throw new Error("expected make-widget tool");
-        }
-        makeWidgetTool.tool.accessLevel = 20;
-        const provider = (0, contract_proxy_1.createContractProvider)(resolution);
-        const consumer = consumerVia(contract, provider, {
-            callerUserId: (0, utils_1.newid)(),
-            localUserId: (0, utils_1.newid)(),
-        });
-        await expect(consumer.tools["make-widget"]({ color: "blue" })).rejects.toThrow("User context is not available");
-    });
-    it("denies unclassified tools when the caller identity is missing", async () => {
-        const contract = makeContract();
-        const { resolution } = makeResolution();
-        const makeWidgetTool = resolution.tools?.["make-widget"];
-        if (!makeWidgetTool) {
-            throw new Error("expected make-widget tool");
-        }
-        makeWidgetTool.tool.accessLevel = undefined;
-        const provider = (0, contract_proxy_1.createContractProvider)(resolution);
-        const consumer = consumerVia(contract, provider, {});
-        await expect(consumer.tools["make-widget"]({ color: "blue" })).rejects.toThrow("missing caller identity");
-    });
-    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 — remote (device-targeted) consumers", () => {
-    /** Wire a remote factory to a request handler that echoes the target device. */
-    function wireRemote(contract = makeContract({ observable: true })) {
-        const seen = [];
-        const [consumerTransport, providerTransport] = (0, contract_transport_1.inProcessTransportPair)();
-        const offRequest = providerTransport.on(contract_transport_1.CONTRACT_REQUEST_CHANNEL, async (call) => {
-            seen.push(call);
-            return { ok: call.targetDeviceId };
-        });
-        const remote = (0, contract_proxy_1.createRemoteContractConsumer)(contract, consumerTransport, {
-            dataContextId: "group-1",
-        });
-        cleanups.push(() => {
-            remote.dispose();
-            offRequest();
-        });
-        return { remote, seen, contract };
-    }
-    it("stamps targetDeviceId and the data context on every tool call", async () => {
-        const { remote, seen, contract } = wireRemote();
-        const deviceB = remote.device("device-b");
-        await expect(deviceB.tools["make-widget"]({ color: "red" })).resolves.toEqual({
-            ok: "device-b",
-        });
-        expect(seen).toHaveLength(1);
-        expect(seen[0]).toMatchObject({
-            member: "tool",
-            name: "make-widget",
-            operation: "run",
-            targetDeviceId: "device-b",
-            dataContextId: "group-1",
-            args: [{ color: "red" }],
-        });
-        // Nothing implicit hits the wire: no observable subscribe/get for remote consumers.
-        expect(seen.filter((call) => call.member === "observable")).toHaveLength(0);
-        expect(deviceB.contractId).toBe(contract.contractId);
-        expect(remote.contractId).toBe(contract.contractId);
-        await expect(deviceB.loadingPromise).resolves.toBeUndefined();
-    });
-    it("exposes only tools on a device consumer", () => {
-        const { remote } = wireRemote();
-        const deviceB = remote.device("device-b");
-        expect(() => deviceB.tables.Widgets).toThrow("not remotely accessible");
-        expect(() => deviceB.observables.widgetCount).toThrow("not remotely accessible");
-        expect(() => deviceB.events.anything).toThrow("not remotely accessible");
-        expect(Object.keys(deviceB.tools)).toEqual(["make-widget"]);
-    });
-    it("caches one consumer per device and rejects empty device ids", () => {
-        const { remote } = wireRemote();
-        expect(remote.device("device-b")).toBe(remote.device("device-b"));
-        expect(remote.device("device-b")).not.toBe(remote.device("device-c"));
-        expect(() => remote.device("")).toThrow("non-empty device id");
-    });
-    it("disposes device consumers with the factory and independently", async () => {
-        const { remote } = wireRemote();
-        const deviceA = remote.device("device-a");
-        const deviceB = remote.device("device-b");
-        deviceA.dispose();
-        await expect(deviceA.tools["make-widget"]({ color: "x" })).rejects.toThrow("disposed");
-        await expect(deviceB.tools["make-widget"]({ color: "x" })).resolves.toBeDefined();
-        // A disposed device consumer is evicted so the next lookup gets a fresh one.
-        expect(remote.device("device-a")).not.toBe(deviceA);
-        remote.dispose();
-        await expect(deviceB.tools["make-widget"]({ color: "x" })).rejects.toThrow("disposed");
-        expect(() => remote.device("device-c")).toThrow("disposed");
-    });
-});
-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("forwards callerPackageId when the resolution opts into call context", async () => {
-        const seen = [];
-        const provider = (0, contract_proxy_1.createContractProvider)({
-            contractId: CONTRACT_ID,
-            version: 1,
-            forwardCallContext: true,
-            tools: {
-                listGrants: {
-                    tool: { toolId: (0, utils_1.newid)(), name: "listGrants", accessLevel: 0 },
-                    toolFn: async (_input, host) => {
-                        seen.push(host.callerPackageId ?? null);
-                        return "ok";
-                    },
-                },
-            },
-        });
-        await provider({
-            contractId: CONTRACT_ID,
-            version: 1,
-            member: "tool",
-            name: "listGrants",
-            operation: "run",
-            args: [],
-        }, { callerPackageId: "00pkg00000000000000000001" });
-        expect(seen).toEqual(["00pkg00000000000000000001"]);
-    });
-    it("rejects extra arguments that could shadow forwarded call context", async () => {
-        const toolFn = jest.fn(async (_input, host) => host.callerPackageId ?? null);
-        const provider = (0, contract_proxy_1.createContractProvider)({
-            contractId: CONTRACT_ID,
-            version: 1,
-            forwardCallContext: true,
-            tools: {
-                request: {
-                    tool: { toolId: (0, utils_1.newid)(), name: "request", accessLevel: 0 },
-                    toolFn,
-                },
-            },
-        });
-        await expect(provider({
-            contractId: CONTRACT_ID,
-            version: 1,
-            member: "tool",
-            name: "request",
-            operation: "run",
-            args: [{ url: "https://example.com" }, { callerPackageId: (0, utils_1.newid)() }],
-        }, { callerPackageId: (0, utils_1.newid)() })).rejects.toThrow(/single argument when host context is forwarded/);
-        expect(toolFn).not.toHaveBeenCalled();
-    });
-    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("contract provider endpoint event filter", () => {
-    it("delivers a generic event only to subscribers the filter allows", async () => {
-        const handlers = new Set();
-        const changed = {
-            eventName: () => "changed",
-            subscribe: (handler) => {
-                handlers.add(handler);
-                return {
-                    unsubscribe: () => {
-                        handlers.delete(handler);
-                        return true;
-                    },
-                };
-            },
-        };
-        const resolution = {
-            contractId: CONTRACT_ID,
-            version: 1,
-            events: { changed: changed },
-            eventFilter: (_eventName, payload, context) => payload.owner === context.callerPackageId,
-        };
-        const delivered = [];
-        const endpoint = (0, contract_proxy_1.createContractProviderEndpoint)(resolution, {
-            notify: async (notification) => {
-                delivered.push(notification.subscriptionId);
-            },
-        });
-        const subscribe = (subscriptionId, callerPackageId) => endpoint.handleCall({
-            contractId: CONTRACT_ID,
-            version: 1,
-            member: "event",
-            name: "changed",
-            operation: "subscribe",
-            subscriptionId,
-            args: [],
-        }, { callerPackageId });
-        await subscribe("allowed", "pkg-a");
-        await subscribe("denied", "pkg-b");
-        for (const handler of handlers) {
-            handler({ owner: "pkg-a" });
-        }
-        await new Promise((resolve) => setImmediate(resolve));
-        expect(delivered).toEqual(["allowed"]);
-        endpoint.dispose();
-    });
-});
-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" }],
-        }));
-    });
-});
-test("a provider-local implementation needs no toolId and still enforces access", async () => {
-    const toolFn = jest.fn(() => "bound");
-    const dispatch = (0, contract_proxy_1.createContractProvider)({
-        contractId: CONTRACT_ID,
-        version: 1,
-        tools: { run: { tool: { name: "run", usageDescription: "run", accessLevel: 40 }, toolFn } },
-    });
-    const call = {
-        contractId: CONTRACT_ID,
-        version: 1,
-        member: "tool",
-        name: "run",
-        operation: "run",
-        args: [{}],
-    };
-    jest.spyOn(groupPermissions, "getUserRole").mockResolvedValue(20);
-    await expect(dispatch(call, { callerUserId: (0, utils_1.newid)() })).rejects.toThrow(/Permission denied/);
-    jest.spyOn(groupPermissions, "getUserRole").mockResolvedValue(40);
-    await expect(dispatch(call, { callerUserId: (0, utils_1.newid)() })).resolves.toBe("bound");
-    expect(toolFn).toHaveBeenCalledTimes(1);
-});

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

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