@seamapi/http 0.6.0 → 0.7.0

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

@@ -1,5 +1,10 @@
 import type { Client, ClientOptions } from './client.js'
 
+export type SeamHttpMultiWorkspaceOptions =
+  | SeamHttpMultiWorkspaceOptionsWithClient
+  | SeamHttpMultiWorkspaceOptionsWithConsoleSessionToken
+  | SeamHttpMultiWorkspaceOptionsWithPersonalAccessToken
+
 export type SeamHttpOptions =
   | SeamHttpOptionsFromEnv
   | SeamHttpOptionsWithClient
@@ -17,6 +22,15 @@ export interface SeamHttpFromPublishableKeyOptions
 
 export interface SeamHttpOptionsFromEnv extends SeamHttpCommonOptions {}
 
+export interface SeamHttpMultiWorkspaceOptionsWithClient {
+  client: Client
+}
+
+export const isSeamHttpMultiWorkspaceOptionsWithClient = (
+  options: SeamHttpOptions,
+): options is SeamHttpMultiWorkspaceOptionsWithClient =>
+  isSeamHttpOptionsWithClient(options)
+
 export interface SeamHttpOptionsWithClient {
   client: Client
 }
@@ -102,24 +116,17 @@ export const isSeamHttpOptionsWithClientSessionToken = (
   return true
 }
 
-export interface SeamHttpOptionsWithConsoleSessionToken
+export interface SeamHttpMultiWorkspaceOptionsWithConsoleSessionToken
   extends SeamHttpCommonOptions {
   consoleSessionToken: string
-  workspaceId: string
 }
 
