@seamapi/http 0.1.0 → 0.2.0

package/src/lib/seam/connect/{client-options.ts → options.ts}

@@ -1,19 +1,21 @@
-import type { Axios, AxiosRequestConfig } from 'axios'
+import type { Client, ClientOptions } from './client.js'
 
 export type SeamHttpOptions =
+  | SeamHttpOptionsFromEnv
   | SeamHttpOptionsWithClient
   | SeamHttpOptionsWithApiKey
   | SeamHttpOptionsWithClientSessionToken
 
-interface SeamHttpCommonOptions {
+interface SeamHttpCommonOptions extends ClientOptions {
   endpoint?: string
-  axiosOptions?: AxiosRequestConfig
-  enableLegacyMethodBehaivor?: boolean
 }
 
-export interface SeamHttpOptionsWithClient
-  extends Pick<SeamHttpCommonOptions, 'enableLegacyMethodBehaivor'> {
-  client: Axios
+export type SeamHttpFromPublishableKeyOptions = SeamHttpCommonOptions
+
+export type SeamHttpOptionsFromEnv = SeamHttpCommonOptions
+
+export interface SeamHttpOptionsWithClient {
+  client: Client
 }
 
 export const isSeamHttpOptionsWithClient = (
@@ -22,12 +24,10 @@ export const isSeamHttpOptionsWithClient = (
   if (!('client' in options)) return false
   if (options.client == null) return false
 
-  const keys = Object.keys(options).filter(
-    (k) => !['client', 'enableLegacyMethodBehaivor'].includes(k),
-  )
+  const keys = Object.keys(options).filter((k) => k !== 'client')
   if (keys.length > 0) {
     throw new SeamHttpInvalidOptionsError(
-      `The client option cannot be used with any other option except enableLegacyMethodBehaivor, but received: ${keys.join(
+      `The client option cannot be used with any other option, but received: ${keys.join(
         ', ',
       )}`,
     )
@@ -48,7 +48,7 @@ export const isSeamHttpOptionsWithApiKey = (
 
   if ('clientSessionToken' in options && options.clientSessionToken != null) {
     throw new SeamHttpInvalidOptionsError(
-      'The clientSessionToken option cannot be used with the apiKey option.',
+      'The clientSessionToken option cannot be used with the apiKey option',
     )
   }
 
@@ -68,7 +68,7 @@ export const isSeamHttpOptionsWithClientSessionToken = (
 
   if ('apiKey' in options && options.apiKey != null) {
     throw new SeamHttpInvalidOptionsError(
-      'The clientSessionToken option cannot be used with the apiKey option.',
+      'The clientSessionToken option cannot be used with the apiKey option',
     )
   }
 
@@ -82,9 +82,3 @@ export class SeamHttpInvalidOptionsError extends Error {
     Error.captureStackTrace(this, this.constructor)
   }
 }
-
-// TODO: withSessionToken { sessionToken } or withMultiWorkspaceApiKey { apiKey }?
-// export interface SeamHttpOptionsWithSessionToken extends SeamHttpCommonOptions {
-//   workspaceId: string
-//   apiKey: string
-// }

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

@@ -1,42 +1,69 @@
+import { getAuthHeaders } from './auth.js'
+import type { ClientOptions } from './client.js'
 import {
   isSeamHttpOptionsWithClient,
+  isSeamHttpOptionsWithClientSessionToken,
   type SeamHttpOptions,
-} from './client-options.js'
+} from './options.js'
 
-const enableLegacyMethodBehaivorDefault = true
+const defaultEndpoint = 'https://connect.getseam.com'
+
+export type Options = SeamHttpOptions & { publishableKey?: string }
 
 export const parseOptions = (
-  apiKeyOrOptions: string | SeamHttpOptions,
-): Required<SeamHttpOptions> => {
+  apiKeyOrOptions: string | Options,
+): ClientOptions => {
+  const options = getNormalizedOptions(apiKeyOrOptions)
+
+  if (isSeamHttpOptionsWithClient(options)) return options
+
+  return {
+    axiosOptions: {
+      baseURL: options.endpoint ?? getEndpointFromEnv() ?? defaultEndpoint,
+      withCredentials: isSeamHttpOptionsWithClientSessionToken(options),
+      ...options.axiosOptions,
+      headers: {
+        ...getAuthHeaders(options),
+        ...options.axiosOptions?.headers,
+      },
+    },
+    axiosRetryOptions: {
+      ...options.axiosRetryOptions,
+    },
+  }
+}
+
+const getNormalizedOptions = (
+  apiKeyOrOptions: string | Options,
+): SeamHttpOptions => {
   const options =
     typeof apiKeyOrOptions === 'string'
       ? { apiKey: apiKeyOrOptions }
       : apiKeyOrOptions
 
-  if (isSeamHttpOptionsWithClient(options))
-    return {
-      ...options,
-      enableLegacyMethodBehaivor:
-        options.enableLegacyMethodBehaivor ?? enableLegacyMethodBehaivorDefault,
-    }
-
-  const endpoint =
-    options.endpoint ??
-    globalThis.process?.env?.['SEAM_ENDPOINT'] ??
-    globalThis.process?.env?.['SEAM_API_URL'] ??
-    'https://connect.getseam.com'
+  if (isSeamHttpOptionsWithClient(options)) return options
 
   const apiKey =
-    'apiKey' in options
-      ? options.apiKey
-      : globalThis.process?.env?.['SEAM_API_KEY']
+    'apiKey' in options ? options.apiKey : getApiKeyFromEnv(options)
 
   return {
     ...options,
     ...(apiKey != null ? { apiKey } : {}),
-    endpoint,
-    axiosOptions: options.axiosOptions ?? {},
-    enableLegacyMethodBehaivor:
-      options.enableLegacyMethodBehaivor ?? enableLegacyMethodBehaivorDefault,
   }
 }
+
+const getApiKeyFromEnv = (
+  options: SeamHttpOptions,
+): string | null | undefined => {
+  if ('clientSessionToken' in options && options.clientSessionToken != null) {
+    return null
+  }
+  return globalThis.process?.env?.SEAM_API_KEY
+}
+
+const getEndpointFromEnv = (): string | null | undefined => {
+  return (
+    globalThis.process?.env?.SEAM_ENDPOINT ??
+    globalThis.process?.env?.SEAM_API_URL
+  )
+}

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

@@ -4,50 +4,53 @@
  */
 
 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 { warnOnInsecureuserIdentifierKey } from 'lib/seam/connect/auth.js'
+import { type Client, createClient } from 'lib/seam/connect/client.js'
 import {
   isSeamHttpOptionsWithApiKey,
   isSeamHttpOptionsWithClient,
   isSeamHttpOptionsWithClientSessionToken,
+  type SeamHttpFromPublishableKeyOptions,
   SeamHttpInvalidOptionsError,
   type SeamHttpOptions,
   type SeamHttpOptionsWithApiKey,
   type SeamHttpOptionsWithClient,
   type SeamHttpOptionsWithClientSessionToken,
-} from 'lib/seam/connect/client-options.js'
+} from 'lib/seam/connect/options.js'
 import { parseOptions } from 'lib/seam/connect/parse-options.js'
 
+import { SeamHttpClientSessions } from './client-sessions.js'
+
 export class SeamHttpAccessCodesUnmanaged {
-  client: Axios
+  client: Client
 
-  constructor(apiKeyOrOptions: string | SeamHttpOptions) {
-    const options = parseOptions(apiKeyOrOptions)
-    this.client = createAxiosClient(options)
+  constructor(apiKeyOrOptions: string | SeamHttpOptions = {}) {
+    const clientOptions = parseOptions(apiKeyOrOptions)
+    this.client = createClient(clientOptions)
   }
 
   static fromClient(
     client: SeamHttpOptionsWithClient['client'],
     options: Omit<SeamHttpOptionsWithClient, 'client'> = {},
   ): SeamHttpAccessCodesUnmanaged {
-    const opts = { ...options, client }
-    if (!isSeamHttpOptionsWithClient(opts)) {
+    const constructorOptions = { ...options, client }
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError('Missing client')
     }
-    return new SeamHttpAccessCodesUnmanaged(opts)
+    return new SeamHttpAccessCodesUnmanaged(constructorOptions)
   }
 
   static fromApiKey(
     apiKey: SeamHttpOptionsWithApiKey['apiKey'],
     options: Omit<SeamHttpOptionsWithApiKey, 'apiKey'> = {},
   ): SeamHttpAccessCodesUnmanaged {
-    const opts = { ...options, apiKey }
-    if (!isSeamHttpOptionsWithApiKey(opts)) {
+    const constructorOptions = { ...options, apiKey }
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError('Missing apiKey')
     }
-    return new SeamHttpAccessCodesUnmanaged(opts)
+    return new SeamHttpAccessCodesUnmanaged(constructorOptions)
   }
 
   static fromClientSessionToken(
@@ -57,11 +60,26 @@ export class SeamHttpAccessCodesUnmanaged {
       'clientSessionToken'
     > = {},
   ): SeamHttpAccessCodesUnmanaged {
-    const opts = { ...options, clientSessionToken }
-    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+    const constructorOptions = { ...options, clientSessionToken }
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError('Missing clientSessionToken')
     }
-    return new SeamHttpAccessCodesUnmanaged(opts)
+    return new SeamHttpAccessCodesUnmanaged(constructorOptions)
+  }
+
+  static async fromPublishableKey(
+    publishableKey: string,
+    userIdentifierKey: string,
+    options: SeamHttpFromPublishableKeyOptions = {},
+  ): Promise<SeamHttpAccessCodesUnmanaged> {
+    warnOnInsecureuserIdentifierKey(userIdentifierKey)
+    const clientOptions = parseOptions({ ...options, publishableKey })
+    const client = createClient(clientOptions)
+    const clientSessions = SeamHttpClientSessions.fromClient(client)
+    const { token } = await clientSessions.getOrCreate({
+      user_identifier_key: userIdentifierKey,
+    })
+    return SeamHttpAccessCodesUnmanaged.fromClientSessionToken(token, options)
   }
 
   async convertToManaged(
@@ -116,41 +134,36 @@ export class SeamHttpAccessCodesUnmanaged {
   }
 }
 
-export type AccessCodesUnmanagedConvertToManagedBody = SetNonNullable<
-  Required<RouteRequestBody<'/access_codes/unmanaged/convert_to_managed'>>
->
+export type AccessCodesUnmanagedConvertToManagedBody =
+  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 AccessCodesUnmanagedDeleteBody =
+  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 AccessCodesUnmanagedGetBody =
+  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 AccessCodesUnmanagedListBody =
+  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 AccessCodesUnmanagedUpdateBody =
+  RouteRequestBody<'/access_codes/unmanaged/update'>
 
 export type AccessCodesUnmanagedUpdateResponse = SetNonNullable<
   Required<RouteResponse<'/access_codes/unmanaged/update'>>

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

@@ -3,57 +3,55 @@
  * Do not edit this file or add other files to this directory.
  */
 
-import type {
-  RouteRequestBody,
-  RouteRequestParams,
-  RouteResponse,
-} from '@seamapi/types/connect'
-import type { Axios } from 'axios'
+import type { RouteRequestBody, RouteResponse } from '@seamapi/types/connect'
 import type { SetNonNullable } from 'type-fest'
 
-import { createAxiosClient } from 'lib/seam/connect/axios.js'
+import { warnOnInsecureuserIdentifierKey } from 'lib/seam/connect/auth.js'
+import { type Client, createClient } from 'lib/seam/connect/client.js'
 import {
   isSeamHttpOptionsWithApiKey,
   isSeamHttpOptionsWithClient,
   isSeamHttpOptionsWithClientSessionToken,
+  type SeamHttpFromPublishableKeyOptions,
   SeamHttpInvalidOptionsError,
   type SeamHttpOptions,
   type SeamHttpOptionsWithApiKey,
   type SeamHttpOptionsWithClient,
   type SeamHttpOptionsWithClientSessionToken,
-} from 'lib/seam/connect/client-options.js'
+} from 'lib/seam/connect/options.js'
 import { parseOptions } from 'lib/seam/connect/parse-options.js'
 
 import { SeamHttpAccessCodesUnmanaged } from './access-codes-unmanaged.js'
+import { SeamHttpClientSessions } from './client-sessions.js'
 
 export class SeamHttpAccessCodes {
-  client: Axios
+  client: Client
 
-  constructor(apiKeyOrOptions: string | SeamHttpOptions) {
-    const options = parseOptions(apiKeyOrOptions)
-    this.client = createAxiosClient(options)
+  constructor(apiKeyOrOptions: string | SeamHttpOptions = {}) {
+    const clientOptions = parseOptions(apiKeyOrOptions)
+    this.client = createClient(clientOptions)
   }
 
   static fromClient(
     client: SeamHttpOptionsWithClient['client'],
     options: Omit<SeamHttpOptionsWithClient, 'client'> = {},
   ): SeamHttpAccessCodes {
-    const opts = { ...options, client }
-    if (!isSeamHttpOptionsWithClient(opts)) {
+    const constructorOptions = { ...options, client }
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError('Missing client')
     }
-    return new SeamHttpAccessCodes(opts)
+    return new SeamHttpAccessCodes(constructorOptions)
   }
 
   static fromApiKey(
     apiKey: SeamHttpOptionsWithApiKey['apiKey'],
     options: Omit<SeamHttpOptionsWithApiKey, 'apiKey'> = {},
   ): SeamHttpAccessCodes {
-    const opts = { ...options, apiKey }
-    if (!isSeamHttpOptionsWithApiKey(opts)) {
+    const constructorOptions = { ...options, apiKey }
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError('Missing apiKey')
     }
-    return new SeamHttpAccessCodes(opts)
+    return new SeamHttpAccessCodes(constructorOptions)
   }
 
   static fromClientSessionToken(
@@ -63,11 +61,26 @@ export class SeamHttpAccessCodes {
       'clientSessionToken'
     > = {},
   ): SeamHttpAccessCodes {
-    const opts = { ...options, clientSessionToken }
-    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+    const constructorOptions = { ...options, clientSessionToken }
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError('Missing clientSessionToken')
     }
-    return new SeamHttpAccessCodes(opts)
+    return new SeamHttpAccessCodes(constructorOptions)
+  }
+
+  static async fromPublishableKey(
+    publishableKey: string,
+    userIdentifierKey: string,
+    options: SeamHttpFromPublishableKeyOptions = {},
+  ): Promise<SeamHttpAccessCodes> {
+    warnOnInsecureuserIdentifierKey(userIdentifierKey)
+    const clientOptions = parseOptions({ ...options, publishableKey })
+    const client = createClient(clientOptions)
+    const clientSessions = SeamHttpClientSessions.fromClient(client)
+    const { token } = await clientSessions.getOrCreate({
+      user_identifier_key: userIdentifierKey,
+    })
+    return SeamHttpAccessCodes.fromClientSessionToken(token, options)
   }
 
   get unmanaged(): SeamHttpAccessCodesUnmanaged {
@@ -106,13 +119,13 @@ export class SeamHttpAccessCodes {
   }
 
   async generateCode(
-    params?: AccessCodesGenerateCodeParams,
+    body: AccessCodesGenerateCodeBody,
   ): Promise<AccessCodesGenerateCodeResponse['generated_code']> {
     const { data } = await this.client.request<AccessCodesGenerateCodeResponse>(
       {
         url: '/access_codes/generate_code',
-        method: 'get',
-        params,
+        method: 'post',
+        data: body,
       },
     )
     return data.generated_code
@@ -161,65 +174,52 @@ export class SeamHttpAccessCodes {
   }
 }
 
-export type AccessCodesCreateBody = SetNonNullable<
-  Required<RouteRequestBody<'/access_codes/create'>>
->
+export type AccessCodesCreateBody = RouteRequestBody<'/access_codes/create'>
 
 export type AccessCodesCreateResponse = SetNonNullable<
   Required<RouteResponse<'/access_codes/create'>>
 >
 
-export type AccessCodesCreateMultipleBody = SetNonNullable<
-  Required<RouteRequestBody<'/access_codes/create_multiple'>>
->
+export type AccessCodesCreateMultipleBody =
+  RouteRequestBody<'/access_codes/create_multiple'>
 
 export type AccessCodesCreateMultipleResponse = SetNonNullable<
   Required<RouteResponse<'/access_codes/create_multiple'>>
 >
 
-export type AccessCodesDeleteBody = SetNonNullable<
-  Required<RouteRequestBody<'/access_codes/delete'>>
->
+export type AccessCodesDeleteBody = RouteRequestBody<'/access_codes/delete'>
 
 export type AccessCodesDeleteResponse = SetNonNullable<
   Required<RouteResponse<'/access_codes/delete'>>
 >
 
-export type AccessCodesGenerateCodeParams = SetNonNullable<
-  Required<RouteRequestParams<'/access_codes/generate_code'>>
->
+export type AccessCodesGenerateCodeBody =
+  RouteRequestBody<'/access_codes/generate_code'>
 
 export type AccessCodesGenerateCodeResponse = SetNonNullable<
   Required<RouteResponse<'/access_codes/generate_code'>>
 >
 
-export type AccessCodesGetBody = SetNonNullable<
-  Required<RouteRequestBody<'/access_codes/get'>>
->
+export type AccessCodesGetBody = RouteRequestBody<'/access_codes/get'>
 
 export type AccessCodesGetResponse = SetNonNullable<
   Required<RouteResponse<'/access_codes/get'>>
 >
 
-export type AccessCodesListBody = SetNonNullable<
-  Required<RouteRequestBody<'/access_codes/list'>>
->
+export type AccessCodesListBody = RouteRequestBody<'/access_codes/list'>
 
 export type AccessCodesListResponse = SetNonNullable<
   Required<RouteResponse<'/access_codes/list'>>
 >
 
-export type AccessCodesPullBackupAccessCodeBody = SetNonNullable<
-  Required<RouteRequestBody<'/access_codes/pull_backup_access_code'>>
->
+export type AccessCodesPullBackupAccessCodeBody =
+  RouteRequestBody<'/access_codes/pull_backup_access_code'>
 
 export type AccessCodesPullBackupAccessCodeResponse = SetNonNullable<
   Required<RouteResponse<'/access_codes/pull_backup_access_code'>>
 >
 
-export type AccessCodesUpdateBody = SetNonNullable<
-  Required<RouteRequestBody<'/access_codes/update'>>
->
+export type AccessCodesUpdateBody = RouteRequestBody<'/access_codes/update'>
 
 export type AccessCodesUpdateResponse = SetNonNullable<
   Required<RouteResponse<'/access_codes/update'>>