@peers-app/peers-sdk 0.19.13 → 0.20.0

package/dist/contracts/__tests__/playground.test.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * SCRATCH / PLAYGROUND — not a curated part of the suite.
+ *
+ * A place to hand-write contract *provider* (impl side) and *consumer* (caller
+ * side) tests and feel out the ergonomics. Rename, rewrite, or delete freely.
+ *
+ * Run just this file:
+ *   cd peers-sdk && npx jest playground
+ * Watch it:
+ *   cd peers-sdk && npx jest --watch playground
+ */
+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");
+const cleanups = [];
+afterEach(() => {
+    for (const cleanup of cleanups.splice(0).reverse()) {
+        cleanup();
+    }
+});
+/**
+ * Build a consumer wired in-process to a provider *session* (via a transport pair).
+ *
+ * The session (not the stateless `createContractProvider`) is what a consumer should face:
+ * it serves request/response dispatch *and* the subscription/streaming traffic that every
+ * consumer now opens implicitly (observable mirrors fire a `subscribe` at construction, and
+ * the session is what can push updates back on the notify channel). Returns the live session
+ * too so a test can `session.dispose()`.
+ */
+function inProcessConsumer(contract, resolution, opts = {}) {
+    const [consumerTransport, providerTransport] = (0, contract_transport_1.inProcessTransportPair)();
+    const session = (0, contract_proxy_1.createContractProviderSession)(resolution, providerTransport, opts);
+    const consumer = (0, contract_proxy_1.createContractConsumer)(contract, consumerTransport);
+    cleanups.push(() => {
+        consumer.dispose();
+        session.dispose();
+    });
+    return { consumer, session };
+}
+const CONTRACT_ID = "00mrbloudwk9svfxd42oyxqhi";
+/** The contract *shape* a consumer sees: one table, one tool, one observable. */
+function makeContract() {
+    return {
+        contractId: CONTRACT_ID,
+        version: 1,
+        devTag: "dev",
+        name: "Playground Contract",
+        description: "Scratch space",
+        tables: [
+            {
+                name: "Widgets",
+                description: "Widget table",
+                primaryKeyName: "widgetId",
+                fields: [{ name: "widgetId", type: field_type_1.FieldType.id, description: "PK" }],
+            },
+        ],
+        tools: [
+            {
+                name: "make-widget",
+                usageDescription: "Makes a widget",
+                inputFields: [{ name: "color", type: field_type_1.FieldType.string, description: "Color" }],
+                outputFields: [{ name: "widgetId", type: field_type_1.FieldType.id, description: "ID" }],
+            },
+        ],
+        observables: [
+            { name: "widgetCount", description: "Count", valueType: field_type_1.FieldType.number, writable: true },
+        ],
+    };
+}
+/** A live, in-memory implementation the *provider* dispatches to. */
+function makeResolution() {
+    const rows = [];
+    const table = {
+        list: async (filter = {}) => rows.filter((r) => Object.entries(filter).every(([k, v]) => r[k] === v)),
+        get: async (id) => rows.find((r) => r.widgetId === id),
+        save: async (record) => {
+            rows.push(record);
+            return record;
+        },
+    };
+    const makeWidget = async ({ color }) => ({ widgetId: (0, utils_1.newid)(), color });
+    const widgetCount = (0, observable_1.observable)(0);
+    const resolution = {
+        contractId: CONTRACT_ID,
+        version: 1,
+        tables: { Widgets: table },
+        tools: {
+            "make-widget": { tool: { toolId: (0, utils_1.newid)(), name: "make-widget" }, toolFn: makeWidget },
+        },
+        observables: { widgetCount },
+        observableWritability: { widgetCount: true },
+    };
+    return { resolution, table, makeWidget, widgetCount, rows };
+}
+/** Wire a consumer straight to a provider session, in-process (over a transport pair). */
+function wire() {
+    const contract = makeContract();
+    const { resolution, ...rest } = makeResolution();
+    const { consumer, session } = inProcessConsumer(contract, resolution);
+    return { consumer, session, contract, ...rest };
+}
+describe("playground", () => {
+    it("round-trips a save through consumer -> provider -> live table", async () => {
+        const { consumer } = wire();
+        const saved = await consumer.tables.Widgets.save({ widgetId: "w1", color: "red" });
+        expect(saved).toEqual({ widgetId: "w1", color: "red" });
+        const listed = await consumer.tables.Widgets.list({ color: "red" });
+        expect(listed).toEqual([{ widgetId: "w1", color: "red" }]);
+    });
+    // Start fiddling here — try a tool call, observable get/set, permission
+    // checks (sameUserContractPermissionCheck), or swap in your own contract shape.
+    it("keeps compatible contract versions isolated and reactive", async () => {
+        const logs = [];
+        let lastLogTime;
+        const inc = (0, observable_1.observable)(0);
+        const logCountObs = (0, observable_1.computed)(() => {
+            inc();
+            return logs.length;
+        });
+        const lastLogTimeObs = (0, observable_1.computed)(() => {
+            inc();
+            return lastLogTime;
+        });
+        const logTextFn = (text) => {
+            logs.push(text);
+            lastLogTime = Date.now();
+            inc(inc() + 1);
+            return logs.length - 1;
+        };
+        const logsContractV1 = {
+            contractId: CONTRACT_ID,
+            version: 1,
+            devTag: "dev",
+            name: "Playground Contract",
+            description: "Scratch space",
+            tables: [],
+            tools: [
+                {
+                    name: "logText",
+                    usageDescription: "logs text",
+                    inputFields: [{ name: "text", type: field_type_1.FieldType.string }],
+                    outputFields: [{ name: "logId", type: field_type_1.FieldType.id, description: "log id" }],
+                },
+            ],
+            observables: [
+                { name: "logCount", description: "Count", valueType: field_type_1.FieldType.number, writable: false },
+            ],
+        };
+        const providerV1 = {
+            contractId: CONTRACT_ID,
+            version: 1,
+            tools: {
+                logText: { tool: { toolId: "", name: "logText" }, toolFn: logTextFn },
+            },
+            observables: { logCount: logCountObs },
+            observableWritability: { logCount: false },
+        };
+        const logsContractV2 = {
+            ...logsContractV1,
+            version: 2,
+            devTag: "dev",
+            observables: [
+                ...logsContractV1.observables,
+                {
+                    name: "lastLogTime",
+                    description: "last time a log was written",
+                    valueType: field_type_1.FieldType.number,
+                    writable: false,
+                },
+            ],
+        };
+        const providerV2 = {
+            ...providerV1,
+            version: 2,
+            observables: {
+                ...providerV1.observables,
+                lastLogTime: lastLogTimeObs,
+            },
+            observableWritability: {
+                ...providerV1.observableWritability,
+                lastLogTime: false,
+            },
+        };
+        const { consumer: consumerV1 } = inProcessConsumer(logsContractV1, providerV1);
+        const { consumer: consumerV2 } = inProcessConsumer(logsContractV2, providerV2);
+        await Promise.all([consumerV1.loadingPromise, consumerV2.loadingPromise]);
+        await consumerV1.tools.logText("log1");
+        expect(logs).toEqual(["log1"]);
+        let observedLogCount = consumerV1.observables.logCount();
+        expect(observedLogCount).toBe(1);
+        let resolveSecondLog;
+        const secondLogObserved = new Promise((resolve) => {
+            resolveSecondLog = resolve;
+        });
+        const observedSub = consumerV2.observables.logCount.subscribe((value) => {
+            observedLogCount = value;
+            if (value === 2) {
+                resolveSecondLog();
+            }
+        });
+        cleanups.push(() => observedSub.dispose());
+        await consumerV2.tools.logText("log2");
+        await secondLogObserved;
+        expect(logs).toEqual(["log1", "log2"]);
+        expect(observedLogCount).toBe(2);
+        // TODO test tables so we can see what this looks like and how it works for both providers and consumers
+        // TODO consider renaming ContractResolution to ContractProviderInstance or something like that.  ContractResolution is awkward.  
+    });
+});

