houdini 0.13.6 → 0.13.7-alpha.0

package/build/runtime/cache/cache.d.ts

@@ -14,7 +14,7 @@ export declare class Cache {
         selection: SubscriptionSelection;
         variables?: {};
         parent?: string;
-        layer?: LayerID;
+        layer?: LayerID | null;
         applyUpdates?: boolean;
     }): LayerID;
     read(...args: Parameters<CacheInternal['getSelection']>): {

package/build/runtime/cache/cache.js

@@ -210,7 +210,7 @@ var CacheInternal = /** @class */ (function () {
             // look up the previous value
             var _h = this_1.storage.get(parent, key), previousValue = _h.value, displayLayers = _h.displayLayers;
             // if the layer we are updating is the top most layer for the field
-            // then its value is "live", it is providing the current value and
+            // then its value is "live". It is providing the current value and
             // subscribers need to know if the value changed
             var displayLayer = displayLayers.length === 0 || displayLayers.includes(layer.id);
             // if we are writing to the display layer we need to refresh the lifetime of the value

package/build/runtime/mutation.d.ts

@@ -1,2 +1,5 @@
 import { Operation, GraphQLTagResult } from './types';
-export declare function mutation<_Mutation extends Operation<any, any>>(document: GraphQLTagResult): (_input: _Mutation['input']) => Promise<_Mutation['result']>;
+export declare type MutationConfig<_Mutation extends Operation<any, any>> = {
+    optimisticResponse: _Mutation['result'];
+};
+export declare function mutation<_Mutation extends Operation<any, any>>(document: GraphQLTagResult): (_input: _Mutation['input'], config: MutationConfig<_Mutation>) => Promise<_Mutation['result']>;

package/build/runtime/mutation.js

@@ -62,30 +62,61 @@ function mutation(document) {
     // grab the session from the adapter
     var sessionStore = adapter_mjs_1.getSession();
     // return an async function that sends the mutation go the server
-    return function (variables) { return __awaiter(_this, void 0, void 0, function () {
-        var result, error_1;
+    return function (variables, mutationConfig) { return __awaiter(_this, void 0, void 0, function () {
+        var optimisticResponse, layer, result, error_1;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    _a.trys.push([0, 2, , 3]);
+                    optimisticResponse = mutationConfig === null || mutationConfig === void 0 ? void 0 : mutationConfig.optimisticResponse;
+                    layer = cache_1.default._internal_unstable.storage.createLayer(true);
+                    // if there is an optimistic response then we need to write the value immediately
+                    if (optimisticResponse) {
+                        cache_1.default.write({
+                            selection: artifact.selection,
+                            // make sure that any scalar values get processed into something we can cache
+                            data: scalars_1.marshalSelection({
+                                config: config,
+                                selection: artifact.selection,
+                                data: optimisticResponse,
+                            }),
+                            variables: variables,
+                            layer: layer.id,
+                        });
+                    }
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
                     return [4 /*yield*/, network_1.executeQuery(artifact, scalars_1.marshalInputs({
                             input: variables,
                             artifact: document.artifact,
                             config: config,
-                        }), sessionStore, false)];
-                case 1:
+                        }), sessionStore, false)
+                        // clear the layer holding any mutation results
+                    ];
+                case 2:
                     result = (_a.sent()).result;
+                    // clear the layer holding any mutation results
+                    layer.clear();
+                    // write the result of the mutation to the cache
                     cache_1.default.write({
                         selection: artifact.selection,
                         data: result.data,
                         variables: variables,
+                        // if we had an optimistic response we need to write to the appropriate layer
+                        layer: layer.id,
                     });
-                    // unmarshal any scalars on the body
+                    // merge the layer back into the cache
+                    cache_1.default._internal_unstable.storage.resolveLayer(layer.id);
+                    // turn any scalars in the response into their complex form
                     return [2 /*return*/, scalars_1.unmarshalSelection(config, artifact.selection, result.data)];
-                case 2:
+                case 3:
                     error_1 = _a.sent();
+                    // if the mutation failed, roll the layer back and delete it
+                    layer.clear();
+                    cache_1.default._internal_unstable.storage.resolveLayer(layer.id);
+                    // bubble the mutation error up to the caller
                     throw error_1;
-                case 3: return [2 /*return*/];
+                case 4: return [2 /*return*/];
             }
         });
     }); };

