@seamapi/react 2.19.1 → 3.0.0-beta.1

package/src/lib/seam/components/SupportedDeviceTable/use-manufacturers.ts

@@ -1,15 +1,16 @@
+import type { SeamHttpApiError } from '@seamapi/http/connect'
 import type {
   Manufacturer,
   RouteRequestParams,
   RouteResponse,
 } from '@seamapi/types/devicedb'
 import { useQuery, useQueryClient } from '@tanstack/react-query'
-import type { SeamError } from 'seamapi'
 
 import { useSeamClient } from 'lib/seam/use-seam-client.js'
 import type { UseSeamQueryResult } from 'lib/seam/use-seam-query-result.js'
 
 export type UseManufacturersParams = ManufacturersListParams
+
 export type UseManufacturersData = Manufacturer[]
 
 export function useManufacturers(
@@ -18,10 +19,7 @@ export function useManufacturers(
   const { client: seam } = useSeamClient()
   const queryClient = useQueryClient()
 
-  const { data, ...rest } = useQuery<
-    ManufacturersListResponse['manufacturers'],
-    SeamError
-  >({
+  const { data, ...rest } = useQuery<UseManufacturersData, SeamHttpApiError>({
     enabled: seam != null,
     queryKey: ['internal', 'manufacturers', 'list', params],
     queryFn: async () => {
@@ -32,9 +30,6 @@ export function useManufacturers(
         '/internal/devicedb/v1/manufacturers/list',
         { params }
       )
-      return manufacturers
-    },
-    onSuccess: (manufacturers) => {
       for (const manufacturer of manufacturers) {
         queryClient.setQueryData(
           [
@@ -46,6 +41,7 @@ export function useManufacturers(
           manufacturer
         )
       }
+      return manufacturers
     },
   })
 

package/src/lib/seam/components/common-props.tsx

@@ -1,10 +1,12 @@
-import type { ComponentType } from 'react'
 import type {
   AccessCodeError,
+  AccessCodeWarning,
   ConnectedAccountError,
+  ConnectedAccountWarning,
   DeviceError,
-  SeamWarning,
-} from 'seamapi'
+  DeviceWarning,
+} from '@seamapi/types/connect'
+import type { ComponentType } from 'react'
 
 export interface RequiredCommonProps {
   className: string | undefined
@@ -12,7 +14,9 @@ export interface RequiredCommonProps {
   errorFilter: (
     error: ConnectedAccountError | DeviceError | AccessCodeError
   ) => boolean
-  warningFilter: (warning: SeamWarning) => boolean
+  warningFilter: (
+    warning: ConnectedAccountWarning | DeviceWarning | AccessCodeWarning
+  ) => boolean
   disableDeleteAccessCode: boolean | undefined
   disableCreateAccessCode: boolean | undefined
   disableEditAccessCode: boolean | undefined

package/src/lib/seam/connect-webviews/use-create-connect-webview.ts

@@ -1,10 +1,9 @@
-import { useMutation, type UseMutationResult } from '@tanstack/react-query'
 import type {
-  ConnectWebview,
-  ConnectWebviewCreateRequest,
-  ConnectWebviewCreateResponse,
-  SeamError,
-} from 'seamapi'
+  ConnectWebviewsCreateBody,
+  SeamHttpApiError,
+} from '@seamapi/http/connect'
+import type { ConnectWebview } from '@seamapi/types/connect'
+import { useMutation, type UseMutationResult } from '@tanstack/react-query'
 
 import { useClientSession } from 'lib/seam/client-sessions/use-client-session.js'
 import { NullSeamClientError, useSeamClient } from 'lib/seam/use-seam-client.js'
@@ -14,34 +13,33 @@ export interface UseCreateConnectWebviewParams {
 }
 
 export type UseCreateConnectWebviewData = ConnectWebview
-export type UseCreateConnectWebviewMutationParams = ConnectWebviewCreateRequest
+
+export type UseCreateConnectWebviewMutationVariables = ConnectWebviewsCreateBody
 
 export function useCreateConnectWebview({
   willNavigateToWebview = false,
 }: UseCreateConnectWebviewParams = {}): UseMutationResult<
   UseCreateConnectWebviewData,
-  SeamError,
-  UseCreateConnectWebviewMutationParams
+  SeamHttpApiError,
+  UseCreateConnectWebviewMutationVariables
 > {
   const { client } = useSeamClient()
   const { clientSession } = useClientSession()
 
   return useMutation<
-    ConnectWebviewCreateResponse['connect_webview'],
-    SeamError,
-    ConnectWebviewCreateRequest
+    UseCreateConnectWebviewData,
+    SeamHttpApiError,
+    UseCreateConnectWebviewMutationVariables
   >({
-    mutationFn: async (
-      mutationParams: UseCreateConnectWebviewMutationParams
-    ) => {
+    mutationFn: async (variables) => {
       if (client === null) throw new NullSeamClientError()
       return await client.connectWebviews.create({
         custom_metadata: {
           client_session_id: clientSession?.client_session_id ?? null,
           user_identifier_key: clientSession?.user_identifier_key ?? null,
-          ...mutationParams.custom_metadata,
+          ...variables.custom_metadata,
         },
-        ...mutationParams,
+        ...variables,
       })
     },
     onSuccess: ({ url }) => {

package/src/lib/seam/connected-accounts/use-connected-account.ts

@@ -1,35 +1,31 @@
-import { useQuery } from '@tanstack/react-query'
 import type {
-  ConnectedAccount,
-  ConnectedAccountsGetRequest,
-  ConnectedAccountsGetResponse,
-  SeamError,
-} from 'seamapi'
+  ConnectedAccountsGetParams,
+  SeamHttpApiError,
+} from '@seamapi/http/connect'
+import type { ConnectedAccount } from '@seamapi/types/connect'
+import { useQuery } from '@tanstack/react-query'
 
 import { useSeamClient } from 'lib/seam/use-seam-client.js'
 import type { UseSeamQueryResult } from 'lib/seam/use-seam-query-result.js'
 
-export type UseConnectedAccountParams = ConnectedAccountsGetRequest | string
+export type UseConnectedAccountParams = ConnectedAccountsGetParams
+
 export type UseConnectedAccountData = ConnectedAccount | null
 
 export function useConnectedAccount(
   params: UseConnectedAccountParams
 ): UseSeamQueryResult<'connectedAccount', UseConnectedAccountData> {
-  const normalizedParams =
-    typeof params === 'string' ? { connected_account_id: params } : params
-
   const { client } = useSeamClient()
-  const { data, ...rest } = useQuery<
-    ConnectedAccountsGetResponse['connected_account'] | null,
-    SeamError
-  >({
-    enabled: client != null,
-    queryKey: ['connected_accounts', 'get', normalizedParams],
-    queryFn: async () => {
-      if (client == null) return null
-      return await client.connectedAccounts.get(normalizedParams)
-    },
-  })
+  const { data, ...rest } = useQuery<UseConnectedAccountData, SeamHttpApiError>(
+    {
+      enabled: client != null,
+      queryKey: ['connected_accounts', 'get', params],
+      queryFn: async () => {
+        if (client == null) return null
+        return await client.connectedAccounts.get(params)
+      },
+    }
+  )
 
   return { ...rest, connectedAccount: data }
 }

package/src/lib/seam/devices/use-device-providers.ts

@@ -1,15 +1,15 @@
-import { useQuery } from '@tanstack/react-query'
 import type {
-  DeviceProvider,
-  DeviceProvidersListRequest,
-  DeviceProvidersListResponse,
-  SeamError,
-} from 'seamapi'
+  DevicesListDeviceProvidersParams,
+  SeamHttpApiError,
+} from '@seamapi/http/connect'
+import type { DeviceProvider } from '@seamapi/types/connect'
+import { useQuery } from '@tanstack/react-query'
 
 import { useSeamClient } from 'lib/seam/use-seam-client.js'
 import type { UseSeamQueryResult } from 'lib/seam/use-seam-query-result.js'
 
-export type UseDeviceProvidersParams = DeviceProvidersListRequest
+export type UseDeviceProvidersParams = DevicesListDeviceProvidersParams
+
 export type UseDeviceProvidersData = DeviceProvider[]
 
 export function useDeviceProviders(
@@ -17,10 +17,7 @@ export function useDeviceProviders(
 ): UseSeamQueryResult<'deviceProviders', UseDeviceProvidersData> {
   const { client } = useSeamClient()
 
-  const { data, ...rest } = useQuery<
-    DeviceProvidersListResponse['device_providers'],
-    SeamError
-  >({
+  const { data, ...rest } = useQuery<UseDeviceProvidersData, SeamHttpApiError>({
     enabled: client != null,
     queryKey: ['devices', 'list_device_providers', params],
     queryFn: async () => {

package/src/lib/seam/devices/use-device.ts

@@ -1,33 +1,24 @@
+import type { DevicesGetParams, SeamHttpApiError } from '@seamapi/http/connect'
+import type { Device } from '@seamapi/types/connect'
 import { useQuery } from '@tanstack/react-query'
-import type {
-  CommonDevice,
-  DeviceGetRequest,
-  DeviceGetResponse,
-  SeamError,
-} from 'seamapi'
 
 import { useSeamClient } from 'lib/seam/use-seam-client.js'
 import type { UseSeamQueryResult } from 'lib/seam/use-seam-query-result.js'
 
-export type UseDeviceParams = DeviceGetRequest | string
-export type UseDeviceData = CommonDevice | null
+export type UseDeviceParams = DevicesGetParams
+
+export type UseDeviceData = Device | null
 
 export function useDevice(
-  params: DeviceGetRequest
+  params: UseDeviceParams
 ): UseSeamQueryResult<'device', UseDeviceData> {
-  const normalizedParams =
-    typeof params === 'string' ? { device_id: params } : params
-
   const { client } = useSeamClient()
-  const { data, ...rest } = useQuery<
-    DeviceGetResponse['device'] | null,
-    SeamError
-  >({
+  const { data, ...rest } = useQuery<UseDeviceData, SeamHttpApiError>({
     enabled: client != null,
-    queryKey: ['devices', 'get', normalizedParams],
+    queryKey: ['devices', 'get', params],
     queryFn: async () => {
       if (client == null) return null
-      return await client.devices.get(normalizedParams)
+      return await client.devices.get(params)
     },
   })
 

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

@@ -1,16 +1,13 @@
+import type { DevicesListParams, SeamHttpApiError } from '@seamapi/http/connect'
+import type { Device } from '@seamapi/types/connect'
 import { useQuery, useQueryClient } from '@tanstack/react-query'
-import type {
-  CommonDevice,
-  DevicesListRequest,
-  DevicesListResponse,
-  SeamError,
-} from 'seamapi'
 
 import { useSeamClient } from 'lib/seam/use-seam-client.js'
 import type { UseSeamQueryResult } from 'lib/seam/use-seam-query-result.js'
 
-export type UseDevicesParams = DevicesListRequest
-export type UseDevicesData = CommonDevice[]
+export type UseDevicesParams = DevicesListParams
+
+export type UseDevicesData = Device[]
 
 export function useDevices(
   params?: UseDevicesParams
@@ -18,24 +15,21 @@ export function useDevices(
   const { client } = useSeamClient()
   const queryClient = useQueryClient()
 
-  const { data, ...rest } = useQuery<DevicesListResponse['devices'], SeamError>(
-    {
-      enabled: client != null,
-      queryKey: ['devices', 'list', params],
-      queryFn: async () => {
-        if (client == null) return []
-        return await client.devices.list(params)
-      },
-      onSuccess: (devices) => {
-        for (const device of devices) {
-          queryClient.setQueryData(
-            ['devices', 'get', { device_id: device.device_id }],
-            device
-          )
-        }
-      },
-    }
-  )
+  const { data, ...rest } = useQuery<UseDevicesData, SeamHttpApiError>({
+    enabled: client != null,
+    queryKey: ['devices', 'list', params],
+    queryFn: async () => {
+      if (client == null) return []
+      const devices = await client.devices.list(params)
+      for (const device of devices) {
+        queryClient.setQueryData(
+          ['devices', 'get', { device_id: device.device_id }],
+          device
+        )
+      }
+      return devices
+    },
+  })
 
   return { ...rest, devices: data }
 }

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

@@ -1,43 +1,41 @@
+import type { EventsListParams, SeamHttpApiError } from '@seamapi/http/connect'
+import type { SeamEvent } from '@seamapi/types/connect'
 import { useQuery, useQueryClient } from '@tanstack/react-query'
-import type {
-  Event,
-  EventsListRequest,
-  EventsListResponse,
-  SeamError,
-} from 'seamapi'
 
 import { useSeamClient } from 'lib/seam/use-seam-client.js'
 import type { UseSeamQueryResult } from 'lib/seam/use-seam-query-result.js'
 
-export type UseEventsParams = EventsListRequest
-export type UseEventsData = Event[]
+export type UseEventsParams = EventsListParams
+
+export type UseEventsData = SeamEvent[]
+
 export interface UseEventsOptions {
   refetchInterval?: number
 }
 
 export function useEvents(
   params?: UseEventsParams,
-  options?: UseEventsOptions
+  { refetchInterval }: UseEventsOptions = {}
 ): UseSeamQueryResult<'events', UseEventsData> {
   const { client } = useSeamClient()
   const queryClient = useQueryClient()
 
-  const { data, ...rest } = useQuery<EventsListResponse['events'], SeamError>({
+  const { data, ...rest } = useQuery<UseEventsData, SeamHttpApiError>({
     enabled: client != null,
     queryKey: ['events', 'list', params],
     queryFn: async () => {
       if (client == null) return []
-      return await client.events.list(params)
-    },
-    onSuccess: (events) => {
+      const events = await client.events.list(params)
       for (const event of events) {
         queryClient.setQueryData(
           ['events', 'get', { event_id: event.event_id }],
           event
         )
       }
+      // UPSTREAM: Response type does not match SeamEvent[].
+      return events as SeamEvent[]
     },
-    refetchInterval: options?.refetchInterval ?? 30_000,
+    refetchInterval,
   })
 
   return { ...rest, events: data }

package/src/lib/seam/filters.ts

@@ -1,30 +1,31 @@
 import type {
   AccessCodeError,
+  AccessCodeWarning,
   ConnectedAccountError,
   DeviceError,
-  SeamWarning,
-} from 'seamapi'
+  DeviceWarning,
+} from '@seamapi/types/connect'
 
-type SeamCompositeError = ConnectedAccountError | DeviceError | AccessCodeError
+type SeamResourceError = ConnectedAccountError | DeviceError | AccessCodeError
 
-export const accessCodeErrorFilter = (error: SeamCompositeError): boolean => {
+export const accessCodeErrorFilter = (error: SeamResourceError): boolean => {
   return 'is_access_code_error' in error && error.is_access_code_error
 }
 
-export const accessCodeWarningFilter = (_: SeamWarning): boolean => {
+export const accessCodeWarningFilter = (_: AccessCodeWarning): boolean => {
   return true
 }
 
-export const deviceErrorFilter = (error: SeamCompositeError): boolean => {
+export const deviceErrorFilter = (error: SeamResourceError): boolean => {
   return 'is_device_error' in error && error.is_device_error
 }
 
-export const deviceWarningFilter = (_: SeamWarning): boolean => {
+export const deviceWarningFilter = (_: DeviceWarning): boolean => {
   return true
 }
 
 export const connectedAccountErrorFilter = (
-  error: SeamCompositeError
+  error: SeamResourceError
 ): boolean => {
   return (
     'is_connected_account_error' in error && error.is_connected_account_error

package/src/lib/seam/locks/lock-device.ts

@@ -0,0 +1,9 @@
+import type { Device } from '@seamapi/types/connect'
+
+export type LockDevice = Omit<Device, 'properties'> & {
+  properties: Device['properties'] &
+    NonNullable<Required<Pick<Device['properties'], 'locked'>>>
+}
+
+export const isLockDevice = (device: Device): device is LockDevice =>
+  'locked' in device.properties

package/src/lib/seam/locks/use-toggle-lock.ts

@@ -0,0 +1,103 @@
+import type {
+  SeamActionAttemptFailedError,
+  SeamActionAttemptTimeoutError,
+  SeamHttpApiError,
+} from '@seamapi/http/connect'
+import type { ActionAttempt, Device } from '@seamapi/types/connect'
+import {
+  useMutation,
+  type UseMutationResult,
+  useQueryClient,
+} from '@tanstack/react-query'
+
+import { NullSeamClientError, useSeamClient } from 'lib/seam/use-seam-client.js'
+
+export type UseToggleLockParams = never
+
+export type UseToggleLockData = undefined
+
+export type UseToggleLockMutationVariables = Pick<Device, 'device_id'> & {
+  properties: Required<Pick<Device['properties'], 'locked'>>
+}
+
+type ToggleLockActionAttempt =
+  | Extract<ActionAttempt, { action_type: 'LOCK_DOOR' }>
+  | Extract<ActionAttempt, { action_type: 'UNLOCK_DOOR' }>
+
+type MutationError =
+  | SeamHttpApiError
+  | SeamActionAttemptFailedError<ToggleLockActionAttempt>
+  | SeamActionAttemptTimeoutError<ToggleLockActionAttempt>
+
+export function useToggleLock(): UseMutationResult<
+  UseToggleLockData,
+  MutationError,
+  UseToggleLockMutationVariables
+> {
+  const { client } = useSeamClient()
+  const queryClient = useQueryClient()
+
+  return useMutation<
+    UseToggleLockData,
+    MutationError,
+    UseToggleLockMutationVariables
+  >({
+    mutationFn: async (variables) => {
+      const {
+        device_id: deviceId,
+        properties: { locked },
+      } = variables
+      if (client === null) throw new NullSeamClientError()
+      if (locked == null) return
+      if (locked) await client.locks.unlockDoor({ device_id: deviceId })
+      if (!locked) await client.locks.lockDoor({ device_id: deviceId })
+    },
+    onMutate: (variables) => {
+      queryClient.setQueryData<Device[]>(['devices', 'list', {}], (devices) => {
+        if (devices == null) {
+          return devices
+        }
+
+        return devices.map((device) => {
+          if (
+            device.device_id !== variables.device_id ||
+            device.properties.locked == null
+          ) {
+            return device
+          }
+
+          return {
+            ...device,
+            properties: {
+              ...device.properties,
+              locked: !variables.properties.locked,
+            },
+          }
+        })
+      })
+
+      queryClient.setQueryData<Device>(
+        ['devices', 'get', { device_id: variables.device_id }],
+        (device) => {
+          if (device?.properties.locked == null) return device
+
+          return {
+            ...device,
+            properties: {
+              ...device.properties,
+              locked: !variables.properties.locked,
+            },
+          }
+        }
+      )
+    },
+    onError: async (_error, variables) => {
+      await queryClient.invalidateQueries({
+        queryKey: ['devices', 'list'],
+      })
+      await queryClient.invalidateQueries({
+        queryKey: ['devices', 'get', { device_id: variables.device_id }],
+      })
+    },
+  })
+}

package/src/lib/seam/noise-sensors/noise-sensor-device.ts

@@ -0,0 +1,10 @@
+import type { Device } from '@seamapi/types/connect'
+
+export type NoiseSensorDevice = Omit<Device, 'properties'> & {
+  properties: Device['properties'] &
+    NonNullable<Required<Pick<Device['properties'], 'noise_level_decibels'>>>
+}
+
+export const isNoiseSensorDevice = (
+  device: Device
+): device is NoiseSensorDevice => 'noise_level_decibels' in device.properties

package/src/lib/seam/noise-sensors/use-noise-thresholds.ts

@@ -1,16 +1,16 @@
-import { useQuery, useQueryClient } from '@tanstack/react-query'
 import type {
-  NoiseThresholds,
-  NoiseThresholdsListRequest,
-  NoiseThresholdsListResponse,
-  SeamError,
-} from 'seamapi'
+  NoiseSensorsNoiseThresholdsListParams,
+  SeamHttpApiError,
+} from '@seamapi/http/connect'
+import type { NoiseThreshold } from '@seamapi/types/connect'
+import { useQuery, useQueryClient } from '@tanstack/react-query'
 
 import { useSeamClient } from 'lib/seam/use-seam-client.js'
 import type { UseSeamQueryResult } from 'lib/seam/use-seam-query-result.js'
 
-export type UseNoiseThresholdsParams = NoiseThresholdsListRequest
-export type UseNoiseThresholdsData = NoiseThresholds[]
+export type UseNoiseThresholdsParams = NoiseSensorsNoiseThresholdsListParams
+
+export type UseNoiseThresholdsData = NoiseThreshold[]
 
 export function useNoiseThresholds(
   params: UseNoiseThresholdsParams
@@ -18,17 +18,13 @@ export function useNoiseThresholds(
   const { client } = useSeamClient()
   const queryClient = useQueryClient()
 
-  const { data, ...rest } = useQuery<
-    NoiseThresholdsListResponse['noise_thresholds'],
-    SeamError
-  >({
+  const { data, ...rest } = useQuery<UseNoiseThresholdsData, SeamHttpApiError>({
     enabled: client != null,
     queryKey: ['noise_thresholds', 'list', params],
     queryFn: async () => {
       if (client == null) return []
-      return await client.noiseThresholds.list(params)
-    },
-    onSuccess: (noiseThresholds) => {
+      const noiseThresholds =
+        await client.noiseSensors.noiseThresholds.list(params)
       for (const noiseThreshold of noiseThresholds) {
         queryClient.setQueryData(
           [
@@ -39,6 +35,7 @@ export function useNoiseThresholds(
           noiseThreshold
         )
       }
+      return noiseThresholds
     },
   })
 

package/src/lib/seam/thermostats/climate-setting-schedules/use-climate-setting-schedule.ts

@@ -1,45 +1,32 @@
-import { useQuery } from '@tanstack/react-query'
 import type {
-  ClimateSettingSchedule,
-  ClimateSettingScheduleGetRequest,
-  ClimateSettingScheduleGetResponse,
-  SeamError,
-} from 'seamapi'
+  SeamHttpApiError,
+  ThermostatsClimateSettingSchedulesGetParams,
+} from '@seamapi/http/connect'
+import type { ClimateSettingSchedule } from '@seamapi/types/connect'
+import { useQuery } from '@tanstack/react-query'
 
 import { useSeamClient } from 'lib/seam/use-seam-client.js'
 import type { UseSeamQueryResult } from 'lib/seam/use-seam-query-result.js'
 
 export type UseClimateSettingScheduleParams =
-  | ClimateSettingScheduleGetRequest
-  | string
+  ThermostatsClimateSettingSchedulesGetParams
 
 export type UseClimateSettingScheduleData = ClimateSettingSchedule | null
 
 export function useClimateSettingSchedule(
   params: UseClimateSettingScheduleParams
 ): UseSeamQueryResult<'climateSettingSchedule', UseClimateSettingScheduleData> {
-  const normalizedParams =
-    typeof params === 'string'
-      ? { climate_setting_schedule_id: params }
-      : params
   const { client } = useSeamClient()
 
   const { data, ...rest } = useQuery<
-    ClimateSettingScheduleGetResponse['climate_setting_schedule'] | null,
-    SeamError
+    UseClimateSettingScheduleData,
+    SeamHttpApiError
   >({
     enabled: client != null,
-    queryKey: [
-      'thermostats',
-      'climate_setting_schedules',
-      'get',
-      normalizedParams,
-    ],
+    queryKey: ['thermostats', 'climate_setting_schedules', 'get', params],
     queryFn: async () => {
       if (client == null) return null
-      return await client.thermostats.climateSettingSchedules.get(
-        normalizedParams
-      )
+      return await client.thermostats.climateSettingSchedules.get(params)
     },
   })