@peers-app/peers-sdk 0.26.5 → 0.27.0

package/dist/contracts/__tests__/frozen-contracts.test.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const field_type_1 = require("../../types/field-type");
+const utils_1 = require("../../utils");
+const frozen_contracts_1 = require("../frozen-contracts");
+function contract(contractId, version, fieldType = field_type_1.FieldType.string) {
+    return {
+        contractId,
+        version,
+        devTag: "dev",
+        name: `Contract ${version}`,
+        description: "",
+        tables: [],
+        tools: [
+            {
+                name: "run",
+                usageDescription: "Run.",
+                inputFields: [{ name: "value", type: fieldType }],
+                outputFields: [],
+            },
+        ],
+        observables: [],
+        events: [],
+    };
+}
+describe("frozen contracts", () => {
+    const id = (0, utils_1.newid)();
+    it("freezes what a release provides, without its dev tag, and keeps what it froze before", () => {
+        const first = (0, frozen_contracts_1.freezeContracts)(undefined, [contract(id, 1)], "1.0.0");
+        expect(first.added.map((frozen) => [frozen.version, frozen.frozenBy])).toEqual([[1, "1.0.0"]]);
+        expect(first.frozen.contracts[0]).not.toHaveProperty("devTag");
+        const second = (0, frozen_contracts_1.freezeContracts)(first.frozen, [contract(id, 1), contract(id, 2)], "1.1.0");
+        expect(second.frozen.contracts.map((frozen) => [frozen.version, frozen.frozenBy])).toEqual([
+            [1, "1.0.0"],
+            [2, "1.1.0"],
+        ]);
+        expect(second.added.map((frozen) => frozen.version)).toEqual([2]);
+    });
+    it("refuses a changed shape, allows new descriptions, and notes a version no longer provided", () => {
+        const { frozen } = (0, frozen_contracts_1.freezeContracts)(undefined, [contract(id, 1), contract(id, 2)], "1.0.0");
+        const described = { ...contract(id, 1), description: "Use v2 instead." };
+        described.tools = [{ ...described.tools[0], usageDescription: "Deprecated." }];
+        expect((0, frozen_contracts_1.checkFrozenContracts)(frozen, [described, contract(id, 2)])).toEqual({
+            changed: [],
+            notProvided: [],
+        });
+        const changed = (0, frozen_contracts_1.checkFrozenContracts)(frozen, [contract(id, 1, field_type_1.FieldType.number)]);
+        expect(changed.changed.map(({ changes }) => changes)).toEqual([["tool run changed"]]);
+        expect(changed.notProvided.map((frozen) => frozen.version)).toEqual([2]);
+        expect((0, frozen_contracts_1.describeFrozenContractChanges)(changed)).toEqual([
+            `Contract 1 (${id}@1), frozen by 1.0.0: tool run changed. Declare a new version instead.`,
+        ]);
+        const refused = (0, frozen_contracts_1.freezeContracts)(frozen, [contract(id, 1, field_type_1.FieldType.number)], "1.1.0");
+        expect(refused.added).toEqual([]);
+        expect(refused.frozen).toBe(frozen);
+    });
+    it("rejects duplicate provided identities instead of hiding a changed shape or freezing duplicates", () => {
+        const original = contract(id, 1);
+        const changed = contract(id, 1, field_type_1.FieldType.number);
+        const { frozen } = (0, frozen_contracts_1.freezeContracts)(undefined, [original], "1.0.0");
+        for (const provided of [
+            [changed, original],
+            [original, changed],
+            [original, original],
+        ]) {
+            expect(() => (0, frozen_contracts_1.checkFrozenContracts)(frozen, provided)).toThrow(`Duplicate provided contract ${id}@1`);
+            expect(() => (0, frozen_contracts_1.freezeContracts)(undefined, provided, "1.0.0")).toThrow("Duplicate provided contract");
+            expect(() => (0, frozen_contracts_1.freezeContracts)(frozen, provided, "1.1.0")).toThrow("Duplicate provided contract");
+        }
+    });
+});
+const sample = {
+    contractId: (0, utils_1.newid)(),
+    version: 1,
+    name: "All members",
+    description: "",
+    tables: [
+        {
+            name: "Rows",
+            description: "",
+            primaryKeyName: "id",
+            fields: [{ name: "id", type: field_type_1.FieldType.id }],
+        },
+    ],
+    tools: [
+        {
+            name: "run",
+            usageDescription: "",
+            inputFields: [{ name: "mode", type: field_type_1.FieldType.string, enumValues: ["on", "off"] }],
+            outputFields: [
+                {
+                    name: "result",
+                    type: field_type_1.FieldType.object,
+                    fields: [{ name: "ok", type: field_type_1.FieldType.boolean }],
+                },
+            ],
+        },
+    ],
+    observables: [
+        {
+            name: "state",
+            description: "",
+            valueType: field_type_1.FieldType.string,
+            writable: false,
+            value: { type: field_type_1.FieldType.string, enumValues: ["on", "off"] },
+        },
+    ],
+    events: [
+        { name: "changed", description: "", payloadFields: [{ name: "id", type: field_type_1.FieldType.id }] },
+    ],
+};
+test.each([
+    "tables",
+    "tools",
+    "observables",
+    "events",
+])("detects added and removed %s", (kind) => {
+    const { frozen } = (0, frozen_contracts_1.freezeContracts)(undefined, [sample], "1.0.0");
+    const removed = { ...sample, [kind]: [] };
+    const added = {
+        ...sample,
+        [kind]: [...(sample[kind] ?? []), { ...(sample[kind] ?? [])[0], name: "another" }],
+    };
+    for (const changed of [removed, added]) {
+        expect((0, frozen_contracts_1.checkFrozenContracts)(frozen, [changed]).changed).toHaveLength(1);
+    }
+});
+test.each([
+    [
+        "primary key",
+        (value) => {
+            value.tables[0].primaryKeyName = "other";
+        },
+    ],
+    [
+        "table field type",
+        (value) => {
+            value.tables[0].fields[0].type = field_type_1.FieldType.string;
+        },
+    ],
+    [
+        "tool optionality",
+        (value) => {
+            value.tools[0].inputFields[0].optional = true;
+        },
+    ],
+    [
+        "enum values",
+        (value) => {
+            value.tools[0].inputFields[0].enumValues = ["on"];
+        },
+    ],
+    [
+        "nested field",
+        (value) => {
+            (value.tools[0].outputFields[0].fields ?? [])[0].type = field_type_1.FieldType.string;
+        },
+    ],
+    [
+        "observable type",
+        (value) => {
+            value.observables[0].valueType = field_type_1.FieldType.object;
+        },
+    ],
+    [
+        "observable writability",
+        (value) => {
+            value.observables[0].writable = true;
+        },
+    ],
+    [
+        "observable enum",
+        (value) => {
+            value.observables[0].value = { type: field_type_1.FieldType.string, enumValues: ["on"] };
+        },
+    ],
+    [
+        "event field",
+        (value) => {
+            (value.events ?? [])[0].payloadFields[0].isArray = true;
+        },
+    ],
+])("detects changed %s", (_label, mutate) => {
+    const { frozen } = (0, frozen_contracts_1.freezeContracts)(undefined, [sample], "1.0.0");
+    const changed = structuredClone(sample);
+    mutate(changed);
+    expect((0, frozen_contracts_1.checkFrozenContracts)(frozen, [changed]).changed).toHaveLength(1);
+});
+test("does not freeze without a package version", () => {
+    expect(() => (0, frozen_contracts_1.freezeContracts)(undefined, [sample], "")).toThrow("no version");
+});