package/build/runtime/scalars.d.ts

@@ -1,5 +1,10 @@
 import type { Config } from 'houdini-common';
 import { MutationArtifact, QueryArtifact, SubscriptionArtifact, SubscriptionSelection } from './types';
+export declare function marshalSelection({ config, selection, data, }: {
+    config: Config;
+    selection: SubscriptionSelection;
+    data: unknown;
+}): {} | null | undefined;
 export declare function marshalInputs<T>({ artifact, config, input, rootType, }: {
     artifact: QueryArtifact | MutationArtifact | SubscriptionArtifact;
     config: Config;

package/build/runtime/scalars.js

@@ -16,7 +16,49 @@ var __read = (this && this.__read) || function (o, n) {
     return ar;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isScalar = exports.unmarshalSelection = exports.marshalInputs = void 0;
+exports.isScalar = exports.unmarshalSelection = exports.marshalInputs = exports.marshalSelection = void 0;
+function marshalSelection(_a) {
+    var config = _a.config, selection = _a.selection, data = _a.data;
+    if (data === null || typeof data === 'undefined') {
+        return data;
+    }
+    // if we are looking at a list
+    if (Array.isArray(data)) {
+        // unmarshal every entry in the list
+        return data.map(function (val) { return marshalSelection({ config: config, selection: selection, data: val }); });
+    }
+    // we're looking at an object, build it up from the current input
+    return Object.fromEntries(Object.entries(data).map(function (_a) {
+        var _b;
+        var _c = __read(_a, 2), fieldName = _c[0], value = _c[1];
+        // look up the type for the field
+        var _d = selection[fieldName], type = _d.type, fields = _d.fields;
+        // if we don't have type information for this field, just use it directly
+        // it's most likely a non-custom scalars or enums
+        if (!type) {
+            return [fieldName, value];
+        }
+        // if there is a sub selection, walk down the selection
+        if (fields) {
+            return [fieldName, marshalSelection({ config: config, selection: fields, data: value })];
+        }
+        // is the type something that requires marshaling
+        if ((_b = config.scalars) === null || _b === void 0 ? void 0 : _b[type]) {
+            var marshalFn = config.scalars[type].marshal;
+            if (!marshalFn) {
+                throw new Error("scalar type " + type + " is missing a `marshal` function. see https://github.com/AlecAivazis/houdini#%EF%B8%8Fcustom-scalars");
+            }
+            if (Array.isArray(value)) {
+                return [fieldName, value.map(marshalFn)];
+            }
+            return [fieldName, marshalFn(value)];
+        }
+        // if the type doesn't require marshaling and isn't a referenced type
+        // then the type is a scalar that doesn't require marshaling
+        return [fieldName, value];
+    }));
+}
+exports.marshalSelection = marshalSelection;
 function marshalInputs(_a) {
     var artifact = _a.artifact, config = _a.config, input = _a.input, _b = _a.rootType, rootType = _b === void 0 ? '@root' : _b;
     if (input === null || typeof input === 'undefined') {

package/build/runtime-cjs/cache/cache.d.ts

@@ -14,7 +14,7 @@ export declare class Cache {
         selection: SubscriptionSelection;
         variables?: {};
         parent?: string;
-        layer?: LayerID;
+        layer?: LayerID | null;
         applyUpdates?: boolean;
     }): LayerID;
     read(...args: Parameters<CacheInternal['getSelection']>): {

package/build/runtime-cjs/cache/cache.js

@@ -210,7 +210,7 @@ var CacheInternal = /** @class */ (function () {
             // look up the previous value
             var _h = this_1.storage.get(parent, key), previousValue = _h.value, displayLayers = _h.displayLayers;
             // if the layer we are updating is the top most layer for the field
-            // then its value is "live", it is providing the current value and
+            // then its value is "live". It is providing the current value and
             // subscribers need to know if the value changed
             var displayLayer = displayLayers.length === 0 || displayLayers.includes(layer.id);
             // if we are writing to the display layer we need to refresh the lifetime of the value

package/build/runtime-cjs/mutation.d.ts

@@ -1,2 +1,5 @@
 import { Operation, GraphQLTagResult } from './types';
-export declare function mutation<_Mutation extends Operation<any, any>>(document: GraphQLTagResult): (_input: _Mutation['input']) => Promise<_Mutation['result']>;
+export declare type MutationConfig<_Mutation extends Operation<any, any>> = {
+    optimisticResponse: _Mutation['result'];
+};
+export declare function mutation<_Mutation extends Operation<any, any>>(document: GraphQLTagResult): (_input: _Mutation['input'], config: MutationConfig<_Mutation>) => Promise<_Mutation['result']>;

package/build/runtime-cjs/mutation.js

@@ -62,30 +62,61 @@ function mutation(document) {
     // grab the session from the adapter
     var sessionStore = adapter_mjs_1.getSession();
     // return an async function that sends the mutation go the server
-    return function (variables) { return __awaiter(_this, void 0, void 0, function () {
-        var result, error_1;
+    return function (variables, mutationConfig) { return __awaiter(_this, void 0, void 0, function () {
+        var optimisticResponse, layer, result, error_1;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    _a.trys.push([0, 2, , 3]);
+                    optimisticResponse = mutationConfig === null || mutationConfig === void 0 ? void 0 : mutationConfig.optimisticResponse;
+                    layer = cache_1.default._internal_unstable.storage.createLayer(true);
+                    // if there is an optimistic response then we need to write the value immediately
+                    if (optimisticResponse) {
+                        cache_1.default.write({
+                            selection: artifact.selection,
+                            // make sure that any scalar values get processed into something we can cache
+                            data: scalars_1.marshalSelection({
+                                config: config,
+                                selection: artifact.selection,
+                                data: optimisticResponse,
+                            }),
+                            variables: variables,
+                            layer: layer.id,
+                        });
+                    }
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
                     return [4 /*yield*/, network_1.executeQuery(artifact, scalars_1.marshalInputs({
                             input: variables,
                             artifact: document.artifact,
                             config: config,
-                        }), sessionStore, false)];
-                case 1:
+                        }), sessionStore, false)
+                        // clear the layer holding any mutation results
+                    ];
+                case 2:
                     result = (_a.sent()).result;
+                    // clear the layer holding any mutation results
+                    layer.clear();
+                    // write the result of the mutation to the cache
                     cache_1.default.write({
                         selection: artifact.selection,
                         data: result.data,
                         variables: variables,
+                        // if we had an optimistic response we need to write to the appropriate layer
+                        layer: layer.id,
                     });
-                    // unmarshal any scalars on the body
+                    // merge the layer back into the cache
+                    cache_1.default._internal_unstable.storage.resolveLayer(layer.id);
+                    // turn any scalars in the response into their complex form
                     return [2 /*return*/, scalars_1.unmarshalSelection(config, artifact.selection, result.data)];
-                case 2:
+                case 3:
                     error_1 = _a.sent();
+                    // if the mutation failed, roll the layer back and delete it
+                    layer.clear();
+                    cache_1.default._internal_unstable.storage.resolveLayer(layer.id);
+                    // bubble the mutation error up to the caller
                     throw error_1;
-                case 3: return [2 /*return*/];
+                case 4: return [2 /*return*/];
             }
         });
     }); };

package/build/runtime-cjs/scalars.d.ts

@@ -1,5 +1,10 @@
 import type { Config } from 'houdini-common';
 import { MutationArtifact, QueryArtifact, SubscriptionArtifact, SubscriptionSelection } from './types';
+export declare function marshalSelection({ config, selection, data, }: {
+    config: Config;
+    selection: SubscriptionSelection;
+    data: unknown;
+}): {} | null | undefined;
 export declare function marshalInputs<T>({ artifact, config, input, rootType, }: {
     artifact: QueryArtifact | MutationArtifact | SubscriptionArtifact;
     config: Config;

package/build/runtime-cjs/scalars.js

@@ -16,7 +16,49 @@ var __read = (this && this.__read) || function (o, n) {
     return ar;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isScalar = exports.unmarshalSelection = exports.marshalInputs = void 0;
+exports.isScalar = exports.unmarshalSelection = exports.marshalInputs = exports.marshalSelection = void 0;
+function marshalSelection(_a) {
+    var config = _a.config, selection = _a.selection, data = _a.data;
+    if (data === null || typeof data === 'undefined') {
+        return data;
+    }
+    // if we are looking at a list
+    if (Array.isArray(data)) {
+        // unmarshal every entry in the list
+        return data.map(function (val) { return marshalSelection({ config: config, selection: selection, data: val }); });
+    }
+    // we're looking at an object, build it up from the current input
+    return Object.fromEntries(Object.entries(data).map(function (_a) {
+        var _b;
+        var _c = __read(_a, 2), fieldName = _c[0], value = _c[1];
+        // look up the type for the field
+        var _d = selection[fieldName], type = _d.type, fields = _d.fields;
+        // if we don't have type information for this field, just use it directly
+        // it's most likely a non-custom scalars or enums
+        if (!type) {
+            return [fieldName, value];
+        }
+        // if there is a sub selection, walk down the selection
+        if (fields) {
+            return [fieldName, marshalSelection({ config: config, selection: fields, data: value })];
+        }
+        // is the type something that requires marshaling
+        if ((_b = config.scalars) === null || _b === void 0 ? void 0 : _b[type]) {
+            var marshalFn = config.scalars[type].marshal;
+            if (!marshalFn) {
+                throw new Error("scalar type " + type + " is missing a `marshal` function. see https://github.com/AlecAivazis/houdini#%EF%B8%8Fcustom-scalars");
+            }
+            if (Array.isArray(value)) {
+                return [fieldName, value.map(marshalFn)];
+            }
+            return [fieldName, marshalFn(value)];
+        }
+        // if the type doesn't require marshaling and isn't a referenced type
+        // then the type is a scalar that doesn't require marshaling
+        return [fieldName, value];
+    }));
+}
+exports.marshalSelection = marshalSelection;
 function marshalInputs(_a) {
     var artifact = _a.artifact, config = _a.config, input = _a.input, _b = _a.rootType, rootType = _b === void 0 ? '@root' : _b;
     if (input === null || typeof input === 'undefined') {

package/build/runtime-esm/cache/cache.d.ts

@@ -14,7 +14,7 @@ export declare class Cache {
         selection: SubscriptionSelection;
         variables?: {};
         parent?: string;
-        layer?: LayerID;
+        layer?: LayerID | null;
         applyUpdates?: boolean;
     }): LayerID;
     read(...args: Parameters<CacheInternal['getSelection']>): {

package/build/runtime-esm/cache/cache.js

@@ -129,7 +129,7 @@ class CacheInternal {
             // look up the previous value
             const { value: previousValue, displayLayers } = this.storage.get(parent, key);
             // if the layer we are updating is the top most layer for the field
-            // then its value is "live", it is providing the current value and
+            // then its value is "live". It is providing the current value and
             // subscribers need to know if the value changed
             const displayLayer = displayLayers.length === 0 || displayLayers.includes(layer.id);
             // if we are writing to the display layer we need to refresh the lifetime of the value

package/build/runtime-esm/cache/list.d.ts

@@ -0,0 +1,35 @@
+import { SubscriptionSelection, ListWhen, SubscriptionSpec } from '../types';
+import { Cache } from './cache';
+import { Record } from './record';
+export declare class ListHandler {
+    readonly record: Record;
+    readonly key: string;
+    readonly listType: string;
+    private cache;
+    readonly selection: SubscriptionSelection;
+    private _when?;
+    private filters?;
+    readonly name: string;
+    readonly parentID: SubscriptionSpec['parentID'];
+    private connection;
+    constructor({ name, cache, record, key, listType, selection, when, filters, parentID, connection, }: {
+        name: string;
+        connection: boolean;
+        cache: Cache;
+        record: Record;
+        key: string;
+        listType: string;
+        selection: SubscriptionSelection;
+        when?: ListWhen;
+        filters?: ListHandler['filters'];
+        parentID?: SubscriptionSpec['parentID'];
+    });
+    when(when?: ListWhen): ListHandler;
+    append(selection: SubscriptionSelection, data: {}, variables?: {}): void;
+    prepend(selection: SubscriptionSelection, data: {}, variables?: {}): void;
+    addToList(selection: SubscriptionSelection, data: {}, variables: {}, where: 'first' | 'last'): void;
+    removeID(id: string, variables?: {}): void;
+    remove(data: {}, variables?: {}): void;
+    private validateWhen;
+    [Symbol.iterator](): Generator<Record, void, unknown>;
+}

package/build/runtime-esm/cache/list.js

@@ -0,0 +1,203 @@
+export class ListHandler {
+    constructor({ name, cache, record, key, listType, selection, when, filters, parentID, connection, }) {
+        this.record = record;
+        this.key = key;
+        this.listType = listType;
+        this.cache = cache;
+        this.selection = selection;
+        this._when = when;
+        this.filters = filters;
+        this.name = name;
+        this.parentID = parentID;
+        this.connection = connection;
+    }
+    // when applies a when condition to a new list pointing to the same spot
+    when(when) {
+        return new ListHandler({
+            cache: this.cache,
+            record: this.record,
+            key: this.key,
+            listType: this.listType,
+            selection: this.selection,
+            when,
+            filters: this.filters,
+            parentID: this.parentID,
+            name: this.name,
+            connection: this.connection,
+        });
+    }
+    append(selection, data, variables = {}) {
+        return this.addToList(selection, data, variables, 'last');
+    }
+    prepend(selection, data, variables = {}) {
+        return this.addToList(selection, data, variables, 'first');
+    }
+    addToList(selection, data, variables = {}, where) {
+        // figure out the id of the type we are adding
+        const dataID = this.cache.id(this.listType, data);
+        // if there are conditions for this operation
+        if (!this.validateWhen() || !dataID) {
+            return;
+        }
+        // we are going to implement the insert as a write with an update flag on a field
+        // that matches the key of the list. We'll have to embed the lists data and selection
+        // in the appropriate objects
+        let insertSelection = selection;
+        let insertData = data;
+        // if we are wrapping a connection, we have to embed the data under edges > node
+        if (this.connection) {
+            insertSelection = {
+                newEntry: {
+                    keyRaw: this.key,
+                    type: 'Connection',
+                    fields: {
+                        edges: {
+                            keyRaw: 'edges',
+                            type: 'ConnectionEdge',
+                            update: (where === 'first' ? 'prepend' : 'append'),
+                            fields: {
+                                node: {
+                                    type: this.listType,
+                                    keyRaw: 'node',
+                                    fields: {
+                                        ...selection,
+                                        __typename: {
+                                            keyRaw: '__typename',
+                                            type: 'String',
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            };
+            insertData = {
+                newEntry: {
+                    edges: [{ node: { ...data, __typename: this.listType } }],
+                },
+            };
+        }
+        else {
+            insertSelection = {
+                newEntries: {
+                    keyRaw: this.key,
+                    type: this.listType,
+                    update: (where === 'first' ? 'prepend' : 'append'),
+                    fields: {
+                        ...selection,
+                        __typename: {
+                            keyRaw: '__typename',
+                            type: 'String',
+                        },
+                    },
+                },
+            };
+            insertData = {
+                newEntries: [{ ...data, __typename: this.listType }],
+            };
+        }
+        // get the list of specs that are subscribing to the list
+        const subscribers = this.record.getSubscribers(this.key);
+        // look up the new record in the cache
+        const newRecord = this.cache.internal.record(dataID);
+        // walk down the list fields relative to the new record
+        // and make sure all of the list's subscribers are listening
+        // to that object
+        this.cache.internal.insertSubscribers(newRecord, selection, variables, ...subscribers);
+        // update the cache with the data we just found
+        this.cache.write({
+            selection: insertSelection,
+            data: insertData,
+            variables,
+            parent: this.record.id,
+            applyUpdates: true,
+        });
+    }
+    removeID(id, variables = {}) {
+        // if there are conditions for this operation
+        if (!this.validateWhen()) {
+            return;
+        }
+        // if we are removing from a connection, the id we are removing from
+        // has to be computed
+        let parentID = this.record.id;
+        let targetID = id;
+        let targetKey = this.key;
+        // if we are removing a record from a connection we have to walk through
+        // some embedded references first
+        if (this.connection) {
+            const embeddedConnection = this.record.linkedRecord(this.key);
+            if (!embeddedConnection) {
+                return;
+            }
+            // look at every embedded edge for the one with a node corresponding to the element
+            // we want to delete
+            for (const edge of embeddedConnection.flatLinkedList('edges') || []) {
+                if (!edge) {
+                    continue;
+                }
+                // look at the edge's node
+                const node = edge.linkedRecord('node');
+                if (!node) {
+                    continue;
+                }
+                // if we found the node
+                if (node.id === id) {
+                    targetID = edge.id;
+                }
+            }
+            parentID = embeddedConnection.id;
+            targetKey = 'edges';
+        }
+        // get the list of specs that are subscribing to the list
+        const subscribers = this.record.getSubscribers(this.key);
+        // disconnect record from any subscriptions associated with the list
+        this.cache.internal.unsubscribeSelection(this.cache.internal.record(targetID), 
+        // if we're unsubscribing from a connection, only unsubscribe from the target
+        this.connection ? this.selection.edges.fields : this.selection, variables, ...subscribers.map(({ set }) => set));
+        // remove the target from the parent
+        this.cache.internal.record(parentID).removeFromLinkedList(targetKey, targetID);
+        // notify the subscribers about the change
+        this.cache.internal.notifySubscribers(subscribers, variables);
+        // if we are removing from a connection, delete the embedded edge holding the record
+        if (this.connection) {
+            this.cache.internal.deleteID(targetID);
+        }
+    }
+    remove(data, variables = {}) {
+        const targetID = this.cache.id(this.listType, data);
+        if (!targetID) {
+            return;
+        }
+        // figure out the id of the type we are adding
+        this.removeID(targetID, variables);
+    }
+    validateWhen() {
+        // if this when doesn't apply, we should look at others to see if we should update those behind the scenes
+        let ok = true;
+        // if there are conditions for this operation
+        if (this._when) {
+            // we only NEED there to be target filters for must's
+            const targets = this.filters;
+            // check must's first
+            if (this._when.must && targets) {
+                ok = Object.entries(this._when.must).reduce((prev, [key, value]) => Boolean(prev && targets[key] == value), ok);
+            }
+            // if there are no targets, nothing could be true that can we compare against
+            if (this._when.must_not) {
+                ok =
+                    !targets ||
+                        Object.entries(this._when.must_not).reduce((prev, [key, value]) => Boolean(prev && targets[key] != value), ok);
+            }
+        }
+        return ok;
+    }
+    // iterating over the list handler should be the same as iterating over
+    // the underlying linked list
+    *[Symbol.iterator]() {
+        for (let record of this.record.flatLinkedList(this.key)) {
+            yield record;
+        }
+    }
+}

package/build/runtime-esm/cache/record.d.ts

@@ -0,0 +1,40 @@
+import { GraphQLValue, Maybe, SubscriptionSpec } from '../types';
+import { Cache, LinkedList } from './cache';
+export declare class Record {
+    fields: {
+        [key: string]: GraphQLValue;
+    };
+    keyVersions: {
+        [key: string]: Set<string>;
+    };
+    readonly id: string;
+    private subscribers;
+    private recordLinks;
+    listLinks: {
+        [key: string]: LinkedList;
+    };
+    private cache;
+    private referenceCounts;
+    private lifetimes;
+    constructor(cache: Cache, id: string);
+    allSubscribers(): SubscriptionSpec[];
+    getField(fieldName: string): GraphQLValue;
+    writeField(fieldName: string, value: GraphQLValue): void;
+    writeRecordLink(fieldName: string, value: string | null): void;
+    writeListLink(fieldName: string, value: LinkedList): void;
+    linkedRecord(fieldName: string): Record;
+    linkedRecordID(fieldName: string): string;
+    linkedListIDs(fieldName: string): (string | null)[];
+    flatLinkedList(fieldName: string): Maybe<Record>[];
+    appendLinkedList(fieldName: string, id: string): void;
+    prependLinkedList(fieldName: string, id: string): void;
+    removeFromLinkedList(fieldName: string, id: string): void;
+    addSubscriber(rawKey: string, key: string, ...specs: SubscriptionSpec[]): void;
+    getSubscribers(fieldName: string): SubscriptionSpec[];
+    forgetSubscribers(...targets: SubscriptionSpec[]): void;
+    removeAllSubscribers(): void;
+    removeAllSubscriptionVersions(keyRaw: string, spec: SubscriptionSpec): void;
+    private forgetSubscribers_walk;
+    removeSubscribers(fields: string[], sets: SubscriptionSpec['set'][]): void;
+    onGcTick(): void;
+}