@seamapi/react 4.12.1 → 4.13.1

package/src/lib/seam/use-seam-infinite-query.ts

@@ -1,103 +0,0 @@
-import type {
-  SeamActionAttemptFailedError,
-  SeamActionAttemptTimeoutError,
-  SeamHttpApiError,
-  SeamHttpEndpointPaginatedQueryPaths,
-  SeamHttpEndpoints,
-  SeamHttpInvalidInputError,
-  SeamHttpRequest,
-  SeamPageCursor,
-} from '@seamapi/http/connect'
-import type { ActionAttempt } from '@seamapi/types/connect'
-import {
-  type QueryKey,
-  useInfiniteQuery,
-  type UseInfiniteQueryOptions,
-  type UseInfiniteQueryResult,
-} from '@tanstack/react-query'
-
-import { useSeamClient } from 'lib/seam/use-seam-client.js'
-
-export type UseSeamInfiniteQueryParameters<
-  T extends SeamHttpEndpointPaginatedQueryPaths,
-> = Parameters<SeamHttpEndpoints[T]>[0]
-
-export type UseSeamInfiniteQueryResult<
-  T extends SeamHttpEndpointPaginatedQueryPaths,
-> = UseInfiniteQueryResult<QueryData<T>, QueryError<T>>
-
-export function useSeamInfiniteQuery<
-  T extends SeamHttpEndpointPaginatedQueryPaths,
->(
-  endpointPath: T,
-  parameters: UseSeamInfiniteQueryParameters<T> = {},
-  options: Parameters<SeamHttpEndpoints[T]>[1] &
-    QueryOptions<QueryData<T>, QueryError<T>> = {}
-): UseSeamInfiniteQueryResult<T> & { queryKey: QueryKey } {
-  const { endpointClient: client, queryKeyPrefixes } = useSeamClient()
-
-  if ('page_cursor' in (parameters ?? {})) {
-    throw new Error('Cannot use page_cursor with useSeamInfiniteQuery')
-  }
-
-  const queryKey = [
-    ...queryKeyPrefixes,
-    ...endpointPath.split('/').filter((v) => v !== ''),
-    parameters ?? {},
-  ]
-  const result = useInfiniteQuery({
-    enabled: client != null,
-    ...options,
-    queryKey,
-    initialPageParam: null,
-    getNextPageParam: (lastPage) => lastPage.nextPageCursor,
-    queryFn: async ({ pageParam }) => {
-      if (client == null)
-        return {
-          data: [] as Awaited<ReturnType<SeamHttpEndpoints[T]>>,
-          nextPageCursor: null,
-        }
-      // Using @ts-expect-error over any is preferred, but not possible here because TypeScript will run out of memory.
-      // Type assertion is needed here for performance reasons. The types are correct at runtime.
-      const endpoint = client[endpointPath] as (...args: any) => any
-      const request = endpoint(parameters, options)
-      const pages = client.createPaginator(request as SeamHttpRequest<any, any>)
-      if (pageParam == null) {
-        const [data, { nextPageCursor }] = await pages.firstPage()
-        return {
-          data: data as Awaited<ReturnType<SeamHttpEndpoints[T]>>,
-          nextPageCursor,
-        }
-      }
-      // Type assertion is needed for pageParam since the Seam API expects a branded PageCursor type.
-      const [data, { nextPageCursor }] = await pages.nextPage(
-        pageParam as SeamPageCursor
-      )
-      return {
-        data: data as Awaited<ReturnType<SeamHttpEndpoints[T]>>,
-        nextPageCursor,
-      }
-    },
-  })
-  return { ...result, queryKey }
-}
-
-interface QueryData<T extends SeamHttpEndpointPaginatedQueryPaths> {
-  data: Awaited<ReturnType<SeamHttpEndpoints[T]>>
-  nextPageCursor: SeamPageCursor | null
-}
-
-type QueryError<T extends SeamHttpEndpointPaginatedQueryPaths> =
-  | Error
-  | SeamHttpApiError
-  | SeamHttpInvalidInputError
-  | (QueryData<T>['data'] extends ActionAttempt
-      ?
-          | SeamActionAttemptFailedError<QueryData<T>['data']>
-          | SeamActionAttemptTimeoutError<QueryData<T>['data']>
-      : never)
-
-type QueryOptions<X, Y> = Omit<
-  UseInfiniteQueryOptions<X, Y>,
-  'queryKey' | 'queryFn' | 'initialPageParam' | 'getNextPageParam'
->

package/src/lib/seam/use-seam-mutation-without-workspace.ts

