houdini 1.0.0-next.0 → 1.0.0-next.2

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

@@ -1,10 +1,12 @@
-import { ConfigFile } from '../lib/config';
-import { GraphQLObject, GraphQLValue, SubscriptionSelection, SubscriptionSpec } from '../lib/types';
+import type { ConfigFile } from '../lib/config';
+import type { GraphQLObject, GraphQLValue, SubscriptionSelection, SubscriptionSpec } from '../lib/types';
 import { GarbageCollector } from './gc';
-import { ListCollection, ListManager } from './lists';
+import type { ListCollection } from './lists';
+import { ListManager } from './lists';
 import { SchemaManager } from './schema';
-import { InMemoryStorage, Layer, LayerID } from './storage';
-import { InMemorySubscriptions } from './subscription';
+import type { Layer, LayerID } from './storage';
+import { InMemoryStorage } from './storage';
+import { type FieldSelection, InMemorySubscriptions } from './subscription';
 export declare class Cache {
     _internal_unstable: CacheInternal;
     constructor(config?: ConfigFile);
@@ -59,10 +61,10 @@ declare class CacheInternal {
         parent?: string;
         root?: string;
         layer: Layer;
-        toNotify?: SubscriptionSpec[];
+        toNotify?: FieldSelection[];
         applyUpdates?: boolean;
         forceNotify?: boolean;
-    }): SubscriptionSpec[];
+    }): FieldSelection[];
     getSelection({ selection, parent, variables, stepsFromConnection, }: {
         selection: SubscriptionSelection;
         parent?: string;
@@ -94,7 +96,7 @@ declare class CacheInternal {
         linkedType: string;
         abstract: boolean;
         variables: {};
-        specs: SubscriptionSpec[];
+        specs: FieldSelection[];
         applyUpdates: boolean;
         fields: SubscriptionSelection;
         layer: Layer;

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

@@ -1,4 +1,4 @@
-import { Cache } from './cache';
+import type { Cache } from './cache';
 export declare class GarbageCollector {
     cache: Cache;
     private lifetimes;

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

@@ -1,5 +1,5 @@
-import { SubscriptionSelection, ListWhen, SubscriptionSpec } from '../lib/types';
-import { Cache } from './cache';
+import type { SubscriptionSelection, ListWhen, SubscriptionSpec } from '../lib/types';
+import type { Cache } from './cache';
 export declare class ListManager {
     rootID: string;
     cache: Cache;

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

@@ -1,5 +1,5 @@
-import { ConfigFile } from '../lib';
-import { Cache } from './cache';
+import type { ConfigFile } from '../lib/config';
+import type { Cache } from './cache';
 export type TypeInfo = {
     type: string;
     nullable: boolean;

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

@@ -1,5 +1,5 @@
-import { GraphQLValue } from '../lib/types';
-import { LinkedList } from './cache';
+import type { GraphQLValue } from '../lib/types';
+import type { LinkedList } from './cache';
 export declare function flattenList<T>(source: LinkedList<T>): T[];
 export declare function evaluateKey(key: string, variables?: {
     [key: string]: GraphQLValue;

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

@@ -1,6 +1,9 @@
-import type { SubscriptionSpec, SubscriptionSelection, GraphQLObject } from '../lib/types';
-import type { GraphQLValue } from '../lib/types';
-import { Cache } from './cache';
+import type { GraphQLValue, SubscriptionSelection, SubscriptionSpec } from '../lib/types';
+import type { Cache } from './cache';
+export type FieldSelection = [
+    SubscriptionSpec,
+    Required<SubscriptionSelection>['fields'] | undefined
+];
 export declare class InMemorySubscriptions {
     private cache;
     constructor(cache: Cache);
@@ -16,22 +19,27 @@ export declare class InMemorySubscriptions {
             [key: string]: GraphQLValue;
         };
     }): void;
-    addFieldSubscription({ id, key, field, spec, parentType, variables, }: {
+    addFieldSubscription({ id, key, selection, }: {
         id: string;
         key: string;
-        field: Required<SubscriptionSelection>['fields'][string];
-        spec: SubscriptionSpec;
+        selection: FieldSelection;
+    }): void;
+    registerList({ list, id, key, parentType, selection, filters, variables, }: {
+        list: Required<Required<SubscriptionSelection>['fields'][string]>['list'];
+        selection: SubscriptionSelection;
+        id: string;
         parentType: string;
-        variables: GraphQLObject;
+        key: string;
+        filters: Required<SubscriptionSelection>['fields'][string]['filters'];
+        variables: Record<string, any>;
     }): void;
-    addMany({ parent, selection, variables, subscribers, parentType, }: {
+    addMany({ parent, variables, subscribers, parentType, }: {
         parent: string;
-        selection: SubscriptionSelection;
         variables: {};
-        subscribers: SubscriptionSpec[];
+        subscribers: FieldSelection[];
         parentType: string;
     }): void;
-    get(id: string, field: string): SubscriptionSpec[];
+    get(id: string, field: string): FieldSelection[];
     remove(id: string, selection: SubscriptionSelection, targets: SubscriptionSpec[], variables: {}, visited?: string[]): void;
     private removeSubscribers;
     removeAllSubscribers(id: string, targets?: SubscriptionSpec[], visited?: string[]): void;

package/build/runtime/client/documentStore.d.ts

@@ -0,0 +1,87 @@
+import type { HoudiniClient } from '.';
+import type { Layer } from '../cache/storage';
+import type { ConfigFile } from '../lib/config';
+import { Writable } from '../lib/store';
+import type { CachePolicy, DocumentArtifact, QueryResult, GraphQLObject, SubscriptionSpec } from '../lib/types';
+export declare class DocumentStore<_Data extends GraphQLObject, _Input extends Record<string, any>> extends Writable<QueryResult<_Data, _Input>> {
+    #private;
+    constructor({ artifact, plugins, pipeline, client, cache, initialValue, fetching, }: {
+        artifact: DocumentArtifact;
+        plugins?: ClientPlugin[];
+        pipeline?: ClientPlugin[];
+        client: HoudiniClient;
+        cache?: boolean;
+        initialValue?: _Data | null;
+        fetching?: boolean;
+    });
+    send({ metadata, session, fetch, variables, policy, stuff, cacheParams, setup, }?: {
+        fetch?: Fetch;
+        variables?: Record<string, any> | null;
+        metadata?: App.Metadata | null;
+        session?: App.Session | null;
+        policy?: CachePolicy;
+        stuff?: Partial<App.Stuff>;
+        cacheParams?: ClientPluginContext['cacheParams'];
+        setup?: boolean;
+    }): Promise<QueryResult<_Data, _Input>>;
+}
+declare function marshalVariables<_Data extends GraphQLObject, _Input extends {}>(ctx: ClientPluginContext): Record<string, any>;
+export type ClientPlugin = () => {
+    start?: ClientPluginEnterPhase;
+    beforeNetwork?: ClientPluginEnterPhase;
+    network?: ClientPluginEnterPhase;
+    afterNetwork?: ClientPluginExitPhase;
+    end?: ClientPluginExitPhase;
+    cleanup?(ctx: ClientPluginContext): void | Promise<void>;
+    catch?(ctx: ClientPluginContext, args: ClientPluginErrorHandlers): void | Promise<void>;
+};
+export type Fetch = typeof globalThis.fetch;
+export type ClientPluginContext = {
+    config: ConfigFile;
+    text: string;
+    hash: string;
+    artifact: DocumentArtifact;
+    policy?: CachePolicy;
+    fetch?: Fetch;
+    variables?: Record<string, any>;
+    metadata?: App.Metadata | null;
+    session?: App.Session | null;
+    fetchParams?: RequestInit;
+    cacheParams?: {
+        layer?: Layer;
+        notifySubscribers?: SubscriptionSpec[];
+        forceNotify?: boolean;
+        disableWrite?: boolean;
+        disableRead?: boolean;
+        applyUpdates?: boolean;
+    };
+    stuff: App.Stuff;
+};
+type ClientPluginPhase<Handlers> = (ctx: ClientPluginContext, handlers: Handlers) => void | Promise<void>;
+export type ClientPluginEnterPhase = ClientPluginPhase<ClientPluginEnterHandlers>;
+export type ClientPluginExitPhase = ClientPluginPhase<ClientPluginExitHandlers>;
+export type ClientPluginEnterHandlers = {
+    initialValue: QueryResult;
+    /** A reference to the houdini client to access any configuration values */
+    client: HoudiniClient;
+    /** Move onto the next step using the provided context.  */
+    next(ctx: ClientPluginContext): void;
+    /** Terminate the current chain  */
+    resolve(ctx: ClientPluginContext, data: QueryResult): void;
+    /** Update the stores state without resolving the promise */
+    updateState(updater: (old: QueryResult) => QueryResult): void;
+    /** Return true if the variables have changed */
+    variablesChanged: (ctx: ClientPluginContext) => boolean;
+    /** Returns the marshaled variables for the operation */
+    marshalVariables: typeof marshalVariables;
+};
+/** Exit handlers are the same as enter handles but don't need to resolve with a specific value */
+export type ClientPluginExitHandlers = Omit<ClientPluginEnterHandlers, 'resolve'> & {
+    resolve: (ctx: ClientPluginContext, data?: QueryResult) => void;
+    value: QueryResult;
+};
+/** Exit handlers are the same as enter handles but don't need to resolve with a specific value */
+export type ClientPluginErrorHandlers = ClientPluginEnterHandlers & {
+    error: unknown;
+};
+export {};

package/build/runtime/client/index.d.ts

@@ -0,0 +1,25 @@
+/// <reference path="../../../../../houdini.d.ts" />
+import type { DocumentArtifact, GraphQLObject } from '../lib/types';
+import type { ClientPlugin } from './documentStore';
+import { DocumentStore } from './documentStore';
+import { type FetchParamFn, type ThrowOnErrorParams } from './plugins';
+export { DocumentStore, type ClientPlugin } from './documentStore';
+export { fetchPlugin, mutationPlugin, queryPlugin, subscriptionPlugin } from './plugins';
+type ConstructorArgs = {
+    url: string;
+    fetchParams?: FetchParamFn;
+    plugins?: ClientPlugin[];
+    pipeline?: ClientPlugin[];
+    throwOnError?: ThrowOnErrorParams;
+};
+export declare class HoudiniClient {
+    #private;
+    url: string;
+    constructor({ url, fetchParams, plugins, pipeline, throwOnError }: ConstructorArgs);
+    observe<_Data extends GraphQLObject, _Input extends Record<string, any>>({ artifact, cache, initialValue, fetching, }: {
+        artifact: DocumentArtifact;
+        cache?: boolean;
+        initialValue?: _Data | null;
+        fetching?: boolean;
+    }): DocumentStore<_Data, _Input>;
+}

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

@@ -0,0 +1,8 @@
+import cache from '../../cache';
+import type { Cache } from '../../cache/cache';
+import type { ClientPlugin } from '../documentStore';
+export declare const cachePolicyPlugin: ({ enabled, setFetching, cache: localCache, }: {
+    enabled: boolean;
+    setFetching: (val: boolean) => void;
+    cache?: Cache | undefined;
+}) => ClientPlugin;

package/build/runtime/client/plugins/fetch.d.ts

@@ -0,0 +1,37 @@
+import type { RequestPayload } from '../../lib/types';
+import type { ClientPlugin } from '../documentStore';
+export declare const fetchPlugin: (target?: RequestHandler | string) => ClientPlugin;
+export type FetchContext = {
+    fetch: typeof globalThis.fetch;
+    metadata?: App.Metadata | null;
+    session: App.Session | null;
+};
+/**
+ * ## Tip 👇
+ *
+ * To define types for your metadata, create a file `src/app.d.ts` containing the followingI:
+ *
+ * ```ts
+ * declare namespace App { *
+ * 	interface Metadata {}
+ * }
+ * ```
+ *
+ */
+export type RequestHandlerArgs = FetchContext & FetchParams;
+export type RequestHandler<_Data = any> = (args: RequestHandlerArgs) => Promise<RequestPayload<_Data>>;
+export type FetchParams = {
+    text: string;
+    hash: string;
+    variables: {
+        [key: string]: any;
+    };
+};
+export declare function isExtractableFile(value: any): value is ExtractableFile;
+type ExtractableFile = File | Blob;
+/** @typedef {import("./isExtractableFile.mjs").default} isExtractableFile */
+export declare function extractFiles(value: any): {
+    clone: any;
+    files: Map<any, any>;
+};
+export {};

package/build/runtime/client/plugins/fetchParams.d.ts

@@ -0,0 +1,9 @@
+import type { DocumentArtifact } from '../../lib/types';
+import type { ClientPlugin, ClientPluginContext } from '../documentStore';
+export type FetchParamFn = (ctx: FetchParamsInput) => Required<ClientPluginContext>['fetchParams'];
+export declare const fetchParamsPlugin: (fn?: FetchParamFn) => ClientPlugin;
+export type FetchParamsInput = Pick<ClientPluginContext, 'config' | 'policy' | 'variables' | 'metadata' | 'session' | 'stuff'> & {
+    text: string;
+    hash: string;
+    artifact: DocumentArtifact;
+};

package/build/runtime/client/plugins/index.d.ts

@@ -0,0 +1,7 @@
+export * from './fetch';
+export * from './cache';
+export * from './query';
+export * from './mutation';
+export * from './subscription';
+export * from './throwOnError';
+export * from './fetchParams';

package/build/runtime/client/plugins/injectedPlugins.d.ts

@@ -0,0 +1,3 @@
+import type { ClientPlugin } from '../documentStore';
+declare const plugins: ClientPlugin[];
+export default plugins;

package/build/runtime/client/plugins/mutation.d.ts

@@ -0,0 +1 @@
+export declare const mutationPlugin: import("..").ClientPlugin;

package/build/runtime/client/plugins/query.d.ts

@@ -0,0 +1,2 @@
+import type { ClientPlugin } from '../documentStore';
+export declare const queryPlugin: ClientPlugin;

package/build/runtime/client/plugins/subscription.d.ts

@@ -0,0 +1,18 @@
+import type { GraphQLObject } from '../../lib/types';
+import type { ClientPluginContext } from '../documentStore';
+export declare function subscriptionPlugin(factory: SubscriptionHandler): import("../documentStore").ClientPlugin;
+export type SubscriptionHandler = (ctx: ClientPluginContext) => {
+    subscribe: (payload: {
+        query: string;
+        variables?: {};
+    }, handlers: {
+        next: (payload: {
+            data?: GraphQLObject;
+            errors?: readonly {
+                message: string;
+            }[];
+        }) => void;
+        error: (data: {}) => void;
+        complete: () => void;
+    }) => () => void;
+};

package/build/runtime/client/plugins/throwOnError.d.ts

@@ -0,0 +1,7 @@
+import type { QueryResult } from '../../lib';
+import type { ClientPlugin } from '../documentStore';
+export type ThrowOnErrorParams = {
+    operations: ('all' | 'query' | 'mutation' | 'subscription')[];
+    error?: (errors: NonNullable<QueryResult<any, any>['errors']>) => unknown;
+};
+export declare const throwOnErrorPlugin: ({ operations, error }: ThrowOnErrorParams) => ClientPlugin;

package/build/runtime/client/utils/documentPlugins.d.ts

@@ -0,0 +1,3 @@
+import type { ArtifactKind } from '../../lib/types';
+import type { ClientPlugin } from '../documentStore';
+export declare const documentPlugin: (kind: ArtifactKind, source: ClientPlugin) => ClientPlugin;

package/build/runtime/client/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './documentPlugins';

package/build/runtime/imports/config.d.ts

@@ -0,0 +1,3 @@
+import type { ConfigFile } from '../lib/config';
+declare const _default: ConfigFile;
+export default _default;

package/build/runtime/index.d.ts

@@ -1,6 +1,7 @@
-import { Cache as InternalCache } from './cache/cache';
+import type { Cache as InternalCache } from './cache/cache';
 import type { CacheTypeDef } from './generated';
 import { Cache } from './public';
+export * from './client';
 export * from './lib';
 export declare function graphql(str: string | TemplateStringsArray): any;
 export declare const cache: Cache<CacheTypeDef>;

package/build/runtime/lib/config.d.ts

@@ -1,11 +1,11 @@
-import { GraphQLSchema } from 'graphql';
-import { CachePolicy } from './types';
+import type { GraphQLSchema } from 'graphql';
+import type { CachePolicy } from './types';
 export declare function getMockConfig(): ConfigFile | null;
 export declare function setMockConfig(config: ConfigFile | null): void;
 export declare function defaultConfigValues(file: ConfigFile): ConfigFile;
 export declare function keyFieldsForType(configFile: ConfigFile, type: string): string[];
 export declare function computeID(configFile: ConfigFile, type: string, data: any): string;
-export declare function getCurrentConfig(): Promise<ConfigFile>;
+export declare function getCurrentConfig(): ConfigFile;
 export type ConfigFile = {
     /**
      * A glob pointing to all files that houdini should consider. Note, this must include .js files
@@ -140,4 +140,6 @@ export type ScalarSpec = {
 };
 export interface HoudiniPluginConfig {
 }
+export interface HoudiniClientPluginConfig {
+}
 export {};

package/build/runtime/lib/index.d.ts

@@ -1,8 +1,7 @@
 export * from './config';
 export * from './constants';
 export * from './deepEquals';
-export * from './errors';
 export * from './log';
-export * from './network';
 export * from './scalars';
 export * from './types';
+export * from './store';

package/build/runtime/lib/scalars.d.ts

@@ -1,14 +1,15 @@
-import { ConfigFile } from './config';
-import { MutationArtifact, QueryArtifact, SubscriptionArtifact, SubscriptionSelection } from './types';
+import type { ConfigFile } from './config';
+import type { MutationArtifact, QueryArtifact, SubscriptionArtifact, SubscriptionSelection } from './types';
 export declare function marshalSelection({ selection, data, }: {
     selection: SubscriptionSelection;
     data: any;
 }): Promise<{} | null | undefined>;
-export declare function marshalInputs<T>({ artifact, input, rootType, }: {
+export declare function marshalInputs<T>({ artifact, input, config, rootType, }: {
     artifact: QueryArtifact | MutationArtifact | SubscriptionArtifact;
     input: unknown;
     rootType?: string;
-}): Promise<{} | null | undefined>;
+    config: ConfigFile;
+}): {} | null | undefined;
 export declare function unmarshalSelection(config: ConfigFile, selection: SubscriptionSelection, data: any): {} | null | undefined;
 export declare function isScalar(config: ConfigFile, type: string): boolean;
 export declare function parseScalar(config: ConfigFile, type: string, value: string): string | number | boolean;

package/build/runtime/lib/selection.d.ts

@@ -1,2 +1,2 @@
-import { SubscriptionSelection } from './types';
+import type { SubscriptionSelection } from './types';
 export declare function getFieldsForType(selection: SubscriptionSelection, __typename: string | undefined | null): Required<SubscriptionSelection>['fields'];

package/build/runtime/lib/store.d.ts

@@ -0,0 +1,19 @@
+export declare class Writable<T> {
+    #private;
+    state: T;
+    constructor(value: T, start?: StartStopNotifier<T>);
+    set(new_value: T): void;
+    update(fn: Updater<T>): void;
+    subscribe(run: Subscriber<T>, invalidate?: Invalidator<T>): Unsubscriber;
+}
+/** Start and stop notification callbacks. */
+type StartStopNotifier<T> = (set: Subscriber<T>) => Unsubscriber | void;
+/** Callback to inform of a value updates. */
+export type Subscriber<T> = (value: T) => void;
+/** Unsubscribes from value updates. */
+export type Unsubscriber = () => void;
+/** Callback to update a value. */
+type Updater<T> = (value: T) => T;
+/** Cleanup logic callback. */
+type Invalidator<T> = (value?: T) => void;
+export {};

package/build/runtime/lib/types.d.ts

@@ -4,6 +4,22 @@ export declare enum CachePolicy {
     NetworkOnly = "NetworkOnly",
     CacheAndNetwork = "CacheAndNetwork"
 }
+declare global {
+    namespace App {
+        interface Session {
+        }
+        interface Metadata {
+        }
+        interface Stuff {
+            inputs: {
+                init: boolean;
+                marshaled: Record<string, any>;
+                changed: boolean;
+            };
+            optimisticResponse?: GraphQLObject;
+        }
+    }
+}
 export type Fragment<_Result> = {
     readonly shape?: _Result;
 };
@@ -65,6 +81,7 @@ export type BaseCompiledDocument = {
         paginated: boolean;
         direction?: 'forward' | 'backwards';
     };
+    pluginsData?: Record<string, any>;
 };
 export type HoudiniFetchContext = {
     variables: () => {};
@@ -150,7 +167,7 @@ export type FetchQueryResult<_Data> = {
     source: DataSource | null;
     partial: boolean;
 };
-export type QueryResult<_Data, _Input, _Extra = {}> = {
+export type QueryResult<_Data = GraphQLObject, _Input = Record<string, any>> = {
     data: _Data | null;
     errors: {
         message: string;
@@ -158,16 +175,12 @@ export type QueryResult<_Data, _Input, _Extra = {}> = {
     fetching: boolean;
     partial: boolean;
     source: DataSource | null;
-    variables: _Input;
-} & _Extra;
-export type RequestPayload<_Data = any> = {
-    data: _Data | null;
+    variables: _Input | null;
+};
+export type RequestPayload<GraphQLObject = any> = {
+    data: GraphQLObject | null;
     errors: {
         message: string;
     }[] | null;
 };
-export type RequestPayloadMagic<_Data = any> = {
-    ssr: boolean;
-    body: RequestPayload<_Data>;
-};
 export {};

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

@@ -1,5 +1,5 @@
-import { Cache as _Cache } from '../cache/cache';
-import { SchemaManager, TypeInfo } from '../cache/schema';
+import type { Cache as _Cache } from '../cache/cache';
+import type { SchemaManager, TypeInfo } from '../cache/schema';
 import { ListCollection } from './list';
 import { Record } from './record';
 import type { CacheTypeDef, IDFields, TypeNames, ValidLists } from './types';

package/build/runtime/public/list.d.ts

@@ -1,5 +1,5 @@
-import { Cache } from './cache';
-import { CacheTypeDef, ListType, ValidLists, ListFilters } from './types';
+import type { Cache } from './cache';
+import type { CacheTypeDef, ListType, ValidLists, ListFilters } from './types';
 export declare class ListCollection<Def extends CacheTypeDef, ListName extends ValidLists<Def>> {
     #private;
     constructor({ parentID, allLists, when, cache, name, }: {

package/build/runtime/public/record.d.ts

@@ -1,4 +1,4 @@
-import { Cache } from './cache';
+import type { Cache } from './cache';
 import type { ArgType, CacheTypeDef, FieldType, TypeFieldNames, ValidTypes } from './types';
 export declare class Record<Def extends CacheTypeDef, Type extends ValidTypes<Def>> {
     #private;

package/build/runtime/public/tests/test.d.ts

@@ -1,5 +1,5 @@
 import { Cache } from '../cache';
-import { Record } from '../record';
+import type { Record } from '../record';
 type CacheTypeDef = {
     types: {
         __ROOT__: {

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

@@ -1,10 +1,12 @@
-import { ConfigFile } from '../lib/config';
-import { GraphQLObject, GraphQLValue, SubscriptionSelection, SubscriptionSpec } from '../lib/types';
+import type { ConfigFile } from '../lib/config';
+import type { GraphQLObject, GraphQLValue, SubscriptionSelection, SubscriptionSpec } from '../lib/types';
 import { GarbageCollector } from './gc';
-import { ListCollection, ListManager } from './lists';
+import type { ListCollection } from './lists';
+import { ListManager } from './lists';
 import { SchemaManager } from './schema';
-import { InMemoryStorage, Layer, LayerID } from './storage';
-import { InMemorySubscriptions } from './subscription';
+import type { Layer, LayerID } from './storage';
+import { InMemoryStorage } from './storage';
+import { type FieldSelection, InMemorySubscriptions } from './subscription';
 export declare class Cache {
     _internal_unstable: CacheInternal;
     constructor(config?: ConfigFile);
@@ -59,10 +61,10 @@ declare class CacheInternal {
         parent?: string;
         root?: string;
         layer: Layer;
-        toNotify?: SubscriptionSpec[];
+        toNotify?: FieldSelection[];
         applyUpdates?: boolean;
         forceNotify?: boolean;
-    }): SubscriptionSpec[];
+    }): FieldSelection[];
     getSelection({ selection, parent, variables, stepsFromConnection, }: {
         selection: SubscriptionSelection;
         parent?: string;
@@ -94,7 +96,7 @@ declare class CacheInternal {
         linkedType: string;
         abstract: boolean;
         variables: {};
-        specs: SubscriptionSpec[];
+        specs: FieldSelection[];
         applyUpdates: boolean;
         fields: SubscriptionSelection;
         layer: Layer;

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

@@ -52,7 +52,7 @@ class Cache {
     ...args
   }) {
     const layer = layerID ? this._internal_unstable.storage.getLayer(layerID) : this._internal_unstable.storage.topLayer;
-    const subscribers = this._internal_unstable.writeSelection({ ...args, layer });
+    const subscribers = this._internal_unstable.writeSelection({ ...args, layer }).map((sub) => sub[0]);
     const notified = [];
     for (const spec of subscribers.concat(notifySubscribers)) {
       if (!notified.includes(spec.set)) {
@@ -190,6 +190,7 @@ class CacheInternal {
         link: !!fieldSelection
       });
       const currentSubscribers = this.subscriptions.get(parent, key);
+      const specs = currentSubscribers.map((sub) => sub[0]);
       const { value: previousValue, displayLayers } = this.storage.get(parent, key);
       const displayLayer = layer.isDisplayLayer(displayLayers);
       if (displayLayer) {
@@ -215,7 +216,7 @@ class CacheInternal {
         }
         const previousLinks = (0, import_stuff.flattenList)([previousValue]);
         for (const link of previousLinks) {
-          this.subscriptions.remove(link, fieldSelection, currentSubscribers, variables);
+          this.subscriptions.remove(link, fieldSelection, specs, variables);
         }
         layer.writeLink(parent, key, null);
         toNotify.push(...currentSubscribers);
@@ -239,16 +240,10 @@ class CacheInternal {
         layer.writeLink(parent, key, linkedID);
         if (linkedID && displayLayer && (linkChange || forceNotify)) {
           if (previousValue && typeof previousValue === "string") {
-            this.subscriptions.remove(
-              previousValue,
-              fieldSelection,
-              currentSubscribers,
-              variables
-            );
+            this.subscriptions.remove(previousValue, fieldSelection, specs, variables);
           }
           this.subscriptions.addMany({
             parent: linkedID,
-            selection: fieldSelection,
             subscribers: currentSubscribers,
             variables,
             parentType: linkedType
@@ -343,7 +338,7 @@ class CacheInternal {
           if (linkedIDs.includes(lostID) || !lostID) {
             continue;
           }
-          this.subscriptions.remove(lostID, fieldSelection, currentSubscribers, variables);
+          this.subscriptions.remove(lostID, fieldSelection, specs, variables);
         }
         if (contentChanged || oldIDs.length === 0 && newIDs.length === 0) {
           layer.writeLink(parent, key, linkedIDs);
@@ -354,7 +349,6 @@ class CacheInternal {
           }
           this.subscriptions.addMany({
             parent: id,
-            selection: fieldSelection,
             subscribers: currentSubscribers,
             variables,
             parentType: linkedType