@peers-app/peers-sdk 0.27.3 → 0.27.5

package/dist/contracts/__tests__/action-dispatch.test.js

@@ -1,319 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const group_member_roles_1 = require("../../data/group-member-roles");
-const utils_1 = require("../../utils");
-/** Voice Hub's contract, whose `voice-hub-run-action` declares preserve. */
-const VOICE_HUB_CONTRACT_ID = "00mskqamhdq1327mqehy58pps";
-/** The contract whose tools a test's entry tool dispatches to. */
-const TARGETS = (0, utils_1.newid)();
-const contract_provider_router_1 = require("../contract-provider-router");
-const contract_proxy_1 = require("../contract-proxy");
-const contract_transport_1 = require("../contract-transport");
-const target_dispatch_1 = require("./target-dispatch");
-function groupContext() {
-    const userId = (0, utils_1.newid)();
-    const groupId = (0, utils_1.newid)();
-    const founderUserId = (0, utils_1.newid)();
-    let role = group_member_roles_1.GroupMemberRole.Writer;
-    const dataContext = {
-        dataContextId: groupId,
-        groupId,
-        tableContainer: {
-            getTable: (meta) => {
-                if (meta.name === "Groups")
-                    return { get: async () => ({ groupId, founderUserId }) };
-                if (meta.name === "GroupMembers")
-                    return { findOne: async () => ({ userId, role }) };
-                throw new Error(`Unexpected table ${meta.name}`);
-            },
-        },
-    };
-    Object.assign(dataContext, {
-        userContext: {
-            userId,
-            loadingPromise: Promise.resolve(),
-            userDataContext: dataContext,
-            getDataContext: () => dataContext,
-        },
-    });
-    return {
-        dataContext,
-        userId,
-        groupId,
-        setRole: (value) => {
-            role = value;
-        },
-    };
-}
-function tool(name, level, toolFn) {
-    return {
-        tool: {
-            name,
-            toolId: (0, utils_1.newid)(),
-            usageDescription: name,
-            accessLevel: level,
-            code: "",
-            inputSchema: { type: "simple", fields: [] },
-            outputSchema: { type: "simple", fields: [] },
-        },
-        toolFn,
-    };
-}
-/** A tool that runs the target `name` through `context.dispatchTool`. */
-function hop(name, level, target) {
-    return tool(name, level, (_, context) => context.dispatchTool?.({ contractId: TARGETS, version: 1, toolName: target }, {}));
-}
-describe("strict delegated tool dispatch in a group", () => {
-    it("leaves ordinary host-tool admission outside the action scope on its existing user-role path", async () => {
-        const group = groupContext();
-        const contractId = (0, utils_1.newid)();
-        const effect = jest.fn(async () => "written");
-        const dispatch = (0, contract_proxy_1.createContractProvider)({
-            contractId,
-            version: 1,
-            tools: { write: tool("write", 40, effect) },
-        });
-        const call = {
-            contractId,
-            version: 1,
-            member: "tool",
-            name: "write",
-            operation: "run",
-            args: [{}],
-        };
-        const context = {
-            callerUserId: group.userId,
-            dataContext: group.dataContext,
-            authority: {
-                userId: group.userId,
-                userAccessLevel: 40,
-                assistantAccessLevel: 20,
-                callingToolAccessLevel: 20,
-                strictActionScope: false,
-            },
-        };
-        await expect(dispatch(call, context)).resolves.toBe("written");
-        group.setRole(group_member_roles_1.GroupMemberRole.Reader);
-        await expect(dispatch(call, context)).rejects.toThrow("Reader (20)");
-        expect(effect).toHaveBeenCalledTimes(1);
-    });
-    function setup(authority) {
-        const group = groupContext();
-        const writes = jest.fn(async () => ({ result: "milk" }));
-        const targets = {
-            list: tool("list", 20, async () => ({ result: [] })),
-            add: tool("add", 40, writes),
-            reader: hop("reader", 20, "add"),
-            writer: hop("writer", 40, "history"),
-            "writer-self": hop("writer-self", 40, "self"),
-            history: tool("history", 80, writes),
-            self: tool("self", undefined, writes),
-        };
-        const resolution = {
-            contractId: VOICE_HUB_CONTRACT_ID,
-            version: 1,
-            forwardCallContext: true,
-            tools: {
-                invoke: tool("invoke", 20, (input, context) => context.dispatchTool?.({ contractId: TARGETS, version: 1, toolName: input.tool }, input.args ?? {})),
-            },
-        };
-        Object.assign(resolution.tools.invoke.tool, { authorityPropagation: "preserve" });
-        const context = {
-            callerUserId: group.userId,
-            localUserId: group.userId,
-            dataContext: group.dataContext,
-            authority,
-        };
-        const [client, server] = (0, contract_transport_1.inProcessTransportPair)();
-        const session = (0, contract_proxy_1.createContractProviderSession)(resolution, server, {
-            context,
-            dispatchTool: (0, target_dispatch_1.targetDispatch)(TARGETS, targets),
-        });
-        const consumer = (0, contract_proxy_1.createContractConsumer)({
-            contractId: VOICE_HUB_CONTRACT_ID,
-            version: 1,
-            name: "Hub",
-            description: "",
-            tables: [],
-            observables: [],
-            events: [],
-            tools: [{ name: "invoke", usageDescription: "invoke", inputFields: [], outputFields: [] }],
-        }, client, { dataContextId: group.groupId });
-        return {
-            ...group,
-            writes,
-            targets,
-            context,
-            consumer,
-            dispose: () => {
-                consumer.dispose();
-                session.dispose();
-            },
-        };
-    }
-    it("allows direct Writer dispatch while a group Reader can only list, ignoring payload grants", async () => {
-        const p = setup();
-        try {
-            await expect(p.consumer.tools.invoke({ tool: "add", args: { name: "milk" } })).resolves.toEqual({ result: "milk" });
-            p.setRole(group_member_roles_1.GroupMemberRole.Reader);
-            await expect(p.consumer.tools.invoke({ tool: "list" })).resolves.toEqual({
-                result: [],
-            });
-            await expect(p.consumer.tools.invoke({
-                tool: "add",
-                args: {
-                    name: "milk",
-                    userId: p.userId,
-                    userAccessLevel: 100,
-                    assistantAccessLevel: 100,
-                    directUserInvocation: true,
-                    hostApprovedApprovalId: (0, utils_1.newid)(),
-                },
-            })).rejects.toThrow("Permission denied");
-            expect(p.writes).toHaveBeenCalledTimes(1);
-        }
-        finally {
-            p.dispose();
-        }
-    });
-    it("caps Reader tools through invoke, and denies Owner and Self from Writer tools", async () => {
-        const p = setup();
-        try {
-            await expect(p.consumer.tools.invoke({ tool: "reader" })).rejects.toThrow("Permission denied");
-            await expect(p.consumer.tools.invoke({ tool: "writer" })).rejects.toThrow("Permission denied");
-            await expect(p.consumer.tools.invoke({ tool: "self" })).rejects.toThrow("Permission denied");
-            p.setRole(group_member_roles_1.GroupMemberRole.Owner);
-            await expect(p.consumer.tools.invoke({ tool: "writer" })).rejects.toThrow("Permission denied");
-            p.setRole(group_member_roles_1.GroupMemberRole.Founder);
-            await expect(p.consumer.tools.invoke({ tool: "writer-self" })).rejects.toThrow("Permission denied");
-            expect(p.writes).not.toHaveBeenCalled();
-        }
-        finally {
-            p.dispose();
-        }
-    });
-    it("rechecks role and live metadata on every call", async () => {
-        const p = setup();
-        try {
-            p.setRole(group_member_roles_1.GroupMemberRole.Reader);
-            await expect(p.consumer.tools.invoke({ tool: "add" })).rejects.toThrow("Permission denied");
-            p.setRole(group_member_roles_1.GroupMemberRole.Writer);
-            p.targets.add.tool.accessLevel = 80;
-            await expect(p.consumer.tools.invoke({ tool: "add" })).rejects.toThrow("Permission denied");
-            await expect(p.consumer.tools.invoke({ tool: "invented" })).rejects.toThrow("does not provide tool 'invented'");
-            expect(p.writes).not.toHaveBeenCalled();
-        }
-        finally {
-            p.dispose();
-        }
-    });
-    it("retains a delegated Reader frame from a trusted caller and fails missing identity closed", async () => {
-        const p = setup({ userAccessLevel: 40, assistantAccessLevel: 20, strictActionScope: true });
-        try {
-            await expect(p.consumer.tools.invoke({ tool: "add" })).rejects.toThrow("Permission denied");
-            delete p.context.callerUserId;
-            delete p.context.localUserId;
-            await expect(p.consumer.tools.invoke({ tool: "list", args: { callerUserId: p.userId } })).rejects.toThrow("missing caller identity");
-            expect(p.writes).not.toHaveBeenCalled();
-        }
-        finally {
-            p.dispose();
-        }
-    });
-    it("refuses remote forwarding rather than dropping a strict ceiling", async () => {
-        const [client, server] = (0, contract_transport_1.inProcessTransportPair)();
-        const resolveEndpoint = jest.fn();
-        const router = (0, contract_provider_router_1.createContractProviderRouter)(server, {
-            context: {
-                authority: { userAccessLevel: 40, assistantAccessLevel: 20, strictActionScope: true },
-            },
-            authorizeCall: () => ({ context: {} }),
-            resolveEndpoint,
-        });
-        try {
-            await expect(client.emit(contract_transport_1.CONTRACT_REQUEST_CHANNEL, {
-                contractId: (0, utils_1.newid)(),
-                version: 1,
-                member: "tool",
-                name: "write",
-                operation: "run",
-                args: [],
-                targetDeviceId: (0, utils_1.newid)(),
-            })).rejects.toThrow("cannot target another device");
-            expect(resolveEndpoint).not.toHaveBeenCalled();
-        }
-        finally {
-            router.dispose();
-        }
-    });
-});
-describe("declared tool authority propagation", () => {
-    it.each([
-        [60, undefined, 20, true, 60, true],
-        [60, 20, 20, true, 40, false],
-        [60, undefined, 20, false, 40, false],
-        [0, undefined, undefined, true, 0, true],
-        [0, undefined, undefined, true, 20, false],
-        [20, undefined, 40, true, 20, false],
-    ])("generic host propagation U=%s A=%s entry=%s preserve=%s target=%s", async (userLevel, ceiling, entryLevel, preserve, targetLevel, allowed) => {
-        const group = groupContext();
-        group.setRole(userLevel);
-        const effect = jest.fn(() => "executed");
-        const router = hop("route", entryLevel, "target");
-        if (preserve)
-            Object.assign(router.tool, { authorityPropagation: "preserve" });
-        const contractId = (0, utils_1.newid)();
-        const dispatch = (0, contract_proxy_1.createContractProvider)({ contractId, version: 1, tools: { route: router }, forwardCallContext: true }, { dispatchTool: (0, target_dispatch_1.targetDispatch)(TARGETS, { target: tool("target", targetLevel, effect) }) });
-        const result = dispatch({ contractId, version: 1, member: "tool", name: "route", operation: "run", args: [{}] }, {
-            callerUserId: group.userId,
-            dataContext: group.dataContext,
-            authority: { userAccessLevel: userLevel, assistantAccessLevel: ceiling },
-        });
-        if (allowed)
-            await expect(result).resolves.toBe("executed");
-        else
-            await expect(result).rejects.toThrow(/Permission denied/);
-        expect(effect).toHaveBeenCalledTimes(allowed ? 1 : 0);
-    });
-    it("honors declared preserve on Voice Hub's voice-hub-run-action without raising an inherited ceiling", async () => {
-        const contractId = VOICE_HUB_CONTRACT_ID;
-        const version = 4;
-        const name = "voice-hub-run-action";
-        const group = groupContext();
-        const effect = jest.fn(() => ({ writerTargetExecuted: true }));
-        const resolution = {
-            contractId,
-            version,
-            forwardCallContext: true,
-            tools: { [name]: hop(name, 20, "write") },
-        };
-        const dispatchTool = (0, target_dispatch_1.targetDispatch)(TARGETS, { write: tool("write", 40, effect) });
-        const call = {
-            contractId,
-            version,
-            member: "tool",
-            name,
-            operation: "run",
-            args: [{}],
-        };
-        const context = { callerUserId: group.userId, dataContext: group.dataContext };
-        // An ordinary Reader wrapper caps a direct Writer at Reader inside the action scope.
-        const capped = (0, contract_proxy_1.createContractProvider)(resolution, { dispatchTool });
-        await expect(capped(call, context)).rejects.toThrow("Permission denied: strict delegation");
-        expect(effect).not.toHaveBeenCalled();
-        // The same wrapper declared preserve passes the Writer through to a Writer target.
-        Object.assign(resolution.tools[name].tool, { authorityPropagation: "preserve" });
-        const preserving = (0, contract_proxy_1.createContractProvider)(resolution, { dispatchTool });
-        await expect(preserving(call, context)).resolves.toEqual({ writerTargetExecuted: true });
-        // An inherited Reader frame from an upstream ordinary tool is never raised.
-        await expect(preserving(call, {
-            ...context,
-            authority: {
-                userAccessLevel: 40,
-                assistantAccessLevel: 20,
-                strictActionScope: true,
-            },
-        })).rejects.toThrow("Permission denied: strict delegation");
-        expect(effect).toHaveBeenCalledTimes(1);
-    });
-});

