@seamapi/react 4.9.1 → 4.11.0

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,8 @@ 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
@@ -18,6 +25,8 @@ export function useSeamClient(): {
     clientOptions,
     publishableKey,
     clientSessionToken,
+    consoleSessionToken,
+    workspaceId,
     queryKeyPrefix,
     ...context
   } = useSeamQueryContext()
@@ -25,9 +34,12 @@ export function useSeamClient(): {
     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',
@@ -41,46 +53,93 @@ 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,
@@ -132,11 +191,15 @@ const getQueryKeyPrefixes = ({
   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'
 
@@ -150,5 +213,13 @@ const getQueryKeyPrefixes = ({
     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-infinite-query.ts

@@ -0,0 +1,81 @@
+import type {
+  SeamHttpApiError,
+  SeamHttpEndpointPaginatedQueryPaths,
+  SeamHttpEndpoints,
+  SeamHttpRequest,
+  SeamPageCursor,
+} from '@seamapi/http/connect'
+import {
+  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>, SeamHttpApiError>
+
+export function useSeamInfiniteQuery<
+  T extends SeamHttpEndpointPaginatedQueryPaths,
+>(
+  endpointPath: T,
+  parameters?: UseSeamInfiniteQueryParameters<T>,
+  options: Parameters<SeamHttpEndpoints[T]>[1] &
+    QueryOptions<QueryData<T>, SeamHttpApiError> = {}
+): UseSeamInfiniteQueryResult<T> {
+  const { endpointClient: client, queryKeyPrefixes } = useSeamClient()
+  return useInfiniteQuery({
+    enabled: client != null,
+    ...options,
+    queryKey: [
+      ...queryKeyPrefixes,
+      ...endpointPath.split('/').filter((v) => v !== ''),
+      parameters,
+    ],
+    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,
+      }
+    },
+  })
+}
+
+interface QueryData<T extends SeamHttpEndpointPaginatedQueryPaths> {
+  data: Awaited<ReturnType<SeamHttpEndpoints[T]>>
+  nextPageCursor: SeamPageCursor | null
+}
+
+type QueryOptions<X, Y> = Omit<
+  UseInfiniteQueryOptions<X, Y>,
+  'queryKey' | 'queryFn' | 'initialPageParam' | 'getNextPageParam'
+>

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/version.ts

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