@seamapi/http 0.0.2 → 0.1.0

package/src/lib/seam/connect/auth.ts

@@ -1,7 +1,7 @@
 import {
-  InvalidSeamHttpOptionsError,
   isSeamHttpOptionsWithApiKey,
   isSeamHttpOptionsWithClientSessionToken,
+  SeamHttpInvalidOptionsError,
   type SeamHttpOptions,
   type SeamHttpOptionsWithApiKey,
   type SeamHttpOptionsWithClientSessionToken,
@@ -18,7 +18,7 @@ export const getAuthHeaders = (options: SeamHttpOptions): Headers => {
     return getAuthHeadersForClientSessionToken(options)
   }
 
-  throw new InvalidSeamHttpOptionsError(
+  throw new SeamHttpInvalidOptionsError(
     'Must specify an apiKey or clientSessionToken',
   )
 }
@@ -27,19 +27,19 @@ const getAuthHeadersForApiKey = ({
   apiKey,
 }: SeamHttpOptionsWithApiKey): Headers => {
   if (isClientSessionToken(apiKey)) {
-    throw new InvalidSeamTokenError(
+    throw new SeamHttpInvalidTokenError(
       'A Client Session Token cannot be used as an apiKey',
     )
   }
 
   if (isAccessToken(apiKey)) {
-    throw new InvalidSeamTokenError(
+    throw new SeamHttpInvalidTokenError(
       'An access token cannot be used as an apiKey',
     )
   }
 
   if (isJwt(apiKey) || !isSeamToken(apiKey)) {
-    throw new InvalidSeamTokenError(
+    throw new SeamHttpInvalidTokenError(
       `Unknown or invalid apiKey format, expected token to start with ${tokenPrefix}`,
     )
   }
@@ -53,7 +53,7 @@ const getAuthHeadersForClientSessionToken = ({
   clientSessionToken,
 }: SeamHttpOptionsWithClientSessionToken): Headers => {
   if (!isClientSessionToken(clientSessionToken)) {
-    throw new InvalidSeamTokenError(
+    throw new SeamHttpInvalidTokenError(
       `Unknown or invalid clientSessionToken format, expected token to start with ${clientSessionTokenPrefix}`,
     )
   }
@@ -64,7 +64,7 @@ const getAuthHeadersForClientSessionToken = ({
   }
 }
 
-export class InvalidSeamTokenError extends Error {
+export class SeamHttpInvalidTokenError extends Error {
   constructor(message: string) {
     super(`SeamHttp received an invalid token: ${message}`)
     this.name = this.constructor.name

package/src/lib/seam/connect/axios.ts

@@ -2,6 +2,7 @@ import axios, { type Axios } from 'axios'
 
 import { getAuthHeaders } from './auth.js'
 import {
+  isSeamHttpOptionsWithClient,
   isSeamHttpOptionsWithClientSessionToken,
   type SeamHttpOptions,
 } from './client-options.js'
@@ -9,6 +10,7 @@ import {
 export const createAxiosClient = (
   options: Required<SeamHttpOptions>,
 ): Axios => {
+  if (isSeamHttpOptionsWithClient(options)) return options.client
   // TODO: axiosRetry? Allow options to configure this if so
   return axios.create({
     baseURL: options.endpoint,

package/src/lib/seam/connect/client-options.ts

@@ -1,6 +1,7 @@
-import type { AxiosRequestConfig } from 'axios'
+import type { Axios, AxiosRequestConfig } from 'axios'
 
 export type SeamHttpOptions =
+  | SeamHttpOptionsWithClient
   | SeamHttpOptionsWithApiKey
   | SeamHttpOptionsWithClientSessionToken
 
@@ -10,6 +11,31 @@ interface SeamHttpCommonOptions {
   enableLegacyMethodBehaivor?: boolean
 }
 
+export interface SeamHttpOptionsWithClient
+  extends Pick<SeamHttpCommonOptions, 'enableLegacyMethodBehaivor'> {
+  client: Axios
+}
+
+export const isSeamHttpOptionsWithClient = (
+  options: SeamHttpOptions,
+): options is SeamHttpOptionsWithClient => {
+  if (!('client' in options)) return false
+  if (options.client == null) return false
+
+  const keys = Object.keys(options).filter(
+    (k) => !['client', 'enableLegacyMethodBehaivor'].includes(k),
+  )
+  if (keys.length > 0) {
+    throw new SeamHttpInvalidOptionsError(
+      `The client option cannot be used with any other option except enableLegacyMethodBehaivor, but received: ${keys.join(
+        ', ',
+      )}`,
+    )
+  }
+
+  return true
+}
+
 export interface SeamHttpOptionsWithApiKey extends SeamHttpCommonOptions {
   apiKey: string
 }
@@ -18,9 +44,10 @@ export const isSeamHttpOptionsWithApiKey = (
   options: SeamHttpOptions,
 ): options is SeamHttpOptionsWithApiKey => {
   if (!('apiKey' in options)) return false
+  if (options.apiKey == null) return false
 
   if ('clientSessionToken' in options && options.clientSessionToken != null) {
-    throw new InvalidSeamHttpOptionsError(
+    throw new SeamHttpInvalidOptionsError(
       'The clientSessionToken option cannot be used with the apiKey option.',
     )
   }
@@ -37,9 +64,10 @@ export const isSeamHttpOptionsWithClientSessionToken = (
   options: SeamHttpOptions,
 ): options is SeamHttpOptionsWithClientSessionToken => {
   if (!('clientSessionToken' in options)) return false
+  if (options.clientSessionToken == null) return false
 
   if ('apiKey' in options && options.apiKey != null) {
-    throw new InvalidSeamHttpOptionsError(
+    throw new SeamHttpInvalidOptionsError(
       'The clientSessionToken option cannot be used with the apiKey option.',
     )
   }
@@ -47,7 +75,7 @@ export const isSeamHttpOptionsWithClientSessionToken = (
   return true
 }
 
-export class InvalidSeamHttpOptionsError extends Error {
+export class SeamHttpInvalidOptionsError extends Error {
   constructor(message: string) {
     super(`SeamHttp received invalid options: ${message}`)
     this.name = this.constructor.name

package/src/lib/seam/connect/client.ts

@@ -2,35 +2,61 @@ import type { Axios } from 'axios'
 
 import { createAxiosClient } from './axios.js'
 import {
-  InvalidSeamHttpOptionsError,
   isSeamHttpOptionsWithApiKey,
+  isSeamHttpOptionsWithClient,
   isSeamHttpOptionsWithClientSessionToken,
+  SeamHttpInvalidOptionsError,
   type SeamHttpOptions,
   type SeamHttpOptionsWithApiKey,
+  type SeamHttpOptionsWithClient,
   type SeamHttpOptionsWithClientSessionToken,
 } from './client-options.js'
-import { LegacyWorkspacesHttp } from './legacy/workspaces.js'
 import { parseOptions } from './parse-options.js'
-import { WorkspacesHttp } from './routes/workspaces.js'
+import {
+  SeamHttpAccessCodes,
+  SeamHttpAcs,
+  SeamHttpActionAttempts,
+  SeamHttpClientSessions,
+  SeamHttpConnectedAccounts,
+  SeamHttpConnectWebviews,
+  SeamHttpDevices,
+  SeamHttpEvents,
+  SeamHttpLocks,
+  SeamHttpNoiseSensors,
+  SeamHttpThermostats,
+  SeamHttpWebhooks,
+  SeamHttpWorkspaces,
+} from './routes/index.js'
 
 export class SeamHttp {
   client: Axios
 
-  #legacy: boolean
+  // #legacy: boolean
 
   constructor(apiKeyOrOptions: string | SeamHttpOptions) {
     const options = parseOptions(apiKeyOrOptions)
-    this.#legacy = options.enableLegacyMethodBehaivor
+    // this.#legacy = options.enableLegacyMethodBehaivor
     this.client = createAxiosClient(options)
   }
 
+  static fromClient(
+    client: SeamHttpOptionsWithClient['client'],
+    options: Omit<SeamHttpOptionsWithClient, 'client'> = {},
+  ): SeamHttp {
+    const opts = { ...options, client }
+    if (!isSeamHttpOptionsWithClient(opts)) {
+      throw new SeamHttpInvalidOptionsError('Missing client')
+    }
+    return new SeamHttp(opts)
+  }
+
   static fromApiKey(
     apiKey: SeamHttpOptionsWithApiKey['apiKey'],
     options: Omit<SeamHttpOptionsWithApiKey, 'apiKey'> = {},
   ): SeamHttp {
     const opts = { ...options, apiKey }
     if (!isSeamHttpOptionsWithApiKey(opts)) {
-      throw new InvalidSeamHttpOptionsError('Missing apiKey')
+      throw new SeamHttpInvalidOptionsError('Missing apiKey')
     }
     return new SeamHttp(opts)
   }
@@ -44,20 +70,67 @@ export class SeamHttp {
   ): SeamHttp {
     const opts = { ...options, clientSessionToken }
     if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
-      throw new InvalidSeamHttpOptionsError('Missing clientSessionToken')
+      throw new SeamHttpInvalidOptionsError('Missing clientSessionToken')
     }
     return new SeamHttp(opts)
   }
 
-  // TODO
-  // static fromPublishableKey and deprecate getClientSessionToken
+  get accessCodes(): SeamHttpAccessCodes {
+    return SeamHttpAccessCodes.fromClient(this.client)
+  }
+
+  get acs(): SeamHttpAcs {
+    return SeamHttpAcs.fromClient(this.client)
+  }
+
+  get actionAttempts(): SeamHttpActionAttempts {
+    return SeamHttpActionAttempts.fromClient(this.client)
+  }
+
+  get clientSessions(): SeamHttpClientSessions {
+    return SeamHttpClientSessions.fromClient(this.client)
+  }
+
+  get connectedAccounts(): SeamHttpConnectedAccounts {
+    return SeamHttpConnectedAccounts.fromClient(this.client)
+  }
+
+  get connectWebviews(): SeamHttpConnectWebviews {
+    return SeamHttpConnectWebviews.fromClient(this.client)
+  }
+
+  get devices(): SeamHttpDevices {
+    return SeamHttpDevices.fromClient(this.client)
+  }
+
+  get events(): SeamHttpEvents {
+    return SeamHttpEvents.fromClient(this.client)
+  }
 
-  // TODO: Should we keep makeRequest?
-  // Better to implement error handling and wrapping in an error handler.
-  // makeRequest
+  get locks(): SeamHttpLocks {
+    return SeamHttpLocks.fromClient(this.client)
+  }
 
-  get workspaces(): WorkspacesHttp {
-    if (this.#legacy) return new LegacyWorkspacesHttp(this.client)
-    return new WorkspacesHttp(this.client)
+  get noiseSensors(): SeamHttpNoiseSensors {
+    return SeamHttpNoiseSensors.fromClient(this.client)
+  }
+
+  get thermostats(): SeamHttpThermostats {
+    return SeamHttpThermostats.fromClient(this.client)
+  }
+
+  get webhooks(): SeamHttpWebhooks {
+    return SeamHttpWebhooks.fromClient(this.client)
+  }
+
+  get workspaces(): SeamHttpWorkspaces {
+    return SeamHttpWorkspaces.fromClient(this.client)
   }
 }
+
+// TODO
+// static fromPublishableKey and deprecate getClientSessionToken
+
+// TODO: Should we keep makeRequest?
+// Better to implement error handling and wrapping in an error handler.
+// makeRequest

package/src/lib/seam/connect/parse-options.ts

@@ -1,4 +1,10 @@
-import type { SeamHttpOptions } from './client-options.js'
+import {
+  isSeamHttpOptionsWithClient,
+  type SeamHttpOptions,
+} from './client-options.js'
+
+const enableLegacyMethodBehaivorDefault = true
+
 export const parseOptions = (
   apiKeyOrOptions: string | SeamHttpOptions,
 ): Required<SeamHttpOptions> => {
@@ -7,6 +13,13 @@ export const parseOptions = (
       ? { apiKey: apiKeyOrOptions }
       : apiKeyOrOptions
 
+  if (isSeamHttpOptionsWithClient(options))
+    return {
+      ...options,
+      enableLegacyMethodBehaivor:
+        options.enableLegacyMethodBehaivor ?? enableLegacyMethodBehaivorDefault,
+    }
+
   const endpoint =
     options.endpoint ??
     globalThis.process?.env?.['SEAM_ENDPOINT'] ??
@@ -23,6 +36,7 @@ export const parseOptions = (
     ...(apiKey != null ? { apiKey } : {}),
     endpoint,
     axiosOptions: options.axiosOptions ?? {},
-    enableLegacyMethodBehaivor: false,
+    enableLegacyMethodBehaivor:
+      options.enableLegacyMethodBehaivor ?? enableLegacyMethodBehaivorDefault,
   }
 }

package/src/lib/seam/connect/routes/access-codes-unmanaged.ts

@@ -0,0 +1,157 @@
+/*
+ * Automatically generated by generate-routes.ts.
+ * Do not edit this file or add other files to this directory.
+ */
+
+import type { RouteRequestBody, RouteResponse } from '@seamapi/types/connect'
+import type { Axios } from 'axios'
+import type { SetNonNullable } from 'type-fest'
+
+import { createAxiosClient } from 'lib/seam/connect/axios.js'
+import {
+  isSeamHttpOptionsWithApiKey,
+  isSeamHttpOptionsWithClient,
+  isSeamHttpOptionsWithClientSessionToken,
+  SeamHttpInvalidOptionsError,
+  type SeamHttpOptions,
+  type SeamHttpOptionsWithApiKey,
+  type SeamHttpOptionsWithClient,
+  type SeamHttpOptionsWithClientSessionToken,
+} from 'lib/seam/connect/client-options.js'
+import { parseOptions } from 'lib/seam/connect/parse-options.js'
+
+export class SeamHttpAccessCodesUnmanaged {
+  client: Axios
+
+  constructor(apiKeyOrOptions: string | SeamHttpOptions) {
+    const options = parseOptions(apiKeyOrOptions)
+    this.client = createAxiosClient(options)
+  }
+
+  static fromClient(
+    client: SeamHttpOptionsWithClient['client'],
+    options: Omit<SeamHttpOptionsWithClient, 'client'> = {},
+  ): SeamHttpAccessCodesUnmanaged {
+    const opts = { ...options, client }
+    if (!isSeamHttpOptionsWithClient(opts)) {
+      throw new SeamHttpInvalidOptionsError('Missing client')
+    }
+    return new SeamHttpAccessCodesUnmanaged(opts)
+  }
+
+  static fromApiKey(
+    apiKey: SeamHttpOptionsWithApiKey['apiKey'],
+    options: Omit<SeamHttpOptionsWithApiKey, 'apiKey'> = {},
+  ): SeamHttpAccessCodesUnmanaged {
+    const opts = { ...options, apiKey }
+    if (!isSeamHttpOptionsWithApiKey(opts)) {
+      throw new SeamHttpInvalidOptionsError('Missing apiKey')
+    }
+    return new SeamHttpAccessCodesUnmanaged(opts)
+  }
+
+  static fromClientSessionToken(
+    clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'],
+    options: Omit<
+      SeamHttpOptionsWithClientSessionToken,
+      'clientSessionToken'
+    > = {},
+  ): SeamHttpAccessCodesUnmanaged {
+    const opts = { ...options, clientSessionToken }
+    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+      throw new SeamHttpInvalidOptionsError('Missing clientSessionToken')
+    }
+    return new SeamHttpAccessCodesUnmanaged(opts)
+  }
+
+  async convertToManaged(
+    body: AccessCodesUnmanagedConvertToManagedBody,
+  ): Promise<void> {
+    await this.client.request<AccessCodesUnmanagedConvertToManagedResponse>({
+      url: '/access_codes/unmanaged/convert_to_managed',
+      method: 'post',
+      data: body,
+    })
+  }
+
+  async delete(body: AccessCodesUnmanagedDeleteBody): Promise<void> {
+    await this.client.request<AccessCodesUnmanagedDeleteResponse>({
+      url: '/access_codes/unmanaged/delete',
+      method: 'post',
+      data: body,
+    })
+  }
+
+  async get(
+    body: AccessCodesUnmanagedGetBody,
+  ): Promise<AccessCodesUnmanagedGetResponse['access_code']> {
+    const { data } = await this.client.request<AccessCodesUnmanagedGetResponse>(
+      {
+        url: '/access_codes/unmanaged/get',
+        method: 'post',
+        data: body,
+      },
+    )
+    return data.access_code
+  }
+
+  async list(
+    body: AccessCodesUnmanagedListBody,
+  ): Promise<AccessCodesUnmanagedListResponse['access_codes']> {
+    const { data } =
+      await this.client.request<AccessCodesUnmanagedListResponse>({
+        url: '/access_codes/unmanaged/list',
+        method: 'post',
+        data: body,
+      })
+    return data.access_codes
+  }
+
+  async update(body: AccessCodesUnmanagedUpdateBody): Promise<void> {
+    await this.client.request<AccessCodesUnmanagedUpdateResponse>({
+      url: '/access_codes/unmanaged/update',
+      method: 'post',
+      data: body,
+    })
+  }
+}
+
+export type AccessCodesUnmanagedConvertToManagedBody = SetNonNullable<
+  Required<RouteRequestBody<'/access_codes/unmanaged/convert_to_managed'>>
+>
+
+export type AccessCodesUnmanagedConvertToManagedResponse = SetNonNullable<
+  Required<RouteResponse<'/access_codes/unmanaged/convert_to_managed'>>
+>
+
+export type AccessCodesUnmanagedDeleteBody = SetNonNullable<
+  Required<RouteRequestBody<'/access_codes/unmanaged/delete'>>
+>
+
+export type AccessCodesUnmanagedDeleteResponse = SetNonNullable<
+  Required<RouteResponse<'/access_codes/unmanaged/delete'>>
+>
+
+export type AccessCodesUnmanagedGetBody = SetNonNullable<
+  Required<RouteRequestBody<'/access_codes/unmanaged/get'>>
+>
+
+export type AccessCodesUnmanagedGetResponse = SetNonNullable<
+  Required<RouteResponse<'/access_codes/unmanaged/get'>>
+>
+
+export type AccessCodesUnmanagedListBody = SetNonNullable<
+  Required<RouteRequestBody<'/access_codes/unmanaged/list'>>
+>
+
+export type AccessCodesUnmanagedListResponse = SetNonNullable<
+  Required<RouteResponse<'/access_codes/unmanaged/list'>>
+>
+
+export type AccessCodesUnmanagedUpdateBody = SetNonNullable<
+  Required<RouteRequestBody<'/access_codes/unmanaged/update'>>
+>
+
+export type AccessCodesUnmanagedUpdateResponse = SetNonNullable<
+  Required<RouteResponse<'/access_codes/unmanaged/update'>>
+>