@peers-app/peers-sdk 0.19.14 → 0.20.0

package/dist/contracts/__tests__/contract-table-events.test.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const event_registry_1 = require("../../data/orm/event-registry");
+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");
+/** Contract-member name of the single table under test. */
+const TABLE_NAME = "Widgets";
+/** Flush pending micro/macrotasks so fire-and-forget subscribe requests land. */
+const flush = () => new Promise((resolve) => setTimeout(resolve, 0));
+/** Build a `dataChanged` payload matching the real `Table.dataChanged` shape. */
+const mkEvent = (id, op = "insert") => ({ dataObject: { id }, op, source: "local" });
+/** A minimal contract that declares exactly one table (no generic events). */
+function makeContract(contractId) {
+    return {
+        contractId,
+        version: 1,
+        devTag: "dev",
+        name: "Table Events Test Contract",
+        description: "For contract table dataChanged proxy tests",
+        tables: [
+            {
+                name: TABLE_NAME,
+                description: "Widgets",
+                primaryKeyName: "id",
+                fields: [{ name: "id", type: field_type_1.FieldType.id, description: "ID" }],
+            },
+        ],
+        tools: [],
+        observables: [],
+        events: [],
+    };
+}
+/**
+ * Wire a consumer to a provider session over an in-process transport pair. The provider
+ * "table" is a fake exposing a `save` method plus `dataChanged: emitter.event`, mirroring
+ * the real {@link Table.dataChanged}. The emitter is built through an {@link EventRegistry}
+ * scoped by a unique `dataContextId`, so the actual `${tableName}_DataChanged_${dataContextId}`
+ * name path drives delivery (proves dataContext scoping) and never collides across tests.
+ */
+function wire(opts = {}) {
+    const contractId = (0, utils_1.newid)();
+    const dataContextId = (0, utils_1.newid)();
+    const registry = new event_registry_1.EventRegistry(dataContextId);
+    const emitter = registry.getEmitter(`${TABLE_NAME}_DataChanged`);
+    const save = jest.fn(async (record) => record);
+    const table = { dataChanged: emitter.event, save };
+    const resolution = {
+        contractId,
+        version: 1,
+        // Fake table stands in for a real Table<Widget>; the session only touches
+        // `dataChanged` (an Event) and dispatched method names.
+        tables: { [TABLE_NAME]: table },
+    };
+    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)(makeContract(contractId), consumerTransport);
+    return {
+        consumer,
+        session,
+        emitter,
+        save,
+        contractId,
+        consumerTransport,
+        providerTransport,
+    };
+}
+describe("contract table dataChanged — end-to-end", () => {
+    it("delivers a dataChanged payload to a subscribed consumer", async () => {
+        const { consumer, session, emitter } = wire();
+        const received = [];
+        consumer.tables[TABLE_NAME].dataChanged.subscribe((v) => received.push(v));
+        await flush();
+        await emitter.emit(mkEvent("w1"));
+        expect(received).toEqual([mkEvent("w1")]);
+        session.dispose();
+        consumer.dispose();
+    });
+});
+describe("contract table dataChanged — subscription gating", () => {
+    it("pushes nothing on the notify channel when nobody is subscribed", async () => {
+        const { emitter, providerTransport, session, consumer } = wire();
+        const notifySpy = jest.spyOn(providerTransport, "emit");
+        await emitter.emit(mkEvent("w0"));
+        expect(notifySpy).not.toHaveBeenCalled();
+        session.dispose();
+        consumer.dispose();
+    });
+});
+describe("contract table dataChanged — unsubscribe + refcount", () => {
+    it("stops delivering after unsubscribe and detaches the live subscription", async () => {
+        const { consumer, session, emitter, providerTransport } = wire();
+        const originalSubscribe = emitter.event.subscribe;
+        const liveUnsubscribe = jest.fn();
+        jest.spyOn(emitter.event, "subscribe").mockImplementation((handler) => {
+            const subscription = originalSubscribe(handler);
+            return {
+                unsubscribe: () => {
+                    liveUnsubscribe();
+                    return subscription.unsubscribe();
+                },
+            };
+        });
+        const received = [];
+        const sub = consumer.tables[TABLE_NAME].dataChanged.subscribe((v) => received.push(v));
+        await flush();
+        await emitter.emit(mkEvent("a"));
+        expect(received).toEqual([mkEvent("a")]);
+        const notifySpy = jest.spyOn(providerTransport, "emit");
+        sub.unsubscribe();
+        await flush();
+        // Refcount reached 0, so the provider detached its live handler: no further pushes.
+        expect(liveUnsubscribe).toHaveBeenCalledTimes(1);
+        await emitter.emit(mkEvent("b", "update"));
+        expect(notifySpy).not.toHaveBeenCalled();
+        expect(received).toEqual([mkEvent("a")]);
+        session.dispose();
+        consumer.dispose();
+    });
+});
+describe("contract table dataChanged — fan-out", () => {
+    it("delivers to multiple subscribers through a single live subscription", async () => {
+        const { consumer, session, emitter, providerTransport } = wire();
+        const liveSubscribeSpy = jest.spyOn(emitter.event, "subscribe");
+        const a = [];
+        const b = [];
+        consumer.tables[TABLE_NAME].dataChanged.subscribe((v) => a.push(v));
+        consumer.tables[TABLE_NAME].dataChanged.subscribe((v) => b.push(v));
+        await flush();
+        // One live subscription is shared across both consumer subscriptions (refcount by key).
+        expect(liveSubscribeSpy).toHaveBeenCalledTimes(1);
+        const notifySpy = jest.spyOn(providerTransport, "emit");
+        await emitter.emit(mkEvent("x"));
+        expect(a).toEqual([mkEvent("x")]);
+        expect(b).toEqual([mkEvent("x")]);
+        // One push per subscriptionId fanned out from the single emit.
+        expect(notifySpy).toHaveBeenCalledTimes(2);
+        session.dispose();
+        consumer.dispose();
+    });
+});
+describe("contract table dataChanged — permission gating", () => {
+    it("rejects a denied subscribe and attaches no live subscription", async () => {
+        const consoleError = jest.spyOn(console, "error").mockImplementation();
+        const localUserId = (0, utils_1.newid)();
+        const { providerTransport, emitter, session, consumer } = wire({
+            permissionCheck: contract_proxy_1.sameUserContractPermissionCheck,
+            context: { localUserId, callerUserId: (0, utils_1.newid)() },
+        });
+        const liveSubscribeSpy = jest.spyOn(emitter.event, "subscribe");
+        const received = [];
+        consumer.tables[TABLE_NAME].dataChanged.subscribe((value) => received.push(value));
+        await flush();
+        // No live subscription attached, so emitting the event pushes nothing.
+        const notifySpy = jest.spyOn(providerTransport, "emit");
+        await emitter.emit(mkEvent("z"));
+        expect(notifySpy).not.toHaveBeenCalled();
+        expect(liveSubscribeSpy).not.toHaveBeenCalled();
+        expect(received).toEqual([]);
+        expect(consoleError).toHaveBeenCalledWith("Contract subscribe failed", expect.objectContaining({ message: expect.stringMatching(/Permission denied/) }));
+        session.dispose();
+        consumer.dispose();
+    });
+});
+describe("contract table dataChanged — methods coexist", () => {
+    it("forwards table methods as calls alongside dataChanged subscriptions", async () => {
+        const { consumer, session, save } = wire();
+        const saved = await consumer.tables[TABLE_NAME].save({ id: "w9", label: "hi" });
+        expect(save).toHaveBeenCalledWith({ id: "w9", label: "hi" });
+        expect(saved).toEqual({ id: "w9", label: "hi" });
+        session.dispose();
+        consumer.dispose();
+    });
+});
+describe("contract table dataChanged — teardown", () => {
+    it("session.dispose() detaches live subscriptions and stops pushes", async () => {
+        const { consumer, session, emitter, providerTransport } = wire();
+        const received = [];
+        consumer.tables[TABLE_NAME].dataChanged.subscribe((v) => received.push(v));
+        await flush();
+        await emitter.emit(mkEvent("1"));
+        expect(received).toEqual([mkEvent("1")]);
+        const notifySpy = jest.spyOn(providerTransport, "emit");
+        session.dispose();
+        await emitter.emit(mkEvent("2", "update"));
+        expect(notifySpy).not.toHaveBeenCalled();
+        expect(received).toEqual([mkEvent("1")]);
+        consumer.dispose();
+    });
+    it("consumer.dispose() unsubscribes the provider and drops later pushes", async () => {
+        const { consumer, session, emitter, providerTransport } = wire();
+        const received = [];
+        consumer.tables[TABLE_NAME].dataChanged.subscribe((v) => received.push(v));
+        await flush();
+        await emitter.emit(mkEvent("1"));
+        expect(received).toEqual([mkEvent("1")]);
+        const notifySpy = jest.spyOn(providerTransport, "emit");
+        consumer.dispose();
+        await flush();
+        await emitter.emit(mkEvent("2", "update"));
+        expect(notifySpy).not.toHaveBeenCalled();
+        expect(received).toEqual([mkEvent("1")]);
+        session.dispose();
+    });
+});

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

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

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

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+describe("inProcessTransportPair", () => {
+    it("delivers a request to the peer handler and resolves with its return (ack)", async () => {
+        const [a, b] = (0, contract_transport_1.inProcessTransportPair)();
+        b.on(contract_transport_1.CONTRACT_REQUEST_CHANNEL, (x, y) => x + y);
+        await expect(a.emit(contract_transport_1.CONTRACT_REQUEST_CHANNEL, 2, 3)).resolves.toBe(5);
+    });
+    it("awaits async handlers before resolving the emit", async () => {
+        const [a, b] = (0, contract_transport_1.inProcessTransportPair)();
+        b.on(contract_transport_1.CONTRACT_REQUEST_CHANNEL, async (value) => {
+            await new Promise((r) => setTimeout(r, 5));
+            return `handled:${value}`;
+        });
+        await expect(a.emit(contract_transport_1.CONTRACT_REQUEST_CHANNEL, "x")).resolves.toBe("handled:x");
+    });
+    it("propagates a thrown handler error as a rejected emit", async () => {
+        const [a, b] = (0, contract_transport_1.inProcessTransportPair)();
+        b.on(contract_transport_1.CONTRACT_REQUEST_CHANNEL, () => {
+            throw new Error("boom");
+        });
+        await expect(a.emit(contract_transport_1.CONTRACT_REQUEST_CHANNEL, {})).rejects.toThrow("boom");
+    });
+    it("propagates a rejected async handler as a rejected emit", async () => {
+        const [a, b] = (0, contract_transport_1.inProcessTransportPair)();
+        b.on(contract_transport_1.CONTRACT_REQUEST_CHANNEL, async () => {
+            throw new Error("async-boom");
+        });
+        await expect(a.emit(contract_transport_1.CONTRACT_REQUEST_CHANNEL, {})).rejects.toThrow("async-boom");
+    });
+    it("resolves undefined when the peer has no handler for the channel", async () => {
+        const [a] = (0, contract_transport_1.inProcessTransportPair)();
+        await expect(a.emit("no-such-channel", 1)).resolves.toBeUndefined();
+    });
+    it("stops delivering after unsubscribe", async () => {
+        const [a, b] = (0, contract_transport_1.inProcessTransportPair)();
+        const handler = jest.fn(() => "ok");
+        const unsubscribe = b.on(contract_transport_1.CONTRACT_REQUEST_CHANNEL, handler);
+        await expect(a.emit(contract_transport_1.CONTRACT_REQUEST_CHANNEL, 1)).resolves.toBe("ok");
+        expect(handler).toHaveBeenCalledTimes(1);
+        unsubscribe();
+        await expect(a.emit(contract_transport_1.CONTRACT_REQUEST_CHANNEL, 1)).resolves.toBeUndefined();
+        expect(handler).toHaveBeenCalledTimes(1);
+    });
+    it("is bidirectional: either end can emit and handle", async () => {
+        const [a, b] = (0, contract_transport_1.inProcessTransportPair)();
+        a.on("ping", (msg) => `a-got:${msg}`);
+        b.on("ping", (msg) => `b-got:${msg}`);
+        // a -> b uses b's handler; b -> a uses a's handler.
+        await expect(a.emit("ping", "hi")).resolves.toBe("b-got:hi");
+        await expect(b.emit("ping", "yo")).resolves.toBe("a-got:yo");
+    });
+    it("supports provider->consumer pushes on the notify channel (fire-and-forget)", async () => {
+        const [consumer, provider] = (0, contract_transport_1.inProcessTransportPair)();
+        const received = [];
+        consumer.on(contract_transport_1.CONTRACT_NOTIFY_CHANNEL, (payload) => {
+            received.push(payload);
+        });
+        // The provider pushes and ignores the returned promise, exactly as a notification would.
+        void provider.emit(contract_transport_1.CONTRACT_NOTIFY_CHANNEL, { event: "changed", id: "abc" });
+        // The ack is still available if awaited, but pushes typically drop it.
+        await expect(provider.emit(contract_transport_1.CONTRACT_NOTIFY_CHANNEL, { event: "again" })).resolves.toBeUndefined();
+        expect(received).toEqual([{ event: "changed", id: "abc" }, { event: "again" }]);
+    });
+    it("rejects multiple request handlers instead of using last-result-wins", () => {
+        const [, provider] = (0, contract_transport_1.inProcessTransportPair)();
+        provider.on(contract_transport_1.CONTRACT_REQUEST_CHANNEL, () => "first");
+        expect(() => provider.on(contract_transport_1.CONTRACT_REQUEST_CHANNEL, () => "second")).toThrow(/one provider router/);
+    });
+});
+describe("connectionContractTransport", () => {
+    it("delegates emit to the underlying emitter", async () => {
+        const emit = jest.fn(async () => "result");
+        const emitter = { emit, on: jest.fn() };
+        const transport = (0, contract_transport_1.connectionContractTransport)(emitter);
+        await expect(transport.emit(contract_transport_1.CONTRACT_REQUEST_CHANNEL, { a: 1 })).resolves.toBe("result");
+        expect(emit).toHaveBeenCalledWith(contract_transport_1.CONTRACT_REQUEST_CHANNEL, { a: 1 });
+    });
+    it("removes only the requested handler from a shared channel dispatcher", async () => {
+        const listeners = new Map();
+        const on = jest.fn((channel, listener) => {
+            listeners.set(channel, listener);
+        });
+        const emitter = { emit: jest.fn(), on };
+        const transportA = (0, contract_transport_1.connectionContractTransport)(emitter);
+        const transportB = (0, contract_transport_1.connectionContractTransport)(emitter);
+        const handlerA = jest.fn();
+        const handlerB = jest.fn();
+        const unsubscribeA = transportA.on(contract_transport_1.CONTRACT_NOTIFY_CHANNEL, handlerA);
+        transportB.on(contract_transport_1.CONTRACT_NOTIFY_CHANNEL, handlerB);
+        expect(on).toHaveBeenCalledTimes(1);
+        await listeners.get(contract_transport_1.CONTRACT_NOTIFY_CHANNEL)?.("first");
+        expect(handlerA).toHaveBeenCalledWith("first");
+        expect(handlerB).toHaveBeenCalledWith("first");
+        unsubscribeA();
+        unsubscribeA();
+        await listeners.get(contract_transport_1.CONTRACT_NOTIFY_CHANNEL)?.("second");
+        expect(handlerA).toHaveBeenCalledTimes(1);
+        expect(handlerB).toHaveBeenLastCalledWith("second");
+    });
+    it("lets two consumers share notify traffic and dispose independently", async () => {
+        const listeners = new Map();
+        const emitter = {
+            emit: jest.fn(async () => undefined),
+            on: (channel, listener) => {
+                listeners.set(channel, listener);
+            },
+        };
+        const transport = (0, contract_transport_1.connectionContractTransport)(emitter);
+        const contract = {
+            contractId: (0, utils_1.newid)(),
+            version: 1,
+            devTag: "dev",
+            name: "Shared transport",
+            description: "Shared notify channel",
+            tables: [],
+            tools: [],
+            observables: [],
+            events: [
+                {
+                    name: "changed",
+                    description: "Changed",
+                    payloadFields: [{ name: "id", type: field_type_1.FieldType.id }],
+                },
+            ],
+        };
+        const consumerA = (0, contract_proxy_1.createContractConsumer)(contract, transport);
+        const consumerB = (0, contract_proxy_1.createContractConsumer)(contract, transport);
+        const receivedA = [];
+        const receivedB = [];
+        consumerA.events.changed.subscribe((value) => receivedA.push(value));
+        consumerB.events.changed.subscribe((value) => receivedB.push(value));
+        const subscribeCalls = emitter.emit.mock.calls
+            .filter(([channel, call]) => channel === contract_transport_1.CONTRACT_REQUEST_CHANNEL && call.operation === "subscribe")
+            .map(([, call]) => call);
+        const consumerASubscriptionId = subscribeCalls[0].subscriptionId;
+        const consumerBSubscriptionId = subscribeCalls[1].subscriptionId;
+        await listeners.get(contract_transport_1.CONTRACT_NOTIFY_CHANNEL)?.({
+            subscriptionId: consumerASubscriptionId,
+            value: "for-a",
+        });
+        expect(receivedA).toEqual(["for-a"]);
+        expect(receivedB).toEqual([]);
+        await listeners.get(contract_transport_1.CONTRACT_NOTIFY_CHANNEL)?.({
+            subscriptionId: consumerBSubscriptionId,
+            value: "before",
+        });
+        expect(receivedA).toEqual(["for-a"]);
+        expect(receivedB).toEqual(["before"]);
+        consumerA.dispose();
+        await listeners.get(contract_transport_1.CONTRACT_NOTIFY_CHANNEL)?.({
+            subscriptionId: consumerBSubscriptionId,
+            value: "after",
+        });
+        expect(receivedA).toEqual(["for-a"]);
+        expect(receivedB).toEqual(["before", "after"]);
+        consumerB.dispose();
+    });
+});