@@ -1,56 +0,0 @@
-import type {
-  SeamHttpApiError,
-  SeamHttpEndpointsWithoutWorkspace,
-  SeamHttpEndpointWithoutWorkspaceMutationPaths,
-  SeamHttpInvalidInputError,
-} from '@seamapi/http/connect'
-import {
-  useMutation,
-  type UseMutationOptions,
-  type UseMutationResult,
-} from '@tanstack/react-query'
-
-import { NullSeamClientError, useSeamClient } from 'lib/seam/use-seam-client.js'
-
-export type UseSeamMutationWithoutWorkspaceVariables<
-  T extends SeamHttpEndpointWithoutWorkspaceMutationPaths,
-> = Parameters<SeamHttpEndpointsWithoutWorkspace[T]>[0]
-
-export type UseSeamMutationWithoutWorkspaceResult<
-  T extends SeamHttpEndpointWithoutWorkspaceMutationPaths,
-> = UseMutationResult<
-  MutationData<T>,
-  MutationError,
-  UseSeamMutationWithoutWorkspaceVariables<T>
->
-
-export function useSeamMutationWithoutWorkspace<
-  T extends SeamHttpEndpointWithoutWorkspaceMutationPaths,
->(
-  endpointPath: T,
-  options: Parameters<SeamHttpEndpointsWithoutWorkspace[T]>[1] &
-    MutationOptions<
-      MutationData<T>,
-      MutationError,
-      UseSeamMutationWithoutWorkspaceVariables<T>
-    > = {}
-): UseSeamMutationWithoutWorkspaceResult<T> {
-  const { endpointClient: client } = useSeamClient()
-  return useMutation({
-    ...options,
-    mutationFn: async (variables) => {
-      if (client === null) throw new NullSeamClientError()
-      // Using @ts-expect-error over any is preferred, but not possible here because TypeScript will run out of memory.
-      // Type assertion is needed here for performance reasons. The types are correct at runtime.
-      const endpoint = client[endpointPath] as (...args: any) => Promise<any>
-      return await endpoint(variables, options)
-    },
-  })
-}
-
-type MutationData<T extends SeamHttpEndpointWithoutWorkspaceMutationPaths> =
-  Awaited<ReturnType<SeamHttpEndpointsWithoutWorkspace[T]>>
-
-type MutationError = Error | SeamHttpApiError | SeamHttpInvalidInputError
-
-type MutationOptions<X, Y, Z> = Omit<UseMutationOptions<X, Y, Z>, 'mutationFn'>

package/src/lib/seam/use-seam-mutation.ts

@@ -1,64 +0,0 @@
-import type {
-  SeamActionAttemptFailedError,
-  SeamActionAttemptTimeoutError,
-  SeamHttpApiError,
-  SeamHttpEndpointMutationPaths,
-  SeamHttpEndpoints,
-  SeamHttpInvalidInputError,
-} from '@seamapi/http/connect'
-import type { ActionAttempt } from '@seamapi/types/connect'
-import {
-  useMutation,
-  type UseMutationOptions,
-  type UseMutationResult,
-} from '@tanstack/react-query'
-
-import { NullSeamClientError, useSeamClient } from 'lib/seam/use-seam-client.js'
-
-export type UseSeamMutationVariables<T extends SeamHttpEndpointMutationPaths> =
-  Parameters<SeamHttpEndpoints[T]>[0]
-
-export type UseSeamMutationResult<T extends SeamHttpEndpointMutationPaths> =
-  UseMutationResult<
-    MutationData<T>,
-    MutationError<T>,
-    UseSeamMutationVariables<T>
-  >
-
-export function useSeamMutation<T extends SeamHttpEndpointMutationPaths>(
-  endpointPath: T,
-  options: Parameters<SeamHttpEndpoints[T]>[1] &
-    MutationOptions<
-      MutationData<T>,
-      MutationError<T>,
-      UseSeamMutationVariables<T>
-    > = {}
-): UseSeamMutationResult<T> {
-  const { endpointClient: client } = useSeamClient()
-  return useMutation({
-    ...options,
-    mutationFn: async (variables) => {
-      if (client === null) throw new NullSeamClientError()
-      // Using @ts-expect-error over any is preferred, but not possible here because TypeScript will run out of memory.
-      // Type assertion is needed here for performance reasons. The types are correct at runtime.
-      const endpoint = client[endpointPath] as (...args: any) => Promise<any>
-      return await endpoint(variables, options)
-    },
-  })
-}
-
-type MutationData<T extends SeamHttpEndpointMutationPaths> = Awaited<
-  ReturnType<SeamHttpEndpoints[T]>
->
-
-type MutationError<T extends SeamHttpEndpointMutationPaths> =
-  | Error
-  | SeamHttpApiError
-  | SeamHttpInvalidInputError
-  | (MutationData<T> extends ActionAttempt
-      ?
-          | SeamActionAttemptFailedError<MutationData<T>>
-          | SeamActionAttemptTimeoutError<MutationData<T>>
-      : never)
-
-type MutationOptions<X, Y, Z> = Omit<UseMutationOptions<X, Y, Z>, 'mutationFn'>

package/src/lib/seam/use-seam-query-without-workspace.ts

