houdini 1.1.7 → 1.2.0-next.0

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

@@ -3,7 +3,6 @@ import type { GraphQLObject, GraphQLValue, NestedList, SubscriptionSelection, Su
 import { GarbageCollector } from './gc';
 import type { ListCollection } from './lists';
 import { ListManager } from './lists';
-import { SchemaManager } from './schema';
 import { StaleManager } from './staleManager';
 import type { Layer, LayerID } from './storage';
 import { InMemoryStorage } from './storage';
@@ -57,15 +56,13 @@ declare class CacheInternal {
     cache: Cache;
     lifetimes: GarbageCollector;
     staleManager: StaleManager;
-    schema: SchemaManager;
-    constructor({ storage, subscriptions, lists, cache, lifetimes, staleManager, schema, disabled, config, }: {
+    constructor({ storage, subscriptions, lists, cache, lifetimes, staleManager, disabled, config, }: {
         storage: InMemoryStorage;
         subscriptions: InMemorySubscriptions;
         lists: ListManager;
         cache: Cache;
         lifetimes: GarbageCollector;
         staleManager: StaleManager;
-        schema: SchemaManager;
         disabled: boolean;
         config?: ConfigFile;
     });
@@ -87,12 +84,13 @@ declare class CacheInternal {
         forceNotify?: boolean;
         forceStale?: boolean;
     }): FieldSelection[];
-    getSelection({ selection, parent, variables, stepsFromConnection, ignoreMasking, fullCheck, }: {
+    getSelection({ selection, parent, variables, stepsFromConnection, ignoreMasking, fullCheck, loading: generateLoading, }: {
         selection: SubscriptionSelection;
         parent?: string;
         variables?: {};
         stepsFromConnection?: number | null;
         ignoreMasking?: boolean;
+        loading?: boolean;
         fullCheck?: boolean;
     }): {
         data: GraphQLObject | null;
@@ -104,13 +102,14 @@ declare class CacheInternal {
     id(type: string, id: string): string | null;
     idFields(type: string): string[];
     computeID(type: string, data: any): string;
-    hydrateNestedList({ fields, variables, linkedList, stepsFromConnection, ignoreMasking, fullCheck, }: {
+    hydrateNestedList({ fields, variables, linkedList, stepsFromConnection, ignoreMasking, fullCheck, loading, }: {
         fields: SubscriptionSelection;
         variables?: {};
         linkedList: NestedList;
         stepsFromConnection: number | null;
         ignoreMasking: boolean;
         fullCheck?: boolean;
+        loading?: boolean;
     }): {
         data: NestedList<GraphQLValue>;
         partial: boolean;

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

@@ -5,6 +5,9 @@ import { Writable } from '../lib/store';
 import type { DocumentArtifact, QueryResult, GraphQLObject, SubscriptionSpec, CachePolicies } from '../lib/types';
 export declare class DocumentStore<_Data extends GraphQLObject, _Input extends Record<string, any>> extends Writable<QueryResult<_Data, _Input>> {
     #private;
+    pendingPromise: {
+        then: (val: any) => void;
+    } | null;
     constructor({ artifact, plugins, pipeline, client, cache, initialValue, fetching, }: {
         artifact: DocumentArtifact;
         plugins?: ClientHooks[];

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

@@ -1,11 +1,11 @@
 /// <reference path="../../../../../houdini.d.ts" />
 import type { DocumentArtifact, GraphQLObject, NestedList } from '../lib/types';
-import type { ClientPlugin, ClientHooks } from './documentStore';
+import type { ClientHooks, ClientPlugin } from './documentStore';
 import { DocumentStore } from './documentStore';
-import { type FetchParamFn, type ThrowOnErrorParams } from './plugins';
-export { DocumentStore, type ClientPlugin } from './documentStore';
+import type { FetchParamFn, ThrowOnErrorOperations, ThrowOnErrorParams } from './plugins';
+export { DocumentStore, type ClientPlugin, type SendParams } from './documentStore';
 export { fetch, mutation, query, subscription } from './plugins';
-type ConstructorArgs = {
+export type HoudiniClientConstructorArgs = {
     url: string;
     fetchParams?: FetchParamFn;
     plugins?: NestedList<ClientPlugin>;
@@ -19,9 +19,10 @@ export type ObserveParams<_Data extends GraphQLObject, _Artifact extends Documen
     fetching?: boolean;
 };
 export declare class HoudiniClient {
-    #private;
     url: string;
-    constructor({ url, fetchParams, plugins, pipeline, throwOnError }: ConstructorArgs);
+    readonly plugins: ClientPlugin[];
+    readonly throwOnError_operations: ThrowOnErrorOperations[];
+    constructor({ url, fetchParams, plugins, pipeline, throwOnError, }: HoudiniClientConstructorArgs);
     observe<_Data extends GraphQLObject, _Input extends Record<string, any>>({ artifact, cache, initialValue, fetching, }: ObserveParams<_Data>): DocumentStore<_Data, _Input>;
 }
 export declare function createPluginHooks(plugins: ClientPlugin[]): ClientHooks[];

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

@@ -3,7 +3,7 @@ import { Cache } from '../../cache/cache';
 import type { ClientPlugin } from '../documentStore';
 export declare const cachePolicy: ({ enabled, setFetching, cache: localCache, serverSideFallback, }: {
     enabled: boolean;
-    setFetching: (val: boolean) => void;
+    setFetching: (val: boolean, data?: any) => void;
     cache?: Cache | undefined;
     serverSideFallback?: boolean | undefined;
 }) => ClientPlugin;

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

@@ -21,6 +21,7 @@ export type FetchContext = {
 export type RequestHandlerArgs = FetchContext & FetchParams;
 export type RequestHandler<_Data = any> = (args: RequestHandlerArgs) => Promise<RequestPayload<_Data>>;
 export type FetchParams = {
+    name: string;
     text: string;
     hash: string;
     variables: {

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

@@ -3,6 +3,7 @@ export declare function subscription(factory: SubscriptionHandler): import("../d
 export type SubscriptionHandler = (ctx: ClientPluginContext) => SubscriptionClient;
 export type SubscriptionClient = {
     subscribe: (payload: {
+        operationName: string;
         query: string;
         variables?: {};
     }, handlers: {

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

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

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

@@ -0,0 +1,7 @@
+import type { GraphQLObject, PageInfo } from './types';
+export declare function nullPageInfo(): PageInfo;
+export declare function missingPageSizeError(fnName: string): {
+    message: string;
+};
+export declare function extractPageInfo(data: any, path: string[]): PageInfo;
+export declare function countPage<_Data extends GraphQLObject>(source: string[], value: _Data | null): number;

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

@@ -0,0 +1,27 @@
+import type { SendParams } from '../client/documentStore';
+import type { CursorHandlers, FetchFn, GraphQLObject, QueryArtifact, QueryResult, FetchParams } from './types';
+export declare function cursorHandlers<_Data extends GraphQLObject, _Input extends Record<string, any>>({ artifact, fetchUpdate: parentFetchUpdate, fetch: parentFetch, getState, getVariables, getSession, }: {
+    artifact: QueryArtifact;
+    getState: () => _Data | null;
+    getVariables: () => _Input;
+    getSession: () => Promise<App.Session>;
+    fetch: FetchFn<_Data, _Input>;
+    fetchUpdate: (arg: SendParams, updates: string[]) => ReturnType<FetchFn<_Data, _Input>>;
+}): CursorHandlers<_Data, _Input>;
+export declare function offsetHandlers<_Data extends GraphQLObject, _Input extends {}>({ artifact, storeName, getState, getVariables, fetch: parentFetch, fetchUpdate: parentFetchUpdate, getSession, }: {
+    artifact: QueryArtifact;
+    fetch: FetchFn<_Data, _Input>;
+    fetchUpdate: (arg: SendParams) => ReturnType<FetchFn<_Data, _Input>>;
+    storeName: string;
+    getState: () => _Data | null;
+    getVariables: () => _Input;
+    getSession: () => Promise<App.Session>;
+}): {
+    loadNextPage: ({ limit, offset, fetch, metadata, }?: {
+        limit?: number | undefined;
+        offset?: number | undefined;
+        fetch?: typeof fetch | undefined;
+        metadata?: {} | undefined;
+    }) => Promise<void>;
+    fetch(params?: FetchParams<_Input>): Promise<QueryResult<_Data, _Input>>;
+};

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

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

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

@@ -25,6 +25,7 @@ declare global {
             };
             optimisticResponse?: GraphQLObject;
             parentID?: string;
+            silenceLoading?: boolean;
         }
     }
 }
@@ -52,9 +53,12 @@ export type CompiledDocumentKind = ArtifactKinds;
 export type QueryArtifact = BaseCompiledDocument<'HoudiniQuery'> & {
     policy?: CachePolicies;
     partial?: boolean;
+    enableLoadingState?: boolean;
 };
 export type MutationArtifact = BaseCompiledDocument<'HoudiniMutation'>;
-export type FragmentArtifact = BaseCompiledDocument<'HoudiniFragment'>;
+export type FragmentArtifact = BaseCompiledDocument<'HoudiniFragment'> & {
+    enableLoadingState?: boolean;
+};
 export type SubscriptionArtifact = BaseCompiledDocument<'HoudiniSubscription'>;
 export declare const RefetchUpdateMode: {
     readonly append: "append";
@@ -128,12 +132,31 @@ export type GraphQLObject = {
     [key: string]: GraphQLValue;
 };
 export type GraphQLValue = number | string | boolean | null | GraphQLObject | GraphQLValue[] | undefined;
+export type LoadingSpec = {
+    kind: 'continue';
+    list?: {
+        depth: number;
+        count: number;
+    };
+} | {
+    kind: 'value';
+    value?: any;
+    list?: {
+        depth: number;
+        count: number;
+    };
+};
 export type SubscriptionSelection = {
-    fragments?: Record<string, ValueMap>;
+    loadingTypes?: string[];
+    fragments?: Record<string, {
+        arguments: ValueMap;
+        loading?: boolean;
+    }>;
     fields?: {
         [fieldName: string]: {
             type: string;
             nullable?: boolean;
+            required?: boolean;
             keyRaw: string;
             operations?: MutationOperation[];
             list?: {
@@ -141,6 +164,7 @@ export type SubscriptionSelection = {
                 connection: boolean;
                 type: string;
             };
+            loading?: LoadingSpec;
             directives?: {
                 name: string;
                 arguments: ValueMap;
@@ -153,6 +177,7 @@ export type SubscriptionSelection = {
             }>;
             selection?: SubscriptionSelection;
             abstract?: boolean;
+            abstractHasRequired?: boolean;
         };
     };
     abstractFields?: {
@@ -194,9 +219,54 @@ export type RequestPayload<GraphQLObject = any> = {
 };
 export type NestedList<_Result = string> = (_Result | null | NestedList<_Result>)[];
 export type ValueOf<Parent> = Parent[keyof Parent];
-export declare const fragmentKey = " $fragments";
+export declare const fragmentKey: " $fragments";
 export type ValueNode = VariableNode | IntValueNode | FloatValueNode | StringValueNode | BooleanValueNode | NullValueNode | EnumValueNode | ListValueNode | ObjectValueNode;
 export type ValueMap = Record<string, ValueNode>;
+export type FetchParams<_Input> = {
+    variables?: _Input;
+    /**
+     * The policy to use when performing the fetch. If set to CachePolicy.NetworkOnly,
+     * a request will always be sent, even if the variables are the same as the last call
+     * to fetch.
+     */
+    policy?: CachePolicies;
+    /**
+     * An object that will be passed to the fetch function.
+     * You can do what you want with it!
+     */
+    metadata?: App.Metadata;
+};
+export type FetchFn<_Data extends GraphQLObject, _Input = any> = (params?: FetchParams<_Input>) => Promise<QueryResult<_Data, _Input>>;
+export type CursorHandlers<_Data extends GraphQLObject, _Input> = {
+    loadNextPage: (args?: {
+        first?: number;
+        after?: string;
+        fetch?: typeof globalThis.fetch;
+        metadata?: {};
+    }) => Promise<void>;
+    loadPreviousPage: (args?: {
+        last?: number;
+        before?: string;
+        fetch?: typeof globalThis.fetch;
+        metadata?: {};
+    }) => Promise<void>;
+    fetch(args?: FetchParams<_Input> | undefined): Promise<QueryResult<_Data, _Input>>;
+};
+export type OffsetHandlers<_Data extends GraphQLObject, _Input> = {
+    loadNextPage: (args?: {
+        limit?: number;
+        offset?: number;
+        metadata?: {};
+        fetch?: typeof globalThis.fetch;
+    }) => Promise<void>;
+    fetch(args?: FetchParams<_Input> | undefined): Promise<QueryResult<_Data, _Input>>;
+};
+export type PageInfo = {
+    startCursor: string | null;
+    endCursor: string | null;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+};
 interface IntValueNode {
     readonly kind: 'IntValue';
     readonly value: string;
@@ -241,4 +311,6 @@ interface VariableNode {
     readonly kind: 'Variable';
     readonly name: NameNode;
 }
+export declare const PendingValue: unique symbol;
+export type LoadingType = typeof PendingValue;
 export {};

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

@@ -3,7 +3,6 @@ import type { GraphQLObject, GraphQLValue, NestedList, SubscriptionSelection, Su
 import { GarbageCollector } from './gc';
 import type { ListCollection } from './lists';
 import { ListManager } from './lists';
-import { SchemaManager } from './schema';
 import { StaleManager } from './staleManager';
 import type { Layer, LayerID } from './storage';
 import { InMemoryStorage } from './storage';
@@ -57,15 +56,13 @@ declare class CacheInternal {
     cache: Cache;
     lifetimes: GarbageCollector;
     staleManager: StaleManager;
-    schema: SchemaManager;
-    constructor({ storage, subscriptions, lists, cache, lifetimes, staleManager, schema, disabled, config, }: {
+    constructor({ storage, subscriptions, lists, cache, lifetimes, staleManager, disabled, config, }: {
         storage: InMemoryStorage;
         subscriptions: InMemorySubscriptions;
         lists: ListManager;
         cache: Cache;
         lifetimes: GarbageCollector;
         staleManager: StaleManager;
-        schema: SchemaManager;
         disabled: boolean;
         config?: ConfigFile;
     });
@@ -87,12 +84,13 @@ declare class CacheInternal {
         forceNotify?: boolean;
         forceStale?: boolean;
     }): FieldSelection[];
-    getSelection({ selection, parent, variables, stepsFromConnection, ignoreMasking, fullCheck, }: {
+    getSelection({ selection, parent, variables, stepsFromConnection, ignoreMasking, fullCheck, loading: generateLoading, }: {
         selection: SubscriptionSelection;
         parent?: string;
         variables?: {};
         stepsFromConnection?: number | null;
         ignoreMasking?: boolean;
+        loading?: boolean;
         fullCheck?: boolean;
     }): {
         data: GraphQLObject | null;
@@ -104,13 +102,14 @@ declare class CacheInternal {
     id(type: string, id: string): string | null;
     idFields(type: string): string[];
     computeID(type: string, data: any): string;
-    hydrateNestedList({ fields, variables, linkedList, stepsFromConnection, ignoreMasking, fullCheck, }: {
+    hydrateNestedList({ fields, variables, linkedList, stepsFromConnection, ignoreMasking, fullCheck, loading, }: {
         fields: SubscriptionSelection;
         variables?: {};
         linkedList: NestedList;
         stepsFromConnection: number | null;
         ignoreMasking: boolean;
         fullCheck?: boolean;
+        loading?: boolean;
     }): {
         data: NestedList<GraphQLValue>;
         partial: boolean;

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

@@ -31,7 +31,6 @@ var import_selection = require("../lib/selection");
 var import_types = require("../lib/types");
 var import_gc = require("./gc");
 var import_lists = require("./lists");
-var import_schema = require("./schema");
 var import_staleManager = require("./staleManager");
 var import_storage = require("./storage");
 var import_stuff = require("./stuff");
@@ -46,7 +45,6 @@ class Cache {
       lists: new import_lists.ListManager(this, rootID),
       lifetimes: new import_gc.GarbageCollector(this),
       staleManager: new import_staleManager.StaleManager(this),
-      schema: new import_schema.SchemaManager(this),
       disabled: disabled ?? typeof globalThis.window === "undefined"
     });
     if (Object.keys(config).length > 0) {
@@ -157,7 +155,6 @@ class CacheInternal {
   cache;
   lifetimes;
   staleManager;
-  schema;
   constructor({
     storage,
     subscriptions,
@@ -165,7 +162,6 @@ class CacheInternal {
     cache,
     lifetimes,
     staleManager,
-    schema,
     disabled,
     config
   }) {
@@ -175,7 +171,6 @@ class CacheInternal {
     this.cache = cache;
     this.lifetimes = lifetimes;
     this.staleManager = staleManager;
-    this.schema = schema;
     this._config = config;
     this._disabled = disabled;
     try {
@@ -205,7 +200,11 @@ class CacheInternal {
     if (this._disabled) {
       return [];
     }
-    let targetSelection = (0, import_selection.getFieldsForType)(selection, data["__typename"]);
+    let targetSelection = (0, import_selection.getFieldsForType)(
+      selection,
+      data["__typename"],
+      false
+    );
     for (const [field, value] of Object.entries(data)) {
       if (!selection || !targetSelection[field]) {
         continue;
@@ -216,17 +215,9 @@ class CacheInternal {
         selection: fieldSelection,
         operations,
         abstract: isAbstract,
-        updates,
-        nullable
+        updates
       } = targetSelection[field];
       const key = (0, import_stuff.evaluateKey)(keyRaw, variables);
-      this.schema.setFieldType({
-        parent,
-        key: keyRaw,
-        type: linkedType,
-        nullable,
-        link: !!fieldSelection
-      });
       if (value && typeof value === "object" && "__typename" in value && value["__typename"]) {
         linkedType = value["__typename"];
       }
@@ -472,32 +463,49 @@ class CacheInternal {
     variables,
     stepsFromConnection = null,
     ignoreMasking,
-    fullCheck = false
+    fullCheck = false,
+    loading: generateLoading
   }) {
     if (parent === null) {
       return { data: null, partial: false, stale: false, hasData: true };
     }
     const target = {};
     if (selection.fragments) {
-      target[import_types.fragmentKey] = Object.fromEntries(
-        Object.entries(selection.fragments).map(([key, value]) => [
-          key,
-          {
-            parent,
-            variables: evaluateFragmentVariables(value, variables ?? {})
-          }
-        ])
-      );
+      target[import_types.fragmentKey] = {
+        loading: Boolean(generateLoading),
+        values: Object.fromEntries(
+          Object.entries(selection.fragments).filter(([, value]) => !generateLoading || value.loading).map(([key, value]) => [
+            key,
+            {
+              parent,
+              variables: evaluateFragmentVariables(
+                value.arguments,
+                variables ?? {}
+              )
+            }
+          ])
+        )
+      };
     }
     let hasData = !!selection.fragments;
     let partial = false;
     let cascadeNull = false;
     let stale = false;
     const typename = this.storage.get(parent, "__typename").value;
-    let targetSelection = (0, import_selection.getFieldsForType)(selection, typename);
+    let targetSelection = (0, import_selection.getFieldsForType)(selection, typename, !!generateLoading);
     for (const [
       attributeName,
-      { type, keyRaw, selection: fieldSelection, nullable, list, visible, directives }
+      {
+        type,
+        keyRaw,
+        selection: fieldSelection,
+        nullable,
+        list,
+        visible,
+        directives,
+        loading: fieldLoading,
+        abstractHasRequired
+      }
     ] of Object.entries(targetSelection)) {
       if (!visible && !ignoreMasking && !fullCheck) {
         continue;
@@ -520,11 +528,17 @@ class CacheInternal {
       }
       const fieldTarget = visible || ignoreMasking ? target : {};
       const key = (0, import_stuff.evaluateKey)(keyRaw, variables);
-      const { value } = this.storage.get(parent, key);
+      if (generateLoading && !fieldLoading) {
+        continue;
+      }
+      let { value } = this.storage.get(parent, key);
       const dt_field = this.staleManager.getFieldTime(parent, key);
       if (dt_field === null) {
         stale = true;
       }
+      if (generateLoading) {
+        value = void 0;
+      }
       let nextStep = stepsFromConnection;
       if (nextStep !== null) {
         if (nextStep >= 2) {
@@ -540,7 +554,10 @@ class CacheInternal {
       if (typeof value === "undefined" && !embeddedCursor) {
         partial = true;
       }
-      if (typeof value === "undefined" || value === null) {
+      if (generateLoading && fieldLoading?.kind === "value") {
+        fieldTarget[attributeName] = import_lib.PendingValue;
+        hasData = true;
+      } else if (!generateLoading && typeof value === "undefined" || value === null) {
         fieldTarget[attributeName] = null;
         if (typeof value !== "undefined") {
           hasData = true;
@@ -560,7 +577,8 @@ class CacheInternal {
           linkedList: value,
           stepsFromConnection: nextStep,
           ignoreMasking: !!ignoreMasking,
-          fullCheck
+          fullCheck,
+          loading: generateLoading
         });
         fieldTarget[attributeName] = listValue.data;
         if (listValue.partial) {
@@ -579,7 +597,8 @@ class CacheInternal {
           variables,
           stepsFromConnection: nextStep,
           ignoreMasking,
-          fullCheck
+          fullCheck,
+          loading: generateLoading
         });
         fieldTarget[attributeName] = objectFields.data;
         if (objectFields.partial) {
@@ -592,13 +611,27 @@ class CacheInternal {
           hasData = true;
         }
       }
+      if (generateLoading && fieldLoading?.list) {
+        fieldTarget[attributeName] = wrapInLists(
+          Array.from({ length: fieldLoading.list.count }).fill(
+            fieldTarget[attributeName]
+          ),
+          fieldLoading.list.depth - 1
+        );
+      }
       if (fieldTarget[attributeName] === null && !nullable && !embeddedCursor) {
-        cascadeNull = true;
+        if (abstractHasRequired) {
+          target[attributeName] = {
+            __typename: "@required field missing; don't match this"
+          };
+        } else {
+          cascadeNull = true;
+        }
       }
     }
     return {
       data: cascadeNull ? null : target,
-      partial: hasData && partial,
+      partial: !generateLoading && hasData && partial,
       stale: hasData && stale,
       hasData
     };
@@ -625,7 +658,8 @@ class CacheInternal {
     linkedList,
     stepsFromConnection,
     ignoreMasking,
-    fullCheck
+    fullCheck,
+    loading
   }) {
     const result = [];
     let partialData = false;
@@ -639,7 +673,8 @@ class CacheInternal {
           linkedList: entry,
           stepsFromConnection,
           ignoreMasking,
-          fullCheck
+          fullCheck,
+          loading
         });
         result.push(nestedValue.data);
         if (nestedValue.partial) {
@@ -662,7 +697,8 @@ class CacheInternal {
         variables,
         stepsFromConnection,
         ignoreMasking,
-        fullCheck
+        fullCheck,
+        loading
       });
       result.push(data);
       if (partial) {
@@ -769,6 +805,12 @@ function evaluateFragmentVariables(variables, args) {
     Object.entries(variables).map(([key, value]) => [key, fragmentVariableValue(value, args)])
   );
 }
+function wrapInLists(target, count = 0) {
+  if (count === 0) {
+    return target;
+  }
+  return wrapInLists([target], count - 1);
+}
 function fragmentVariableValue(value, args) {
   if (value.kind === "StringValue") {
     return value.value;

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

@@ -40,7 +40,7 @@ class InMemorySubscriptions {
     parentType
   }) {
     const __typename = this.cache._internal_unstable.storage.get(parent, "__typename").value;
-    let targetSelection = (0, import_selection.getFieldsForType)(selection, __typename);
+    let targetSelection = (0, import_selection.getFieldsForType)(selection, __typename, false);
     for (const fieldSelection of Object.values(targetSelection || {})) {
       const {
         keyRaw,
@@ -57,7 +57,7 @@ class InMemorySubscriptions {
       let targetSelection2;
       if (innerSelection) {
         const __typename2 = this.cache._internal_unstable.storage.get(parent, "__typename").value;
-        targetSelection2 = (0, import_selection.getFieldsForType)(innerSelection, __typename2);
+        targetSelection2 = (0, import_selection.getFieldsForType)(innerSelection, __typename2, false);
       }
       this.addFieldSubscription({
         id: parent,
@@ -168,7 +168,7 @@ class InMemorySubscriptions {
           filters
         } = selection;
         const key = (0, import_stuff.evaluateKey)(keyRaw, variables);
-        const fieldSelection = innerSelection ? (0, import_selection.getFieldsForType)(innerSelection, parentType) : void 0;
+        const fieldSelection = innerSelection ? (0, import_selection.getFieldsForType)(innerSelection, parentType, false) : void 0;
         this.addFieldSubscription({
           id: parent,
           key,
@@ -198,7 +198,7 @@ class InMemorySubscriptions {
               linkedRecord,
               "__typename"
             ).value;
-            let targetSelection2 = (0, import_selection.getFieldsForType)(childSelection, __typename);
+            let targetSelection2 = (0, import_selection.getFieldsForType)(childSelection, __typename, false);
             this.addMany({
               parent: linkedRecord,
               variables,
@@ -217,7 +217,7 @@ class InMemorySubscriptions {
     visited.push(id);
     const linkedIDs = [];
     const __typename = this.cache._internal_unstable.storage.get(id, "__typename").value;
-    let targetSelection = (0, import_selection.getFieldsForType)(selection, __typename);
+    let targetSelection = (0, import_selection.getFieldsForType)(selection, __typename, false);
     for (const fieldSelection of Object.values(targetSelection || {})) {
       const key = (0, import_stuff.evaluateKey)(fieldSelection.keyRaw, variables);
       this.removeSubscribers(id, key, targets);

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

@@ -5,6 +5,9 @@ import { Writable } from '../lib/store';
 import type { DocumentArtifact, QueryResult, GraphQLObject, SubscriptionSpec, CachePolicies } from '../lib/types';
 export declare class DocumentStore<_Data extends GraphQLObject, _Input extends Record<string, any>> extends Writable<QueryResult<_Data, _Input>> {
     #private;
+    pendingPromise: {
+        then: (val: any) => void;
+    } | null;
     constructor({ artifact, plugins, pipeline, client, cache, initialValue, fetching, }: {
         artifact: DocumentArtifact;
         plugins?: ClientHooks[];