houdini 1.2.0-react.1 → 1.2.0

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

@@ -1,4 +1,4 @@
-import { computeKey } from "../lib";
+import { computeKey, PendingValue } from "../lib";
 import { computeID, defaultConfigValues, keyFieldsForType, getCurrentConfig } from "../lib/config";
 import { deepEquals } from "../lib/deepEquals";
 import { flatten } from "../lib/flatten";
@@ -6,7 +6,6 @@ import { getFieldsForType } from "../lib/selection";
 import { fragmentKey } from "../lib/types";
 import { GarbageCollector } from "./gc";
 import { ListManager } from "./lists";
-import { SchemaManager } from "./schema";
 import { StaleManager } from "./staleManager";
 import { InMemoryStorage } from "./storage";
 import { evaluateKey } from "./stuff";
@@ -21,7 +20,6 @@ class Cache {
       lists: new ListManager(this, rootID),
       lifetimes: new GarbageCollector(this),
       staleManager: new StaleManager(this),
-      schema: new SchemaManager(this),
       disabled: disabled ?? typeof globalThis.window === "undefined"
     });
     if (Object.keys(config).length > 0) {
@@ -132,7 +130,6 @@ class CacheInternal {
   cache;
   lifetimes;
   staleManager;
-  schema;
   constructor({
     storage,
     subscriptions,
@@ -140,7 +137,6 @@ class CacheInternal {
     cache,
     lifetimes,
     staleManager,
-    schema,
     disabled,
     config
   }) {
@@ -150,7 +146,6 @@ class CacheInternal {
     this.cache = cache;
     this.lifetimes = lifetimes;
     this.staleManager = staleManager;
-    this.schema = schema;
     this._config = config;
     this._disabled = disabled;
     try {
@@ -180,7 +175,11 @@ class CacheInternal {
     if (this._disabled) {
       return [];
     }
-    let targetSelection = getFieldsForType(selection, data["__typename"]);
+    let targetSelection = getFieldsForType(
+      selection,
+      data["__typename"],
+      false
+    );
     for (const [field, value] of Object.entries(data)) {
       if (!selection || !targetSelection[field]) {
         continue;
@@ -191,17 +190,9 @@ class CacheInternal {
         selection: fieldSelection,
         operations,
         abstract: isAbstract,
-        updates,
-        nullable
+        updates
       } = targetSelection[field];
       const key = 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"];
       }
@@ -446,42 +437,83 @@ class CacheInternal {
     parent = rootID,
     variables,
     stepsFromConnection = null,
-    ignoreMasking
+    ignoreMasking,
+    fullCheck = false,
+    loading: generateLoading
   }) {
     if (parent === null) {
       return { data: null, partial: false, stale: false, hasData: true };
     }
     const target = {};
     if (selection.fragments) {
-      target[fragmentKey] = Object.fromEntries(
-        Object.entries(selection.fragments).map(([key, value]) => [
-          key,
-          {
-            parent,
-            variables: evaluateFragmentVariables(value, variables ?? {})
-          }
-        ])
-      );
+      target[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 = getFieldsForType(selection, typename);
+    let targetSelection = getFieldsForType(selection, typename, !!generateLoading);
     for (const [
       attributeName,
-      { type, keyRaw, selection: fieldSelection, nullable, list, visible }
+      {
+        type,
+        keyRaw,
+        selection: fieldSelection,
+        nullable,
+        list,
+        visible,
+        directives,
+        loading: fieldLoading,
+        abstractHasRequired
+      }
     ] of Object.entries(targetSelection)) {
-      if (!visible && !ignoreMasking) {
+      if (!visible && !ignoreMasking && !fullCheck) {
         continue;
       }
+      const includeDirective = directives?.find((d) => {
+        return d.name === "include";
+      });
+      if (includeDirective) {
+        if (!evaluateFragmentVariables(includeDirective.arguments, variables ?? {})["if"]) {
+          continue;
+        }
+      }
+      const skipDirective = directives?.find((d) => {
+        return d.name === "skip";
+      });
+      if (skipDirective) {
+        if (evaluateFragmentVariables(skipDirective.arguments, variables ?? {})["if"]) {
+          continue;
+        }
+      }
+      const fieldTarget = visible || ignoreMasking ? target : {};
       const key = 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) {
@@ -497,17 +529,20 @@ class CacheInternal {
       if (typeof value === "undefined" && !embeddedCursor) {
         partial = true;
       }
-      if (typeof value === "undefined" || value === null) {
-        target[attributeName] = null;
+      if (generateLoading && fieldLoading?.kind === "value") {
+        fieldTarget[attributeName] = PendingValue;
+        hasData = true;
+      } else if (!generateLoading && typeof value === "undefined" || value === null) {
+        fieldTarget[attributeName] = null;
         if (typeof value !== "undefined") {
           hasData = true;
         }
       } else if (!fieldSelection) {
         const fnUnmarshal = this.config?.scalars?.[type]?.unmarshal;
         if (fnUnmarshal) {
-          target[attributeName] = fnUnmarshal(value);
+          fieldTarget[attributeName] = fnUnmarshal(value);
         } else {
-          target[attributeName] = value;
+          fieldTarget[attributeName] = value;
         }
         hasData = true;
       } else if (Array.isArray(value)) {
@@ -516,9 +551,11 @@ class CacheInternal {
           variables,
           linkedList: value,
           stepsFromConnection: nextStep,
-          ignoreMasking: !!ignoreMasking
+          ignoreMasking: !!ignoreMasking,
+          fullCheck,
+          loading: generateLoading
         });
-        target[attributeName] = listValue.data;
+        fieldTarget[attributeName] = listValue.data;
         if (listValue.partial) {
           partial = true;
         }
@@ -534,9 +571,11 @@ class CacheInternal {
           selection: fieldSelection,
           variables,
           stepsFromConnection: nextStep,
-          ignoreMasking
+          ignoreMasking,
+          fullCheck,
+          loading: generateLoading
         });
-        target[attributeName] = objectFields.data;
+        fieldTarget[attributeName] = objectFields.data;
         if (objectFields.partial) {
           partial = true;
         }
@@ -547,13 +586,27 @@ class CacheInternal {
           hasData = true;
         }
       }
-      if (target[attributeName] === null && !nullable && !embeddedCursor) {
-        cascadeNull = 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) {
+        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
     };
@@ -579,7 +632,9 @@ class CacheInternal {
     variables,
     linkedList,
     stepsFromConnection,
-    ignoreMasking
+    ignoreMasking,
+    fullCheck,
+    loading
   }) {
     const result = [];
     let partialData = false;
@@ -592,7 +647,9 @@ class CacheInternal {
           variables,
           linkedList: entry,
           stepsFromConnection,
-          ignoreMasking
+          ignoreMasking,
+          fullCheck,
+          loading
         });
         result.push(nestedValue.data);
         if (nestedValue.partial) {
@@ -614,7 +671,9 @@ class CacheInternal {
         selection: fields,
         variables,
         stepsFromConnection,
-        ignoreMasking
+        ignoreMasking,
+        fullCheck,
+        loading
       });
       result.push(data);
       if (partial) {
@@ -721,6 +780,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-esm/cache/stuff.d.ts

@@ -1,4 +1 @@
-import type { GraphQLValue } from '../lib/types';
-export declare function evaluateKey(key: string, variables?: {
-    [key: string]: GraphQLValue;
-}): string;
+export declare function evaluateKey(key: string, variables?: Record<string, any> | null): string;

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

@@ -1,4 +1,4 @@
-function evaluateKey(key, variables = {}) {
+function evaluateKey(key, variables = null) {
   let evaluated = "";
   let varName = "";
   let inString = false;
@@ -8,7 +8,7 @@ function evaluateKey(key, variables = {}) {
         varName += char;
         continue;
       }
-      const value = variables[varName.slice(1)];
+      const value = variables?.[varName.slice(1)];
       evaluated += typeof value !== "undefined" ? JSON.stringify(value) : "undefined";
       varName = "";
     }

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

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

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

@@ -2,8 +2,8 @@ import type { HoudiniClient } from '.';
 import type { Layer } from '../cache/storage';
 import type { ConfigFile } from '../lib/config';
 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>> {
+import type { DocumentArtifact, QueryResult, GraphQLObject, SubscriptionSpec, CachePolicies, GraphQLVariables } from '../lib/types';
+export declare class DocumentStore<_Data extends GraphQLObject, _Input extends GraphQLVariables> extends Writable<QueryResult<_Data, _Input>> {
     #private;
     pendingPromise: {
         then: (val: any) => void;
@@ -20,7 +20,7 @@ export declare class DocumentStore<_Data extends GraphQLObject, _Input extends R
     send({ metadata, session, fetch, variables, policy, stuff, cacheParams, setup, silenceEcho, }?: SendParams): Promise<QueryResult<_Data, _Input>>;
     cleanup(): Promise<void>;
 }
-declare function marshalVariables<_Data extends GraphQLObject, _Input extends {}>(ctx: ClientPluginContext): Record<string, any>;
+declare function marshalVariables<_Data extends GraphQLObject, _Input extends GraphQLVariables>(ctx: ClientPluginContext): Record<string, any>;
 export type ClientPlugin = () => ClientHooks | null | (ClientHooks | ClientPlugin | null)[];
 export type ClientHooks = {
     start?: ClientPluginEnterPhase;

package/build/runtime-esm/client/documentStore.js

@@ -48,7 +48,15 @@ class DocumentStore extends Writable {
     this.#plugins = pipeline ?? [
       cachePolicy({
         enabled: cache,
-        setFetching: (fetching2) => this.update((state) => ({ ...state, fetching: fetching2 }))
+        setFetching: (fetching2, data) => {
+          this.update((state) => {
+            const newState = { ...state, fetching: fetching2 };
+            if (fetching2 && data) {
+              newState.data = data;
+            }
+            return newState;
+          });
+        }
       })(),
       ...plugins ?? []
     ];
@@ -292,7 +300,7 @@ class ClientPluginContextWrapper {
     };
     const firstInit = !ctx.stuff.inputs || !ctx.stuff.inputs.init;
     const hasChanged = Object.keys(changed).length > 0 || firstInit;
-    if (artifact.kind !== ArtifactKind.Fragment && hasChanged) {
+    if (hasChanged) {
       const newVariables = {
         ...ctx.stuff.inputs?.marshaled,
         ...marshalInputs({

package/build/runtime-esm/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 { DocumentArtifact, GraphQLVariables, GraphQLObject, NestedList } from '../lib/types';
+import type { ClientHooks, ClientPlugin } from './documentStore';
 import { DocumentStore } from './documentStore';
-import { type FetchParamFn, type ThrowOnErrorParams } from './plugins';
+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);
-    observe<_Data extends GraphQLObject, _Input extends Record<string, any>>({ artifact, cache, initialValue, fetching, }: ObserveParams<_Data>): DocumentStore<_Data, _Input>;
+    readonly plugins: ClientPlugin[];
+    readonly throwOnError_operations: ThrowOnErrorOperations[];
+    constructor({ url, fetchParams, plugins, pipeline, throwOnError, }: HoudiniClientConstructorArgs);
+    observe<_Data extends GraphQLObject, _Input extends GraphQLVariables>({ artifact, cache, initialValue, fetching, }: ObserveParams<_Data>): DocumentStore<_Data, _Input>;
 }
 export declare function createPluginHooks(plugins: ClientPlugin[]): ClientHooks[];

package/build/runtime-esm/client/index.js

@@ -2,25 +2,33 @@ import { flatten } from "../lib/flatten";
 import { DocumentStore } from "./documentStore";
 import {
   fetch as fetchPlugin,
+  fetchParams as fetchParamsPlugin,
+  fragment as fragmentPlugin,
   mutation as mutationPlugin,
   query as queryPlugin,
-  fragment as fragmentPlugin,
-  throwOnError as throwOnErrorPlugin,
-  fetchParams as fetchParamsPlugin
+  throwOnError as throwOnErrorPlugin
 } from "./plugins";
 import pluginsFromPlugins from "./plugins/injectedPlugins";
 import { DocumentStore as DocumentStore2 } from "./documentStore";
 import { fetch, mutation, query, subscription } from "./plugins";
 class HoudiniClient {
   url;
-  #plugins;
-  constructor({ url, fetchParams, plugins, pipeline, throwOnError }) {
+  plugins;
+  throwOnError_operations;
+  constructor({
+    url,
+    fetchParams,
+    plugins,
+    pipeline,
+    throwOnError
+  }) {
     if (plugins && pipeline) {
       throw new Error(
         "A client cannot be given a pipeline and a list of plugins at the same time."
       );
     }
-    this.#plugins = flatten(
+    this.throwOnError_operations = throwOnError?.operations ?? [];
+    this.plugins = flatten(
       [].concat(
         throwOnError ? [throwOnErrorPlugin(throwOnError)] : [],
         fetchParamsPlugin(fetchParams),
@@ -46,7 +54,7 @@ class HoudiniClient {
     return new DocumentStore({
       client: this,
       artifact,
-      plugins: createPluginHooks(this.#plugins),
+      plugins: createPluginHooks(this.plugins),
       cache,
       initialValue,
       fetching

package/build/runtime-esm/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-esm/client/plugins/cache.js

@@ -17,7 +17,7 @@ const cachePolicy = ({
           const value = localCache.read({
             selection: artifact.selection,
             variables: marshalVariables(ctx),
-            parent: ctx.stuff?.parentID
+            fullCheck: true
           });
           const allowed = !value.partial || artifact.kind === ArtifactKind.Query && artifact.partial;
           if (policy === CachePolicy.CacheOnly) {
@@ -54,7 +54,15 @@ const cachePolicy = ({
         }, 0);
       }
       if (!ctx.stuff?.silenceLoading) {
-        setFetching(!useCache);
+        let fetchingState = null;
+        if (!useCache && "enableLoadingState" in artifact && artifact.enableLoadingState) {
+          fetchingState = localCache.read({
+            selection: artifact.selection,
+            variables: marshalVariables(ctx),
+            loading: true
+          }).data;
+        }
+        setFetching(!useCache, fetchingState);
       }
       return next(ctx);
     },

package/build/runtime-esm/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-esm/client/plugins/fetch.js

@@ -8,6 +8,7 @@ const fetch = (target) => {
         }
         const fetch2 = ctx.fetch ?? globalThis.fetch;
         const fetchParams = {
+          name: ctx.artifact.name,
           text: ctx.text,
           hash: ctx.hash,
           variables: marshalVariables(ctx)
@@ -48,10 +49,10 @@ const defaultFetch = (url, params) => {
       "Could not find configured client url. Please specify one in your HoudiniClient constructor."
     );
   }
-  return async ({ fetch: fetch2, text, variables }) => {
+  return async ({ fetch: fetch2, name, text, variables }) => {
     const result = await fetch2(url, {
       method: "POST",
-      body: JSON.stringify({ query: text, variables }),
+      body: JSON.stringify({ operationName: name, query: text, variables }),
       ...params,
       headers: {
         Accept: "application/graphql+json, application/json",

package/build/runtime-esm/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-esm/client/plugins/subscription.js

@@ -32,6 +32,7 @@ function subscription(factory) {
         clearSubscription?.();
         clearSubscription = client.subscribe(
           {
+            operationName: ctx.artifact.name,
             query: ctx.artifact.raw,
             variables: marshalVariables(ctx)
           },

package/build/runtime-esm/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-esm/lib/config.js

@@ -24,7 +24,8 @@ function defaultConfigValues(file) {
   };
 }
 function keyFieldsForType(configFile, type) {
-  return configFile.types?.[type]?.keys || configFile.defaultKeys;
+  const withDefault = defaultConfigValues(configFile);
+  return withDefault.types?.[type]?.keys || withDefault.defaultKeys;
 }
 function computeID(configFile, type, data) {
   const fields = keyFieldsForType(configFile, type);

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

@@ -1,16 +1,14 @@
 import type { SendParams } from '../client/documentStore';
-import { FetchParams } from './types';
-import type { CursorHandlers, FetchFn, GraphQLObject, QueryArtifact, QueryResult } from './types';
-export declare function cursorHandlers<_Data extends GraphQLObject, _Input extends Record<string, any>>({ artifact, storeName, fetchUpdate: parentFetchUpdate, fetch: parentFetch, getState, getVariables, getSession, }: {
+import type { CursorHandlers, FetchFn, GraphQLObject, GraphQLVariables, QueryArtifact, QueryResult, FetchParams } from './types';
+export declare function cursorHandlers<_Data extends GraphQLObject, _Input extends GraphQLVariables>({ artifact, fetchUpdate: parentFetchUpdate, fetch: parentFetch, getState, getVariables, getSession, }: {
     artifact: QueryArtifact;
-    storeName: string;
     getState: () => _Data | null;
-    getVariables: () => _Input;
+    getVariables: () => NonNullable<_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, }: {
+export declare function offsetHandlers<_Data extends GraphQLObject, _Input extends GraphQLVariables>({ artifact, storeName, getState, getVariables, fetch: parentFetch, fetchUpdate: parentFetchUpdate, getSession, }: {
     artifact: QueryArtifact;
     fetch: FetchFn<_Data, _Input>;
     fetchUpdate: (arg: SendParams) => ReturnType<FetchFn<_Data, _Input>>;

package/build/runtime-esm/lib/pagination.js

@@ -1,11 +1,9 @@
 import { getCurrentConfig } from "./config";
-import { siteURL } from "./constants";
 import { deepEquals } from "./deepEquals";
 import { countPage, extractPageInfo, missingPageSizeError } from "./pageInfo";
 import { CachePolicy } from "./types";
 function cursorHandlers({
   artifact,
-  storeName,
   fetchUpdate: parentFetchUpdate,
   fetch: parentFetch,
   getState,
@@ -39,16 +37,6 @@ function cursorHandlers({
       },
       isSinglePage ? [] : [where === "start" ? "prepend" : "append"]
     );
-    const resultPath = [...artifact.refetch.path];
-    if (artifact.refetch.embedded) {
-      const { targetType } = artifact.refetch;
-      if (!config.types?.[targetType]?.resolve) {
-        throw new Error(
-          `Missing type resolve configuration for ${targetType}. For more information, see ${siteURL}/guides/pagination#paginated-fragments`
-        );
-      }
-      resultPath.unshift(config.types[targetType].resolve.queryField);
-    }
   };
   const getPageInfo = () => {
     return extractPageInfo(getState(), artifact.refetch?.path ?? []);

package/build/runtime-esm/lib/scalars.js

@@ -11,7 +11,7 @@ async function marshalSelection({
   if (Array.isArray(data)) {
     return await Promise.all(data.map((val) => marshalSelection({ selection, data: val })));
   }
-  const targetSelection = getFieldsForType(selection, data["__typename"]);
+  const targetSelection = getFieldsForType(selection, data["__typename"], false);
   return Object.fromEntries(
     await Promise.all(
       Object.entries(data).map(async ([fieldName, value]) => {