@seamapi/http 0.1.0 → 0.2.0

package/src/lib/seam/connect/routes/acs.ts

@@ -3,54 +3,55 @@
  * Do not edit this file or add other files to this directory.
  */
 
-import type { Axios } from 'axios'
-
-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 { SeamHttpAcsAccessGroups } from './acs-access-groups.js'
 import { SeamHttpAcsCredentials } from './acs-credentials.js'
 import { SeamHttpAcsSystems } from './acs-systems.js'
 import { SeamHttpAcsUsers } from './acs-users.js'
+import { SeamHttpClientSessions } from './client-sessions.js'
 
 export class SeamHttpAcs {
-  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'> = {},
   ): SeamHttpAcs {
-    const opts = { ...options, client }
-    if (!isSeamHttpOptionsWithClient(opts)) {
+    const constructorOptions = { ...options, client }
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError('Missing client')
     }
-    return new SeamHttpAcs(opts)
+    return new SeamHttpAcs(constructorOptions)
   }
 
   static fromApiKey(
     apiKey: SeamHttpOptionsWithApiKey['apiKey'],
     options: Omit<SeamHttpOptionsWithApiKey, 'apiKey'> = {},
   ): SeamHttpAcs {
-    const opts = { ...options, apiKey }
-    if (!isSeamHttpOptionsWithApiKey(opts)) {
+    const constructorOptions = { ...options, apiKey }
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError('Missing apiKey')
     }
-    return new SeamHttpAcs(opts)
+    return new SeamHttpAcs(constructorOptions)
   }
 
   static fromClientSessionToken(
@@ -60,11 +61,26 @@ export class SeamHttpAcs {
       'clientSessionToken'
     > = {},
   ): SeamHttpAcs {
-    const opts = { ...options, clientSessionToken }
-    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+    const constructorOptions = { ...options, clientSessionToken }
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError('Missing clientSessionToken')
     }
-    return new SeamHttpAcs(opts)
+    return new SeamHttpAcs(constructorOptions)
+  }
+
+  static async fromPublishableKey(
+    publishableKey: string,
+    userIdentifierKey: string,
+    options: SeamHttpFromPublishableKeyOptions = {},
+  ): Promise<SeamHttpAcs> {
+    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 SeamHttpAcs.fromClientSessionToken(token, options)
   }
 
   get accessGroups(): SeamHttpAcsAccessGroups {

package/src/lib/seam/connect/routes/action-attempts.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 SeamHttpActionAttempts {
-  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'> = {},
   ): SeamHttpActionAttempts {
-    const opts = { ...options, client }
-    if (!isSeamHttpOptionsWithClient(opts)) {
+    const constructorOptions = { ...options, client }
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError('Missing client')
     }
-    return new SeamHttpActionAttempts(opts)
+    return new SeamHttpActionAttempts(constructorOptions)
   }
 
   static fromApiKey(
     apiKey: SeamHttpOptionsWithApiKey['apiKey'],
     options: Omit<SeamHttpOptionsWithApiKey, 'apiKey'> = {},
   ): SeamHttpActionAttempts {
-    const opts = { ...options, apiKey }
-    if (!isSeamHttpOptionsWithApiKey(opts)) {
+    const constructorOptions = { ...options, apiKey }
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError('Missing apiKey')
     }
-    return new SeamHttpActionAttempts(opts)
+    return new SeamHttpActionAttempts(constructorOptions)
   }
 
   static fromClientSessionToken(
@@ -57,11 +60,26 @@ export class SeamHttpActionAttempts {
       'clientSessionToken'
     > = {},
   ): SeamHttpActionAttempts {
-    const opts = { ...options, clientSessionToken }
-    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+    const constructorOptions = { ...options, clientSessionToken }
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError('Missing clientSessionToken')
     }
-    return new SeamHttpActionAttempts(opts)
+    return new SeamHttpActionAttempts(constructorOptions)
+  }
+
+  static async fromPublishableKey(
+    publishableKey: string,
+    userIdentifierKey: string,
+    options: SeamHttpFromPublishableKeyOptions = {},
+  ): Promise<SeamHttpActionAttempts> {
+    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 SeamHttpActionAttempts.fromClientSessionToken(token, options)
   }
 
   async get(
@@ -87,17 +105,13 @@ export class SeamHttpActionAttempts {
   }
 }
 
-export type ActionAttemptsGetBody = SetNonNullable<
-  Required<RouteRequestBody<'/action_attempts/get'>>
->
+export type ActionAttemptsGetBody = RouteRequestBody<'/action_attempts/get'>
 
 export type ActionAttemptsGetResponse = SetNonNullable<
   Required<RouteResponse<'/action_attempts/get'>>
 >
 
-export type ActionAttemptsListBody = SetNonNullable<
-  Required<RouteRequestBody<'/action_attempts/list'>>
->
+export type ActionAttemptsListBody = RouteRequestBody<'/action_attempts/list'>
 
 export type ActionAttemptsListResponse = SetNonNullable<
   Required<RouteResponse<'/action_attempts/list'>>

package/src/lib/seam/connect/routes/client-sessions.ts

@@ -4,50 +4,51 @@
  */
 
 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'
 
 export class SeamHttpClientSessions {
-  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'> = {},
   ): SeamHttpClientSessions {
-    const opts = { ...options, client }
-    if (!isSeamHttpOptionsWithClient(opts)) {
+    const constructorOptions = { ...options, client }
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError('Missing client')
     }
-    return new SeamHttpClientSessions(opts)
+    return new SeamHttpClientSessions(constructorOptions)
   }
 
   static fromApiKey(
     apiKey: SeamHttpOptionsWithApiKey['apiKey'],
     options: Omit<SeamHttpOptionsWithApiKey, 'apiKey'> = {},
   ): SeamHttpClientSessions {
-    const opts = { ...options, apiKey }
-    if (!isSeamHttpOptionsWithApiKey(opts)) {
+    const constructorOptions = { ...options, apiKey }
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError('Missing apiKey')
     }
-    return new SeamHttpClientSessions(opts)
+    return new SeamHttpClientSessions(constructorOptions)
   }
 
   static fromClientSessionToken(
@@ -57,11 +58,26 @@ export class SeamHttpClientSessions {
       'clientSessionToken'
     > = {},
   ): SeamHttpClientSessions {
-    const opts = { ...options, clientSessionToken }
-    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+    const constructorOptions = { ...options, clientSessionToken }
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError('Missing clientSessionToken')
     }
-    return new SeamHttpClientSessions(opts)
+    return new SeamHttpClientSessions(constructorOptions)
+  }
+
+  static async fromPublishableKey(
+    publishableKey: string,
+    userIdentifierKey: string,
+    options: SeamHttpFromPublishableKeyOptions = {},
+  ): Promise<SeamHttpClientSessions> {
+    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 SeamHttpClientSessions.fromClientSessionToken(token, options)
   }
 
   async create(
@@ -94,6 +110,18 @@ export class SeamHttpClientSessions {
     return data.client_session
   }
 
+  async getOrCreate(
+    body: ClientSessionsGetOrCreateBody,
+  ): Promise<ClientSessionsGetOrCreateResponse['client_session']> {
+    const { data } =
+      await this.client.request<ClientSessionsGetOrCreateResponse>({
+        url: '/client_sessions/get_or_create',
+        method: 'post',
+        data: body,
+      })
+    return data.client_session
+  }
+
   async grantAccess(
     body: ClientSessionsGrantAccessBody,
   ): Promise<ClientSessionsGrantAccessResponse['client_session']> {
@@ -118,41 +146,41 @@ export class SeamHttpClientSessions {
   }
 }
 
-export type ClientSessionsCreateBody = SetNonNullable<
-  Required<RouteRequestBody<'/client_sessions/create'>>
->
+export type ClientSessionsCreateBody =
+  RouteRequestBody<'/client_sessions/create'>
 
 export type ClientSessionsCreateResponse = SetNonNullable<
   Required<RouteResponse<'/client_sessions/create'>>
 >
 
-export type ClientSessionsDeleteBody = SetNonNullable<
-  Required<RouteRequestBody<'/client_sessions/delete'>>
->
+export type ClientSessionsDeleteBody =
+  RouteRequestBody<'/client_sessions/delete'>
 
 export type ClientSessionsDeleteResponse = SetNonNullable<
   Required<RouteResponse<'/client_sessions/delete'>>
 >
 
-export type ClientSessionsGetBody = SetNonNullable<
-  Required<RouteRequestBody<'/client_sessions/get'>>
->
+export type ClientSessionsGetBody = RouteRequestBody<'/client_sessions/get'>
 
 export type ClientSessionsGetResponse = SetNonNullable<
   Required<RouteResponse<'/client_sessions/get'>>
 >
 
-export type ClientSessionsGrantAccessBody = SetNonNullable<
-  Required<RouteRequestBody<'/client_sessions/grant_access'>>
+export type ClientSessionsGetOrCreateBody =
+  RouteRequestBody<'/client_sessions/get_or_create'>
+
+export type ClientSessionsGetOrCreateResponse = SetNonNullable<
+  Required<RouteResponse<'/client_sessions/get_or_create'>>
 >
 
+export type ClientSessionsGrantAccessBody =
+  RouteRequestBody<'/client_sessions/grant_access'>
+
 export type ClientSessionsGrantAccessResponse = SetNonNullable<
   Required<RouteResponse<'/client_sessions/grant_access'>>
 >
 
-export type ClientSessionsListBody = SetNonNullable<
-  Required<RouteRequestBody<'/client_sessions/list'>>
->
+export type ClientSessionsListBody = RouteRequestBody<'/client_sessions/list'>
 
 export type ClientSessionsListResponse = SetNonNullable<
   Required<RouteResponse<'/client_sessions/list'>>

package/src/lib/seam/connect/routes/connect-webviews.ts

@@ -8,50 +8,53 @@ import type {
   RouteRequestParams,
   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 SeamHttpConnectWebviews {
-  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'> = {},
   ): SeamHttpConnectWebviews {
-    const opts = { ...options, client }
-    if (!isSeamHttpOptionsWithClient(opts)) {
+    const constructorOptions = { ...options, client }
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError('Missing client')
     }
-    return new SeamHttpConnectWebviews(opts)
+    return new SeamHttpConnectWebviews(constructorOptions)
   }
 
   static fromApiKey(
     apiKey: SeamHttpOptionsWithApiKey['apiKey'],
     options: Omit<SeamHttpOptionsWithApiKey, 'apiKey'> = {},
   ): SeamHttpConnectWebviews {
-    const opts = { ...options, apiKey }
-    if (!isSeamHttpOptionsWithApiKey(opts)) {
+    const constructorOptions = { ...options, apiKey }
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError('Missing apiKey')
     }
-    return new SeamHttpConnectWebviews(opts)
+    return new SeamHttpConnectWebviews(constructorOptions)
   }
 
   static fromClientSessionToken(
@@ -61,11 +64,26 @@ export class SeamHttpConnectWebviews {
       'clientSessionToken'
     > = {},
   ): SeamHttpConnectWebviews {
-    const opts = { ...options, clientSessionToken }
-    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+    const constructorOptions = { ...options, clientSessionToken }
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError('Missing clientSessionToken')
     }
-    return new SeamHttpConnectWebviews(opts)
+    return new SeamHttpConnectWebviews(constructorOptions)
+  }
+
+  static async fromPublishableKey(
+    publishableKey: string,
+    userIdentifierKey: string,
+    options: SeamHttpFromPublishableKeyOptions = {},
+  ): Promise<SeamHttpConnectWebviews> {
+    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 SeamHttpConnectWebviews.fromClientSessionToken(token, options)
   }
 
   async create(
@@ -99,12 +117,12 @@ export class SeamHttpConnectWebviews {
   }
 
   async list(
-    params?: ConnectWebviewsListParams,
+    body: ConnectWebviewsListBody,
   ): Promise<ConnectWebviewsListResponse['connect_webviews']> {
     const { data } = await this.client.request<ConnectWebviewsListResponse>({
       url: '/connect_webviews/list',
-      method: 'get',
-      params,
+      method: 'post',
+      data: body,
     })
     return data.connect_webviews
   }
@@ -118,41 +136,34 @@ export class SeamHttpConnectWebviews {
   }
 }
 
-export type ConnectWebviewsCreateBody = SetNonNullable<
-  Required<RouteRequestBody<'/connect_webviews/create'>>
->
+export type ConnectWebviewsCreateBody =
+  RouteRequestBody<'/connect_webviews/create'>
 
 export type ConnectWebviewsCreateResponse = SetNonNullable<
   Required<RouteResponse<'/connect_webviews/create'>>
 >
 
-export type ConnectWebviewsDeleteBody = SetNonNullable<
-  Required<RouteRequestBody<'/connect_webviews/delete'>>
->
+export type ConnectWebviewsDeleteBody =
+  RouteRequestBody<'/connect_webviews/delete'>
 
 export type ConnectWebviewsDeleteResponse = SetNonNullable<
   Required<RouteResponse<'/connect_webviews/delete'>>
 >
 
-export type ConnectWebviewsGetBody = SetNonNullable<
-  Required<RouteRequestBody<'/connect_webviews/get'>>
->
+export type ConnectWebviewsGetBody = RouteRequestBody<'/connect_webviews/get'>
 
 export type ConnectWebviewsGetResponse = SetNonNullable<
   Required<RouteResponse<'/connect_webviews/get'>>
 >
 
-export type ConnectWebviewsListParams = SetNonNullable<
-  Required<RouteRequestParams<'/connect_webviews/list'>>
->
+export type ConnectWebviewsListBody = RouteRequestBody<'/connect_webviews/list'>
 
 export type ConnectWebviewsListResponse = SetNonNullable<
   Required<RouteResponse<'/connect_webviews/list'>>
 >
 
-export type ConnectWebviewsViewParams = SetNonNullable<
-  Required<RouteRequestParams<'/connect_webviews/view'>>
->
+export type ConnectWebviewsViewParams =
+  RouteRequestParams<'/connect_webviews/view'>
 
 export type ConnectWebviewsViewResponse = SetNonNullable<
   Required<RouteResponse<'/connect_webviews/view'>>

package/src/lib/seam/connect/routes/connected-accounts.ts

@@ -8,50 +8,53 @@ import type {
   RouteRequestParams,
   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 SeamHttpConnectedAccounts {
-  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'> = {},
   ): SeamHttpConnectedAccounts {
-    const opts = { ...options, client }
-    if (!isSeamHttpOptionsWithClient(opts)) {
+    const constructorOptions = { ...options, client }
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError('Missing client')
     }
-    return new SeamHttpConnectedAccounts(opts)
+    return new SeamHttpConnectedAccounts(constructorOptions)
   }
 
   static fromApiKey(
     apiKey: SeamHttpOptionsWithApiKey['apiKey'],
     options: Omit<SeamHttpOptionsWithApiKey, 'apiKey'> = {},
   ): SeamHttpConnectedAccounts {
-    const opts = { ...options, apiKey }
-    if (!isSeamHttpOptionsWithApiKey(opts)) {
+    const constructorOptions = { ...options, apiKey }
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError('Missing apiKey')
     }
-    return new SeamHttpConnectedAccounts(opts)
+    return new SeamHttpConnectedAccounts(constructorOptions)
   }
 
   static fromClientSessionToken(
@@ -61,11 +64,26 @@ export class SeamHttpConnectedAccounts {
       'clientSessionToken'
     > = {},
   ): SeamHttpConnectedAccounts {
-    const opts = { ...options, clientSessionToken }
-    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+    const constructorOptions = { ...options, clientSessionToken }
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError('Missing clientSessionToken')
     }
-    return new SeamHttpConnectedAccounts(opts)
+    return new SeamHttpConnectedAccounts(constructorOptions)
+  }
+
+  static async fromPublishableKey(
+    publishableKey: string,
+    userIdentifierKey: string,
+    options: SeamHttpFromPublishableKeyOptions = {},
+  ): Promise<SeamHttpConnectedAccounts> {
+    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 SeamHttpConnectedAccounts.fromClientSessionToken(token, options)
   }
 
   async delete(body: ConnectedAccountsDeleteBody): Promise<void> {
@@ -99,25 +117,22 @@ export class SeamHttpConnectedAccounts {
   }
 }
 
-export type ConnectedAccountsDeleteBody = SetNonNullable<
-  Required<RouteRequestBody<'/connected_accounts/delete'>>
->
+export type ConnectedAccountsDeleteBody =
+  RouteRequestBody<'/connected_accounts/delete'>
 
 export type ConnectedAccountsDeleteResponse = SetNonNullable<
   Required<RouteResponse<'/connected_accounts/delete'>>
 >
 
-export type ConnectedAccountsGetBody = SetNonNullable<
-  Required<RouteRequestBody<'/connected_accounts/get'>>
->
+export type ConnectedAccountsGetBody =
+  RouteRequestBody<'/connected_accounts/get'>
 
 export type ConnectedAccountsGetResponse = SetNonNullable<
   Required<RouteResponse<'/connected_accounts/get'>>
 >
 
-export type ConnectedAccountsListParams = SetNonNullable<
-  Required<RouteRequestParams<'/connected_accounts/list'>>
->
+export type ConnectedAccountsListParams =
+  RouteRequestParams<'/connected_accounts/list'>
 
 export type ConnectedAccountsListResponse = SetNonNullable<
   Required<RouteResponse<'/connected_accounts/list'>>