houdini-react 2.0.0-go.0 → 2.0.0-go.2

package/build/houdini-react/runtime/hooks/useDocumentHandle.ts

@@ -1,224 +0,0 @@
-import { extractPageInfo } from 'houdini/runtime'
-import { cursorHandlers, offsetHandlers } from 'houdini/runtime'
-import { ArtifactKind } from 'houdini/runtime'
-import type {
-	GraphQLObject,
-	GraphQLVariables,
-	CursorHandlers,
-	OffsetHandlers,
-	PageInfo,
-	FetchFn,
-	QueryResult,
-	DocumentArtifact,
-	QueryArtifact,
-} from 'houdini/runtime'
-import type { DocumentStore } from 'houdini/runtime/client'
-import React from 'react'
-
-import { useClient, useLocation, useSession } from '../routing/Router'
-
-export function useDocumentHandle<
-	_Artifact extends QueryArtifact,
-	_Data extends GraphQLObject,
-	_Input extends GraphQLVariables
->({
-	artifact,
-	observer,
-	storeValue,
-}: {
-	artifact: DocumentArtifact
-	observer: DocumentStore<_Data, _Input>
-	storeValue: QueryResult<_Data, _Input>
-}): DocumentHandle<_Artifact, _Data, _Input> & { fetch: FetchFn<_Data, _Input> } {
-	const [forwardPending, setForwardPending] = React.useState(false)
-	const [backwardPending, setBackwardPending] = React.useState(false)
-	const location = useLocation()
-
-	// grab the current session value
-	const [session] = useSession()
-
-	// we want to use a separate observer for pagination queries
-	const client = useClient()
-	const paginationObserver = React.useMemo(() => {
-		// if the artifact doesn't support pagination, don't do anything
-		if (!artifact.refetch?.paginated) {
-			return null
-		}
-
-		return client.observe<_Data, _Input>({ artifact })
-	}, [artifact.name])
-
-	// @ts-expect-error: avoiding an as DocumentHandle<_Artifact, _Data, _Input>
-	return React.useMemo<DocumentHandle<_Artifact, _Data, _Input>>(() => {
-		const wrapLoad = <_Result>(
-			setLoading: (val: boolean) => void,
-			fn: (value: any) => Promise<_Result>
-		) => {
-			return async (value: any) => {
-				setLoading(true)
-				let result: _Result | null = null
-				let err: Error | null = null
-				try {
-					result = await fn(value)
-				} catch (e) {
-					err = e as Error
-				}
-				setLoading(false)
-				// ignore abort errors when loading pages
-				if (err && err.name !== 'AbortError') {
-					throw err
-				}
-
-				// we're done
-				return result || observer.state
-			}
-		}
-
-		// add the session value to the
-		const fetchQuery: FetchFn<_Data, _Input> = (args) => {
-			// before we send the query, we need to figure out which variables are
-			// actually useful for this document
-			const usedVariables = Object.fromEntries(
-				Object.keys(observer.artifact.input?.fields ?? {}).reduce<[string, any][]>(
-					(entries, fieldName) => {
-						// if the field is not a url parameter, skip it
-						if (!(fieldName in location.params)) {
-							return entries
-						}
-
-						return [...entries, [fieldName, location.params[fieldName]]]
-					},
-					[]
-				)
-			)
-
-			return observer.send({
-				...args,
-				variables: {
-					...usedVariables,
-					...args?.variables,
-				},
-				session,
-			})
-		}
-
-		// only consider paginated queries
-		if (artifact.kind !== ArtifactKind.Query || !artifact.refetch?.paginated) {
-			return {
-				artifact,
-				data: storeValue.data,
-				variables: storeValue.variables,
-				fetch: fetchQuery,
-				partial: storeValue.partial,
-			}
-		}
-
-		// if the artifact supports cursor pagination, then add the cursor handlers
-		if (artifact.refetch.method === 'cursor') {
-			const handlers = cursorHandlers<_Data, _Input>({
-				artifact,
-				getState: () => storeValue.data,
-				getVariables: () => storeValue.variables!,
-				fetch: fetchQuery,
-				fetchUpdate: (args, updates) => {
-					return paginationObserver!.send({
-						...args,
-						cacheParams: {
-							...args?.cacheParams,
-							disableSubscriptions: true,
-							applyUpdates: updates,
-						},
-						session,
-					})
-				},
-				getSession: async () => session,
-			})
-
-			return {
-				artifact,
-				data: storeValue.data,
-				variables: storeValue.variables,
-				fetch: handlers.fetch,
-				partial: storeValue.partial,
-				loadNext: wrapLoad(setForwardPending, handlers.loadNextPage),
-				loadNextPending: forwardPending,
-				loadPrevious: wrapLoad(setBackwardPending, handlers.loadPreviousPage),
-				loadPreviousPending: backwardPending,
-				pageInfo: extractPageInfo(storeValue.data, artifact.refetch!.path),
-			}
-		}
-
-		if (artifact.refetch.method === 'offset') {
-			const handlers = offsetHandlers({
-				artifact,
-				getState: () => storeValue.data,
-				getVariables: () => storeValue.variables!,
-				storeName: artifact.name,
-				fetch: fetchQuery,
-				fetchUpdate: async (args, updates = ['append']) => {
-					return paginationObserver!.send({
-						...args,
-						cacheParams: {
-							disableSubscriptions: true,
-							applyUpdates: updates,
-							...args?.cacheParams,
-						},
-					})
-				},
-				getSession: async () => session,
-			})
-
-			return {
-				artifact,
-				data: storeValue.data,
-				variables: storeValue.variables,
-				fetch: handlers.fetch,
-				partial: storeValue.partial,
-				loadNext: wrapLoad(setForwardPending, handlers.loadNextPage),
-				loadNextPending: forwardPending,
-			}
-		}
-
-		// we don't want to add anything
-		return {
-			artifact,
-			data: storeValue.data,
-			variables: storeValue.variables,
-			fetch: fetchQuery,
-			refetch: fetchQuery,
-			partial: storeValue.partial,
-		}
-	}, [artifact, observer, session, storeValue])
-}
-
-export type DocumentHandle<
-	_Artifact extends QueryArtifact,
-	_Data extends GraphQLObject = GraphQLObject,
-	_Input extends GraphQLVariables = GraphQLVariables
-> = {
-	data: _Data
-	partial: boolean
-	fetch: FetchFn<_Data, Partial<_Input>>
-	variables: _Input
-} & RefetchHandlers<_Artifact, _Data, _Input>
-
-type RefetchHandlers<_Artifact extends QueryArtifact, _Data extends GraphQLObject, _Input> =
-	// we need to add different methods if the artifact supports cursor pagination
-	_Artifact extends {
-		refetch: { paginated: true; method: 'cursor' }
-	}
-		? {
-				loadNext: CursorHandlers<_Data, _Input>['loadNextPage']
-				loadNextPending: boolean
-				loadPrevious: CursorHandlers<_Data, _Input>['loadPreviousPage']
-				loadPreviousPending: boolean
-				pageInfo: PageInfo
-		  }
-		: // offset pagination
-		_Artifact extends { refetch: { paginated: true; method: 'offset' } }
-		? {
-				loadNext: OffsetHandlers<_Data, _Input>['loadNextPage']
-				loadNextPending: boolean
-		  }
-		: // the artifact does not support a known pagination method, don't add anything
-		  {}

