@peers-app/peers-sdk 0.27.3 → 0.27.5

package/dist/contracts/__tests__/contract-subscription-lifecycle.test.d.ts

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

package/dist/contracts/__tests__/contract-subscription-lifecycle.test.js

@@ -1,353 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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");
-function deferred() {
-    let resolve;
-    const promise = new Promise((resolvePromise) => {
-        resolve = resolvePromise;
-    });
-    return { promise, resolve };
-}
-function trackedEvent() {
-    const handlers = new Set();
-    const event = {
-        subscribe: jest.fn((handler) => {
-            handlers.add(handler);
-            let active = true;
-            return {
-                unsubscribe: () => {
-                    if (!active) {
-                        return false;
-                    }
-                    active = false;
-                    return handlers.delete(handler);
-                },
-            };
-        }),
-    };
-    return {
-        event,
-        activeCount: () => handlers.size,
-        emit: async (value) => {
-            for (const handler of [...handlers]) {
-                await handler(value);
-            }
-        },
-    };
-}
-function trackedObservable(initialValue) {
-    const source = (0, observable_1.observable)(initialValue);
-    const subscribe = source.subscribe;
-    let activeCount = 0;
-    source.subscribe = (handler) => {
-        activeCount += 1;
-        const subscription = subscribe(handler);
-        let active = true;
-        return {
-            dispose: () => {
-                if (!active) {
-                    return;
-                }
-                active = false;
-                activeCount -= 1;
-                subscription.dispose();
-            },
-        };
-    };
-    return { source, activeCount: () => activeCount };
-}
-async function settleTransport(emitSpy) {
-    let previousCount = -1;
-    while (previousCount !== emitSpy.mock.results.length) {
-        previousCount = emitSpy.mock.results.length;
-        const pending = emitSpy.mock.results
-            .map((result) => result.value)
-            .filter((value) => value instanceof Promise);
-        await Promise.allSettled(pending);
-        await Promise.resolve();
-    }
-}
-const cleanups = [];
-afterEach(() => {
-    for (const cleanup of cleanups.splice(0).reverse()) {
-        cleanup();
-    }
-    jest.restoreAllMocks();
-});
-function makeHarness(opts = {}) {
-    const contractId = (0, utils_1.newid)();
-    const generic = trackedEvent();
-    const tableChanged = trackedEvent();
-    const count = trackedObservable(0);
-    const list = jest.fn(async () => []);
-    const run = jest.fn(async () => "ok");
-    const contract = {
-        contractId,
-        version: 1,
-        devTag: "dev",
-        name: "Lifecycle Contract",
-        description: "Exercises every subscription surface",
-        tables: [
-            {
-                name: "Widgets",
-                description: "Widgets",
-                primaryKeyName: "id",
-                fields: [{ name: "id", type: field_type_1.FieldType.id }],
-            },
-        ],
-        tools: [
-            {
-                name: "run",
-                usageDescription: "Run",
-                inputFields: [],
-                outputFields: [],
-            },
-        ],
-        observables: [
-            {
-                name: "count",
-                description: "Count",
-                valueType: field_type_1.FieldType.number,
-                writable: true,
-            },
-        ],
-        events: [
-            {
-                name: "changed",
-                description: "Changed",
-                payloadFields: [{ name: "id", type: field_type_1.FieldType.id }],
-            },
-        ],
-    };
-    const resolution = {
-        contractId,
-        version: 1,
-        tables: {
-            Widgets: { dataChanged: tableChanged.event, list },
-        },
-        tools: {
-            run: {
-                tool: { toolId: (0, utils_1.newid)(), name: "run" },
-                toolFn: run,
-            },
-        },
-        observables: { count: count.source },
-        observableWritability: { count: true },
-        events: { changed: generic.event },
-    };
-    const [consumerTransport, providerTransport] = (0, contract_transport_1.inProcessTransportPair)();
-    const emitSpy = jest.spyOn(consumerTransport, "emit");
-    const session = (0, contract_proxy_1.createContractProviderSession)(resolution, providerTransport, {
-        permissionCheck: opts.permissionCheck,
-    });
-    const consumer = (0, contract_proxy_1.createContractConsumer)(contract, consumerTransport);
-    cleanups.push(() => {
-        consumer.dispose();
-        session.dispose();
-    });
-    return {
-        consumer,
-        session,
-        generic,
-        tableChanged,
-        count,
-        emitSpy,
-        consumerTransport,
-        providerTransport,
-        contractId,
-    };
-}
-describe("contract subscription lifecycle — consumer teardown", () => {
-    it("detaches generic, table, and observable provider subscriptions", async () => {
-        const { consumer, generic, tableChanged, count, emitSpy } = makeHarness();
-        consumer.events.changed.subscribe(() => { });
-        consumer.tables.Widgets.dataChanged.subscribe(() => { });
-        await consumer.loadingPromise;
-        expect(generic.activeCount()).toBe(1);
-        expect(tableChanged.activeCount()).toBe(1);
-        expect(count.activeCount()).toBe(1);
-        consumer.dispose();
-        await settleTransport(emitSpy);
-        expect(generic.activeCount()).toBe(0);
-        expect(tableChanged.activeCount()).toBe(0);
-        expect(count.activeCount()).toBe(0);
-    });
-    it("is idempotent and sends each wire unsubscribe at most once", async () => {
-        const { consumer, emitSpy } = makeHarness();
-        consumer.events.changed.subscribe(() => { });
-        await consumer.loadingPromise;
-        consumer.dispose();
-        consumer.dispose();
-        await settleTransport(emitSpy);
-        const unsubscribeCalls = emitSpy.mock.calls.filter(([channel, call]) => channel === contract_transport_1.CONTRACT_REQUEST_CHANNEL && call.operation === "unsubscribe");
-        expect(unsubscribeCalls).toHaveLength(2);
-    });
-    it("returns false and emits nothing for a repeated event unsubscribe", async () => {
-        const { consumer, emitSpy } = makeHarness();
-        const subscription = consumer.events.changed.subscribe(() => { });
-        await settleTransport(emitSpy);
-        emitSpy.mockClear();
-        expect(subscription.unsubscribe()).toBe(true);
-        expect(subscription.unsubscribe()).toBe(false);
-        await settleTransport(emitSpy);
-        const unsubscribeCalls = emitSpy.mock.calls
-            .map(([, call]) => call)
-            .filter((call) => call.name === "changed" && call.operation === "unsubscribe");
-        expect(unsubscribeCalls).toHaveLength(1);
-    });
-    it("rejects new remote operations and writes after disposal without emitting", async () => {
-        const { consumer, emitSpy } = makeHarness();
-        await consumer.loadingPromise;
-        expect(consumer.observables.count()).toBe(0);
-        consumer.dispose();
-        await settleTransport(emitSpy);
-        emitSpy.mockClear();
-        await expect(consumer.tables.Widgets.list()).rejects.toThrow(/consumer .* disposed/i);
-        await expect(consumer.tools.run()).rejects.toThrow(/consumer .* disposed/i);
-        expect(() => consumer.events.changed.subscribe(() => { })).toThrow(/consumer .* disposed/i);
-        expect(() => consumer.tables.Widgets.dataChanged.subscribe(() => { })).toThrow(/consumer .* disposed/i);
-        expect(() => consumer.observables.count(1)).toThrow(/consumer .* disposed/i);
-        expect(consumer.observables.count()).toBe(0);
-        expect(emitSpy).not.toHaveBeenCalled();
-    });
-});
-describe("contract subscription lifecycle — ordering and failures", () => {
-    it("queues immediate unsubscribe behind a delayed subscribe acknowledgement", async () => {
-        const permissionStarted = deferred();
-        const permissionResult = deferred();
-        const permissionCheck = async (call) => {
-            if (call.operation === "subscribe") {
-                permissionStarted.resolve();
-                return permissionResult.promise;
-            }
-            return true;
-        };
-        const { consumer, generic, emitSpy } = makeHarness({ permissionCheck });
-        const subscription = consumer.events.changed.subscribe(() => { });
-        await permissionStarted.promise;
-        expect(subscription.unsubscribe()).toBe(true);
-        expect(generic.activeCount()).toBe(0);
-        permissionResult.resolve(true);
-        await settleTransport(emitSpy);
-        expect(generic.activeCount()).toBe(0);
-        const operations = emitSpy.mock.calls
-            .filter(([channel]) => channel === contract_transport_1.CONTRACT_REQUEST_CHANNEL)
-            .map(([, call]) => call.operation)
-            .filter((operation) => operation === "subscribe" || operation === "unsubscribe");
-        expect(operations).toEqual(["subscribe", "subscribe", "unsubscribe"]);
-    });
-    it("does not unsubscribe after a failed subscribe", async () => {
-        const consoleError = jest.spyOn(console, "error").mockImplementation();
-        const permissionStarted = deferred();
-        const permissionResult = deferred();
-        const permissionCheck = async (call) => {
-            if (call.operation === "subscribe") {
-                permissionStarted.resolve();
-                return permissionResult.promise;
-            }
-            return true;
-        };
-        const { consumer, generic, emitSpy } = makeHarness({ permissionCheck });
-        const subscription = consumer.events.changed.subscribe(() => { });
-        await permissionStarted.promise;
-        subscription.unsubscribe();
-        consumer.dispose();
-        permissionResult.resolve(false);
-        await settleTransport(emitSpy);
-        expect(generic.activeCount()).toBe(0);
-        const changedCalls = emitSpy.mock.calls
-            .map(([, call]) => call)
-            .filter((call) => call.name === "changed");
-        expect(changedCalls.map((call) => call.operation)).toEqual(["subscribe"]);
-        expect(consoleError).toHaveBeenCalledWith("Contract subscribe failed", expect.objectContaining({ message: expect.stringMatching(/Permission denied/) }));
-    });
-});
-describe("contract subscription lifecycle — provider protocol", () => {
-    it("rejects duplicate subscription ids without corrupting the existing refcount", async () => {
-        const { generic, consumerTransport, contractId } = makeHarness();
-        const subscriptionId = (0, utils_1.newid)();
-        const call = {
-            contractId,
-            version: 1,
-            member: "event",
-            name: "changed",
-            operation: "subscribe",
-            subscriptionId,
-            args: [],
-        };
-        await consumerTransport.emit(contract_transport_1.CONTRACT_REQUEST_CHANNEL, call);
-        await expect(consumerTransport.emit(contract_transport_1.CONTRACT_REQUEST_CHANNEL, call)).rejects.toThrow(/Duplicate contract subscriptionId/);
-        expect(generic.activeCount()).toBe(1);
-        await consumerTransport.emit(contract_transport_1.CONTRACT_REQUEST_CHANNEL, {
-            ...call,
-            operation: "unsubscribe",
-            subscriptionId: (0, utils_1.newid)(),
-        });
-        expect(generic.activeCount()).toBe(1);
-        await consumerTransport.emit(contract_transport_1.CONTRACT_REQUEST_CHANNEL, {
-            ...call,
-            operation: "unsubscribe",
-        });
-        expect(generic.activeCount()).toBe(0);
-    });
-    it("rejects missing ids and unsupported member/operation combinations", async () => {
-        const { consumerTransport, contractId } = makeHarness();
-        const base = {
-            contractId,
-            version: 1,
-            name: "changed",
-            args: [],
-        };
-        await expect(consumerTransport.emit(contract_transport_1.CONTRACT_REQUEST_CHANNEL, {
-            ...base,
-            member: "event",
-            operation: "subscribe",
-        })).rejects.toThrow(/requires a subscriptionId/);
-        await expect(consumerTransport.emit(contract_transport_1.CONTRACT_REQUEST_CHANNEL, {
-            ...base,
-            member: "tool",
-            operation: "subscribe",
-            subscriptionId: (0, utils_1.newid)(),
-        })).rejects.toThrow(/does not support subscriptions/);
-        await expect(consumerTransport.emit(contract_transport_1.CONTRACT_REQUEST_CHANNEL, {
-            ...base,
-            member: "event",
-            operation: "get",
-            subscriptionId: (0, utils_1.newid)(),
-        })).rejects.toThrow(/Unsupported subscription operation/);
-        await expect(consumerTransport.emit(contract_transport_1.CONTRACT_REQUEST_CHANNEL, {
-            ...base,
-            member: "table",
-            name: "Widgets",
-            operation: "subscribe",
-            event: "privateEvent",
-            subscriptionId: (0, utils_1.newid)(),
-        })).rejects.toThrow(/Unsupported table event/);
-    });
-    it("isolates a rejected notify so later subscribers still receive the payload", async () => {
-        const consoleError = jest.spyOn(console, "error").mockImplementation();
-        const { consumer, generic, emitSpy } = makeHarness();
-        consumer.events.changed.subscribe(() => {
-            throw new Error("first handler failed");
-        });
-        const received = [];
-        consumer.events.changed.subscribe((value) => received.push(value));
-        await settleTransport(emitSpy);
-        await generic.emit({ id: "w1" });
-        await Promise.resolve();
-        expect(received).toEqual([{ id: "w1" }]);
-        expect(consoleError).toHaveBeenCalledWith(expect.stringMatching(/Contract notify failed/), expect.objectContaining({ message: "first handler failed" }));
-    });
-    it("allows provider session disposal more than once", () => {
-        const { session, generic } = makeHarness();
-        expect(() => {
-            session.dispose();
-            session.dispose();
-        }).not.toThrow();
-        expect(generic.activeCount()).toBe(0);
-    });
-});

package/dist/contracts/__tests__/contract-table-events.test.d.ts

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

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

@@ -1,209 +0,0 @@
-"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

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