houdini-svelte 1.1.4-react.0 → 1.1.4

package/build/runtime-cjs/stores/pagination/offset.js

@@ -0,0 +1,89 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var offset_exports = {};
+__export(offset_exports, {
+  offsetHandlers: () => offsetHandlers
+});
+module.exports = __toCommonJS(offset_exports);
+var import_lib = require("$houdini/runtime/lib");
+var import_deepEquals = require("$houdini/runtime/lib/deepEquals");
+var import_session = require("../../session");
+var import_query = require("../query");
+var import_pageInfo = require("./pageInfo");
+function offsetHandlers({
+  artifact,
+  storeName,
+  getState,
+  getVariables,
+  fetch: parentFetch,
+  fetchUpdate: parentFetchUpdate
+}) {
+  let getOffset = () => artifact.refetch?.start || (0, import_pageInfo.countPage)(artifact.refetch.path, getState()) || artifact.refetch.pageSize;
+  let currentOffset = getOffset() ?? 0;
+  return {
+    loadNextPage: async ({
+      limit,
+      offset,
+      fetch,
+      metadata
+    } = {}) => {
+      const queryVariables = {
+        ...getVariables(),
+        offset: offset ?? getOffset()
+      };
+      if (limit || limit === 0) {
+        queryVariables.limit = limit;
+      }
+      if (!queryVariables.limit && !artifact.refetch.pageSize) {
+        throw (0, import_pageInfo.missingPageSizeError)("loadNextPage");
+      }
+      let isSinglePage = artifact.refetch?.mode === "SinglePage";
+      const targetFetch = isSinglePage ? parentFetch : parentFetchUpdate;
+      await targetFetch({
+        variables: queryVariables,
+        fetch,
+        metadata,
+        policy: isSinglePage ? artifact.policy : import_lib.CachePolicy.NetworkOnly,
+        session: await (0, import_session.getSession)()
+      });
+      const pageSize = queryVariables.limit || artifact.refetch.pageSize;
+      currentOffset = offset + pageSize;
+    },
+    async fetch(args) {
+      const { params } = await (0, import_query.fetchParams)(artifact, storeName, args);
+      const { variables } = params ?? {};
+      if (variables && !(0, import_deepEquals.deepEquals)(getVariables(), variables)) {
+        return parentFetch.call(this, params);
+      }
+      const count = currentOffset || getOffset();
+      const queryVariables = {};
+      if (!artifact.refetch.pageSize || count > artifact.refetch.pageSize) {
+        queryVariables.limit = count;
+      }
+      return await parentFetch.call(this, {
+        ...params,
+        variables: queryVariables
+      });
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  offsetHandlers
+});

package/build/runtime-cjs/stores/pagination/pageInfo.d.ts

@@ -0,0 +1,13 @@
+import type { GraphQLObject } from '$houdini/runtime/lib/types';
+export declare function nullPageInfo(): PageInfo;
+export type PageInfo = {
+    startCursor: string | null;
+    endCursor: string | null;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+};
+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-cjs/stores/pagination/pageInfo.js

@@ -0,0 +1,79 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var pageInfo_exports = {};
+__export(pageInfo_exports, {
+  countPage: () => countPage,
+  extractPageInfo: () => extractPageInfo,
+  missingPageSizeError: () => missingPageSizeError,
+  nullPageInfo: () => nullPageInfo
+});
+module.exports = __toCommonJS(pageInfo_exports);
+var import_constants = require("$houdini/runtime/lib/constants");
+function nullPageInfo() {
+  return { startCursor: null, endCursor: null, hasNextPage: false, hasPreviousPage: false };
+}
+function missingPageSizeError(fnName) {
+  return {
+    message: `${fnName} is missing the required page arguments. For more information, please visit this link: ${import_constants.siteURL}/guides/pagination`
+  };
+}
+function extractPageInfo(data, path) {
+  if (!data) {
+    return {
+      startCursor: null,
+      endCursor: null,
+      hasNextPage: false,
+      hasPreviousPage: false
+    };
+  }
+  let localPath = [...path];
+  let current = data;
+  while (localPath.length > 0) {
+    if (!current) {
+      break;
+    }
+    current = current[localPath.shift()];
+  }
+  return current?.pageInfo ?? nullPageInfo();
+}
+function countPage(source, value) {
+  let data = value;
+  if (value === null || data === null || data === void 0) {
+    return 0;
+  }
+  for (const field of source) {
+    const obj = data[field];
+    if (obj && !Array.isArray(obj)) {
+      data = obj;
+    } else if (!data) {
+      throw new Error("Could not count page size");
+    }
+    if (Array.isArray(obj)) {
+      return obj.length;
+    }
+  }
+  return 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  countPage,
+  extractPageInfo,
+  missingPageSizeError,
+  nullPageInfo
+});