package/build/houdini-react/runtime/hooks/useDocumentStore.ts

@@ -1,76 +0,0 @@
-import type {
-	DocumentArtifact,
-	GraphQLVariables,
-	QueryResult,
-	GraphQLObject,
-} from 'houdini/runtime'
-import type { DocumentStore, ObserveParams } from 'houdini/runtime/client'
-import * as React from 'react'
-
-import { useClient } from '../routing'
-import { useIsMountedRef } from './useIsMounted'
-
-export type UseDocumentStoreParams<
-	_Artifact extends DocumentArtifact,
-	_Data extends GraphQLObject,
-	_Input extends GraphQLVariables
-> = {
-	artifact: _Artifact
-	observer?: DocumentStore<_Data, _Input>
-} & Partial<ObserveParams<_Data, DocumentArtifact, _Input>>
-
-export function useDocumentStore<
-	_Data extends GraphQLObject = GraphQLObject,
-	_Input extends GraphQLVariables = GraphQLVariables,
-	_Artifact extends DocumentArtifact = DocumentArtifact
->({
-	artifact,
-	observer: obs,
-	...observeParams
-}: UseDocumentStoreParams<_Artifact, _Data, _Input>): [
-	QueryResult<_Data, _Input>,
-	DocumentStore<_Data, _Input>
-] {
-	const client = useClient()
-	const isMountedRef = useIsMountedRef()
-
-	// hold onto an observer we'll use
-	let [observer, setObserver] = React.useState(
-		() =>
-			obs ??
-			client.observe<_Data, _Input>({
-				artifact,
-				...observeParams,
-			})
-	)
-
-	const box = React.useRef(observer.state)
-
-	// if the observer changes, we need to track the new one
-	if (obs && obs !== observer) {
-		box.current = obs.state
-		setObserver(obs)
-	}
-
-	// the function that registers a new subscription for the observer
-	const subscribe: any = React.useCallback(
-		(fn: () => void) => {
-			return observer.subscribe((val) => {
-				box.current = val
-				if (isMountedRef.current) {
-					fn()
-				}
-			})
-		},
-		[observer]
-	)
-
-	// get a safe reference to the cache
-	const storeValue = React.useSyncExternalStore(
-		subscribe,
-		() => box.current,
-		() => box.current
-	)
-
-	return [storeValue!, observer]
-}

