@peers-app/peers-sdk 0.27.3 → 0.27.5

package/dist/package-loader/resolve-consumed-contracts.test.d.ts

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

package/dist/package-loader/resolve-consumed-contracts.test.js

@@ -1,166 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const builder_1 = require("../contracts/builder");
-const contract_resolvers_1 = require("../contracts/contract-resolvers");
-const registry_1 = require("../contracts/registry");
-const utils_1 = require("../utils");
-const resolve_consumed_contracts_1 = require("./resolve-consumed-contracts");
-describe("resolveConsumedContracts", () => {
-    const contractId = (0, utils_1.newid)();
-    const providerPackageId = (0, utils_1.newid)();
-    function mockDataContext() {
-        return { dataContextId: "test-ctx" };
-    }
-    function makeProvidingRegistry() {
-        const registry = new registry_1.ContractRegistry();
-        registry.register(providerPackageId, {
-            contractId,
-            version: 1,
-            devTag: "dev",
-            name: "Fake Contract",
-            description: "test",
-            tables: [
-                {
-                    name: "Items",
-                    description: "Items table",
-                    primaryKeyName: "itemId",
-                    fields: [],
-                },
-            ],
-            tools: [],
-            observables: [],
-            events: [],
-        });
-        return registry;
-    }
-    beforeEach(() => {
-        const resolution = {
-            contractId,
-            version: 1,
-            tables: {
-                Items: {
-                    list: jest.fn().mockResolvedValue([{ itemId: "1" }]),
-                    count: jest.fn().mockResolvedValue(1),
-                },
-            },
-        };
-        (0, contract_resolvers_1.registerContractResolver)(contractId, 1, () => resolution);
-    });
-    it("settles a required consume with a live local consumer proxy", async () => {
-        const registry = makeProvidingRegistry();
-        let consumeHandle;
-        const packageDefinition = (0, builder_1.definePackage)((pkg) => {
-            pkg.packageId = (0, utils_1.newid)();
-            pkg.version = "1.0.0";
-            consumeHandle = pkg.consumes(contractId, 1);
-        });
-        await (0, resolve_consumed_contracts_1.resolveConsumedContracts)(mockDataContext(), registry, packageDefinition);
-        if (!consumeHandle) {
-            throw new Error("expected consume handle");
-        }
-        const consumer = (await consumeHandle.consumer);
-        expect(consumer).toBeDefined();
-        expect(consumer?.contractId).toBe(contractId);
-        expect(consumer?.version).toBe(1);
-        await expect(consumer?.tables.Items.list()).resolves.toEqual([{ itemId: "1" }]);
-        await expect(consumer?.tables.Items.count()).resolves.toBe(1);
-    });
-    it("settles optional missing consumes to undefined", async () => {
-        const registry = new registry_1.ContractRegistry();
-        let consumeHandle;
-        const packageDefinition = (0, builder_1.definePackage)((pkg) => {
-            pkg.packageId = (0, utils_1.newid)();
-            pkg.version = "1.0.0";
-            consumeHandle = pkg.consumes(contractId, 1, { optional: true });
-        });
-        await (0, resolve_consumed_contracts_1.resolveConsumedContracts)(mockDataContext(), registry, packageDefinition);
-        if (!consumeHandle) {
-            throw new Error("expected consume handle");
-        }
-        await expect(consumeHandle.consumer).resolves.toBeUndefined();
-    });
-    it("rejects required consumes when no provider is available", async () => {
-        const registry = new registry_1.ContractRegistry();
-        let consumeHandle;
-        const packageDefinition = (0, builder_1.definePackage)((pkg) => {
-            pkg.packageId = (0, utils_1.newid)();
-            pkg.version = "1.0.0";
-            consumeHandle = pkg.consumes(contractId, 1);
-        });
-        await (0, resolve_consumed_contracts_1.resolveConsumedContracts)(mockDataContext(), registry, packageDefinition);
-        if (!consumeHandle) {
-            throw new Error("expected consume handle");
-        }
-        await expect(consumeHandle.consumer).rejects.toThrow(/could not be resolved/);
-    });
-    it("treats a registered provider without a live resolver as missing", async () => {
-        const noResolverContractId = (0, utils_1.newid)();
-        const registry = new registry_1.ContractRegistry();
-        registry.register(providerPackageId, {
-            contractId: noResolverContractId,
-            version: 1,
-            devTag: "dev",
-            name: "No Resolver",
-            description: "test",
-            tables: [],
-            tools: [],
-            observables: [],
-            events: [],
-        });
-        expect((0, contract_resolvers_1.getContractResolver)(noResolverContractId, 1)).toBeUndefined();
-        let consumeHandle;
-        const packageDefinition = (0, builder_1.definePackage)((pkg) => {
-            pkg.packageId = (0, utils_1.newid)();
-            pkg.version = "1.0.0";
-            consumeHandle = pkg.consumes(noResolverContractId, 1, { optional: true });
-        });
-        await (0, resolve_consumed_contracts_1.resolveConsumedContracts)(mockDataContext(), registry, packageDefinition);
-        if (!consumeHandle) {
-            throw new Error("expected consume handle");
-        }
-        await expect(consumeHandle.consumer).resolves.toBeUndefined();
-    });
-    describe("remote declarations", () => {
-        it("settles a remote handle through the package loader without a local provider", async () => {
-            const remote = { contractId, version: 1, device: jest.fn(), dispose: jest.fn() };
-            const resolveRemoteContract = jest.fn().mockResolvedValue(remote);
-            const dataContext = {
-                dataContextId: "test-ctx",
-                packageLoader: { resolveRemoteContract },
-            };
-            let remoteHandle;
-            const packageDefinition = (0, builder_1.definePackage)((pkg) => {
-                pkg.packageId = (0, utils_1.newid)();
-                pkg.version = "1.0.0";
-                remoteHandle = pkg.remote(contractId, 1);
-            });
-            await (0, resolve_consumed_contracts_1.resolveConsumedContracts)(dataContext, new registry_1.ContractRegistry(), packageDefinition);
-            expect(resolveRemoteContract).toHaveBeenCalledWith(expect.objectContaining({ contractId, version: 1 }), packageDefinition.packageId);
-            await expect(remoteHandle?.consumer).resolves.toBe(remote);
-        });
-        it("rejects a remote handle when the contract definition is unknown locally", async () => {
-            const dataContext = {
-                dataContextId: "test-ctx",
-                packageLoader: { resolveRemoteContract: jest.fn().mockResolvedValue(undefined) },
-            };
-            let remoteHandle;
-            const packageDefinition = (0, builder_1.definePackage)((pkg) => {
-                pkg.packageId = (0, utils_1.newid)();
-                pkg.version = "1.0.0";
-                remoteHandle = pkg.remote(contractId, 1);
-            });
-            await (0, resolve_consumed_contracts_1.resolveConsumedContracts)(dataContext, new registry_1.ContractRegistry(), packageDefinition);
-            await expect(remoteHandle?.consumer).rejects.toThrow(/not registered on this device/);
-        });
-        it("rejects a remote handle when no package loader owns the context", async () => {
-            let remoteHandle;
-            const packageDefinition = (0, builder_1.definePackage)((pkg) => {
-                pkg.packageId = (0, utils_1.newid)();
-                pkg.version = "1.0.0";
-                remoteHandle = pkg.remote(contractId, 1);
-            });
-            await (0, resolve_consumed_contracts_1.resolveConsumedContracts)(mockDataContext(), new registry_1.ContractRegistry(), packageDefinition);
-            await expect(remoteHandle?.consumer).rejects.toThrow(/requires a package loader/);
-        });
-    });
-});

