@seamapi/react 4.9.0 → 4.10.0

package/src/lib/seam/SeamQueryProvider.tsx

@@ -3,7 +3,11 @@ import type {
   SeamHttpEndpoints,
   SeamHttpOptionsWithClientSessionToken,
 } from '@seamapi/http/connect'
-import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import {
+  QueryClient,
+  QueryClientContext,
+  QueryClientProvider,
+} from '@tanstack/react-query'
 import {
   createContext,
   type PropsWithChildren,
@@ -21,16 +25,21 @@ export interface SeamQueryContext {
   publishableKey?: string | undefined
   userIdentifierKey?: string | undefined
   clientSessionToken?: string | undefined
+  consoleSessionToken?: string | undefined
+  workspaceId?: string | undefined
+  queryKeyPrefix?: string | undefined
 }
 
 export type SeamQueryProviderProps =
   | SeamQueryProviderPropsWithClient
   | SeamQueryProviderPropsWithPublishableKey
   | SeamQueryProviderPropsWithClientSessionToken
+  | SeamQueryProviderPropsWithConsoleSessionToken
 
 export interface SeamQueryProviderPropsWithClient
   extends SeamQueryProviderBaseProps {
   client: SeamHttp
+  queryKeyPrefix: string
 }
 
 export interface SeamQueryProviderPropsWithPublishableKey
@@ -46,6 +55,13 @@ export interface SeamQueryProviderPropsWithClientSessionToken
   clientSessionToken: string
 }
 