package/dist/contracts/__tests__/also-implements.test.d.ts

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

package/dist/contracts/__tests__/also-implements.test.js

@@ -1,110 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const field_type_1 = require("../../types/field-type");
-const utils_1 = require("../../utils");
-const registry_1 = require("../registry");
-const validate_1 = require("../validate");
-const contractId = (0, utils_1.newid)();
-/** Notes vN with one `add` tool taking `inputs`, returning `outputs`, and one `Notes` table. */
-function notes(version, { inputs = [], outputs = [], rows = [], } = {}, devTag) {
-    return {
-        contractId,
-        version,
-        ...(devTag ? { devTag } : {}),
-        name: "Notes",
-        description: "",
-        tables: [
-            {
-                name: "Notes",
-                description: "",
-                primaryKeyName: "noteId",
-                fields: [{ name: "noteId", type: field_type_1.FieldType.id }, ...rows],
-            },
-        ],
-        tools: [{ name: "add", usageDescription: "Add.", inputFields: inputs, outputFields: outputs }],
-        observables: [],
-        events: [],
-    };
-}
-const field = (name, optional = false) => ({
-    name,
-    type: field_type_1.FieldType.string,
-    ...(optional ? { optional } : {}),
-});
-describe("alsoImplements compatibility, by what callers send and receive", () => {
-    const satisfies = (implementation, target) => (0, validate_1.validateProviderSatisfiesContract)(implementation, target).valid;
-    it("lets an input become optional, but not an optional one required", () => {
-        expect(satisfies(notes(2, { inputs: [field("title", true)] }), notes(1, { inputs: [field("title")] }))).toBe(true);
-        expect(satisfies(notes(2, { inputs: [field("title")] }), notes(1, { inputs: [field("title", true)] }))).toBe(false);
-    });
-    it("keeps a required output required, and a table field's optionality as it was", () => {
-        expect(satisfies(notes(2, { outputs: [field("id", true)] }), notes(1, { outputs: [field("id")] }))).toBe(false);
-        expect(satisfies(notes(2, { outputs: [field("id")] }), notes(1, { outputs: [field("id", true)] }))).toBe(true);
-        expect(satisfies(notes(2, { rows: [field("title", true)] }), notes(1, { rows: [field("title")] }))).toBe(false);
-        expect(satisfies(notes(2, { rows: [field("title")] }), notes(1, { rows: [field("title", true)] }))).toBe(false);
-    });
-    it("keeps a required event payload field required, while allowing optional ones to become required", () => {
-        const event = (optional) => ({
-            ...notes(1),
-            events: [{ name: "added", description: "", payloadFields: [field("title", optional)] }],
-        });
-        expect(satisfies(event(true), event(false))).toBe(false);
-        expect(satisfies(event(false), event(true))).toBe(true);
-    });
-});
-describe("a carried alsoImplements definition", () => {
-    const providerId = (0, utils_1.newid)();
-    const v1 = notes(1, { inputs: [field("title")] });
-    const v2 = notes(2, { inputs: [field("title"), field("tag", true)] });
-    const alias = (definition = v1) => ({
-        definition: v2,
-        alsoImplements: [{ contractId, version: 1, definition }],
-    });
-    it("registers the target when the registry has none, and keeps one it already has", () => {
-        const cold = new registry_1.ContractRegistry();
-        expect(cold.registerBatch(providerId, [alias()]).valid).toBe(true);
-        expect(cold.getDefinition(contractId, 1)).toEqual(v1);
-        expect(cold.getProviderImplementation(contractId, 1, providerId)).toEqual({
-            contractId,
-            version: 2,
-        });
-        const warm = new registry_1.ContractRegistry();
-        const devV1 = { ...v1, devTag: "dev" };
-        warm.registerBatch((0, utils_1.newid)(), [{ definition: devV1 }]);
-        warm.registerBatch(providerId, [alias()]);
-        expect(warm.getDefinition(contractId, 1)).toEqual(devV1);
-    });
-    it("must match a frozen registered target, and be the version it declares", () => {
-        const registry = new registry_1.ContractRegistry();
-        registry.registerBatch((0, utils_1.newid)(), [{ definition: v1 }]);
-        const changed = notes(1, { inputs: [field("title"), field("body", true)] });
-        const refused = registry.registerBatch(providerId, [alias(changed)]);
-        expect(refused.valid).toBe(false);
-        expect(refused.errors[0].message).toContain("is frozen and cannot be modified");
-        expect(registry.getProviderPackageId(contractId, 2)).toBeUndefined();
-        const mislabeled = new registry_1.ContractRegistry().registerBatch(providerId, [
-            alias(notes(3, { inputs: [field("title")] })),
-        ]);
-        expect(mislabeled.errors[0].message).toContain("alsoImplements carries a definition that isn't");
-    });
-});
-test("legacy ranges retain explicitly provided handlers and alias the remaining versions", () => {
-    const registry = new registry_1.ContractRegistry();
-    const providerId = (0, utils_1.newid)();
-    expect(registry.register((0, utils_1.newid)(), notes(2)).valid).toBe(true);
-    expect(registry.registerBatch(providerId, [
-        { definition: notes(1) },
-        {
-            definition: notes(3),
-            alsoImplements: [{ contractId, version: { from: 1, to: 2 } }],
-        },
-    ]).valid).toBe(true);
-    expect(registry.getProviderImplementation(contractId, 1, providerId)).toEqual({
-        contractId,
-        version: 1,
-    });
-    expect(registry.getProviderImplementation(contractId, 2, providerId)).toEqual({
-        contractId,
-        version: 3,
-    });
-});

package/dist/contracts/__tests__/builder.test.d.ts

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