package/dist/serial-json.compat.test.d.ts

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

package/dist/serial-json.compat.test.js

@@ -1,369 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const node_vm_1 = require("node:vm");
-const msgpack_1 = require("@msgpack/msgpack");
-const serial_json_1 = require("./serial-json");
-const oracle = require("./serial-json.oracle");
-// Strings and keys that exercise every marker the decoder interprets. "__WINDOW" is left out
-// because the oracle decodes it to `window`, which throws in Node.
-const STRINGS = [
-    "",
-    "plain",
-    "héllo 世界 🚀",
-    "$dollar",
-    "__",
-    "__UNDEFINED",
-    "__NAN",
-    "__INFINITY",
-    "__DATE 2023-01-01T00:00:00.000Z",
-    "__DATE garbage",
-    "__REGEXP /a.c/g",
-    "__ERROR Error: x\n    at nowhere",
-    "__UINT8ARRAY AQID",
-    "__BUFFER AQID",
-    "__HTML <b>x</b>",
-    "__FUNCTION f(){}",
-    "__duplicate_ref_obj_7",
-    "__duplicate_ref_ary_3",
-    "__this_ref:__duplicate_ref_ary_5",
-    "__DOLLAR_x",
-];
-const KEYS = ["a", "b", "c", "0", "$a", "$", "__DOLLAR_b", "__this_ref", "constructor", "toString"];
-const NUMBERS = [0, 1, -1, 1.5, -0, NaN, Infinity, -Infinity, 1e21, Number.MAX_SAFE_INTEGER];
-/** Deterministic PRNG (mulberry32), so a failure names a reproducible seed. */
-function prng(seed) {
-    let state = seed;
-    return () => {
-        state = (state + 0x6d2b79f5) | 0;
-        let t = Math.imul(state ^ (state >>> 15), 1 | state);
-        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
-        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
-    };
-}
-/** A random value graph mixing extended types, marker-like strings, shared nodes and cycles. */
-function generate(seed) {
-    const random = prng(seed);
-    const pick = (items) => items[Math.floor(random() * items.length)];
-    const pool = [];
-    const ancestors = [];
-    function leaf() {
-        switch (Math.floor(random() * 11)) {
-            case 0:
-            case 1:
-                return pick(STRINGS);
-            case 2:
-                return pick(NUMBERS);
-            case 3:
-                return random() < 0.5;
-            case 4:
-                return null;
-            case 5:
-                return undefined;
-            case 6:
-                return new Date(Math.floor(random() * 4e12));
-            case 7:
-                return random() < 0.5 ? new Uint8Array([1, 2, 3]) : Buffer.from([4, 5]);
-            case 8:
-                return new RegExp(pick(["a.c", "^x$", "[0-9]+"]), pick(["", "g", "gi"]));
-            case 9:
-                return new Error(pick(["boom", ""]));
-            default:
-                return () => 1;
-        }
-    }
-    function value(depth) {
-        const roll = random();
-        if (roll < 0.06 && pool.length)
-            return pick(pool);
-        if (roll < 0.09 && ancestors.length)
-            return pick(ancestors);
-        if (depth <= 0 || roll > 0.45)
-            return leaf();
-        const container = random() < 0.5 ? [] : {};
-        ancestors.push(container);
-        const size = Math.floor(random() * 5);
-        for (let i = 0; i < size; i++) {
-            const child = value(depth - 1);
-            if (Array.isArray(container))
-                container.push(child);
-            else
-                container[pick(KEYS)] = child;
-        }
-        ancestors.pop();
-        pool.push(container);
-        return container;
-    }
-    // Top level is always a container, as in columns, change values and messages.
-    let root = value(4);
-    while (root === null || typeof root !== "object" || root instanceof Date)
-        root = value(4);
-    return root;
-}
-function deepFreeze(value) {
-    // Typed arrays with elements can't be frozen; nothing writes to them anyway.
-    if (value && typeof value === "object" && !ArrayBuffer.isView(value) && !Object.isFrozen(value)) {
-        Object.freeze(value);
-        for (const child of Object.values(value))
-            deepFreeze(child);
-    }
-    return value;
-}
-/**
- * First difference between two value graphs, or null. Compares types, prototypes, values, key
- * order, and sharing: a node shared (or cyclic) in one graph must be shared the same way in the other.
- */
-function graphDiff(actual, expected, path = "$", pairs = new Map(), reversePairs = new Map()) {
-    if (typeof actual !== typeof expected)
-        return `${path}: ${typeof actual} vs ${typeof expected}`;
-    if (typeof actual === "number")
-        return Object.is(actual, expected) ? null : `${path}: ${actual} vs ${expected}`;
-    if (actual === null || expected === null || typeof actual !== "object") {
-        return actual === expected ? null : `${path}: ${String(actual)} vs ${String(expected)}`;
-    }
-    const a = actual;
-    const b = expected;
-    if (pairs.has(a) || reversePairs.has(b)) {
-        return pairs.get(a) === b ? null : `${path}: sharing differs`;
-    }
-    pairs.set(a, b);
-    reversePairs.set(b, a);
-    if (Object.getPrototypeOf(a) !== Object.getPrototypeOf(b))
-        return `${path}: prototype differs`;
-    if (Array.isArray(a) && a.length !== b.length)
-        return `${path}: array length differs`;
-    if (a instanceof Date)
-        return Object.is(a.getTime(), b.getTime()) ? null : `${path}: date differs`;
-    if (a instanceof RegExp)
-        return String(a) === String(b) ? null : `${path}: regexp differs`;
-    if (a instanceof Error)
-        return a.stack === b.stack ? null : `${path}: error stack differs`;
-    if (a instanceof Uint8Array)
-        return Buffer.compare(a, b) === 0 ? null : `${path}: bytes differ`;
-    const keysA = Object.keys(a);
-    const keysB = Object.keys(b);
-    if (keysA.length !== keysB.length || keysA.some((key, index) => key !== keysB[index])) {
-        return `${path}: keys [${keysA}] vs [${keysB}]`;
-    }
-    for (const key of keysA) {
-        const diff = graphDiff(a[key], b[key], `${path}.${key}`, pairs, reversePairs);
-        if (diff)
-            return diff;
-    }
-    return null;
-}
-const SEEDS = Array.from({ length: 1500 }, (_, i) => i + 1);
-/**
- * True when an encoded tree tags an object with an `_ary_` marker or an array with an `_obj_`
- * one. toJSON only writes that when a user string collides with a marker; the live decoder no
- * longer merges such a pair (see "does not let an object fill an array target" in
- * serial-json.test.ts), so those seeds are compared separately.
- */
-function hasMixedKindTag(encoded) {
-    if (Array.isArray(encoded)) {
-        const [first] = encoded;
-        if (typeof first === "string" && first.startsWith("__this_ref:") && first.includes("_obj_")) {
-            return true;
-        }
-        return encoded.some(hasMixedKindTag);
-    }
-    if (encoded && typeof encoded === "object") {
-        const tag = encoded.__this_ref;
-        if (typeof tag === "string" && tag.includes("_ary_"))
-            return true;
-        return Object.values(encoded).some(hasMixedKindTag);
-    }
-    return false;
-}
-describe("serial-json compatibility with the frozen oracle", () => {
-    // The corpus holds marker-like strings with no target; the live decoder warns about those.
-    beforeAll(() => {
-        jest.spyOn(console, "warn").mockImplementation(() => undefined);
-    });
-    afterAll(() => {
-        jest.restoreAllMocks();
-    });
-    it("detects differences in values, key order, sparse lengths and sharing", () => {
-        const shared = {};
-        expect(graphDiff({ x: 1 }, { x: 2 })).not.toBeNull();
-        expect(graphDiff({ x: 1, y: 2 }, { y: 2, x: 1 })).not.toBeNull();
-        expect(graphDiff({ "a\u0000b": undefined }, { a: undefined, b: undefined })).not.toBeNull();
-        expect(graphDiff([], new Array(1))).not.toBeNull();
-        expect(graphDiff([shared, shared], [{}, {}])).not.toBeNull();
-        expect(graphDiff([{}, {}], [shared, shared])).not.toBeNull();
-        const cycle = {};
-        cycle.self = cycle;
-        expect(graphDiff(cycle, { self: {} })).not.toBeNull();
-    });
-    it.each([
-        ["sparse arrays", () => ({ a: new Array(3), b: Object.assign(new Array(3), { 0: 1, 2: 3 }) })],
-        ["null prototypes", () => Object.assign(Object.create(null), { a: 1, $b: {} })],
-        ["boxed strings", () => ({ a: new String("__DATE 2000-01-01") })],
-        [
-            "another realm",
-            () => (0, node_vm_1.runInNewContext)("({ a: [1, , 3], d: new Date(0), r: /x/g, u: new Uint8Array([1]) })"),
-        ],
-        [
-            "getters that change later properties",
-            () => {
-                const value = {
-                    a: {
-                        get x() {
-                            value.b = 2;
-                            return value;
-                        },
-                    },
-                    b: 1,
-                };
-                return value;
-            },
-        ],
-        [
-            "callables inheriting from RegExp",
-            () => {
-                const value = () => 1;
-                Object.setPrototypeOf(value, RegExp.prototype);
-                value.toString = () => "/x/g";
-                return value;
-            },
-        ],
-    ])("encodes %s exactly like the oracle", (_name, makeValue) => {
-        expect((0, serial_json_1.toJSONString)(makeValue())).toBe(oracle.toJSONString(makeValue()));
-        expect(graphDiff((0, serial_json_1.toJSON)(makeValue()), oracle.toJSON(makeValue()))).toBeNull();
-    });
-    // A tag that names a target of the other kind (object vs array) is an intended difference; see
-    // serial-json.test.ts.
-    it.each([
-        [["__this_ref:__duplicate_ref_obj_1", 1, 2], "__duplicate_ref_obj_1"],
-        [
-            { __this_ref: "__duplicate_ref_obj_1", a: 1 },
-            { __this_ref: "__duplicate_ref_obj_1", b: 2 },
-            "__duplicate_ref_obj_1",
-        ],
-        [
-            "__duplicate_ref_ary_1",
-            ["__this_ref:__duplicate_ref_ary_1", "first", "extra"],
-            ["__this_ref:__duplicate_ref_ary_1", "last"],
-        ],
-        ["__this_ref:__duplicate_ref_ary_1:ignored", "__duplicate_ref_ary_1"],
-        [
-            { __this_ref: 1, a: 1 },
-            { __this_ref: "1", b: 2 },
-        ],
-    ].map((value) => [value]))("decodes unusual and repeated tags: %j", (value) => {
-        expect(graphDiff((0, serial_json_1.fromJSON)(deepFreeze(value)), oracle.fromJSON(value))).toBeNull();
-    });
-    it.each([
-        "plain",
-        "__UNDEFINED",
-        "__NAN",
-        "__DATE 2000-01-01",
-        "__REGEXP /x/g",
-        "__BUFFER AQID",
-        "__duplicate_ref_obj_boxed",
-    ])("decodes boxed strings like the oracle: %s", (text) => {
-        expect(graphDiff((0, serial_json_1.fromJSON)(new String(text)), oracle.fromJSON(new String(text)))).toBeNull();
-    });
-    it("recognizes a boxed array tag", () => {
-        const value = [new String("__this_ref:__duplicate_ref_ary_1"), "__duplicate_ref_ary_1"];
-        expect(graphDiff((0, serial_json_1.fromJSON)(value), oracle.fromJSON(value))).toBeNull();
-    });
-    it("generates graphs with sharing, cycles and every marker", () => {
-        // Guards the corpus itself: if the generator stops producing these, the checks below go soft.
-        let sharing = false;
-        let cycles = false;
-        const visit = (value, seen, ancestors) => {
-            if (!value || typeof value !== "object")
-                return;
-            if (ancestors.has(value))
-                cycles = true;
-            if (seen.has(value)) {
-                sharing = true;
-                return;
-            }
-            seen.add(value);
-            ancestors.add(value);
-            for (const child of Object.values(value))
-                visit(child, seen, ancestors);
-            ancestors.delete(value);
-        };
-        for (const seed of SEEDS)
-            visit(generate(seed), new Set(), new Set());
-        expect(sharing).toBe(true);
-        expect(cycles).toBe(true);
-        const encoded = SEEDS.map((seed) => oracle.toJSONString(generate(seed))).join("\n");
-        for (const marker of [
-            "__this_ref",
-            "__duplicate_ref_ary_",
-            "__DOLLAR_",
-            "__DATE",
-            "__ERROR",
-            "__BUFFER",
-            "__UINT8ARRAY",
-            "__UNDEFINED",
-            "__NAN",
-            "__INFINITY",
-            "__REGEXP",
-            "__FUNCTION",
-        ]) {
-            expect(encoded).toContain(marker);
-        }
-    });
-    it("encodes byte-identically, as text and as an in-memory tree", () => {
-        for (const seed of SEEDS) {
-            const value = generate(seed);
-            expect({ seed, text: (0, serial_json_1.toJSONString)(value) }).toEqual({
-                seed,
-                text: oracle.toJSONString(value),
-            });
-            expect({ seed, diff: graphDiff((0, serial_json_1.toJSON)(value), oracle.toJSON(value)) }).toEqual({
-                seed,
-                diff: null,
-            });
-        }
-    });
-    const MIXED_KIND_SEEDS = new Set(SEEDS.filter((seed) => hasMixedKindTag(oracle.toJSON(generate(seed)))));
-    it("has a few mixed-kind tags from marker-like strings, and decodes them differently", () => {
-        expect(MIXED_KIND_SEEDS.size).toBeGreaterThan(0);
-        expect(MIXED_KIND_SEEDS.size).toBeLessThan(SEEDS.length / 20);
-        let differing = 0;
-        for (const seed of MIXED_KIND_SEEDS) {
-            const text = oracle.toJSONString(generate(seed));
-            if (graphDiff((0, serial_json_1.fromJSON)(JSON.parse(text)), oracle.fromJSON(JSON.parse(text))))
-                differing++;
-        }
-        expect(differing).toBeGreaterThan(0);
-    });
-    it("decodes the oracle's JSON text the same way, without mutating it", () => {
-        for (const seed of SEEDS) {
-            if (MIXED_KIND_SEEDS.has(seed))
-                continue;
-            const text = oracle.toJSONString(generate(seed));
-            const decoded = (0, serial_json_1.fromJSON)(deepFreeze(JSON.parse(text)));
-            const expected = oracle.fromJSON(deepFreeze(JSON.parse(text)));
-            expect({ seed, diff: graphDiff(decoded, expected) }).toEqual({ seed, diff: null });
-        }
-    });
-    it("decodes msgpack-decoded trees (the device wire) the same way", () => {
-        for (const seed of SEEDS) {
-            if (MIXED_KIND_SEEDS.has(seed))
-                continue;
-            const bytes = (0, msgpack_1.encode)(oracle.toJSON(generate(seed)));
-            const decoded = (0, serial_json_1.fromJSON)(deepFreeze((0, msgpack_1.decode)(bytes)));
-            const expected = oracle.fromJSON(deepFreeze((0, msgpack_1.decode)(bytes)));
-            expect({ seed, diff: graphDiff(decoded, expected) }).toEqual({ seed, diff: null });
-        }
-    });
-    it("produces output the oracle decodes the same way as its own", () => {
-        for (const seed of SEEDS) {
-            const value = generate(seed);
-            const decoded = oracle.fromJSON(JSON.parse((0, serial_json_1.toJSONString)(value)));
-            const expected = oracle.fromJSON(JSON.parse(oracle.toJSONString(value)));
-            expect({ seed, diff: graphDiff(decoded, expected) }).toEqual({ seed, diff: null });
-        }
-    });
-    it("never mutates the value it encodes", () => {
-        for (const seed of SEEDS.slice(0, 300)) {
-            expect(() => (0, serial_json_1.toJSONString)(deepFreeze(generate(seed)))).not.toThrow();
-        }
-    });
-});

package/dist/serial-json.test.d.ts

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