Support publishableKey

Author: razor-x

generate-routes.ts

@@ -256,10 +256,11 @@ import {
   type SeamHttpOptionsWithClientSessionToken,
 } from 'lib/seam/connect/options.js'
 import { parseOptions } from 'lib/seam/connect/parse-options.js'
+
 ${
   namespace === 'client_sessions'
     ? ''
-    : "import { SeamHttpClientSessions } from 'lib/seam/connect/routes/client-sessions.js'"
+    : "import { SeamHttpClientSessions } from './client-sessions.js'"
 }
 ${subresources
   .map((subresource) => renderSubresourceImport(subresource, namespace))

src/lib/seam/connect/auth.ts

@@ -2,16 +2,14 @@ import {
   isSeamHttpOptionsWithApiKey,
   isSeamHttpOptionsWithClientSessionToken,
   SeamHttpInvalidOptionsError,
-  type SeamHttpOptions,
   type SeamHttpOptionsWithApiKey,
   type SeamHttpOptionsWithClientSessionToken,
 } from './options.js'
+import type { Options } from './parse-options.js'
 
 type Headers = Record<string, string>
 
-export const getAuthHeaders = (
-  options: SeamHttpOptions | { publishableKey: string },
-): Headers => {
+export const getAuthHeaders = (options: Options): Headers => {
   if ('publishableKey' in options) {
     return getAuthHeadersForPublishableKey(options.publishableKey)
   }

src/lib/seam/connect/client.ts

@@ -3,39 +3,22 @@ import axiosRetry, { type AxiosRetry, exponentialDelay } from 'axios-retry'
 
 import { paramsSerializer } from 'lib/params-serializer.js'
 
-import { getAuthHeaders } from './auth.js'
-import {
-  isSeamHttpOptionsWithClient,
-  isSeamHttpOptionsWithClientSessionToken,
-  type SeamHttpOptions,
-} from './options.js'
-
 export type Client = Axios
 
 export interface ClientOptions {
-  endpoint?: string
   axiosOptions?: AxiosRequestConfig
   axiosRetryOptions?: AxiosRetryConfig
+  client?: Client
 }
 
 type AxiosRetryConfig = Parameters<AxiosRetry>[1]
 
-type Options =
-  | Required<SeamHttpOptions>
-  | (Required<ClientOptions> & { publishableKey: string })
-
-export const createClient = (options: Options): Axios => {
-  if (isSeamHttpOptionsWithClient(options)) return options.client
+export const createClient = (options: ClientOptions): Axios => {
+  if (options.client != null) return options.client
 
   const client = axios.create({
-    baseURL: options.endpoint,
-    withCredentials: isSeamHttpOptionsWithClientSessionToken(options),
     paramsSerializer,
     ...options.axiosOptions,
-    headers: {
-      ...getAuthHeaders(options),
-      ...options.axiosOptions.headers,
-    },
   })
 
   axiosRetry(client, {

src/lib/seam/connect/options.ts

@@ -6,7 +6,9 @@ export type SeamHttpOptions =
   | SeamHttpOptionsWithApiKey
   | SeamHttpOptionsWithClientSessionToken
 
-type SeamHttpCommonOptions = ClientOptions
+interface SeamHttpCommonOptions extends ClientOptions {
+  endpoint?: string
+}
 
 export type SeamHttpOptionsFromEnv = SeamHttpCommonOptions
 

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

@@ -1,28 +1,54 @@
-import { isSeamHttpOptionsWithClient, type SeamHttpOptions } from './options.js'
+import { getAuthHeaders } from './auth.js'
+import type { ClientOptions } from './client.js'
+import {
+  isSeamHttpOptionsWithClient,
+  isSeamHttpOptionsWithClientSessionToken,
+  type SeamHttpOptions,
+} from './options.js'
 
 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
 
-  const endpoint = options.endpoint ?? getEndpointFromEnv() ?? defaultEndpoint
-
   const apiKey =
     'apiKey' in options ? options.apiKey : getApiKeyFromEnv(options)
 
   return {
     ...options,
     ...(apiKey != null ? { apiKey } : {}),
-    endpoint,
-    axiosOptions: options.axiosOptions ?? {},
-    axiosRetryOptions: options.axiosRetryOptions ?? {},
   }
 }
 

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

@@ -22,36 +22,37 @@ import {
   type SeamHttpOptionsWithClientSessionToken,
 } from 'lib/seam/connect/options.js'
 import { parseOptions } from 'lib/seam/connect/parse-options.js'
-import { SeamHttpClientSessions } from 'lib/seam/connect/routes/client-sessions.js'
+
+import { SeamHttpClientSessions } from './client-sessions.js'
 
 export class SeamHttpAccessCodesUnmanaged {
   client: Client
 
   constructor(apiKeyOrOptions: string | SeamHttpOptions = {}) {
-    const options = parseOptions(apiKeyOrOptions)
-    this.client = createClient(options)
+    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(
@@ -61,20 +62,20 @@ 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: ClientOptions = {},
   ): Promise<SeamHttpAccessCodesUnmanaged> {
-    const opts = parseOptions(options)
-    const client = createClient({ ...opts, publishableKey })
+    const clientOptions = parseOptions({ ...options, publishableKey })
+    const client = createClient(clientOptions)
     const clientSessions = SeamHttpClientSessions.fromClient(client)
     // TODO: clientSessions.getOrCreate({ user_identifier_key: userIdentifierKey })
     const { token } = await clientSessions.create({

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

@@ -22,38 +22,38 @@ import {
   type SeamHttpOptionsWithClientSessionToken,
 } from 'lib/seam/connect/options.js'
 import { parseOptions } from 'lib/seam/connect/parse-options.js'
-import { SeamHttpClientSessions } from 'lib/seam/connect/routes/client-sessions.js'
 
 import { SeamHttpAccessCodesUnmanaged } from './access-codes-unmanaged.js'
+import { SeamHttpClientSessions } from './client-sessions.js'
 
 export class SeamHttpAccessCodes {
   client: Client
 
   constructor(apiKeyOrOptions: string | SeamHttpOptions = {}) {
-    const options = parseOptions(apiKeyOrOptions)
-    this.client = createClient(options)
+    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,20 +63,20 @@ 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: ClientOptions = {},
   ): Promise<SeamHttpAccessCodes> {
-    const opts = parseOptions(options)
-    const client = createClient({ ...opts, publishableKey })
+    const clientOptions = parseOptions({ ...options, publishableKey })
+    const client = createClient(clientOptions)
     const clientSessions = SeamHttpClientSessions.fromClient(client)
     // TODO: clientSessions.getOrCreate({ user_identifier_key: userIdentifierKey })
     const { token } = await clientSessions.create({

src/lib/seam/connect/routes/acs-access-groups.ts

@@ -22,36 +22,37 @@ import {
   type SeamHttpOptionsWithClientSessionToken,
 } from 'lib/seam/connect/options.js'
 import { parseOptions } from 'lib/seam/connect/parse-options.js'
-import { SeamHttpClientSessions } from 'lib/seam/connect/routes/client-sessions.js'
+
+import { SeamHttpClientSessions } from './client-sessions.js'
 
 export class SeamHttpAcsAccessGroups {
   client: Client
 
   constructor(apiKeyOrOptions: string | SeamHttpOptions = {}) {
-    const options = parseOptions(apiKeyOrOptions)
-    this.client = createClient(options)
+    const clientOptions = parseOptions(apiKeyOrOptions)
+    this.client = createClient(clientOptions)
   }
 
   static fromClient(
     client: SeamHttpOptionsWithClient['client'],
     options: Omit<SeamHttpOptionsWithClient, 'client'> = {},
   ): SeamHttpAcsAccessGroups {
-    const opts = { ...options, client }
-    if (!isSeamHttpOptionsWithClient(opts)) {
+    const constructorOptions = { ...options, client }
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError('Missing client')
     }
-    return new SeamHttpAcsAccessGroups(opts)
+    return new SeamHttpAcsAccessGroups(constructorOptions)
   }
 
   static fromApiKey(
     apiKey: SeamHttpOptionsWithApiKey['apiKey'],
     options: Omit<SeamHttpOptionsWithApiKey, 'apiKey'> = {},
   ): SeamHttpAcsAccessGroups {
-    const opts = { ...options, apiKey }
-    if (!isSeamHttpOptionsWithApiKey(opts)) {
+    const constructorOptions = { ...options, apiKey }
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError('Missing apiKey')
     }
-    return new SeamHttpAcsAccessGroups(opts)
+    return new SeamHttpAcsAccessGroups(constructorOptions)
   }
 
   static fromClientSessionToken(
@@ -61,20 +62,20 @@ export class SeamHttpAcsAccessGroups {
       'clientSessionToken'
     > = {},
   ): SeamHttpAcsAccessGroups {
-    const opts = { ...options, clientSessionToken }
-    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+    const constructorOptions = { ...options, clientSessionToken }
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError('Missing clientSessionToken')
     }
-    return new SeamHttpAcsAccessGroups(opts)
+    return new SeamHttpAcsAccessGroups(constructorOptions)
   }
 
   static async fromPublishableKey(
     publishableKey: string,
     userIdentifierKey: string,
     options: ClientOptions = {},
   ): Promise<SeamHttpAcsAccessGroups> {
-    const opts = parseOptions(options)
-    const client = createClient({ ...opts, publishableKey })
+    const clientOptions = parseOptions({ ...options, publishableKey })
+    const client = createClient(clientOptions)
     const clientSessions = SeamHttpClientSessions.fromClient(client)
     // TODO: clientSessions.getOrCreate({ user_identifier_key: userIdentifierKey })
     const { token } = await clientSessions.create({