package/dist/contracts/__tests__/validate.test.js

@@ -15,6 +15,7 @@ function makeContract(overrides = {}) {
         tables: [],
         tools: [],
         observables: [],
+        events: [],
         ...overrides,
     };
 }
@@ -457,6 +458,76 @@ describe("validateProviderSatisfiesContract", () => {
             expect(result.errors[0].message).toContain("writable");
         });
     });
+    describe("events", () => {
+        it("passes when an implementation event has compatible payload fields", () => {
+            const contract = makeContract({
+                events: [
+                    {
+                        name: "taskChanged",
+                        description: "A task changed",
+                        payloadFields: [{ name: "taskId", type: field_type_1.FieldType.id }],
+                    },
+                ],
+            });
+            const impl = makeContract({
+                events: [
+                    {
+                        name: "taskChanged",
+                        description: "A task changed",
+                        payloadFields: [
+                            { name: "taskId", type: field_type_1.FieldType.id },
+                            { name: "source", type: field_type_1.FieldType.string, optional: true },
+                        ],
+                    },
+                ],
+            });
+            expect((0, validate_1.validateProviderSatisfiesContract)(impl, contract)).toEqual({
+                valid: true,
+                errors: [],
+            });
+        });
+        it("fails when a required event is missing", () => {
+            const contract = makeContract({
+                events: [
+                    {
+                        name: "taskChanged",
+                        description: "A task changed",
+                        payloadFields: [],
+                    },
+                ],
+            });
+            const result = (0, validate_1.validateProviderSatisfiesContract)(makeContract(), contract);
+            expect(result.valid).toBe(false);
+            expect(result.errors[0]).toEqual(expect.objectContaining({ kind: "event", name: "taskChanged" }));
+        });
+        it("fails when an event payload field is incompatible", () => {
+            const contract = makeContract({
+                events: [
+                    {
+                        name: "taskChanged",
+                        description: "A task changed",
+                        payloadFields: [{ name: "taskId", type: field_type_1.FieldType.id }],
+                    },
+                ],
+            });
+            const impl = makeContract({
+                events: [
+                    {
+                        name: "taskChanged",
+                        description: "A task changed",
+                        payloadFields: [{ name: "taskId", type: field_type_1.FieldType.number }],
+                    },
+                ],
+            });
+            const result = (0, validate_1.validateProviderSatisfiesContract)(impl, contract);
+            expect(result.valid).toBe(false);
+            expect(result.errors[0]).toEqual(expect.objectContaining({
+                kind: "field",
+                name: "taskChanged.payload.taskId",
+                message: expect.stringMatching(/type mismatch/),
+            }));
+        });
+    });
 });
 describe("validateImmutability", () => {
     it("allows any change for dev contracts", () => {
@@ -543,6 +614,57 @@ describe("validateImmutability", () => {
         expect(result.valid).toBe(false);
         expect(result.errors[0].message).toContain("frozen");
     });
+    it.each([
+        [
+            "addition",
+            [
+                {
+                    name: "taskChanged",
+                    description: "A task changed",
+                    payloadFields: [{ name: "taskId", type: field_type_1.FieldType.id }],
+                },
+                {
+                    name: "taskDeleted",
+                    description: "A task was deleted",
+                    payloadFields: [{ name: "taskId", type: field_type_1.FieldType.id }],
+                },
+            ],
+        ],
+        ["removal", []],
+        [
+            "rename",
+            [
+                {
+                    name: "taskUpdated",
+                    description: "A task changed",
+                    payloadFields: [{ name: "taskId", type: field_type_1.FieldType.id }],
+                },
+            ],
+        ],
+        [
+            "payload change",
+            [
+                {
+                    name: "taskChanged",
+                    description: "A task changed",
+                    payloadFields: [{ name: "taskId", type: field_type_1.FieldType.number }],
+                },
+            ],
+        ],
+    ])("rejects frozen event %s", (_change, incomingEvents) => {
+        const existing = makeContract({
+            events: [
+                {
+                    name: "taskChanged",
+                    description: "A task changed",
+                    payloadFields: [{ name: "taskId", type: field_type_1.FieldType.id }],
+                },
+            ],
+        });
+        const result = (0, validate_1.validateImmutability)(existing, makeContract({ events: incomingEvents }));
+        expect(result.valid).toBe(false);
+        expect(result.errors[0].message).toContain("frozen");
+    });
 });
 describe("validateAlsoImplements", () => {
     const contractStore = new Map();

package/dist/contracts/builder.d.ts

@@ -1,7 +1,7 @@
 import type { ITableDefinition } from "../data/orm/table-definitions.type";
 import type { IToolInstance } from "../data/tools";
 import type { IExtractableTableDef, IExtractableToolInstance } from "./extract";
-import type { IAlsoImplementsDeclaration, IContractDefinition, IContractObservable, IPackageDefinitionResult } from "./types";
+import type { IAlsoImplementsDeclaration, IContractDefinition, IContractEvent, IContractObservable, IPackageDefinitionResult } from "./types";
 /**
  * Scoped builder for a single contract within a package. Returned by
  * `PackageBuilder.contract()`.
@@ -14,6 +14,7 @@ export declare class ContractBuilder {
     private _tables;
     private _tools;
     private _observables;
+    private _events;
     private _alsoImplements;
     /** Full runtime tool instances for this contract (used by the install flow). */
     private _toolInstances;
@@ -26,6 +27,13 @@ export declare class ContractBuilder {
     get tools(): IExtractableToolInstance[];
     set observables(obs: IContractObservable[]);
     get observables(): IContractObservable[];
+    /**
+     * Events this contract may emit. Shape only — the live {@link Event} for each is
+     * supplied by the provider at resolution time (in `IContractResolution.events`),
+     * not here.
+     */
+    set events(events: IContractEvent[]);
+    get events(): IContractEvent[];
     /** Full tool instances with executable toolFn for runtime registration. */
     set toolInstances(instances: IToolInstance[]);
     get toolInstances(): IToolInstance[];

package/dist/contracts/builder.js

@@ -17,6 +17,7 @@ class ContractBuilder {
     _tables = [];
     _tools = [];
     _observables = [];
+    _events = [];
     _alsoImplements = [];
     /** Full runtime tool instances for this contract (used by the install flow). */
     _toolInstances = [];
@@ -46,6 +47,17 @@ class ContractBuilder {
     get observables() {
         return this._observables;
     }
+    /**
+     * Events this contract may emit. Shape only — the live {@link Event} for each is
+     * supplied by the provider at resolution time (in `IContractResolution.events`),
+     * not here.
+     */
+    set events(events) {
+        this._events = events;
+    }
+    get events() {
+        return this._events;
+    }
     /** Full tool instances with executable toolFn for runtime registration. */
     set toolInstances(instances) {
         this._toolInstances = instances;
@@ -82,6 +94,7 @@ class ContractBuilder {
                 tables: this._tables.map(extract_1.extractTableShape),
                 tools: this._tools.map(extract_1.extractToolShape),
                 observables: [...this._observables],
+                events: [...this._events],
             },
             alsoImplements: [...this._alsoImplements],
             toolInstances: [...this._toolInstances],

package/dist/contracts/contract-provider-router.d.ts

@@ -0,0 +1,72 @@
+import type { ContractNotificationSink, IContractCall, IContractCallContext, IContractProviderEndpoint } from "./contract-proxy";
+import { type IContractTransport } from "./contract-transport";
+/**
+ * The trusted host's authorization result for one inbound contract call.
+ *
+ * `dataContextId` is the canonical route chosen by the host. Returning the same
+ * value for an omitted personal context and an explicitly named personal context
+ * makes both calls share one cached provider endpoint.
+ */
+export interface IAuthorizedContractRoute {
+    /** Canonical data-context route selected by the trusted host. */
+    dataContextId?: string;
+    /** Optional caller context to pass to the resolved endpoint. */
+    context?: IContractCallContext;
+}
+/**
+ * Authorizes one inbound call before any provider resolver runs.
+ *
+ * Throw or reject to deny. The hook must derive authority from trusted transport
+ * state rather than caller-supplied identity fields.
+ */
+export type ContractCallAuthorizer = (call: IContractCall, context: IContractCallContext) => IAuthorizedContractRoute | Promise<IAuthorizedContractRoute>;
+/** Input supplied when the router needs a provider endpoint for a new route. */
+export interface IContractProviderEndpointRequest {
+    /** Target contract id. */
+    contractId: string;
+    /** Target contract version. */
+    version: number;
+    /** Canonical data context returned by the authorization hook. */
+    dataContextId?: string;
+    /** Authorized caller context for this route. */
+    context: IContractCallContext;
+    /** Sink for provider-to-consumer subscription notifications. */
+    notify: ContractNotificationSink;
+}
+/**
+ * Resolves an endpoint for an authorized contract/version/data-context route.
+ *
+ * The callback may adapt local live objects or return a remote/sandbox-backed
+ * endpoint. The router caches the result until disposal.
+ */
+export type ContractProviderEndpointResolver = (request: IContractProviderEndpointRequest) => IContractProviderEndpoint | Promise<IContractProviderEndpoint>;
+/** Options for {@link createContractProviderRouter}. */
+export interface IContractProviderRouterOptions {
+    /** Trusted host gate invoked before endpoint lookup or provider resolution. */
+    authorizeCall: ContractCallAuthorizer;
+    /** Resolves an endpoint after authorization succeeds. */
+    resolveEndpoint: ContractProviderEndpointResolver;
+    /** Caller identity derived from the trusted underlying connection/session. */
+    context?: IContractCallContext;
+}
+/** A connection-wide owner of contract request routing and endpoint lifecycle. */
+export interface IContractProviderRouter {
+    /** Remove the request handler and dispose every resolved provider endpoint. */
+    dispose(): void;
+}
+/**
+ * Own the sole {@link CONTRACT_REQUEST_CHANNEL} handler for a shared connection.
+ *
+ * Every ordinary call and subscribe is authorized before endpoint resolution. Caller
+ * context comes only from `opts.context`; additional transport arguments are ignored so a
+ * peer cannot override trusted connection identity. Endpoints are lazily cached by normalized
+ * contract/version/data-context route and may therefore serve many request/response calls
+ * and subscriptions. Successful subscriptions are indexed by id so unsubscribe can remain
+ * idempotent and skip reauthorization while still reaching the endpoint that owns the live
+ * source. Disposing the router removes its request handler and disposes all cached endpoints,
+ * including endpoints whose asynchronous resolution finishes during teardown.
+ *
+ * @param transport  Duplex contract transport shared by all contracts on one connection.
+ * @param opts       Trusted authorization, endpoint resolution, and caller context hooks.
+ */
+export declare function createContractProviderRouter(transport: IContractTransport, opts: IContractProviderRouterOptions): IContractProviderRouter;

package/dist/contracts/contract-provider-router.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createContractProviderRouter = createContractProviderRouter;
+const contract_transport_1 = require("./contract-transport");
+const routeKey = (contractId, version, dataContextId) => JSON.stringify([contractId, version, dataContextId ?? null]);
+/**
+ * Own the sole {@link CONTRACT_REQUEST_CHANNEL} handler for a shared connection.
+ *
+ * Every ordinary call and subscribe is authorized before endpoint resolution. Caller
+ * context comes only from `opts.context`; additional transport arguments are ignored so a
+ * peer cannot override trusted connection identity. Endpoints are lazily cached by normalized
+ * contract/version/data-context route and may therefore serve many request/response calls
+ * and subscriptions. Successful subscriptions are indexed by id so unsubscribe can remain
+ * idempotent and skip reauthorization while still reaching the endpoint that owns the live
+ * source. Disposing the router removes its request handler and disposes all cached endpoints,
+ * including endpoints whose asynchronous resolution finishes during teardown.
+ *
+ * @param transport  Duplex contract transport shared by all contracts on one connection.
+ * @param opts       Trusted authorization, endpoint resolution, and caller context hooks.
+ */
+function createContractProviderRouter(transport, opts) {
+    const endpointEntries = new Map();
+    const subscriptionRoutes = new Map();
+    const pendingSubscriptionIds = new Set();
+    const cancelledPendingSubscriptionIds = new Set();
+    let disposed = false;
+    const notify = (notification) => {
+        if (disposed) {
+            return Promise.reject(new Error("Contract provider router is disposed"));
+        }
+        return transport.emit(contract_transport_1.CONTRACT_NOTIFY_CHANNEL, notification);
+    };
+    const getEndpoint = (key, request) => {
+        const cached = endpointEntries.get(key);
+        if (cached) {
+            return cached.promise;
+        }
+        const entry = {};
+        entry.promise = Promise.resolve()
+            .then(() => opts.resolveEndpoint(request))
+            .then((endpoint) => {
+            entry.endpoint = endpoint;
+            if (disposed) {
+                endpoint.dispose();
+                throw new Error("Contract provider router is disposed");
+            }
+            return endpoint;
+        })
+            .catch((error) => {
+            if (endpointEntries.get(key) === entry) {
+                endpointEntries.delete(key);
+            }
+            throw error;
+        });
+        endpointEntries.set(key, entry);
+        return entry.promise;
+    };
+    const handleUnsubscribe = async (call) => {
+        if (!call.subscriptionId) {
+            throw new Error(`${call.member} '${call.name}'.unsubscribe requires a subscriptionId`);
+        }
+        const route = subscriptionRoutes.get(call.subscriptionId);
+        if (!route) {
+            if (pendingSubscriptionIds.has(call.subscriptionId)) {
+                cancelledPendingSubscriptionIds.add(call.subscriptionId);
+            }
+            return;
+        }
+        subscriptionRoutes.delete(call.subscriptionId);
+        const entry = endpointEntries.get(route.endpointKey);
+        if (!entry) {
+            return;
+        }
+        const endpoint = await entry.promise;
+        await endpoint.handleCall(route.unsubscribeCall, route.context);
+    };
+    const handleAuthorizedCall = async (call) => {
+        if (disposed) {
+            throw new Error("Contract provider router is disposed");
+        }
+        if (call.operation === "unsubscribe") {
+            return handleUnsubscribe(call);
+        }
+        const isSubscribe = call.operation === "subscribe";
+        const subscriptionId = call.subscriptionId;
+        if (isSubscribe &&
+            subscriptionId &&
+            (subscriptionRoutes.has(subscriptionId) || pendingSubscriptionIds.has(subscriptionId))) {
+            throw new Error(`Duplicate contract subscriptionId '${subscriptionId}'`);
+        }
+        if (isSubscribe && subscriptionId) {
+            pendingSubscriptionIds.add(subscriptionId);
+        }
+        try {
+            const inboundContext = opts.context ?? {};
+            const authorization = await opts.authorizeCall(call, inboundContext);
+            if (disposed) {
+                throw new Error("Contract provider router is disposed");
+            }
+            const context = authorization.context ?? inboundContext;
+            const routedCall = {
+                ...call,
+                dataContextId: authorization.dataContextId,
+            };
+            const endpointKey = routeKey(call.contractId, call.version, authorization.dataContextId);
+            const endpoint = await getEndpoint(endpointKey, {
+                contractId: call.contractId,
+                version: call.version,
+                dataContextId: authorization.dataContextId,
+                context,
+                notify,
+            });
+            const result = await endpoint.handleCall(routedCall, context);
+            if (isSubscribe && subscriptionId) {
+                const subscriptionRoute = {
+                    endpointKey,
+                    context,
+                    unsubscribeCall: {
+                        ...routedCall,
+                        operation: "unsubscribe",
+                        args: [],
+                    },
+                };
+                if (cancelledPendingSubscriptionIds.has(subscriptionId)) {
+                    if (!disposed) {
+                        await endpoint.handleCall(subscriptionRoute.unsubscribeCall, context);
+                    }
+                }
+                else if (!disposed) {
+                    subscriptionRoutes.set(subscriptionId, subscriptionRoute);
+                }
+            }
+            return result;
+        }
+        finally {
+            if (isSubscribe && subscriptionId) {
+                pendingSubscriptionIds.delete(subscriptionId);
+                cancelledPendingSubscriptionIds.delete(subscriptionId);
+            }
+        }
+    };
+    const offRequest = transport.on(contract_transport_1.CONTRACT_REQUEST_CHANNEL, handleAuthorizedCall);
+    return {
+        dispose() {
+            if (disposed) {
+                return;
+            }
+            disposed = true;
+            offRequest();
+            for (const entry of endpointEntries.values()) {
+                if (entry.endpoint) {
+                    entry.endpoint.dispose();
+                }
+                else {
+                    void entry.promise.then((endpoint) => endpoint.dispose()).catch(() => { });
+                }
+            }
+            endpointEntries.clear();
+            subscriptionRoutes.clear();
+            pendingSubscriptionIds.clear();
+            cancelledPendingSubscriptionIds.clear();
+        },
+    };
+}