@seamapi/http 2.1.0 → 2.3.0

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

@@ -1,276 +0,0 @@
-import {
-  isSeamHttpOptionsWithApiKey,
-  isSeamHttpOptionsWithClientSessionToken,
-  isSeamHttpOptionsWithConsoleSessionToken,
-  isSeamHttpOptionsWithPersonalAccessToken,
-  isSeamHttpWithoutWorkspaceOptionsWithConsoleSessionToken,
-  isSeamHttpWithoutWorkspaceOptionsWithPersonalAccessToken,
-  SeamHttpInvalidOptionsError,
-  type SeamHttpOptionsWithApiKey,
-  type SeamHttpOptionsWithClientSessionToken,
-  type SeamHttpOptionsWithConsoleSessionToken,
-  type SeamHttpOptionsWithPersonalAccessToken,
-  type SeamHttpWithoutWorkspaceOptionsWithConsoleSessionToken,
-  type SeamHttpWithoutWorkspaceOptionsWithPersonalAccessToken,
-} from './options.js'
-import type { Options } from './parse-options.js'
-import {
-  accessTokenPrefix,
-  clientSessionTokenPrefix,
-  isAccessToken,
-  isClientSessionToken,
-  isJwt,
-  isPublishableKey,
-  isSeamToken,
-  jwtPrefix,
-  publishableKeyTokenPrefix,
-  tokenPrefix,
-} from './token.js'
-
-type Headers = Record<string, string>
-
-export const getAuthHeaders = (options: Options): Headers => {
-  if ('publishableKey' in options && options.publishableKey != null) {
-    return getAuthHeadersForPublishableKey(options.publishableKey)
-  }
-
-  if (isSeamHttpOptionsWithApiKey(options)) {
-    return getAuthHeadersForApiKey(options)
-  }
-
-  if (isSeamHttpOptionsWithClientSessionToken(options)) {
-    return getAuthHeadersForClientSessionToken(options)
-  }
-
-  if (
-    isSeamHttpWithoutWorkspaceOptionsWithConsoleSessionToken(options) ||
-    isSeamHttpOptionsWithConsoleSessionToken(options)
-  ) {
-    return getAuthHeadersForConsoleSessionToken(options)
-  }
-
-  if (
-    isSeamHttpWithoutWorkspaceOptionsWithPersonalAccessToken(options) ||
-    isSeamHttpOptionsWithPersonalAccessToken(options)
-  ) {
-    return getAuthHeadersForPersonalAccessToken(options)
-  }
-
-  throw new SeamHttpInvalidOptionsError(
-    [
-      'Must specify',
-      'an apiKey,',
-      'clientSessionToken,',
-      'publishableKey,',
-      'consoleSessionToken',
-      'or personalAccessToken.',
-      'Attempted reading configuration from the environment, but the environment variable SEAM_API_KEY is not set.',
-    ].join(' '),
-  )
-}
-
-const getAuthHeadersForApiKey = ({
-  apiKey,
-}: SeamHttpOptionsWithApiKey): Headers => {
-  if (isClientSessionToken(apiKey)) {
-    throw new SeamHttpInvalidTokenError(
-      'A Client Session Token cannot be used as an apiKey',
-    )
-  }
-
-  if (isJwt(apiKey)) {
-    throw new SeamHttpInvalidTokenError('A JWT cannot be used as an apiKey')
-  }
-
-  if (isAccessToken(apiKey)) {
-    throw new SeamHttpInvalidTokenError(
-      'An Access Token cannot be used as an apiKey',
-    )
-  }
-
-  if (isPublishableKey(apiKey)) {
-    throw new SeamHttpInvalidTokenError(
-      'A Publishable Key cannot be used as an apiKey',
-    )
-  }
-
-  if (!isSeamToken(apiKey)) {
-    throw new SeamHttpInvalidTokenError(
-      `Unknown or invalid apiKey format, expected token to start with ${tokenPrefix}`,
-    )
-  }
-
-  return {
-    authorization: `Bearer ${apiKey}`,
-  }
-}
-
-export const getAuthHeadersForClientSessionToken = ({
-  clientSessionToken,
-}: SeamHttpOptionsWithClientSessionToken): Headers => {
-  if (isJwt(clientSessionToken)) {
-    throw new SeamHttpInvalidTokenError(
-      'A JWT cannot be used as a clientSessionToken',
-    )
-  }
-
-  if (isAccessToken(clientSessionToken)) {
-    throw new SeamHttpInvalidTokenError(
-      'An Access Token cannot be used as a clientSessionToken',
-    )
-  }
-
-  if (isPublishableKey(clientSessionToken)) {
-    throw new SeamHttpInvalidTokenError(
-      'A Publishable Key cannot be used as a clientSessionToken',
-    )
-  }
-
-  if (!isClientSessionToken(clientSessionToken)) {
-    throw new SeamHttpInvalidTokenError(
-      `Unknown or invalid clientSessionToken format, expected token to start with ${clientSessionTokenPrefix}`,
-    )
-  }
-
-  return {
-    authorization: `Bearer ${clientSessionToken}`,
-    'client-session-token': clientSessionToken,
-  }
-}
-
-const getAuthHeadersForConsoleSessionToken = ({
-  consoleSessionToken,
-  ...options
-}:
-  | SeamHttpWithoutWorkspaceOptionsWithConsoleSessionToken
-  | SeamHttpOptionsWithConsoleSessionToken): Headers => {
-  const workspaceId = 'workspaceId' in options ? options.workspaceId : undefined
-
-  if (isAccessToken(consoleSessionToken)) {
-    throw new SeamHttpInvalidTokenError(
-      'An Access Token cannot be used as a consoleSessionToken',
-    )
-  }
-
-  if (isClientSessionToken(consoleSessionToken)) {
-    throw new SeamHttpInvalidTokenError(
-      'A Client Session Token cannot be used as a consoleSessionToken',
-    )
-  }
-
-  if (isPublishableKey(consoleSessionToken)) {
-    throw new SeamHttpInvalidTokenError(
-      'A Publishable Key cannot be used as a consoleSessionToken',
-    )
-  }
-
-  if (!isJwt(consoleSessionToken)) {
-    throw new SeamHttpInvalidTokenError(
-      `Unknown or invalid consoleSessionToken format, expected a JWT which starts with ${jwtPrefix}`,
-    )
-  }
-
-  return {
-    authorization: `Bearer ${consoleSessionToken}`,
-    ...(workspaceId != null ? { 'seam-workspace': workspaceId } : {}),
-  }
-}
-
-const getAuthHeadersForPersonalAccessToken = ({
-  personalAccessToken,
-  ...options
-}:
-  | SeamHttpWithoutWorkspaceOptionsWithPersonalAccessToken
-  | SeamHttpOptionsWithPersonalAccessToken): Headers => {
-  const workspaceId = 'workspaceId' in options ? options.workspaceId : undefined
-
-  if (isJwt(personalAccessToken)) {
-    throw new SeamHttpInvalidTokenError(
-      'A JWT cannot be used as a personalAccessToken',
-    )
-  }
-
-  if (isClientSessionToken(personalAccessToken)) {
-    throw new SeamHttpInvalidTokenError(
-      'A Client Session Token cannot be used as a personalAccessToken',
-    )
-  }
-
-  if (isPublishableKey(personalAccessToken)) {
-    throw new SeamHttpInvalidTokenError(
-      'A Publishable Key cannot be used as a personalAccessToken',
-    )
-  }
-
-  if (!isAccessToken(personalAccessToken)) {
-    throw new SeamHttpInvalidTokenError(
-      `Unknown or invalid personalAccessToken format, expected token to start with ${accessTokenPrefix}`,
-    )
-  }
-
-  return {
-    authorization: `Bearer ${personalAccessToken}`,
-    ...(workspaceId != null ? { 'seam-workspace': workspaceId } : {}),
-  }
-}
-
-const getAuthHeadersForPublishableKey = (publishableKey: string): Headers => {
-  if (isJwt(publishableKey)) {
-    throw new SeamHttpInvalidTokenError(
-      'A JWT cannot be used as a publishableKey',
-    )
-  }
-
-  if (isAccessToken(publishableKey)) {
-    throw new SeamHttpInvalidTokenError(
-      'An Access Token cannot be used as a publishableKey',
-    )
-  }
-
-  if (isClientSessionToken(publishableKey)) {
-    throw new SeamHttpInvalidTokenError(
-      'A Client Session Token Key cannot be used as a publishableKey',
-    )
-  }
-
-  if (!isPublishableKey(publishableKey)) {
-    throw new SeamHttpInvalidTokenError(
-      `Unknown or invalid publishableKey format, expected token to start with ${publishableKeyTokenPrefix}`,
-    )
-  }
-
-  return {
-    'seam-publishable-key': publishableKey,
-  }
-}
-
-export class SeamHttpInvalidTokenError extends Error {
-  constructor(message: string) {
-    super(`SeamHttp received an invalid token: ${message}`)
-    this.name = this.constructor.name
-  }
-}
-
-export const warnOnInsecureuserIdentifierKey = (
-  userIdentifierKey: string,
-): void => {
-  if (isEmail(userIdentifierKey)) {
-    // eslint-disable-next-line no-console
-    console.warn(
-      ...[
-        'Using an email for the userIdentifierKey is insecure and may return an error in the future!',
-        'This is insecure because an email is common knowledge or easily guessed.',
-        'Use something with sufficient entropy known only to the owner of the client session.',
-        'For help choosing a user identifier key see',
-        'https://docs.seam.co/latest/seam-components/overview/get-started-with-client-side-components#3-select-a-user-identifier-key',
-      ],
-    )
-  }
-}
-
-// SOURCE: https://stackoverflow.com/a/46181
-const isEmail = (value: string): boolean => {
-  if (value.includes('!')) return false
-  // The regex may run slow on strings starting with '!@!.' and with many repetitions of '!.'.
-  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)
-}

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