+export interface SeamQueryProviderPropsWithConsoleSessionToken
+  extends SeamQueryProviderBaseProps,
+    SeamQueryProviderClientOptions {
+  consoleSessionToken: string
+  workspaceId?: string | undefined
+}
+
 interface SeamQueryProviderBaseProps extends PropsWithChildren {
   queryClient?: QueryClient | undefined
   onSessionUpdate?: (client: SeamHttp) => void
@@ -68,7 +84,8 @@ export function SeamQueryProvider({
     if (
       context.client == null &&
       context.publishableKey == null &&
-      context.clientSessionToken == null
+      context.clientSessionToken == null &&
+      context.consoleSessionToken == null
     ) {
       return defaultSeamQueryContextValue
     }
@@ -78,18 +95,30 @@ export function SeamQueryProvider({
   if (
     value.client == null &&
     value.publishableKey == null &&
-    value.clientSessionToken == null
+    value.clientSessionToken == null &&
+    value.consoleSessionToken == null
   ) {
     throw new Error(
-      `Must provide either a Seam client, clientSessionToken, or a publishableKey.`
+      `Must provide either a Seam client, clientSessionToken, publishableKey or consoleSessionToken.`
     )
   }
 
   const { Provider } = seamContext
+  const queryClientFromContext = useContext(QueryClientContext)
+
+  if (
+    queryClientFromContext != null &&
+    queryClient != null &&
+    queryClientFromContext !== queryClient
+  ) {
+    throw new Error(
+      'The QueryClient passed into SeamQueryProvider is different from the one in the existing QueryClientContext. Omit the queryClient prop from SeamProvider or SeamQueryProvider to use the existing QueryClient provided by the QueryClientProvider.'
+    )
+  }
 
   return (
     <QueryClientProvider
-      client={queryClient ?? globalThis.seamQueryClient ?? defaultQueryClient}
+      client={queryClientFromContext ?? queryClient ?? defaultQueryClient}
     >
       <Provider value={value}>
         <Session onSessionUpdate={onSessionUpdate}>{children}</Session>
@@ -128,6 +157,11 @@ const createSeamQueryContextValue = (
   options: SeamQueryProviderProps
 ): SeamQueryContext => {
   if (isSeamQueryProviderPropsWithClient(options)) {
+    if (options.queryKeyPrefix == null) {
+      throw new InvalidSeamQueryProviderProps(
+        'The client prop must be used with a queryKeyPrefix prop.'
+      )
+    }
     return {
       ...options,
       endpointClient: null,
@@ -155,6 +189,17 @@ const createSeamQueryContextValue = (
     }
   }
 
+  if (isSeamQueryProviderPropsWithConsoleSessionToken(options)) {
+    const { consoleSessionToken, workspaceId, ...clientOptions } = options
+    return {
+      consoleSessionToken,
+      workspaceId,
+      clientOptions,
+      client: null,
+      endpointClient: null,
+    }
+  }
+
   return { client: null, endpointClient: null }
 }
 
@@ -207,6 +252,18 @@ const isSeamQueryProviderPropsWithPublishableKey = (
     )
   }
 
+  if ('consoleSessionToken' in props && props.consoleSessionToken != null) {
+    throw new InvalidSeamQueryProviderProps(
+      'The consoleSessionToken prop cannot be used with the publishableKey prop.'
+    )
+  }
+
+  if ('workspaceId' in props && props.workspaceId != null) {
+    throw new InvalidSeamQueryProviderProps(
+      'The workspaceId prop cannot be used with the publishableKey prop.'
+    )
+  }
+
   return true
 }
 
@@ -237,6 +294,54 @@ const isSeamQueryProviderPropsWithClientSessionToken = (
     )
   }
 
+  if ('consoleSessionToken' in props && props.consoleSessionToken != null) {
+    throw new InvalidSeamQueryProviderProps(
+      'The consoleSessionToken prop cannot be used with the clientSessionToken prop.'
+    )
+  }
+
+  if ('workspaceId' in props && props.workspaceId != null) {
+    throw new InvalidSeamQueryProviderProps(
+      'The workspaceId prop cannot be used with the clientSessionToken prop.'
+    )
+  }
+
+  return true
+}
+
+const isSeamQueryProviderPropsWithConsoleSessionToken = (
+  props: SeamQueryProviderProps
+): props is SeamQueryProviderPropsWithConsoleSessionToken &
+  SeamQueryProviderClientOptions => {
+  if (!('consoleSessionToken' in props)) return false
+
+  const { consoleSessionToken } = props
+  if (consoleSessionToken == null) return false
+
+  if ('client' in props && props.client != null) {
+    throw new InvalidSeamQueryProviderProps(
+      'The client prop cannot be used with the publishableKey prop.'
+    )
+  }
+
+  if ('clientSessionToken' in props && props.clientSessionToken != null) {
+    throw new InvalidSeamQueryProviderProps(
+      'The clientSessionToken prop cannot be used with the publishableKey prop.'
+    )
+  }
+
+  if ('publishableKey' in props && props.publishableKey != null) {
+    throw new InvalidSeamQueryProviderProps(
+      'The publishableKey prop cannot be used with the consoleSessionToken prop.'
+    )
+  }
+
+  if ('userIdentifierKey' in props && props.userIdentifierKey != null) {
+    throw new InvalidSeamQueryProviderProps(
+      'The userIdentifierKey prop cannot be used with the consoleSessionToken prop.'
+    )
+  }
+
   return true
 }
 

package/src/lib/seam/index.ts

@@ -13,5 +13,7 @@ export * from './devices/use-devices.js'
 export * from './SeamProvider.js'
 export * from './use-seam-client.js'
 export * from './use-seam-mutation.js'
+export * from './use-seam-mutation-without-workspace.js'
 export * from './use-seam-query.js'
 export * from './use-seam-query-result.js'
+export * from './use-seam-query-without-workspace.js'

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

@@ -1,4 +1,9 @@
-import { SeamHttp, SeamHttpEndpoints } from '@seamapi/http/connect'
+import {
+  SeamHttp,
+  SeamHttpEndpoints,
+  SeamHttpEndpointsWithoutWorkspace,
+  SeamHttpWithoutWorkspace,
+} from '@seamapi/http/connect'
 import { useQuery } from '@tanstack/react-query'
 import { useEffect } from 'react'
 import { v4 as uuidv4 } from 'uuid'
@@ -8,6 +13,9 @@ import { useSeamQueryContext } from './SeamQueryProvider.js'
 export function useSeamClient(): {
   client: SeamHttp | null
   endpointClient: SeamHttpEndpoints | null
+  clientWithoutWorkspace: SeamHttpWithoutWorkspace | null
+  endpointClientWithoutWorkspace: SeamHttpEndpointsWithoutWorkspace | null
+  queryKeyPrefixes: string[]
   isPending: boolean
   isError: boolean
   error: unknown
@@ -17,16 +25,23 @@ export function useSeamClient(): {
     clientOptions,
     publishableKey,
     clientSessionToken,
+    consoleSessionToken,
+    workspaceId,
+    queryKeyPrefix,
     ...context
   } = useSeamQueryContext()
   const userIdentifierKey = useUserIdentifierKeyOrFingerprint(
     clientSessionToken != null ? '' : context.userIdentifierKey
   )
 
-  const { isPending, isError, error, data } = useQuery<
-    [SeamHttp, SeamHttpEndpoints]
-  >({
+  const { isPending, isError, error, data } = useQuery<{
+    client: SeamHttp | null
+    endpointClient: SeamHttpEndpoints | null
+    clientWithoutWorkspace: SeamHttpWithoutWorkspace | null
+    endpointClientWithoutWorkspace: SeamHttpEndpointsWithoutWorkspace | null
+  }>({
     queryKey: [
+      ...getQueryKeyPrefixes({ queryKeyPrefix }),
       'client',
       {
         client,
@@ -38,41 +53,94 @@ export function useSeamClient(): {
     ],
     queryFn: async () => {
       if (client != null)
-        return [client, SeamHttpEndpoints.fromClient(client.client)]
+        return {
+          client,
+          endpointClient: SeamHttpEndpoints.fromClient(client.client),
+          clientWithoutWorkspace: null,
+          endpointClientWithoutWorkspace: null,
+        }
 
       if (clientSessionToken != null) {
-        const clientSessionTokenClient = SeamHttp.fromClientSessionToken(
+        const seam = SeamHttp.fromClientSessionToken(
           clientSessionToken,
           clientOptions
         )
 
-        return [
-          clientSessionTokenClient,
-          SeamHttpEndpoints.fromClient(clientSessionTokenClient.client),
-        ]
+        return {
+          client: seam,
+          endpointClient: SeamHttpEndpoints.fromClient(seam.client),
+          clientWithoutWorkspace: null,
+          endpointClientWithoutWorkspace: null,
+        }
       }
 
-      if (publishableKey == null) {
-        throw new Error(
-          'Missing either a client, publishableKey, or clientSessionToken'
+      if (publishableKey != null) {
+        const seam = await SeamHttp.fromPublishableKey(
+          publishableKey,
+          userIdentifierKey,
+          clientOptions
         )
+
+        return {
+          client: seam,
+          endpointClient: SeamHttpEndpoints.fromClient(seam.client),
+          clientWithoutWorkspace: null,
+          endpointClientWithoutWorkspace: null,
+        }
       }
 
-      const publishableKeyClient = await SeamHttp.fromPublishableKey(
-        publishableKey,
-        userIdentifierKey,
-        clientOptions
+      if (consoleSessionToken != null) {
+        const clientWithoutWorkspace =
+          SeamHttpWithoutWorkspace.fromConsoleSessionToken(consoleSessionToken)
+
+        const endpointClientWithoutWorkspace =
+          SeamHttpEndpointsWithoutWorkspace.fromClient(
+            clientWithoutWorkspace.client
+          )
+
+        if (workspaceId == null) {
+          return {
+            client: null,
+            endpointClient: null,
+            clientWithoutWorkspace,
+            endpointClientWithoutWorkspace,
+          }
+        }
+
+        const seam = SeamHttp.fromConsoleSessionToken(
+          consoleSessionToken,
+          workspaceId,
+          clientOptions
+        )
+
+        return {
+          client: seam,
+          endpointClient: SeamHttpEndpoints.fromClient(seam.client),
+          clientWithoutWorkspace,
+          endpointClientWithoutWorkspace,
+        }
+      }
+
+      throw new Error(
+        'Missing either a client, publishableKey, clientSessionToken, or consoleSessionToken.'
       )
-      return [
-        publishableKeyClient,
-        SeamHttpEndpoints.fromClient(publishableKeyClient.client),
-      ]
     },
   })
 
   return {
-    client: data?.[0] ?? null,
-    endpointClient: data?.[1] ?? null,
+    client: data?.client ?? null,
+    endpointClient: data?.endpointClient ?? null,
+    clientWithoutWorkspace: data?.clientWithoutWorkspace ?? null,
+    endpointClientWithoutWorkspace:
+      data?.endpointClientWithoutWorkspace ?? null,
+    queryKeyPrefixes: getQueryKeyPrefixes({
+      queryKeyPrefix,
+      userIdentifierKey,
+      publishableKey,
+      clientSessionToken,
+      consoleSessionToken,
+      workspaceId,
+    }),
     isPending,
     isError,
     error,
@@ -117,3 +185,41 @@ This is not recommended because the client session is now bound to this machine
 
   return fingerprint
 }
+
+const getQueryKeyPrefixes = ({
+  queryKeyPrefix,
+  userIdentifierKey,
+  publishableKey,
+  clientSessionToken,
+  consoleSessionToken,
+  workspaceId,
+}: {
+  queryKeyPrefix: string | undefined
+  userIdentifierKey?: string
+  publishableKey?: string | undefined
+  clientSessionToken?: string | undefined
+  consoleSessionToken?: string | undefined
+  workspaceId?: 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]
+  }
+
+  if (consoleSessionToken != null) {
+    if (workspaceId != null) {
+      return [seamPrefix, consoleSessionToken, workspaceId]
+    }
+
+    return [seamPrefix, consoleSessionToken, 'without_workspace']
+  }
+
+  return [seamPrefix]
+}

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

@@ -0,0 +1,53 @@
+import type {
+  SeamHttpApiError,
+  SeamHttpEndpointsWithoutWorkspace,
+  SeamHttpEndpointWithoutWorkspaceMutationPaths,
+} 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>,
+  SeamHttpApiError,
+  UseSeamMutationWithoutWorkspaceVariables<T>
+>
+
+export function UseSeamMutationWithoutWorkspace<
+  T extends SeamHttpEndpointWithoutWorkspaceMutationPaths,
+>(
+  endpointPath: T,
+  options: Parameters<SeamHttpEndpointsWithoutWorkspace[T]>[1] &
+    MutationOptions<
+      MutationData<T>,
+      SeamHttpApiError,
+      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 MutationOptions<X, Y, Z> = Omit<UseMutationOptions<X, Y, Z>, 'mutationFn'>

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

@@ -0,0 +1,53 @@
+import type {
+  SeamHttpApiError,
+  SeamHttpEndpointsWithoutWorkspace,
+  SeamHttpEndpointWithoutWorkspaceQueryPaths,
+} 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 UseSeamQueryWithoutWorkspaceParameters<
+  T extends SeamHttpEndpointWithoutWorkspaceQueryPaths,
+> = Parameters<SeamHttpEndpointsWithoutWorkspace[T]>[0]
+
+export type UseSeamQueryWithoutWorkspaceResult<
+  T extends SeamHttpEndpointWithoutWorkspaceQueryPaths,
+> = UseQueryResult<QueryData<T>, SeamHttpApiError>
+
+export function useSeamQueryWithoutWorkspace<
+  T extends SeamHttpEndpointWithoutWorkspaceQueryPaths,
+>(
+  endpointPath: T,
+  parameters?: UseSeamQueryWithoutWorkspaceParameters<T>,
+  options: Parameters<SeamHttpEndpointsWithoutWorkspace[T]>[1] &
+    QueryOptions<QueryData<T>, SeamHttpApiError> = {}
+): UseSeamQueryWithoutWorkspaceResult<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 SeamHttpEndpointWithoutWorkspaceQueryPaths> = Awaited<
+  ReturnType<SeamHttpEndpointsWithoutWorkspace[T]>
+>
+
+type QueryOptions<X, Y> = Omit<UseQueryOptions<X, Y>, 'queryKey' | 'queryFn'>

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

@@ -23,11 +23,15 @@ export function useSeamQuery<T extends SeamHttpEndpointQueryPaths>(
   options: Parameters<SeamHttpEndpoints[T]>[1] &
     QueryOptions<QueryData<T>, SeamHttpApiError> = {}
 ): UseSeamQueryResult<T> {
-  const { endpointClient: client } = useSeamClient()
+  const { endpointClient: client, queryKeyPrefixes } = useSeamClient()
   return useQuery({
     enabled: client != null,
     ...options,
-    queryKey: [endpointPath, parameters],
+    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.

package/src/lib/version.ts

@@ -1,3 +1,3 @@
-const seamapiReactVersion = '4.9.0'
+const seamapiReactVersion = '4.10.0'
 
 export default seamapiReactVersion