package/build/runtime-cjs/stores/pagination/query.d.ts

@@ -1,8 +1,9 @@
-import type { GraphQLObject, QueryArtifact, QueryResult, CursorHandlers, OffsetHandlers, PageInfo } from '$houdini/runtime/lib/types';
+import type { GraphQLObject, QueryArtifact, QueryResult } from '$houdini/runtime/lib/types';
 import type { Subscriber } from 'svelte/store';
-import type { ClientFetchParams, LoadEventFetchParams, QueryStoreFetchParams, RequestEventFetchParams } from '../../types';
-import { StoreConfig } from '../query';
+import type { CursorHandlers, OffsetHandlers } from '../../types';
+import type { ClientFetchParams, LoadEventFetchParams, QueryStoreFetchParams, RequestEventFetchParams, StoreConfig } from '../query';
 import { QueryStore } from '../query';
+import { type PageInfo } from './pageInfo';
 export type CursorStoreResult<_Data extends GraphQLObject, _Input extends {}> = QueryResult<_Data, _Input> & {
     pageInfo: PageInfo;
 };

package/build/runtime-cjs/stores/pagination/query.js

@@ -22,13 +22,13 @@ __export(query_exports, {
   QueryStoreOffset: () => QueryStoreOffset
 });
 module.exports = __toCommonJS(query_exports);
-var import_pageInfo = require("$houdini/runtime/lib/pageInfo");
-var import_pagination = require("$houdini/runtime/lib/pagination");
 var import_store = require("svelte/store");
 var import_client = require("../../client");