package/dist/contracts/__tests__/persistent-registry.test.d.ts

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

package/dist/contracts/__tests__/persistent-registry.test.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const field_type_1 = require("../../types/field-type");
+const utils_1 = require("../../utils");
+const contract_providers_table_1 = require("../contract-providers.table");
+const contracts_table_1 = require("../contracts.table");
+const persistent_registry_1 = require("../persistent-registry");
+const registry_1 = require("../registry");
+jest.mock("../contract-providers.table", () => ({ ContractProviders: jest.fn() }));
+jest.mock("../contracts.table", () => ({ Contracts: jest.fn() }));
+const contracts = contracts_table_1.Contracts;
+const contractProviders = contract_providers_table_1.ContractProviders;
+const dataContext = {};
+const contractRecords = [];
+const providerRecords = [];
+const contractsTable = {
+    findOne: jest.fn(async (filter) => contractRecords.find((record) => Object.entries(filter).every(([key, value]) => record[key] === value))),
+    list: jest.fn(async () => [...contractRecords]),
+    save: jest.fn(async (record) => {
+        const index = contractRecords.findIndex((existing) => existing.contractId === record.contractId && existing.version === record.version);
+        if (index >= 0) {
+            contractRecords[index] = record;
+        }
+        else {
+            contractRecords.push(record);
+        }
+        return record;
+    }),
+};
+const providersTable = {
+    findOne: jest.fn(async (filter) => providerRecords.find((record) => Object.entries(filter).every(([key, value]) => record[key] === value))),
+    list: jest.fn(async () => [...providerRecords]),
+    save: jest.fn(async (record) => {
+        const index = providerRecords.findIndex((existing) => existing.contractProviderId === record.contractProviderId);
+        if (index >= 0) {
+            providerRecords[index] = record;
+        }
+        else {
+            providerRecords.push(record);
+        }
+        return record;
+    }),
+};
+beforeEach(() => {
+    contractRecords.length = 0;
+    providerRecords.length = 0;
+    jest.clearAllMocks();
+    contracts.mockReturnValue(contractsTable);
+    contractProviders.mockReturnValue(providersTable);
+});
+function makeDefinition() {
+    return {
+        contractId: (0, utils_1.newid)(),
+        version: 1,
+        devTag: "dev",
+        name: "Event Contract",
+        description: "Persists events",
+        tables: [],
+        tools: [],
+        observables: [],
+        events: [
+            {
+                name: "widgetChanged",
+                description: "A widget changed",
+                payloadFields: [{ name: "widgetId", type: field_type_1.FieldType.id, description: "Changed widget" }],
+            },
+        ],
+    };
+}
+describe("PersistentContractRegistry event definitions", () => {
+    it("persists and hydrates event names, descriptions, and payload fields", async () => {
+        const definition = makeDefinition();
+        const providerPackageId = (0, utils_1.newid)();
+        const persistent = new persistent_registry_1.PersistentContractRegistry(new registry_1.ContractRegistry(), dataContext);
+        await persistent.persist(definition, providerPackageId, true);
+        expect(JSON.parse(contractRecords[0].shape).events).toEqual(definition.events);
+        const hydratedRegistry = new registry_1.ContractRegistry();
+        await new persistent_registry_1.PersistentContractRegistry(hydratedRegistry, dataContext).hydrate();
+        expect(hydratedRegistry.getDefinition(definition.contractId, definition.version)).toEqual(definition);
+    });
+    it("hydrates old persisted shapes without events as an empty event list", async () => {
+        const definition = makeDefinition();
+        const providerPackageId = (0, utils_1.newid)();
+        contractRecords.push({
+            contractId: definition.contractId,
+            version: definition.version,
+            devTag: definition.devTag,
+            name: definition.name,
+            description: definition.description,
+            shape: JSON.stringify({
+                tables: definition.tables,
+                tools: definition.tools,
+                observables: definition.observables,
+            }),
+            registeredAt: new Date(0).toISOString(),
+        });
+        providerRecords.push({
+            contractProviderId: (0, utils_1.newid)(),
+            contractId: definition.contractId,
+            version: definition.version,
+            providerPackageId,
+            isActive: true,
+            registeredAt: new Date(0).toISOString(),
+        });
+        const registry = new registry_1.ContractRegistry();
+        await new persistent_registry_1.PersistentContractRegistry(registry, dataContext).hydrate();
+        expect(registry.getDefinition(definition.contractId, definition.version)?.events).toEqual([]);
+    });
+});

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

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