@@ -1,32 +0,0 @@
-import { serializeUrlSearchParams } from '@seamapi/url-search-params-serializer'
-import axios, { type AxiosInstance, type AxiosRequestConfig } from 'axios'
-import axiosRetry, { type AxiosRetry, exponentialDelay } from 'axios-retry'
-
-import { errorInterceptor } from './error-interceptor.js'
-
-export type Client = AxiosInstance
-
-export interface ClientOptions {
-  axiosOptions?: AxiosRequestConfig
-  axiosRetryOptions?: AxiosRetryConfig
-}
-
-type AxiosRetryConfig = Parameters<AxiosRetry>[1]
-
-export const createClient = (options: ClientOptions): AxiosInstance => {
-  const client = axios.create({
-    paramsSerializer: serializeUrlSearchParams,
-    adapter: 'fetch',
-    ...options.axiosOptions,
-  })
-
-  axiosRetry(client, {
-    retries: 2,
-    retryDelay: exponentialDelay,
-    ...options.axiosRetryOptions,
-  })
-
-  client.interceptors.response.use(undefined, errorInterceptor)
-
-  return client
-}

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

@@ -1,242 +0,0 @@
-import type { Client, ClientOptions } from './client.js'
-import { isSeamHttpRequestOption } from './parse-options.js'
-import type { ResolveActionAttemptOptions } from './resolve-action-attempt.js'
-
-export type SeamHttpWithoutWorkspaceOptions =
-  | SeamHttpWithoutWorkspaceOptionsFromEnv
-  | SeamHttpWithoutWorkspaceOptionsWithClient
-  | SeamHttpWithoutWorkspaceOptionsWithConsoleSessionToken
-  | SeamHttpWithoutWorkspaceOptionsWithPersonalAccessToken
-
-export type SeamHttpOptions =
-  | SeamHttpOptionsFromEnv
-  | SeamHttpOptionsWithClient
-  | SeamHttpOptionsWithApiKey
-  | SeamHttpOptionsWithClientSessionToken
-  | SeamHttpOptionsWithConsoleSessionToken
-  | SeamHttpOptionsWithPersonalAccessToken
-
-interface SeamHttpCommonOptions extends ClientOptions, SeamHttpRequestOptions {
-  endpoint?: string
-}
-
-export interface SeamHttpRequestOptions {
-  waitForActionAttempt?: boolean | ResolveActionAttemptOptions
-}
-
-export interface SeamHttpFromPublishableKeyOptions extends SeamHttpCommonOptions {}
-
-export interface SeamHttpOptionsFromEnv extends SeamHttpCommonOptions {}
-
-export interface SeamHttpWithoutWorkspaceOptionsFromEnv extends SeamHttpCommonOptions {}
-
-export interface SeamHttpWithoutWorkspaceOptionsWithClient extends SeamHttpCommonOptions {
-  client: Client
-}
-
-export const isSeamHttpWithoutWorkspaceOptionsWithClient = (
-  options: SeamHttpOptions,
-): options is SeamHttpWithoutWorkspaceOptionsWithClient =>
-  isSeamHttpOptionsWithClient(options)
-
-export interface SeamHttpOptionsWithClient extends SeamHttpRequestOptions {
-  client: Client
-}
-
-export const isSeamHttpOptionsWithClient = (
-  options: SeamHttpOptions,
-): options is SeamHttpOptionsWithClient => {
-  if (!('client' in options)) return false
-  if (options.client == null) return false
-
-  const keys = Object.keys(options).filter((k) => k !== 'client')
-  if (keys.filter((k) => !isSeamHttpRequestOption(k)).length > 0) {
-    throw new SeamHttpInvalidOptionsError(
-      `The client option cannot be used with any other option, but received: ${keys.join(
-        ', ',
-      )}`,
-    )
-  }
-
-  return true
-}
-
-export interface SeamHttpOptionsWithApiKey extends SeamHttpCommonOptions {
-  apiKey: string
-}
-
-export const isSeamHttpOptionsWithApiKey = (
-  options: SeamHttpOptions,
-): options is SeamHttpOptionsWithApiKey => {
-  if (!('apiKey' in options)) return false
-  if (options.apiKey == null) return false
-
-  if ('clientSessionToken' in options && options.clientSessionToken != null) {
-    throw new SeamHttpInvalidOptionsError(
-      'The clientSessionToken option cannot be used with the apiKey option',
-    )
-  }
-
-  if ('consoleSessionToken' in options && options.consoleSessionToken != null) {
-    throw new SeamHttpInvalidOptionsError(
-      'The consoleSessionToken option cannot be used with the apiKey option',
-    )
-  }
-
-  if ('personalAccessToken' in options && options.personalAccessToken != null) {
-    throw new SeamHttpInvalidOptionsError(
-      'The personalAccessToken option cannot be used with the apiKey option',
-    )
-  }
-
-  return true
-}
-
-export interface SeamHttpOptionsWithClientSessionToken extends SeamHttpCommonOptions {
-  clientSessionToken: string
-}
-
-export const isSeamHttpOptionsWithClientSessionToken = (
-  options: SeamHttpOptions,
-): options is SeamHttpOptionsWithClientSessionToken => {
-  if (!('clientSessionToken' in options)) return false
-  if (options.clientSessionToken == null) return false
-
-  if ('apiKey' in options && options.apiKey != null) {
-    throw new SeamHttpInvalidOptionsError(
-      'The apiKey option cannot be used with the clientSessionToken option',
-    )
-  }
-
-  if ('consoleSessionToken' in options && options.consoleSessionToken != null) {
-    throw new SeamHttpInvalidOptionsError(
-      'The consoleSessionToken option cannot be used with the clientSessionToken option',
-    )
-  }
-
-  if ('personalAccessToken' in options && options.personalAccessToken != null) {
-    throw new SeamHttpInvalidOptionsError(
-      'The personalAccessToken option cannot be used with the clientSessionToken option',
-    )
-  }
-
-  return true
-}
-
-export interface SeamHttpWithoutWorkspaceOptionsWithConsoleSessionToken extends SeamHttpCommonOptions {
-  consoleSessionToken: string
-}
-
-export const isSeamHttpWithoutWorkspaceOptionsWithConsoleSessionToken = (
-  options: SeamHttpOptions,
-): options is SeamHttpWithoutWorkspaceOptionsWithConsoleSessionToken => {
-  if (!('consoleSessionToken' in options)) return false
-  if (options.consoleSessionToken == null) return false
-
-  if ('apiKey' in options && options.apiKey != null) {
-    throw new SeamHttpInvalidOptionsError(
-      'The apiKey option cannot be used with the consoleSessionToken option',
-    )
-  }
-
-  if ('clientSessionToken' in options && options.clientSessionToken != null) {
-    throw new SeamHttpInvalidOptionsError(
-      'The clientSessionToken option cannot be used with the consoleSessionToken option',
-    )
-  }
-
-  if ('personalAccessToken' in options && options.personalAccessToken != null) {
-    throw new SeamHttpInvalidOptionsError(
-      'The personalAccessToken option cannot be used with the consoleSessionToken option',
-    )
-  }
-
-  return true
-}
-
-export interface SeamHttpOptionsWithConsoleSessionToken extends SeamHttpCommonOptions {
-  consoleSessionToken: string
-  workspaceId: string
-}
-
-export const isSeamHttpOptionsWithConsoleSessionToken = (
-  options: SeamHttpOptions,
-): options is SeamHttpOptionsWithConsoleSessionToken => {
-  if (!isSeamHttpWithoutWorkspaceOptionsWithConsoleSessionToken(options)) {
-    return false
-  }
-
-  if (!('workspaceId' in options) || options.workspaceId == null) {
-    throw new SeamHttpInvalidOptionsError(
-      'Must pass a workspaceId when using a consoleSessionToken',
-    )
-  }
-
-  return true
-}
-
-export interface SeamHttpWithoutWorkspaceOptionsWithPersonalAccessToken extends SeamHttpCommonOptions {
-  personalAccessToken: string
-}
-
-export const isSeamHttpWithoutWorkspaceOptionsWithPersonalAccessToken = (
-  options: SeamHttpOptions,
-): options is SeamHttpWithoutWorkspaceOptionsWithPersonalAccessToken => {
-  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',
-    )
-  }
-
-  if ('clientSessionToken' in options && options.clientSessionToken != null) {
-    throw new SeamHttpInvalidOptionsError(
-      'The clientSessionToken option cannot be used with the personalAccessToken option',
-    )
-  }
-
-  if ('consoleSessionToken' in options && options.consoleSessionToken != null) {
-    throw new SeamHttpInvalidOptionsError(
-      'The consoleSessionToken option cannot be used with the personalAccessToken option',
-    )
-  }
-
-  return true
-}
-
-export interface SeamHttpOptionsWithPersonalAccessToken extends SeamHttpCommonOptions {
-  personalAccessToken: string
-  workspaceId: string
-}
-
-export const isSeamHttpOptionsWithPersonalAccessToken = (
-  options: SeamHttpOptions,
-): options is SeamHttpOptionsWithPersonalAccessToken => {
-  if (!isSeamHttpWithoutWorkspaceOptionsWithPersonalAccessToken(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}`)
-    this.name = this.constructor.name
-  }
-}
-
-export class SeamHttpWithoutWorkspaceInvalidOptionsError extends Error {
-  constructor(message: string) {
-    super(`SeamHttpWithoutWorkspace received invalid options: ${message}`)
-    this.name = this.constructor.name
-  }
-}