@seamapi/react 4.8.2 → 4.9.1

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

@@ -1,12 +1,14 @@
-import { SeamHttp } from '@seamapi/http/connect'
+import { SeamHttp, SeamHttpEndpoints } from '@seamapi/http/connect'
 import { useQuery } from '@tanstack/react-query'
 import { useEffect } from 'react'
 import { v4 as uuidv4 } from 'uuid'
 
-import { useSeamContext } from 'lib/seam/SeamProvider.js'
+import { useSeamQueryContext } from './SeamQueryProvider.js'
 
 export function useSeamClient(): {
   client: SeamHttp | null
+  endpointClient: SeamHttpEndpoints | null
+  queryKeyPrefixes: string[]
   isPending: boolean
   isError: boolean
   error: unknown
@@ -16,14 +18,18 @@ export function useSeamClient(): {
     clientOptions,
     publishableKey,
     clientSessionToken,
+    queryKeyPrefix,
     ...context
-  } = useSeamContext()
+  } = useSeamQueryContext()
   const userIdentifierKey = useUserIdentifierKeyOrFingerprint(
     clientSessionToken != null ? '' : context.userIdentifierKey
   )
 
-  const { isPending, isError, error, data } = useQuery<SeamHttp>({
+  const { isPending, isError, error, data } = useQuery<
+    [SeamHttp, SeamHttpEndpoints]
+  >({
     queryKey: [
+      ...getQueryKeyPrefixes({ queryKeyPrefix }),
       'client',
       {
         client,
@@ -34,13 +40,19 @@ export function useSeamClient(): {
       },
     ],
     queryFn: async () => {
-      if (client != null) return client
+      if (client != null)
+        return [client, SeamHttpEndpoints.fromClient(client.client)]
 
       if (clientSessionToken != null) {
-        return SeamHttp.fromClientSessionToken(
+        const clientSessionTokenClient = SeamHttp.fromClientSessionToken(
           clientSessionToken,
           clientOptions
         )
+
+        return [
+          clientSessionTokenClient,
+          SeamHttpEndpoints.fromClient(clientSessionTokenClient.client),
+        ]
       }
 
       if (publishableKey == null) {
@@ -49,15 +61,31 @@ export function useSeamClient(): {
         )
       }
 
-      return await SeamHttp.fromPublishableKey(
+      const publishableKeyClient = await SeamHttp.fromPublishableKey(
         publishableKey,
         userIdentifierKey,
         clientOptions
       )
+      return [
+        publishableKeyClient,
+        SeamHttpEndpoints.fromClient(publishableKeyClient.client),
+      ]
     },
   })
 
-  return { client: data ?? null, isPending, isError, error }
+  return {
+    client: data?.[0] ?? null,
+    endpointClient: data?.[1] ?? null,
+    queryKeyPrefixes: getQueryKeyPrefixes({
+      queryKeyPrefix,
+      userIdentifierKey,
+      publishableKey,
+      clientSessionToken,
+    }),
+    isPending,
+    isError,
+    error,
+  }
 }
 
 export class NullSeamClientError extends Error {
@@ -65,7 +93,7 @@ export class NullSeamClientError extends Error {
     super(
       [
         'Attempted to use a null Seam client.',
-        'Either a hook using useSeamClient was called outside of a SeamProvider,',
+        'Either a hook using useSeamClient was called outside of a SeamProvider or SeamQueryProvider,',
         'or there was an error when creating the Seam client in useSeamClient,',
         'or useSeamClient is still loading the client.',
       ].join(' ')
@@ -81,7 +109,7 @@ function useUserIdentifierKeyOrFingerprint(
   useEffect(() => {
     if (userIdentifierKey != null) return
     // eslint-disable-next-line no-console
-    console.warn(`Using an automatically generated fingerprint for the SeamProvider userIdentifierKey!
+    console.warn(`Using an automatically generated fingerprint for the Seam userIdentifierKey!
 The user interface will show warnings when using a fingerprint.
 This is not recommended because the client session is now bound to this machine and is effectively ephemeral.`)
   }, [userIdentifierKey])
@@ -98,3 +126,29 @@ This is not recommended because the client session is now bound to this machine
 
   return fingerprint
 }
+
+const getQueryKeyPrefixes = ({
+  queryKeyPrefix,
+  userIdentifierKey,
+  publishableKey,
+  clientSessionToken,
+}: {
+  queryKeyPrefix: string | undefined
+  userIdentifierKey?: string
+  publishableKey?: string | undefined
+  clientSessionToken?: string | undefined
+}): string[] => {
+  const seamPrefix = 'seam'
+
+  if (queryKeyPrefix != null) return [seamPrefix, queryKeyPrefix]
+
+  if (clientSessionToken != null) {
+    return [seamPrefix, clientSessionToken]
+  }
+
+  if (publishableKey != null && userIdentifierKey != null) {
+    return [seamPrefix, publishableKey, userIdentifierKey]
+  }
+
+  return [seamPrefix]
+}

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

@@ -0,0 +1,50 @@
+import type {
+  SeamHttpApiError,
+  SeamHttpEndpointMutationPaths,
+  SeamHttpEndpoints,
+} 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 UseSeamMutationVariables<T extends SeamHttpEndpointMutationPaths> =
+  Parameters<SeamHttpEndpoints[T]>[0]
+
+export type UseSeamMutationResult<T extends SeamHttpEndpointMutationPaths> =
+  UseMutationResult<
+    MutationData<T>,
+    SeamHttpApiError,
+    UseSeamMutationVariables<T>
+  >
+
+export function useSeamMutation<T extends SeamHttpEndpointMutationPaths>(
+  endpointPath: T,
+  options: Parameters<SeamHttpEndpoints[T]>[1] &
+    MutationOptions<
+      MutationData<T>,
+      SeamHttpApiError,
+      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 MutationOptions<X, Y, Z> = Omit<UseMutationOptions<X, Y, Z>, 'mutationFn'>

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

@@ -1,7 +1,9 @@
 import type { SeamHttpApiError } from '@seamapi/http/connect'
 import type { UseQueryResult } from '@tanstack/react-query'
 
-export type UseSeamQueryResult<Field extends string, ResponsePayload> = Omit<
-  UseQueryResult<ResponsePayload, SeamHttpApiError>,
-  'data'
-> & { [key in Field]?: ResponsePayload }
+export type UseSeamQueryResultLegacy<
+  Field extends string,
+  ResponsePayload,
+> = Omit<UseQueryResult<ResponsePayload, SeamHttpApiError>, 'data'> & {
+  [key in Field]?: ResponsePayload
+}

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

@@ -0,0 +1,49 @@
+import type {
+  SeamHttpApiError,
+  SeamHttpEndpointQueryPaths,
+  SeamHttpEndpoints,
+} from '@seamapi/http/connect'
+import {
+  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>, SeamHttpApiError>
+
+export function useSeamQuery<T extends SeamHttpEndpointQueryPaths>(
+  endpointPath: T,
+  parameters?: UseSeamQueryParameters<T>,
+  options: Parameters<SeamHttpEndpoints[T]>[1] &
+    QueryOptions<QueryData<T>, SeamHttpApiError> = {}
+): UseSeamQueryResult<T> {
+  const { endpointClient: client, queryKeyPrefixes } = useSeamClient()
+  return useQuery({
+    enabled: client != null,
+    ...options,
+    queryKey: [
+      ...queryKeyPrefixes,
+      ...endpointPath.split('/').filter((v) => v !== ''),
+      parameters,
+    ],
+    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)
+    },
+  })
+}
+
+type QueryData<T extends SeamHttpEndpointQueryPaths> = Awaited<
+  ReturnType<SeamHttpEndpoints[T]>
+>
+
+type QueryOptions<X, Y> = Omit<UseQueryOptions<X, Y>, 'queryKey' | 'queryFn'>

package/src/lib/telemetry/hooks.ts

@@ -1,7 +1,7 @@
 import { useEffect, useLayoutEffect } from 'react'
 
 import { useClientSession } from 'lib/seam/client-sessions/use-client-session.js'
-import { useSeamContext } from 'lib/seam/SeamProvider.js'
+import { useSeamQueryContext } from 'lib/seam/SeamQueryProvider.js'
 
 import type { TelemetryClient } from './client.js'
 import { useTelemetryContext } from './TelemetryProvider.js'
@@ -23,7 +23,7 @@ export function useComponentTelemetry(name: string): void {
 
 export function useUserTelemetry(): void {
   const telemetry = useTelemetryClient()
-  const { publishableKey } = useSeamContext()
+  const { publishableKey } = useSeamQueryContext()
   const { clientSession } = useClientSession()
 
   // Ensure identify runs earlier than other effects to avoid anonymous telemetry data.

package/src/lib/version.ts

@@ -1,3 +1,3 @@
-const seamapiReactVersion = '4.8.2'
+const seamapiReactVersion = '4.9.1'
 
 export default seamapiReactVersion