package/build/houdini-react/runtime/hooks/useDocumentSubscription.ts

@@ -1,62 +0,0 @@
-import type {
-	DocumentArtifact,
-	GraphQLVariables,
-	QueryResult,
-	GraphQLObject,
-} from 'houdini/runtime'
-import type { DocumentStore, SendParams } from 'houdini/runtime/client'
-
-import { useSession } from '../routing/Router'
-import useDeepCompareEffect from './useDeepCompareEffect'
-import { useDocumentStore, type UseDocumentStoreParams } from './useDocumentStore'
-
-export function useDocumentSubscription<
-	_Artifact extends DocumentArtifact = DocumentArtifact,
-	_Data extends GraphQLObject = GraphQLObject,
-	_Input extends GraphQLVariables = GraphQLVariables
->({
-	artifact,
-	variables,
-	send,
-	disabled,
-	...observeParams
-}: UseDocumentStoreParams<_Artifact, _Data, _Input> & {
-	variables: _Input
-	disabled?: boolean
-	send?: Partial<SendParams>
-}): [QueryResult<_Data, _Input> & { parent?: string | null }, DocumentStore<_Data, _Input>] {
-	const [storeValue, observer] = useDocumentStore<_Data, _Input>({
-		artifact,
-		...observeParams,
-	})
-
-	// grab the current session value
-	const [session] = useSession()
-
-	// whenever the variables change, we need to retrigger the query
-	useDeepCompareEffect(() => {
-		if (!disabled) {
-			observer.send({
-				variables,
-				session,
-				// TODO: metadata
-				metadata: {},
-				...send,
-			})
-		}
-
-		return () => {
-			if (!disabled) {
-				observer.cleanup()
-			}
-		}
-	}, [disabled, session, observer, variables ?? {}, send ?? {}])
-
-	return [
-		{
-			parent: send?.stuff?.parentID,
-			...storeValue,
-		},
-		observer,
-	]
-}

package/build/houdini-react/runtime/hooks/useFragment.ts