-export const isSeamHttpOptionsWithConsoleSessionToken = (
+export const isSeamHttpMultiWorkspaceOptionsWithConsoleSessionToken = (
   options: SeamHttpOptions,
-): options is SeamHttpOptionsWithConsoleSessionToken => {
+): options is SeamHttpMultiWorkspaceOptionsWithConsoleSessionToken => {
   if (!('consoleSessionToken' in options)) return false
   if (options.consoleSessionToken == null) return false
 
-  if (!('workspaceId' in options) || options.workspaceId == null) {
-    throw new SeamHttpInvalidOptionsError(
-      'Must pass a workspaceId when using a consoleSessionToken',
-    )
-  }
-
   if ('apiKey' in options && options.apiKey != null) {
     throw new SeamHttpInvalidOptionsError(
       'The apiKey option cannot be used with the consoleSessionToken option',
@@ -141,24 +148,39 @@ export const isSeamHttpOptionsWithConsoleSessionToken = (
   return true
 }
 
-export interface SeamHttpOptionsWithPersonalAccessToken
+export interface SeamHttpOptionsWithConsoleSessionToken
   extends SeamHttpCommonOptions {
-  personalAccessToken: string
+  consoleSessionToken: string
   workspaceId: string
 }
 
-export const isSeamHttpOptionsWithPersonalAccessToken = (
+export const isSeamHttpOptionsWithConsoleSessionToken = (
   options: SeamHttpOptions,
-): options is SeamHttpOptionsWithPersonalAccessToken => {
-  if (!('personalAccessToken' in options)) return false
-  if (options.personalAccessToken == null) return false
+): options is SeamHttpOptionsWithConsoleSessionToken => {
+  if (!isSeamHttpMultiWorkspaceOptionsWithConsoleSessionToken(options)) {
+    return false
+  }
 
   if (!('workspaceId' in options) || options.workspaceId == null) {
     throw new SeamHttpInvalidOptionsError(
-      'Must pass a workspaceId when using a personalAccessToken',
+      'Must pass a workspaceId when using a consoleSessionToken',
     )
   }
 
+  return true
+}
+
+export interface SeamHttpMultiWorkspaceOptionsWithPersonalAccessToken
+  extends SeamHttpCommonOptions {
+  personalAccessToken: string
+}
+
+export const isSeamHttpMultiWorkspaceOptionsWithPersonalAccessToken = (
+  options: SeamHttpOptions,
+): options is SeamHttpMultiWorkspaceOptionsWithPersonalAccessToken => {
+  if (!('personalAccessToken' in options)) return false
+  if (options.personalAccessToken == null) return false
+
   if ('apiKey' in options && options.apiKey != null) {
     throw new SeamHttpInvalidOptionsError(
       'The apiKey option cannot be used with the personalAccessToken option',
@@ -180,6 +202,28 @@ export const isSeamHttpOptionsWithPersonalAccessToken = (
   return true
 }
 
+export interface SeamHttpOptionsWithPersonalAccessToken
+  extends SeamHttpCommonOptions {
+  personalAccessToken: string
+  workspaceId: string
+}
+
+export const isSeamHttpOptionsWithPersonalAccessToken = (
+  options: SeamHttpOptions,
+): options is SeamHttpOptionsWithPersonalAccessToken => {
+  if (!isSeamHttpMultiWorkspaceOptionsWithPersonalAccessToken(options)) {
+    return false
+  }
+
+  if (!('workspaceId' in options) || options.workspaceId == null) {
+    throw new SeamHttpInvalidOptionsError(
+      'Must pass a workspaceId when using a personalAccessToken',
+    )
+  }
+
+  return true
+}
+
 export class SeamHttpInvalidOptionsError extends Error {
   constructor(message: string) {
     super(`SeamHttp received invalid options: ${message}`)
@@ -187,3 +231,5 @@ export class SeamHttpInvalidOptionsError extends Error {
     Error.captureStackTrace(this, this.constructor)
   }
 }
+
+export class SeamHttpMultiWorkspaceInvalidOptionsError extends SeamHttpInvalidOptionsError {}

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

@@ -3,8 +3,10 @@ import version from 'lib/version.js'
 import { getAuthHeaders } from './auth.js'
 import type { ClientOptions } from './client.js'
 import {
+  isSeamHttpMultiWorkspaceOptionsWithClient,
   isSeamHttpOptionsWithClient,
   isSeamHttpOptionsWithClientSessionToken,
+  type SeamHttpMultiWorkspaceOptions,
   type SeamHttpOptions,
 } from './options.js'
 
@@ -15,7 +17,9 @@ const sdkHeaders = {
   'seam-sdk-version': version,
 }
 
-export type Options = SeamHttpOptions & { publishableKey?: string }
+export type Options =
+  | SeamHttpMultiWorkspaceOptions
+  | (SeamHttpOptions & { publishableKey?: string })
 
 export const parseOptions = (
   apiKeyOrOptions: string | Options,
@@ -23,6 +27,7 @@ export const parseOptions = (
   const options = getNormalizedOptions(apiKeyOrOptions)
 
   if (isSeamHttpOptionsWithClient(options)) return options
+  if (isSeamHttpMultiWorkspaceOptionsWithClient(options)) return options
 
   return {
     axiosOptions: {

package/src/lib/seam/connect/seam-http-multi-workspace.ts

@@ -0,0 +1,77 @@
+import { type Client, createClient } from './client.js'
+import {
+  isSeamHttpMultiWorkspaceOptionsWithClient,
+  isSeamHttpMultiWorkspaceOptionsWithConsoleSessionToken,
+  isSeamHttpMultiWorkspaceOptionsWithPersonalAccessToken,
+  SeamHttpMultiWorkspaceInvalidOptionsError,
+  type SeamHttpMultiWorkspaceOptions,
+  type SeamHttpMultiWorkspaceOptionsWithClient,
+  type SeamHttpMultiWorkspaceOptionsWithConsoleSessionToken,
+  type SeamHttpMultiWorkspaceOptionsWithPersonalAccessToken,
+} from './options.js'
+import { parseOptions } from './parse-options.js'
+import { SeamHttpWorkspaces } from './routes/index.js'
+
+export class SeamHttpMultiWorkspace {
+  client: Client
+
+  constructor(options: SeamHttpMultiWorkspaceOptions) {
+    const clientOptions = parseOptions(options)
+    this.client = createClient(clientOptions)
+  }
+
+  static fromClient(
+    client: SeamHttpMultiWorkspaceOptionsWithClient['client'],
+    options: Omit<SeamHttpMultiWorkspaceOptionsWithClient, 'client'> = {},
+  ): SeamHttpMultiWorkspace {
+    const constructorOptions = { ...options, client }
+    if (!isSeamHttpMultiWorkspaceOptionsWithClient(constructorOptions)) {
+      throw new SeamHttpMultiWorkspaceInvalidOptionsError('Missing client')
+    }
+    return new SeamHttpMultiWorkspace(constructorOptions)
+  }
+
+  static fromConsoleSessionToken(
+    consoleSessionToken: SeamHttpMultiWorkspaceOptionsWithConsoleSessionToken['consoleSessionToken'],
+    options: Omit<
+      SeamHttpMultiWorkspaceOptionsWithConsoleSessionToken,
+      'consoleSessionToken'
+    > = {},
+  ): SeamHttpMultiWorkspace {
+    const constructorOptions = { ...options, consoleSessionToken }
+    if (
+      !isSeamHttpMultiWorkspaceOptionsWithConsoleSessionToken(
+        constructorOptions,
+      )
+    ) {
+      throw new SeamHttpMultiWorkspaceInvalidOptionsError(
+        'Missing consoleSessionToken',
+      )
+    }
+    return new SeamHttpMultiWorkspace(constructorOptions)
+  }
+
+  static fromPersonalAccessToken(
+    personalAccessToken: SeamHttpMultiWorkspaceOptionsWithPersonalAccessToken['personalAccessToken'],
+    options: Omit<
+      SeamHttpMultiWorkspaceOptionsWithPersonalAccessToken,
+      'personalAccessToken'
+    > = {},
+  ): SeamHttpMultiWorkspace {
+    const constructorOptions = { ...options, personalAccessToken }
+    if (
+      !isSeamHttpMultiWorkspaceOptionsWithPersonalAccessToken(
+        constructorOptions,
+      )
+    ) {
+      throw new SeamHttpMultiWorkspaceInvalidOptionsError(
+        'Missing personalAccessToken',
+      )
+    }
+    return new SeamHttpMultiWorkspace(constructorOptions)
+  }
+
+  get workspaces(): SeamHttpWorkspaces {
+    return SeamHttpWorkspaces.fromClient(this.client)
+  }
+}

package/src/lib/version.ts

@@ -1,3 +1,3 @@
-const seamapiJavascriptHttpVersion = '0.6.0'
+const seamapiJavascriptHttpVersion = '0.7.0'
 
 export default seamapiJavascriptHttpVersion