package/dist/contracts/__tests__/generic-tool-dispatch.test.js

@@ -1,7 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const index_1 = require("../../index");
-test("host admission for an omitted preserve level is None and the declared mode is honored", async () => {
+const target_dispatch_1 = require("./target-dispatch");
+test.each([
+    true,
+    false,
+])("host preserve admission is None and forwards context (explicit forwarding: %s)", async (forwardCallContext) => {
     const userId = (0, index_1.newid)();
     const groupId = (0, index_1.newid)();
     const contractId = (0, index_1.newid)();
@@ -23,9 +27,10 @@ test("host admission for an omitted preserve level is None and the declared mode
             getDataContext: () => dc,
         },
     });
+    const targetsId = (0, index_1.newid)();
     const route = {
         tool: { toolId: (0, index_1.newid)(), name: "route", authorityPropagation: "preserve" },
-        toolFn: (name, ctx) => ctx.dispatchAction(name, {}),
+        toolFn: (name, ctx) => ctx.dispatchTool?.({ contractId: targetsId, version: 1, toolName: name }, {}),
     };
     const ordinary = {
         tool: { toolId: (0, index_1.newid)(), name: "ordinary" },
@@ -38,31 +43,25 @@ test("host admission for an omitted preserve level is None and the declared mode
             toolFn: () => "executed",
         },
     ]));
