houdini 1.0.0-next.1 → 1.0.0-next.3

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;
@@ -55,6 +55,7 @@ export declare class List {
 export declare class ListCollection {
     lists: List[];
     constructor(lists: List[]);
+    get selection(): SubscriptionSelection;
     append(...args: Parameters<List['append']>): void;
     prepend(...args: Parameters<List['prepend']>): void;
     addToList(...args: Parameters<List['addToList']>): void;

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/generated.d.ts

@@ -1,4 +1,5 @@
 export type CacheTypeDef = {
     types: {};
     lists: {};
+    queries: [];
 };

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,7 +1,8 @@
-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 function graphql<_Payload>(str: TemplateStringsArray): _Payload;
 export declare const cache: Cache<CacheTypeDef>;
 export declare function getCache(): InternalCache;

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
@@ -31,10 +31,6 @@ export type ConfigFile = {
      * FYI: `schemaPath` or `schema` should be defined
      */
     schema?: string | GraphQLSchema;
-    /**
-     * A url to use to pull the schema. For more information: https://www.houdinigraphql.com/api/cli#generate
-     */
-    apiUrl?: string | ((env: Record<string, string | undefined>) => string);
     /**
      * An object describing custom scalars for your project. For more information: https://www.houdinigraphql.com/api/config#custom-scalars
      */
@@ -43,11 +39,6 @@ export type ConfigFile = {
      * A path that the generator will use to write schema.graphql and documents.gql files containing all of the internal fragment and directive definitions used in the project.
      */
     definitionsPath?: string;
-    /**
-     * One of "kit" or "svelte". Used to tell the preprocessor what kind of loading paradigm to generate for you. (default: `kit`)
-     * @deprecated please follow the steps here: http://www.houdinigraphql.com/guides/release-notes#0170
-     */
-    framework?: 'kit' | 'svelte';
     /**
      * One of "esm" or "commonjs". Tells the artifact generator what kind of modules to create. (default: `esm`)
      */
@@ -90,20 +81,9 @@ export type ConfigFile = {
      */
     defaultFragmentMasking?: 'enable' | 'disable';
     /**
-     * Configures the houdini plugin's schema polling behavior. By default, houdini will poll your APIs
-     * during development in order to keep it's definition of your schema up to date. The schemaPollingInterval
-     * config value sets the amount of time between each request in milliseconds (default 2 seconds).
-     * To limit the schema introspection to just on the start of the server, set schemaPollingInterval to 0.
-     * To disable the schema introspection, set schemaPollingInterval to null.
-     */
-    schemaPollInterval?: number | null;
-    /**
-     * An object containing the environment variables you want passed onto the api when polling for a new schema.
-     * The keys dictate the header names. If the value is a string, the corresponding environment variable will be used
-     * directly. If the value is a function, the current environment will be passed to your function so you can perform any
-     * logic you need
+     * Configure the dev environment to watch a remote schema for changes
      */
-    schemaPollHeaders?: Record<string, string | ((env: Record<string, string | undefined>) => string)> | ((env: Record<string, string | undefined>) => Record<string, string>);
+    watchSchema?: WatchSchemaConfig;
     /**
      * An object describing the plugins enabled for the project
      */
@@ -133,6 +113,25 @@ export type TypeConfig = {
         };
     };
 };
+export type WatchSchemaConfig = {
+    /**
+     * A url to use to pull the schema. For more information: https://www.houdinigraphql.com/api/cli#generate
+     */
+    url: string | ((env: Record<string, string | undefined>) => string);
+    /**
+     * sets the amount of time between each request in milliseconds (default 2 seconds).
+     * To limit the schema introspection to just on the start of the server, set interval to 0.
+     * To disable the schema introspection, set interval to null.
+     */
+    interval?: number | null;
+    /**
+     * An object containing the environment variables you want passed onto the api when polling for a new schema.
+     * The keys dictate the header names. If the value is a string, the corresponding environment variable will be used
+     * directly. If the value is a function, the current environment will be passed to your function so you can perform any
+     * logic you need
+     */
+    headers?: Record<string, string | ((env: Record<string, string | undefined>) => string)> | ((env: Record<string, string | undefined>) => Record<string, string>);
+};
 export type ScalarSpec = {
     type: string;
     marshal?: (val: any) => any;
@@ -140,4 +139,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 { FragmentArtifact, 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, }: {
-    artifact: QueryArtifact | MutationArtifact | SubscriptionArtifact;
+export declare function marshalInputs<T>({ artifact, input, config, rootType, }: {
+    artifact: QueryArtifact | MutationArtifact | SubscriptionArtifact | FragmentArtifact;
     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,19 +1,32 @@
-import { Cache as _Cache } from '../cache/cache';
-import { SchemaManager, TypeInfo } from '../cache/schema';
+import type { Cache as _Cache } from '../cache/cache';
+import { type QueryArtifact } from '../lib';
 import { ListCollection } from './list';
 import { Record } from './record';
-import type { CacheTypeDef, IDFields, TypeNames, ValidLists } from './types';
+import type { CacheTypeDef, IDFields, QueryInput, QueryList, QueryValue, TypeNames, ValidLists } from './types';
 export declare class Cache<Def extends CacheTypeDef> {
     _internal_unstable: _Cache;
     constructor(cache: _Cache);
     validateInstabilityWarning(): void;
-    setFieldType(...args: Parameters<SchemaManager['setFieldType']>): void;
-    get root(): Record<Def, '__ROOT__'>;
     get<T extends TypeNames<Def>>(type: T, data: IDFields<Def, T>): Record<Def, T>;
-    get config(): import("..").ConfigFile;
+    get config(): import("../lib").ConfigFile;
     list<Name extends ValidLists<Def>>(name: Name, { parentID, allLists }?: {
         parentID?: string;
         allLists?: boolean;
     }): ListCollection<Def, Name>;
+    read<_Query extends {
+        artifact: QueryArtifact;
+    }>({ query, variables, }: {
+        query: _Query;
+        variables?: QueryInput<QueryList<Def>, _Query>;
+    }): {
+        data: QueryValue<QueryList<Def>, _Query> | null;
+        partial: boolean;
+    };
+    write<_Query extends {
+        artifact: QueryArtifact;
+    }>({ query, variables, data, }: {
+        query: _Query;
+        data: QueryValue<QueryList<Def>, _Query>;
+        variables?: QueryInput<QueryList<Def>, _Query>;
+    }): void;
 }
-export declare function _typeInfo<Def extends CacheTypeDef>(cache: Cache<Def>, type: string, field: string): TypeInfo;

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, }: {