@seamapi/http 0.23.0 → 0.25.0

package/src/lib/seam/connect/routes/user-identities-enrollment-automations.ts

@@ -31,6 +31,7 @@ import {
   limitToSeamHttpRequestOptions,
   parseOptions,
 } from 'lib/seam/connect/parse-options.js'
+import { SeamHttpRequest } from 'lib/seam/connect/seam-http-request.js'
 
 import { SeamHttpClientSessions } from './client-sessions.js'
 
@@ -156,67 +157,57 @@ export class SeamHttpUserIdentitiesEnrollmentAutomations {
     await clientSessions.get()
   }
 
-  async delete(
+  delete(
     body?: UserIdentitiesEnrollmentAutomationsDeleteBody,
-  ): Promise<void> {
-    await this.client.request<UserIdentitiesEnrollmentAutomationsDeleteResponse>(
-      {
-        url: '/user_identities/enrollment_automations/delete',
-        method: 'post',
-        data: body,
-      },
-    )
+  ): SeamHttpRequest<void, undefined> {
+    return new SeamHttpRequest(this, {
+      path: '/user_identities/enrollment_automations/delete',
+      method: 'post',
+      body,
+      responseKey: undefined,
+    })
   }
 
-  async get(
+  get(
     body?: UserIdentitiesEnrollmentAutomationsGetParams,
-  ): Promise<
-    UserIdentitiesEnrollmentAutomationsGetResponse['enrollment_automation']
+  ): SeamHttpRequest<
+    UserIdentitiesEnrollmentAutomationsGetResponse,
+    'enrollment_automation'
   > {
-    const { data } =
-      await this.client.request<UserIdentitiesEnrollmentAutomationsGetResponse>(
-        {
-          url: '/user_identities/enrollment_automations/get',
-          method: 'post',
-          data: body,
-        },
-      )
-
-    return data.enrollment_automation
+    return new SeamHttpRequest(this, {
+      path: '/user_identities/enrollment_automations/get',
+      method: 'post',
+      body,
+      responseKey: 'enrollment_automation',
+    })
   }
 
-  async launch(
+  launch(
     body?: UserIdentitiesEnrollmentAutomationsLaunchBody,
-  ): Promise<
-    UserIdentitiesEnrollmentAutomationsLaunchResponse['enrollment_automation']
+  ): SeamHttpRequest<
+    UserIdentitiesEnrollmentAutomationsLaunchResponse,
+    'enrollment_automation'
   > {
-    const { data } =
-      await this.client.request<UserIdentitiesEnrollmentAutomationsLaunchResponse>(
-        {
-          url: '/user_identities/enrollment_automations/launch',
-          method: 'post',
-          data: body,
-        },
-      )
-
-    return data.enrollment_automation
+    return new SeamHttpRequest(this, {
+      path: '/user_identities/enrollment_automations/launch',
+      method: 'post',
+      body,
+      responseKey: 'enrollment_automation',
+    })
   }
 
-  async list(
+  list(
     body?: UserIdentitiesEnrollmentAutomationsListParams,
-  ): Promise<
-    UserIdentitiesEnrollmentAutomationsListResponse['enrollment_automations']
+  ): SeamHttpRequest<
+    UserIdentitiesEnrollmentAutomationsListResponse,
+    'enrollment_automations'
   > {
-    const { data } =
-      await this.client.request<UserIdentitiesEnrollmentAutomationsListResponse>(
-        {
-          url: '/user_identities/enrollment_automations/list',
-          method: 'post',
-          data: body,
-        },
-      )
-
-    return data.enrollment_automations
+    return new SeamHttpRequest(this, {
+      path: '/user_identities/enrollment_automations/list',
+      method: 'post',
+      body,
+      responseKey: 'enrollment_automations',
+    })
   }
 }
 

package/src/lib/seam/connect/routes/user-identities.ts

@@ -31,6 +31,7 @@ import {
   limitToSeamHttpRequestOptions,
   parseOptions,
 } from 'lib/seam/connect/parse-options.js'
+import { SeamHttpRequest } from 'lib/seam/connect/seam-http-request.js'
 
 import { SeamHttpClientSessions } from './client-sessions.js'
 import { SeamHttpUserIdentitiesEnrollmentAutomations } from './user-identities-enrollment-automations.js'