-    const provider = (0, index_1.createContractProvider)({
-        contractId,
-        version: 1,
-        tools: { route, ordinary },
-        actionAliases: { zero: "0", reader: "20" },
-        actionTools: targets,
-    });
-    const call = (name, action = "zero") => provider({
+    const provider = (0, index_1.createContractProvider)({ contractId, version: 1, forwardCallContext, tools: { route, ordinary } }, { dispatchTool: (0, target_dispatch_1.targetDispatch)(targetsId, targets) });
+    const call = (name, target = "0") => provider({
         contractId,
         version: 1,
         member: "tool",
         name,
         operation: "run",
-        args: [action],
+        args: [target],
         dataContextId: groupId,
     }, { callerUserId: userId, dataContext: dc });
     role = index_1.GroupMemberRole.None;
     await expect(call("route")).resolves.toBe("executed");
-    await expect(call("route", "reader")).rejects.toThrow(/Permission denied/);
+    await expect(call("route", "20")).rejects.toThrow(/Permission denied/);
     await expect(call("ordinary")).rejects.toThrow(/Permission denied/);
     role = index_1.GroupMemberRole.Admin;
-    await expect(call("route", "reader")).resolves.toBe("executed");
+    await expect(call("route", "20")).resolves.toBe("executed");
     // The same wrapper without a preserve declaration is an ordinary unclassified (Self) tool.
     route.tool.authorityPropagation = undefined;
-    await expect(call("route", "reader")).rejects.toThrow(/Permission denied/);
+    await expect(call("route", "20")).rejects.toThrow(/Permission denied/);
 });
 test("host tool schema retains omitted admission for request-based defaults", () => {
     const tool = index_1.toolSchema.parse({
@@ -129,45 +128,3 @@ test("generic dispatch binds a capped strict frame and rejects cross-context and
     await expect(call({ ...selected, targetDeviceId: (0, index_1.newid)() })).rejects.toThrow("cannot target another device");
     expect(bridge).toHaveBeenCalledTimes(1);
 });
-test("host catalogs use declared preservation for an omitted target admission level", async () => {
-    const { authorizedContractActionNames } = await Promise.resolve().then(() => require("../../index"));
-    const userId = (0, index_1.newid)();
-    const groupId = (0, index_1.newid)();
-    const contractId = (0, index_1.newid)();
-    const dc = {
-        dataContextId: groupId,
-        groupId,
-        tableContainer: {
-            getTable: (meta) => meta.name === "Groups"
-                ? { get: async () => ({ founderUserId: (0, index_1.newid)() }) }
-                : { findOne: async () => ({ role: index_1.GroupMemberRole.Reader }) },
-        },
-    };
-    Object.assign(dc, {
-        userContext: {
-            userId,
-            loadingPromise: Promise.resolve(),
-            userDataContext: dc,
-            getDataContext: () => dc,
-        },
-    });
-    const zero = {
-        tool: { name: "zero", toolId: (0, index_1.newid)(), authorityPropagation: "preserve" },
-        toolFn: () => "executed",
-    };
-    const route = {
-        tool: { name: "route", toolId: (0, index_1.newid)(), accessLevel: 20, authorityPropagation: "preserve" },
-        toolFn: (_, ctx) => ctx.dispatchAction("none", {}),
-    };
-    const resolution = {
-        contractId,
-        version: 1,
-        tools: { route, zero },
-        actionAliases: { none: "zero" },
-        actionTools: { zero },
-    };
-    const context = { callerUserId: userId, dataContext: dc };
-    expect(await authorizedContractActionNames(resolution, context)).toEqual(["none"]);
-    const provider = (0, index_1.createContractProvider)(resolution);
-    await expect(provider({ contractId, version: 1, member: "tool", name: "route", operation: "run", args: [{}] }, context)).resolves.toBe("executed");
-});

package/dist/contracts/__tests__/host-contract-client.test.d.ts

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