@@ -1,102 +0,0 @@
-import { deepEquals } from 'houdini/runtime'
-import { fragmentKey } from 'houdini/runtime'
-import type { GraphQLObject, GraphQLVariables, FragmentArtifact } from 'houdini/runtime'
-import * as React from 'react'
-
-import { useRouterContext } from '../routing'
-import { useDeepCompareMemoize } from './useDeepCompareEffect'
-import { useDocumentSubscription } from './useDocumentSubscription'
-
-export function useFragment<
-	_Data extends GraphQLObject,
-	_ReferenceType extends {},
-	_Input extends GraphQLVariables = GraphQLVariables
->(
-	reference: _Data | { [fragmentKey]: _ReferenceType } | null,
-	document: { artifact: FragmentArtifact }
-) {
-	const { cache } = useRouterContext()
-
-	// get the fragment reference info
-	const { parent, variables, loading } = fragmentReference<_Data, _Input, _ReferenceType>(
-		reference,
-		document
-	)
-
-	// if we got this far then we are safe to use the fields on the object
-	let cachedValue = reference as _Data | null
-
-	// on the client, we want to ensure that we apply masking to the initial value by
-	// loading the value from cache
-	if (reference && parent) {
-		cachedValue = cache.read({
-			selection: document.artifact.selection,
-			parent,
-			variables,
-			loading,
-		}).data as _Data
-	}
-
-	// we're ready to setup the live document
-	const [storeValue] = useDocumentSubscription<FragmentArtifact, _Data, _Input>({
-		artifact: document.artifact,
-		variables,
-		initialValue: cachedValue,
-		// dont subscribe to anything if we are loading
-		disabled: loading,
-		send: {
-			stuff: {
-				parentID: parent,
-			},
-			setup: true,
-		},
-	})
-
-	// the parent has changed, we need to use initialValue for this render
-	// if we don't, then there is a very brief flash where we will show the old data
-	// before the store has had a chance to update
-	const lastReference = React.useRef<{ parent: string; variables: _Input } | null>(null)
-	return React.useMemo(() => {
-		// if the parent reference has changed we need to always prefer the cached value
-		const parentChange =
-			storeValue.parent !== parent ||
-			!deepEquals({ parent, variables }, lastReference.current)
-		if (parentChange) {
-			// make sure we keep track of the last reference we used
-			lastReference.current = { parent, variables: { ...variables } }
-
-			// and use the cached value
-			return cachedValue
-		}
-
-		return storeValue.data
-	}, [
-		useDeepCompareMemoize({
-			parent,
-			variables,
-			cachedValue,
-			storeValue: storeValue.data,
-			storeParent: storeValue.parent,
-		}),
-	])
-}
-
-export function fragmentReference<_Data extends GraphQLObject, _Input, _ReferenceType extends {}>(
-	reference: _Data | { [fragmentKey]: _ReferenceType } | null,
-	document: { artifact: FragmentArtifact }
-): { variables: _Input; parent: string; loading: boolean } {
-	// @ts-expect-error: typescript can't guarantee that the fragment key is defined
-	// but if its not, then the fragment wasn't mixed into the right thing
-	// the variables for the fragment live on the initial value's $fragment key
-	const { variables, parent } = reference?.[fragmentKey]?.values?.[document.artifact.name] ?? {}
-	if (reference && fragmentKey in reference && (!variables || !parent)) {
-		console.warn(
-			`⚠️ Parent does not contain the information for this fragment. Something is wrong.
-Please ensure that you have passed a record that has ${document.artifact.name} mixed into it.`
-		)
-	}
-	// @ts-expect-error
-	const loading = Boolean(reference?.[fragmentKey]?.loading)
-
-	return { variables, parent, loading }
-}

package/build/houdini-react/runtime/hooks/useFragmentHandle.ts