@@ -1,59 +0,0 @@
-import type {
-  SeamHttpApiError,
-  SeamHttpEndpointsWithoutWorkspace,
-  SeamHttpEndpointWithoutWorkspaceQueryPaths,
-  SeamHttpInvalidInputError,
-} from '@seamapi/http/connect'
-import {
-  type QueryKey,
-  useQuery,
-  type UseQueryOptions,
-  type UseQueryResult,
-} from '@tanstack/react-query'
-
-import { useSeamClient } from 'lib/seam/use-seam-client.js'
-
-export type UseSeamQueryWithoutWorkspaceParameters<
-  T extends SeamHttpEndpointWithoutWorkspaceQueryPaths,
-> = Parameters<SeamHttpEndpointsWithoutWorkspace[T]>[0]
-
-export type UseSeamQueryWithoutWorkspaceResult<
-  T extends SeamHttpEndpointWithoutWorkspaceQueryPaths,
-> = UseQueryResult<QueryData<T>, QueryError>
-
-export function useSeamQueryWithoutWorkspace<
-  T extends SeamHttpEndpointWithoutWorkspaceQueryPaths,
->(
-  endpointPath: T,
-  parameters: UseSeamQueryWithoutWorkspaceParameters<T> = {},
-  options: Parameters<SeamHttpEndpointsWithoutWorkspace[T]>[1] &
-    QueryOptions<QueryData<T>, QueryError> = {}
-): UseSeamQueryWithoutWorkspaceResult<T> & { queryKey: QueryKey } {
-  const { endpointClient: client, queryKeyPrefixes } = useSeamClient()
-  const queryKey = [
-    ...queryKeyPrefixes,
-    ...endpointPath.split('/').filter((v) => v !== ''),
-    parameters ?? {},
-  ]
-  const result = useQuery({
-    enabled: client != null,
-    ...options,
-    queryKey,
-    queryFn: async () => {
-      if (client == null) return null
-      // Using @ts-expect-error over any is preferred, but not possible here because TypeScript will run out of memory.
-      // Type assertion is needed here for performance reasons. The types are correct at runtime.
-      const endpoint = client[endpointPath] as (...args: any) => Promise<any>
-      return await endpoint(parameters, options)
-    },
-  })
-  return { ...result, queryKey }
-}
-
-type QueryData<T extends SeamHttpEndpointWithoutWorkspaceQueryPaths> = Awaited<
-  ReturnType<SeamHttpEndpointsWithoutWorkspace[T]>
->
-
-type QueryError = Error | SeamHttpApiError | SeamHttpInvalidInputError
-
-type QueryOptions<X, Y> = Omit<UseQueryOptions<X, Y>, 'queryKey' | 'queryFn'>

package/src/lib/seam/use-seam-query.ts

@@ -1,66 +0,0 @@
-import type {
-  SeamActionAttemptFailedError,
-  SeamActionAttemptTimeoutError,
-  SeamHttpApiError,
-  SeamHttpEndpointQueryPaths,
-  SeamHttpEndpoints,
-  SeamHttpInvalidInputError,
-} from '@seamapi/http/connect'
-import type { ActionAttempt } from '@seamapi/types/connect'
-import {
-  type QueryKey,
-  useQuery,
-  type UseQueryOptions,
-  type UseQueryResult,
-} from '@tanstack/react-query'
-
-import { useSeamClient } from 'lib/seam/use-seam-client.js'
-
-export type UseSeamQueryParameters<T extends SeamHttpEndpointQueryPaths> =
-  Parameters<SeamHttpEndpoints[T]>[0]
-
-export type UseSeamQueryResult<T extends SeamHttpEndpointQueryPaths> =
-  UseQueryResult<QueryData<T>, QueryError<T>>
-
-export function useSeamQuery<T extends SeamHttpEndpointQueryPaths>(
-  endpointPath: T,
-  parameters: UseSeamQueryParameters<T> = {},
-  options: Parameters<SeamHttpEndpoints[T]>[1] &
-    QueryOptions<QueryData<T>, SeamHttpApiError> = {}
-): UseSeamQueryResult<T> & { queryKey: QueryKey } {
-  const { endpointClient: client, queryKeyPrefixes } = useSeamClient()
-  const queryKey = [
-    ...queryKeyPrefixes,
-    ...endpointPath.split('/').filter((v) => v !== ''),
-    parameters ?? {},
-  ]
-  const result = useQuery({
-    enabled: client != null,
-    ...options,
-    queryKey,
-    queryFn: async () => {
-      if (client == null) return null
-      // Using @ts-expect-error over any is preferred, but not possible here because TypeScript will run out of memory.
-      // Type assertion is needed here for performance reasons. The types are correct at runtime.
-      const endpoint = client[endpointPath] as (...args: any) => Promise<any>
-      return await endpoint(parameters, options)
-    },
-  })
-  return { ...result, queryKey }
-}
-
-type QueryData<T extends SeamHttpEndpointQueryPaths> = Awaited<
-  ReturnType<SeamHttpEndpoints[T]>
->
-
-type QueryError<T extends SeamHttpEndpointQueryPaths> =
-  | Error
-  | SeamHttpApiError
-  | SeamHttpInvalidInputError
-  | (QueryData<T> extends ActionAttempt
-      ?
-          | SeamActionAttemptFailedError<QueryData<T>>
-          | SeamActionAttemptTimeoutError<QueryData<T>>
-      : never)
-
-type QueryOptions<X, Y> = Omit<UseQueryOptions<X, Y>, 'queryKey' | 'queryFn'>