@@ -161,132 +162,134 @@ export class SeamHttpUserIdentities {
     )
   }
 
-  async addAcsUser(body?: UserIdentitiesAddAcsUserBody): Promise<void> {
-    await this.client.request<UserIdentitiesAddAcsUserResponse>({
-      url: '/user_identities/add_acs_user',
+  addAcsUser(
+    body?: UserIdentitiesAddAcsUserBody,
+  ): SeamHttpRequest<void, undefined> {
+    return new SeamHttpRequest(this, {
+      path: '/user_identities/add_acs_user',
       method: 'post',
-      data: body,
+      body,
+      responseKey: undefined,
     })
   }
 
-  async create(
+  create(
     body?: UserIdentitiesCreateBody,
-  ): Promise<UserIdentitiesCreateResponse['user_identity']> {
-    const { data } = await this.client.request<UserIdentitiesCreateResponse>({
-      url: '/user_identities/create',
+  ): SeamHttpRequest<UserIdentitiesCreateResponse, 'user_identity'> {
+    return new SeamHttpRequest(this, {
+      path: '/user_identities/create',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'user_identity',
     })
-
-    return data.user_identity
   }
 
-  async delete(body?: UserIdentitiesDeleteBody): Promise<void> {
-    await this.client.request<UserIdentitiesDeleteResponse>({
-      url: '/user_identities/delete',
+  delete(body?: UserIdentitiesDeleteBody): SeamHttpRequest<void, undefined> {
+    return new SeamHttpRequest(this, {
+      path: '/user_identities/delete',
       method: 'post',
-      data: body,
+      body,
+      responseKey: undefined,
     })
   }
 
-  async get(
+  get(
     body?: UserIdentitiesGetParams,
-  ): Promise<UserIdentitiesGetResponse['user_identity']> {
-    const { data } = await this.client.request<UserIdentitiesGetResponse>({
-      url: '/user_identities/get',
+  ): SeamHttpRequest<UserIdentitiesGetResponse, 'user_identity'> {
+    return new SeamHttpRequest(this, {
+      path: '/user_identities/get',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'user_identity',
     })
-
-    return data.user_identity
   }
 
-  async grantAccessToDevice(
+  grantAccessToDevice(
     body?: UserIdentitiesGrantAccessToDeviceBody,
-  ): Promise<void> {
-    await this.client.request<UserIdentitiesGrantAccessToDeviceResponse>({
-      url: '/user_identities/grant_access_to_device',
+  ): SeamHttpRequest<void, undefined> {
+    return new SeamHttpRequest(this, {
+      path: '/user_identities/grant_access_to_device',
       method: 'post',
-      data: body,
+      body,
+      responseKey: undefined,
     })
   }
 
-  async list(
+  list(
     body?: UserIdentitiesListParams,
-  ): Promise<UserIdentitiesListResponse['user_identities']> {
-    const { data } = await this.client.request<UserIdentitiesListResponse>({
-      url: '/user_identities/list',
+  ): SeamHttpRequest<UserIdentitiesListResponse, 'user_identities'> {
+    return new SeamHttpRequest(this, {
+      path: '/user_identities/list',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'user_identities',
     })
-
-    return data.user_identities
   }
 
-  async listAccessibleDevices(
+  listAccessibleDevices(
     body?: UserIdentitiesListAccessibleDevicesParams,
-  ): Promise<
-    UserIdentitiesListAccessibleDevicesResponse['accessible_devices']
+  ): SeamHttpRequest<
+    UserIdentitiesListAccessibleDevicesResponse,
+    'accessible_devices'
   > {
-    const { data } =
-      await this.client.request<UserIdentitiesListAccessibleDevicesResponse>({
-        url: '/user_identities/list_accessible_devices',
-        method: 'post',
-        data: body,
-      })
-
-    return data.accessible_devices
+    return new SeamHttpRequest(this, {
+      path: '/user_identities/list_accessible_devices',
+      method: 'post',
+      body,
+      responseKey: 'accessible_devices',
+    })
   }
 
-  async listAcsSystems(
+  listAcsSystems(
     body?: UserIdentitiesListAcsSystemsParams,
-  ): Promise<UserIdentitiesListAcsSystemsResponse['acs_systems']> {
-    const { data } =
-      await this.client.request<UserIdentitiesListAcsSystemsResponse>({
-        url: '/user_identities/list_acs_systems',
-        method: 'post',
-        data: body,
-      })
-
-    return data.acs_systems
+  ): SeamHttpRequest<UserIdentitiesListAcsSystemsResponse, 'acs_systems'> {
+    return new SeamHttpRequest(this, {
+      path: '/user_identities/list_acs_systems',
+      method: 'post',
+      body,
+      responseKey: 'acs_systems',
+    })
   }
 
-  async listAcsUsers(
+  listAcsUsers(
     body?: UserIdentitiesListAcsUsersParams,
-  ): Promise<UserIdentitiesListAcsUsersResponse['acs_users']> {
-    const { data } =
-      await this.client.request<UserIdentitiesListAcsUsersResponse>({
-        url: '/user_identities/list_acs_users',
-        method: 'post',
-        data: body,
-      })
-
-    return data.acs_users
+  ): SeamHttpRequest<UserIdentitiesListAcsUsersResponse, 'acs_users'> {
+    return new SeamHttpRequest(this, {
+      path: '/user_identities/list_acs_users',
+      method: 'post',
+      body,
+      responseKey: 'acs_users',
+    })
   }
 
-  async removeAcsUser(body?: UserIdentitiesRemoveAcsUserBody): Promise<void> {
-    await this.client.request<UserIdentitiesRemoveAcsUserResponse>({
-      url: '/user_identities/remove_acs_user',
+  removeAcsUser(
+    body?: UserIdentitiesRemoveAcsUserBody,
+  ): SeamHttpRequest<void, undefined> {
+    return new SeamHttpRequest(this, {
+      path: '/user_identities/remove_acs_user',
       method: 'post',
-      data: body,
+      body,
+      responseKey: undefined,
     })
   }
 
-  async revokeAccessToDevice(
+  revokeAccessToDevice(
     body?: UserIdentitiesRevokeAccessToDeviceBody,
-  ): Promise<void> {
-    await this.client.request<UserIdentitiesRevokeAccessToDeviceResponse>({
-      url: '/user_identities/revoke_access_to_device',
+  ): SeamHttpRequest<void, undefined> {
+    return new SeamHttpRequest(this, {
+      path: '/user_identities/revoke_access_to_device',
       method: 'post',
-      data: body,
+      body,
+      responseKey: undefined,
     })
   }
 
-  async update(body?: UserIdentitiesUpdateBody): Promise<void> {
-    await this.client.request<UserIdentitiesUpdateResponse>({
-      url: '/user_identities/update',
+  update(body?: UserIdentitiesUpdateBody): SeamHttpRequest<void, undefined> {
+    return new SeamHttpRequest(this, {
+      path: '/user_identities/update',
       method: 'post',
-      data: body,
+      body,
+      responseKey: undefined,
     })
   }
 }

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

@@ -31,6 +31,7 @@ import {
   limitToSeamHttpRequestOptions,
   parseOptions,
 } from 'lib/seam/connect/parse-options.js'
+import { SeamHttpRequest } from 'lib/seam/connect/seam-http-request.js'
 
 import { SeamHttpClientSessions } from './client-sessions.js'
 
@@ -153,53 +154,54 @@ export class SeamHttpWebhooks {
     await clientSessions.get()
   }
 
-  async create(
+  create(
     body?: WebhooksCreateBody,
-  ): Promise<WebhooksCreateResponse['webhook']> {
-    const { data } = await this.client.request<WebhooksCreateResponse>({
-      url: '/webhooks/create',
+  ): SeamHttpRequest<WebhooksCreateResponse, 'webhook'> {
+    return new SeamHttpRequest(this, {
+      path: '/webhooks/create',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'webhook',
     })
-
-    return data.webhook
   }
 
-  async delete(body?: WebhooksDeleteBody): Promise<void> {
-    await this.client.request<WebhooksDeleteResponse>({
-      url: '/webhooks/delete',
+  delete(body?: WebhooksDeleteBody): SeamHttpRequest<void, undefined> {
+    return new SeamHttpRequest(this, {
+      path: '/webhooks/delete',
       method: 'post',
-      data: body,
+      body,
+      responseKey: undefined,
     })
   }
 
-  async get(body?: WebhooksGetParams): Promise<WebhooksGetResponse['webhook']> {
-    const { data } = await this.client.request<WebhooksGetResponse>({
-      url: '/webhooks/get',
+  get(
+    body?: WebhooksGetParams,
+  ): SeamHttpRequest<WebhooksGetResponse, 'webhook'> {
+    return new SeamHttpRequest(this, {
+      path: '/webhooks/get',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'webhook',
     })
-
-    return data.webhook
   }
 
-  async list(
+  list(
     body?: WebhooksListParams,
-  ): Promise<WebhooksListResponse['webhooks']> {
-    const { data } = await this.client.request<WebhooksListResponse>({
-      url: '/webhooks/list',
+  ): SeamHttpRequest<WebhooksListResponse, 'webhooks'> {
+    return new SeamHttpRequest(this, {
+      path: '/webhooks/list',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'webhooks',
     })
-
-    return data.webhooks
   }
 
-  async update(body?: WebhooksUpdateBody): Promise<void> {
-    await this.client.request<WebhooksUpdateResponse>({
-      url: '/webhooks/update',
+  update(body?: WebhooksUpdateBody): SeamHttpRequest<void, undefined> {
+    return new SeamHttpRequest(this, {
+      path: '/webhooks/update',
       method: 'post',
-      data: body,
+      body,
+      responseKey: undefined,
     })
   }
 }

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

@@ -31,6 +31,7 @@ import {
   limitToSeamHttpRequestOptions,
   parseOptions,
 } from 'lib/seam/connect/parse-options.js'
+import { SeamHttpRequest } from 'lib/seam/connect/seam-http-request.js'
 
 import { SeamHttpClientSessions } from './client-sessions.js'
 
@@ -153,47 +154,47 @@ export class SeamHttpWorkspaces {
     await clientSessions.get()
   }
 
-  async create(
+  create(
     body?: WorkspacesCreateBody,
-  ): Promise<WorkspacesCreateResponse['workspace']> {
-    const { data } = await this.client.request<WorkspacesCreateResponse>({
-      url: '/workspaces/create',
+  ): SeamHttpRequest<WorkspacesCreateResponse, 'workspace'> {
+    return new SeamHttpRequest(this, {
+      path: '/workspaces/create',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'workspace',
     })
-
-    return data.workspace
   }
 
-  async get(
+  get(
     body?: WorkspacesGetParams,
-  ): Promise<WorkspacesGetResponse['workspace']> {
-    const { data } = await this.client.request<WorkspacesGetResponse>({
-      url: '/workspaces/get',
+  ): SeamHttpRequest<WorkspacesGetResponse, 'workspace'> {
+    return new SeamHttpRequest(this, {
+      path: '/workspaces/get',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'workspace',
     })
-
-    return data.workspace
   }
 
-  async list(
+  list(
     body?: WorkspacesListParams,
-  ): Promise<WorkspacesListResponse['workspaces']> {
-    const { data } = await this.client.request<WorkspacesListResponse>({
-      url: '/workspaces/list',
+  ): SeamHttpRequest<WorkspacesListResponse, 'workspaces'> {
+    return new SeamHttpRequest(this, {
+      path: '/workspaces/list',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'workspaces',
     })
-
-    return data.workspaces
   }
 
-  async resetSandbox(body?: WorkspacesResetSandboxBody): Promise<void> {
-    await this.client.request<WorkspacesResetSandboxResponse>({
-      url: '/workspaces/reset_sandbox',
+  resetSandbox(
+    body?: WorkspacesResetSandboxBody,
+  ): SeamHttpRequest<void, undefined> {
+    return new SeamHttpRequest(this, {
+      path: '/workspaces/reset_sandbox',
       method: 'post',
-      data: body,
+      body,
+      responseKey: undefined,
     })
   }
 }

package/src/lib/seam/connect/seam-http-request.ts

@@ -0,0 +1,144 @@
+import { serializeUrlSearchParams } from '@seamapi/url-search-params-serializer'
+import type { Method } from 'axios'
+
+import type { Client } from './client.js'
+import type { SeamHttpRequestOptions } from './options.js'
+import { resolveActionAttempt } from './resolve-action-attempt.js'
+import { SeamHttpActionAttempts } from './routes/index.js'
+
+interface SeamHttpRequestParent {
+  readonly client: Client
+  readonly defaults: Required<SeamHttpRequestOptions>
+}
+
+interface SeamHttpRequestConfig<TResponseKey> {
+  readonly path: string
+  readonly method: Method
+  readonly body?: unknown
+  readonly params?: undefined | Record<string, unknown>
+  readonly responseKey: TResponseKey
+  readonly options?: Pick<SeamHttpRequestOptions, 'waitForActionAttempt'>
+}
+
+export class SeamHttpRequest<
+  const TResponse,
+  const TResponseKey extends keyof TResponse | undefined,
+> implements
+    PromiseLike<
+      TResponseKey extends keyof TResponse ? TResponse[TResponseKey] : undefined
+    >
+{
+  readonly #parent: SeamHttpRequestParent
+  readonly #config: SeamHttpRequestConfig<TResponseKey>
+
+  constructor(
+    parent: SeamHttpRequestParent,
+    config: SeamHttpRequestConfig<TResponseKey>,
+  ) {
+    this.#parent = parent
+    this.#config = config
+  }
+
+  public get responseKey(): TResponseKey {
+    return this.#config.responseKey
+  }
+
+  public get url(): URL {
+    const { client } = this.#parent
+    const { params } = this.#config
+
+    const serializer =
+      typeof client.defaults.paramsSerializer === 'function'
+        ? client.defaults.paramsSerializer
+        : serializeUrlSearchParams
+
+    const origin = getUrlPrefix(client.defaults.baseURL ?? '')
+
+    const pathname = this.#config.path.startsWith('/')
+      ? this.#config.path
+      : `/${this.#config.path}`
+
+    const path = params == null ? pathname : `${pathname}?${serializer(params)}`
+
+    return new URL(`${origin}${path}`)
+  }
+
+  public get method(): Method {
+    return this.#config.method
+  }
+
+  public get body(): unknown {
+    return this.#config.body
+  }
+
+  async execute(): Promise<
+    TResponseKey extends keyof TResponse ? TResponse[TResponseKey] : undefined
+  > {
+    const { client } = this.#parent
+    const response = await client.request({
+      url: this.#config.path,
+      method: this.#config.method,
+      data: this.#config.body,
+      params: this.#config.params,
+    })
+    if (this.responseKey === undefined) {
+      return undefined as TResponseKey extends keyof TResponse
+        ? TResponse[TResponseKey]
+        : undefined
+    }
+    const data = response.data[this.responseKey]
+    if (this.responseKey === 'action_attempt') {
+      const waitForActionAttempt =
+        this.#config.options?.waitForActionAttempt ??
+        this.#parent.defaults.waitForActionAttempt
+      if (waitForActionAttempt !== false) {
+        return await resolveActionAttempt(
+          data,
+          SeamHttpActionAttempts.fromClient(client, {
+            ...this.#parent.defaults,
+            waitForActionAttempt: false,
+          }),
+          typeof waitForActionAttempt === 'boolean' ? {} : waitForActionAttempt,
+        )
+      }
+    }
+    return data
+  }
+
+  then<
+    TResult1 = TResponseKey extends keyof TResponse
+      ? TResponse[TResponseKey]
+      : undefined,
+    TResult2 = never,
+  >(
+    onfulfilled?:
+      | ((
+          value: TResponseKey extends keyof TResponse
+            ? TResponse[TResponseKey]
+            : undefined,
+        ) => TResult1 | PromiseLike<TResult1>)
+      | null
+      | undefined,
+    onrejected?:
+      | ((reason: any) => TResult2 | PromiseLike<TResult2>)
+      | null
+      | undefined,
+  ): PromiseLike<TResult1 | TResult2> {
+    return this.execute().then(onfulfilled, onrejected)
+  }
+}
+
+const getUrlPrefix = (input: string): string => {
+  if (URL.canParse(input)) {
+    const url = new URL(input).toString()
+    if (url.endsWith('/')) return url.slice(0, -1)
+    return url
+  }
+  if (globalThis.location != null) {
+    const pathname = input.startsWith('/') ? input : `/${input}`
+    return new URL(`${globalThis.location.origin}${pathname}`).toString()
+  }
+  throw new Error(
+    `Cannot resolve origin from ${input} in a non-browser environment`,
+  )
+}

package/src/lib/version.ts

@@ -1,3 +1,3 @@
-const seamapiJavascriptHttpVersion = '0.23.0'
+const seamapiJavascriptHttpVersion = '0.25.0'
 
 export default seamapiJavascriptHttpVersion