@@ -1,47 +0,0 @@
-import type {
-	GraphQLObject,
-	FragmentArtifact,
-	QueryArtifact,
-	fragmentKey,
-	GraphQLVariables,
-} from 'houdini/runtime'
-
-import { useDocumentHandle, type DocumentHandle } from './useDocumentHandle'
-import { useDocumentStore } from './useDocumentStore'
-import { fragmentReference, useFragment } from './useFragment'
-
-// useFragmentHandle is just like useFragment except it also returns an imperative handle
-// that users can use to interact with the fragment
-export function useFragmentHandle<
-	_Artifact extends FragmentArtifact,
-	_Data extends GraphQLObject,
-	_ReferenceType extends {},
-	_PaginationArtifact extends QueryArtifact,
-	_Input extends GraphQLVariables = GraphQLVariables
->(
-	reference: _Data | { [fragmentKey]: _ReferenceType } | null,
-	document: { artifact: FragmentArtifact; refetchArtifact?: QueryArtifact }
-): DocumentHandle<_PaginationArtifact, _Data, _Input> {
-	// get the fragment values
-	const data = useFragment<_Data, _ReferenceType, _Input>(reference, document)
-
-	// look at the fragment reference to get the variables
-	const { variables } = fragmentReference<_Data, _Input, _ReferenceType>(reference, document)
-
-	// use the pagination fragment for meta data if it exists.
-	// if we pass this a fragment artifact, it won't add any data
-	const [handleValue, handleObserver] = useDocumentStore<_Data, _Input>({
-		artifact: document.refetchArtifact ?? document.artifact,
-	})
-	const handle = useDocumentHandle<_PaginationArtifact, _Data, _Input>({
-		observer: handleObserver,
-		storeValue: handleValue,
-		artifact: document.refetchArtifact ?? document.artifact,
-	})
-
-	return {
-		...handle,
-		variables,
-		data,
-	}
-}

package/build/houdini-react/runtime/hooks/useIsMounted.ts

@@ -1,14 +0,0 @@
-import { useRef, useEffect } from 'react'
-
-export function useIsMountedRef(): { current: boolean } {
-	const isMountedRef = useRef(true)
-
-	useEffect(() => {
-		isMountedRef.current = true
-		return () => {
-			isMountedRef.current = false
-		}
-	}, [])
-
-	return isMountedRef
-}

package/build/houdini-react/runtime/hooks/useMutation.ts

@@ -1,54 +0,0 @@
-import type {
-	MutationArtifact,
-	GraphQLObject,
-	QueryResult,
-	GraphQLVariables,
-} from 'houdini/runtime'
-
-import { useSession } from '../routing/Router'
-import { useDocumentStore } from './useDocumentStore'
-
-export type MutationHandler<_Result, _Input, _Optimistic extends GraphQLObject> = (args: {
-	variables: _Input
-
-	metadata?: App.Metadata
-	fetch?: typeof globalThis.fetch
-	optimisticResponse?: _Optimistic
-}) => Promise<QueryResult<_Result, _Input>>
-
-export function useMutation<
-	_Result extends GraphQLObject,
-	_Input extends GraphQLVariables,
-	_Optimistic extends GraphQLObject
->({
-	artifact,
-}: {
-	artifact: MutationArtifact
-}): [boolean, MutationHandler<_Result, _Input, _Optimistic>] {
-	// build the live document we'll use to send values
-	const [storeValue, observer] = useDocumentStore<_Result, _Input>({ artifact })
-
-	// grab the pending state from the document store
-	const pending = storeValue.fetching
-
-	// grab the current session value
-	const [session] = useSession()
-
-	//  sending the mutation just means invoking the observer's send method
-	const mutate: MutationHandler<_Result, _Input, _Optimistic> = ({
-		metadata,
-		fetch,
-		variables,
-		...mutationConfig
-	}) =>
-		observer.send({
-			variables,
-			metadata,
-			session,
-			stuff: {
-				...mutationConfig,
-			},
-		})
-
-	return [pending, mutate]
-}

package/build/houdini-react/runtime/hooks/useQuery.ts

@@ -1,17 +0,0 @@
-import type { GraphQLVariables, GraphQLObject, QueryArtifact } from 'houdini/runtime'
-
-import type { UseQueryConfig } from './useQueryHandle'
-import { useQueryHandle } from './useQueryHandle'
-
-export function useQuery<
-	_Artifact extends QueryArtifact,
-	_Data extends GraphQLObject = GraphQLObject,
-	_Input extends GraphQLVariables = GraphQLVariables
->(
-	document: { artifact: QueryArtifact },
-	variables: any = null,
-	config: UseQueryConfig = {}
-): _Data {
-	const { data } = useQueryHandle<_Artifact, _Data, _Input>(document, variables, config)
-	return data
-}