-var import_session = require("../../session");
-var import_query2 = require("../query");
-class QueryStoreCursor extends import_query2.QueryStore {
+var import_query = require("../query");
+var import_cursor = require("./cursor");
+var import_offset = require("./offset");
+var import_pageInfo = require("./pageInfo");
+class QueryStoreCursor extends import_query.QueryStore {
   paginated = true;
   constructor(config) {
     super(config);
@@ -42,13 +42,13 @@ class QueryStoreCursor extends import_query2.QueryStore {
     const paginationObserver = (0, import_client.getClient)().observe({
       artifact: this.artifact
     });
-    this.#_handlers = (0, import_pagination.cursorHandlers)({
+    this.#_handlers = (0, import_cursor.cursorHandlers)({
       artifact: this.artifact,
+      initialValue: (0, import_store.get)(this.observer).data,
       getState: () => (0, import_store.get)(this.observer).data,
       getVariables: () => (0, import_store.get)(this.observer).variables,
       storeName: this.name,
       fetch: super.fetch.bind(this),
-      getSession: import_session.getSession,
       fetchUpdate: async (args, updates) => {
         return paginationObserver.send({
           ...args,
@@ -84,7 +84,7 @@ class QueryStoreCursor extends import_query2.QueryStore {
     return combined.subscribe(run, invalidate);
   }
 }
-class QueryStoreOffset extends import_query2.QueryStore {
+class QueryStoreOffset extends import_query.QueryStore {
   paginated = true;
   async loadNextPage(args) {
     const handlers = await this.#handlers();
@@ -103,13 +103,12 @@ class QueryStoreOffset extends import_query2.QueryStore {
     const paginationObserver = (0, import_client.getClient)().observe({
       artifact: this.artifact
     });
-    this.#_handlers = (0, import_pagination.offsetHandlers)({
+    this.#_handlers = (0, import_offset.offsetHandlers)({
       artifact: this.artifact,
       storeName: this.name,
       fetch: super.fetch,
       getState: () => (0, import_store.get)(this.observer).data,
       getVariables: () => (0, import_store.get)(this.observer).variables,
-      getSession: import_session.getSession,
       fetchUpdate: async (args) => {
         await (0, import_client.initClient)();
         return paginationObserver.send({

package/build/runtime-cjs/stores/query.d.ts

@@ -1,7 +1,7 @@
 import type { FetchContext } from '$houdini/runtime/client/plugins/fetch';
-import type { GraphQLObject, MutationArtifact, QueryArtifact, QueryResult, CachePolicies } from '$houdini/runtime/lib/types';
+import type { GraphQLObject, HoudiniFetchContext, MutationArtifact, QueryArtifact, QueryResult, CachePolicies } from '$houdini/runtime/lib/types';
+import type { LoadEvent, RequestEvent } from '@sveltejs/kit';
 import type { PluginArtifactData } from '../../plugin/artifactData';
-import type { ClientFetchParams, LoadEventFetchParams, QueryStoreFetchParams, RequestEventFetchParams } from '../types';
 import { BaseStore } from './base';
 export declare class QueryStore<_Data extends GraphQLObject, _Input extends {}> extends BaseStore<_Data, _Input, QueryArtifact> {
     variables: boolean;
@@ -31,3 +31,55 @@ export declare function fetchParams<_Data extends GraphQLObject, _Input>(artifac
     policy: CachePolicies | undefined;
     params: QueryStoreFetchParams<_Data, _Input>;
 }>;
+type FetchGlobalParams<_Data extends GraphQLObject, _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;
+    /**
+     * Set to true if you want the promise to pause while it's resolving.
+     * Only enable this if you know what you are doing. This will cause route
+     * transitions to pause while loading data.
+     */
+    blocking?: boolean;
+    /**
+     * A function to call after the fetch happens (whether fake or not)
+     */
+    then?: (val: _Data | null) => void | Promise<void>;
+};
+export type LoadEventFetchParams<_Data extends GraphQLObject, _Input> = FetchGlobalParams<_Data, _Input> & {
+    /**
+     * Directly the `even` param coming from the `load` function
+     */
+    event?: LoadEvent;
+};
+export type RequestEventFetchParams<_Data extends GraphQLObject, _Input> = FetchGlobalParams<_Data, _Input> & {
+    /**
+     * A RequestEvent should be provided when the store is being used in an endpoint.
+     * When this happens, fetch also needs to be provided
+     */
+    event?: RequestEvent;
+    /**
+     * The fetch function to use when using this store in an endpoint.
+     */
+    fetch?: LoadEvent['fetch'];
+};
+export type ClientFetchParams<_Data extends GraphQLObject, _Input> = FetchGlobalParams<_Data, _Input> & {
+    /**
+     * An object containing all of the current info necessary for a
+     * client-side fetch. Must be called in component initialization with
+     * something like this: `const context = getHoudiniFetchContext()`
+     */
+    context?: HoudiniFetchContext;
+};
+export type QueryStoreFetchParams<_Data extends GraphQLObject, _Input> = QueryStoreLoadParams<_Data, _Input> | ClientFetchParams<_Data, _Input>;
+export type QueryStoreLoadParams<_Data extends GraphQLObject, _Input> = LoadEventFetchParams<_Data, _Input> | RequestEventFetchParams<_Data, _Input>;
+export {};

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

@@ -1,6 +1,8 @@
-import type { FetchQueryResult, CompiledFragmentKind, QueryResult, GraphQLObject, CursorHandlers, OffsetHandlers, PageInfo, HoudiniFetchContext, FetchParams } from '$houdini/runtime/lib/types';
-import type { LoadEvent, RequestEvent } from '@sveltejs/kit';
-import type { Readable } from 'svelte/store';
+import type { FetchQueryResult, CompiledFragmentKind, QueryResult, GraphQLObject } from '$houdini/runtime/lib/types';
+import type { LoadEvent } from '@sveltejs/kit';
+import type { Readable, Writable } from 'svelte/store';
+import type { QueryStoreFetchParams } from './stores';
+import type { PageInfo } from './stores/pagination/pageInfo';
 export type QueryInputs<_Data> = FetchQueryResult<_Data> & {
     variables: {
         [key: string]: any;
@@ -52,43 +54,29 @@ export type OffsetFragmentStoreInstance<_Data extends GraphQLObject, _Input> = {
     subscribe: Readable<Reshape<_Data, _Input>>['subscribe'];
     fetching: Readable<boolean>;
 } & OffsetHandlers<_Data, _Input>;
-type FetchGlobalParams<_Data extends GraphQLObject, _Input> = FetchParams<_Input> & {
-    /**
-     * Set to true if you want the promise to pause while it's resolving.
-     * Only enable this if you know what you are doing. This will cause route
-     * transitions to pause while loading data.
-     */
-    blocking?: boolean;
-    /**
-     * A function to call after the fetch happens (whether fake or not)
-     */
-    then?: (val: _Data | null) => void | Promise<void>;
+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>;
+    pageInfo: Writable<PageInfo>;
+    fetch(args?: QueryStoreFetchParams<_Data, _Input> | undefined): Promise<QueryResult<_Data, _Input>>;
 };
-export type LoadEventFetchParams<_Data extends GraphQLObject, _Input> = FetchGlobalParams<_Data, _Input> & {
-    /**
-     * Directly the `even` param coming from the `load` function
-     */
-    event?: LoadEvent;
+export type OffsetHandlers<_Data extends GraphQLObject, _Input> = {
+    loadNextPage: (args?: {
+        limit?: number;
+        offset?: number;
+        metadata?: {};
+        fetch?: typeof globalThis.fetch;
+    }) => Promise<void>;
+    fetch(args?: QueryStoreFetchParams<_Data, _Input> | undefined): Promise<QueryResult<_Data, _Input>>;
 };
-export type RequestEventFetchParams<_Data extends GraphQLObject, _Input> = FetchGlobalParams<_Data, _Input> & {
-    /**
-     * A RequestEvent should be provided when the store is being used in an endpoint.
-     * When this happens, fetch also needs to be provided
-     */
-    event?: RequestEvent;
-    /**
-     * The fetch function to use when using this store in an endpoint.
-     */
-    fetch?: LoadEvent['fetch'];
-};
-export type ClientFetchParams<_Data extends GraphQLObject, _Input> = FetchGlobalParams<_Data, _Input> & {
-    /**
-     * An object containing all of the current info necessary for a
-     * client-side fetch. Must be called in component initialization with
-     * something like this: `const context = getHoudiniFetchContext()`
-     */
-    context?: HoudiniFetchContext;
-};
-export type QueryStoreFetchParams<_Data extends GraphQLObject, _Input> = QueryStoreLoadParams<_Data, _Input> | ClientFetchParams<_Data, _Input>;
-export type QueryStoreLoadParams<_Data extends GraphQLObject, _Input> = LoadEventFetchParams<_Data, _Input> | RequestEventFetchParams<_Data, _Input>;
 export {};

package/build/runtime-esm/stores/index.d.ts

@@ -2,4 +2,4 @@ export * from './pagination';
 export { FragmentStore } from './fragment';
 export { SubscriptionStore } from './subscription';
 export { MutationStore, type MutationConfig } from './mutation';
-export { QueryStore } from './query';
+export { QueryStore, type QueryStoreFetchParams } from './query';

package/build/runtime-esm/stores/pagination/cursor.d.ts

@@ -0,0 +1,13 @@
+import type { SendParams } from '$houdini/runtime/client/documentStore';
+import type { GraphQLObject, QueryArtifact } from '$houdini/runtime/lib/types';
+import type { CursorHandlers } from '../../types';
+import type { FetchFn } from './fetch';
+export declare function cursorHandlers<_Data extends GraphQLObject, _Input extends Record<string, any>>({ artifact, storeName, initialValue, fetchUpdate: parentFetchUpdate, fetch: parentFetch, getState, getVariables, }: {
+    artifact: QueryArtifact;
+    storeName: string;
+    fetch: FetchFn<_Data, _Input>;
+    getState: () => _Data | null;
+    getVariables: () => _Input;
+    initialValue: _Data | null;
+    fetchUpdate: (arg: SendParams, updates: string[]) => ReturnType<FetchFn<_Data, _Input>>;
+}): CursorHandlers<_Data, _Input>;

package/build/runtime-esm/stores/pagination/cursor.js

@@ -0,0 +1,167 @@
+import { CachePolicy } from "$houdini/runtime/lib";
+import { getCurrentConfig } from "$houdini/runtime/lib/config";
+import { siteURL } from "$houdini/runtime/lib/constants";
+import { deepEquals } from "$houdini/runtime/lib/deepEquals";
+import { writable } from "svelte/store";
+import { getSession } from "../../session";
+import { fetchParams } from "../query";
+import { countPage, extractPageInfo, missingPageSizeError } from "./pageInfo";
+function cursorHandlers({
+  artifact,
+  storeName,
+  initialValue,
+  fetchUpdate: parentFetchUpdate,
+  fetch: parentFetch,
+  getState,
+  getVariables
+}) {
+  const pageInfo = writable(extractPageInfo(initialValue, artifact.refetch.path));
+  const loadPage = async ({
+    pageSizeVar,
+    input,
+    functionName,
+    metadata = {},
+    fetch,
+    where
+  }) => {
+    const config = getCurrentConfig();
+    const loadVariables = {
+      ...getVariables(),
+      ...input
+    };
+    if (!loadVariables[pageSizeVar] && !artifact.refetch.pageSize) {
+      throw missingPageSizeError(functionName);
+    }
+    let isSinglePage = artifact.refetch?.mode === "SinglePage";
+    const targetFetch = isSinglePage ? parentFetch : parentFetchUpdate;
+    const { data } = await targetFetch(
+      {
+        variables: loadVariables,
+        fetch,
+        metadata,
+        policy: isSinglePage ? artifact.policy : CachePolicy.NetworkOnly,
+        session: await getSession()
+      },
+      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);
+    }
+    pageInfo.set(extractPageInfo(data, resultPath));
+  };
+  const getPageInfo = () => {
+    return extractPageInfo(getState(), artifact.refetch?.path ?? []);
+  };
+  return {
+    loadNextPage: async ({
+      first,
+      after,
+      fetch,
+      metadata
+    } = {}) => {
+      if (artifact.refetch?.direction === "backward") {
+        console.warn(`\u26A0\uFE0F ${storeName}.loadNextPage was called but it does not support forwards pagination.
+If you think this is an error, please open an issue on GitHub`);
+        return;
+      }
+      const currentPageInfo = getPageInfo();
+      if (!currentPageInfo.hasNextPage) {
+        return;
+      }
+      const input = {
+        first: first ?? artifact.refetch.pageSize,
+        after: after ?? currentPageInfo.endCursor,
+        before: null,
+        last: null
+      };
+      return await loadPage({
+        pageSizeVar: "first",
+        functionName: "loadNextPage",
+        input,
+        fetch,
+        metadata,
+        where: "end"
+      });
+    },
+    loadPreviousPage: async ({
+      last,
+      before,
+      fetch,
+      metadata
+    } = {}) => {
+      if (artifact.refetch?.direction === "forward") {
+        console.warn(`\u26A0\uFE0F ${storeName}.loadPreviousPage was called but it does not support backwards pagination.
+If you think this is an error, please open an issue on GitHub`);
+        return;
+      }
+      const currentPageInfo = getPageInfo();
+      if (!currentPageInfo.hasPreviousPage) {
+        return;
+      }
+      const input = {
+        before: before ?? currentPageInfo.startCursor,
+        last: last ?? artifact.refetch.pageSize,
+        first: null,
+        after: null
+      };
+      return await loadPage({
+        pageSizeVar: "last",
+        functionName: "loadPreviousPage",
+        input,
+        fetch,
+        metadata,
+        where: "start"
+      });
+    },
+    pageInfo,
+    async fetch(args) {
+      const { params } = await fetchParams(artifact, storeName, args);
+      const { variables } = params ?? {};
+      if (variables && !deepEquals(getVariables(), variables)) {
+        return await parentFetch(params);
+      }
+      try {
+        var currentPageInfo = extractPageInfo(getState(), artifact.refetch.path);
+      } catch {
+        return await parentFetch(params);
+      }
+      const queryVariables = {};
+      const count = countPage(artifact.refetch.path.concat("edges"), getState()) || artifact.refetch.pageSize;
+      if (count && count > artifact.refetch.pageSize) {
+        if (currentPageInfo.hasPreviousPage && currentPageInfo.hasNextPage && !(variables?.["first"] && variables?.["after"] || variables?.["last"] && variables?.["before"])) {
+          console.warn(`\u26A0\uFE0F Encountered a fetch() in the middle of the connection.
+Make sure to pass a cursor value by hand that includes the current set (ie the entry before startCursor)
+`);
+        }
+        if (!currentPageInfo.hasPreviousPage) {
+          queryVariables["first"] = count;
+          queryVariables["after"] = null;
+          queryVariables["last"] = null;
+          queryVariables["before"] = null;
+        } else if (!currentPageInfo.hasNextPage) {
+          queryVariables["last"] = count;
+          queryVariables["first"] = null;
+          queryVariables["after"] = null;
+          queryVariables["before"] = null;
+        }
+      }
+      Object.assign(queryVariables, variables ?? {});
+      const result = await parentFetch({
+        ...params,
+        variables: queryVariables
+      });
+      pageInfo.set(extractPageInfo(result.data, artifact.refetch.path));
+      return result;
+    }
+  };
+}
+export {
+  cursorHandlers
+};

package/build/runtime-esm/stores/pagination/fetch.d.ts

@@ -0,0 +1,3 @@
+import type { GraphQLObject, QueryResult } from '$houdini/runtime/lib/types';
+import type { QueryStoreFetchParams } from '../query';
+export type FetchFn<_Data extends GraphQLObject, _Input = any> = (params?: QueryStoreFetchParams<_Data, _Input>) => Promise<QueryResult<_Data, _Input>>;

package/build/runtime-esm/stores/pagination/fragment.d.ts

@@ -1,9 +1,9 @@
 import type { DocumentStore } from '$houdini/runtime/client';
-import type { FragmentArtifact, GraphQLObject, HoudiniFetchContext, QueryArtifact, PageInfo } from '$houdini/runtime/lib/types';
-import { CursorHandlers } from '$houdini/runtime/lib/types';
+import type { FragmentArtifact, GraphQLObject, HoudiniFetchContext, QueryArtifact } from '$houdini/runtime/lib/types';
 import type { Readable, Subscriber } from 'svelte/store';
-import type { OffsetFragmentStoreInstance } from '../../types';
+import type { CursorHandlers, OffsetFragmentStoreInstance } from '../../types';
 import type { StoreConfig } from '../query';
+import { type PageInfo } from './pageInfo';
 type FragmentStoreConfig<_Data extends GraphQLObject, _Input> = StoreConfig<_Data, _Input, FragmentArtifact> & {
     paginationArtifact: QueryArtifact;
 };
@@ -19,12 +19,15 @@ declare class BasePaginatedFragmentStore<_Data extends GraphQLObject, _Input> {
 export declare class FragmentStoreCursor<_Data extends GraphQLObject, _Input extends Record<string, any>> extends BasePaginatedFragmentStore<_Data, _Input> {
     get(initialValue: _Data | null): {
         kind: "HoudiniFragment";
+        data: Readable<_Data | null>;
         subscribe: (run: Subscriber<FragmentPaginatedResult<_Data, {
             pageInfo: PageInfo;
         }>>, invalidate?: ((value?: FragmentPaginatedResult<_Data, {
             pageInfo: PageInfo;
         }> | undefined) => void) | undefined) => (() => void);
-        fetch: (args?: import("$houdini/runtime/lib/types").FetchParams<_Input> | undefined) => Promise<import("$houdini/runtime/lib/types").QueryResult<_Data, _Input>>;
+        fetching: Readable<boolean>;
+        fetch: (args?: import("../query").QueryStoreFetchParams<_Data, _Input> | undefined) => Promise<import("$houdini/runtime/lib/types").QueryResult<_Data, _Input>>;
+        pageInfo: import("svelte/store").Writable<PageInfo>;
         loadNextPage: (args?: {
             first?: number | undefined;
             after?: string | undefined;

package/build/runtime-esm/stores/pagination/fragment.js

@@ -1,12 +1,13 @@
 import { getCurrentConfig, keyFieldsForType } from "$houdini/runtime/lib/config";
 import { siteURL } from "$houdini/runtime/lib/constants";
-import { extractPageInfo } from "$houdini/runtime/lib/pageInfo";
-import { cursorHandlers, offsetHandlers } from "$houdini/runtime/lib/pagination";
 import { CompiledFragmentKind } from "$houdini/runtime/lib/types";
 import { derived, get } from "svelte/store";
 import { getClient, initClient } from "../../client";
 import { getSession } from "../../session";
 import { FragmentStore } from "../fragment";
+import { cursorHandlers } from "./cursor";
+import { offsetHandlers } from "./offset";
+import { extractPageInfo } from "./pageInfo";
 class BasePaginatedFragmentStore {
   paginated = true;
   paginationArtifact;
@@ -69,8 +70,11 @@ class FragmentStoreCursor extends BasePaginatedFragmentStore {
     };
     return {
       kind: CompiledFragmentKind,
+      data: derived(store, ($value) => $value),
       subscribe,
+      fetching: derived([paginationStore], ([$store]) => $store.fetching),
       fetch: handlers.fetch,
+      pageInfo: handlers.pageInfo,
       loadNextPage: handlers.loadNextPage,
       loadPreviousPage: handlers.loadPreviousPage
     };
@@ -109,7 +113,7 @@ class FragmentStoreCursor extends BasePaginatedFragmentStore {
           }
         });
       },
-      getSession,
+      initialValue,
       storeName: this.name
     });
   }
@@ -158,7 +162,6 @@ class FragmentStoreOffset extends BasePaginatedFragmentStore {
           }
         });
       },
-      getSession,
       storeName: this.name
     });
     const subscribe = (run, invalidate) => {