@seamapi/cli 0.0.1 → 0.5.0

package/src/lib/get-api-blueprint.ts

@@ -0,0 +1,27 @@
+import type { Blueprint } from '@seamapi/blueprint'
+
+import getBlueprint from './blueprint.js'
+import { getServer } from './get-server.js'
+
+export type ApiBlueprint = Blueprint
+
+export const getApiBlueprint = async (
+  useRemoteDefinitions: boolean,
+): Promise<ApiBlueprint> => {
+  // Remote definitions describe whatever the server is currently running, so
+  // build them directly from the server's OpenAPI document. This runtime path
+  // does not load @seamapi/types.
+  if (useRemoteDefinitions) return await createRemoteBlueprint()
+
+  return await getBlueprint()
+}
+
+const createRemoteBlueprint = async (): Promise<Blueprint> => {
+  const [{ createBlueprint }, { getOpenapiSchema }] = await Promise.all([
+    import('@seamapi/blueprint'),
+    import('@seamapi/http/connect'),
+  ])
+  const openapi = await getOpenapiSchema(getServer())
+
+  return await createBlueprint({ openapi }, { omitUndocumented: true })
+}

package/src/lib/get-command-blueprint-def.ts

@@ -0,0 +1,15 @@
+import type { ContextHelpers } from './types.js'
+export const getCommandBlueprintDef = (
+  cmd: string[],
+  helpers: ContextHelpers,
+) => {
+  const path = `/${cmd.join('/').replace(/-/g, '_')}`
+  const def = helpers.blueprint.routes
+    .flatMap((route) => route.endpoints)
+    .find((endpoint) => endpoint.path === path)
+  if (!def) {
+    throw new Error(`No definition for path ${path}`)
+  }
+
+  return def
+}

package/src/lib/get-config-store.ts

@@ -0,0 +1,5 @@
+import Configstore from 'configstore'
+
+export const getConfigStore = () => {
+  return new Configstore('seam-cli', {})
+}

package/src/lib/get-current-workspace-id.ts

@@ -0,0 +1,11 @@
+import { getConfigStore } from './get-config-store.js'
+import { interactForWorkspaceId } from './interact-for-workspace-id.js'
+
+export const getCurrentWorkspaceId = async (): Promise<string> => {
+  const configStore = getConfigStore()
+
+  const currentWorkspaceId = configStore.get('current_workspace_id')
+  if (typeof currentWorkspaceId === 'string') return currentWorkspaceId
+
+  return await interactForWorkspaceId()
+}

package/src/lib/get-seam.ts

@@ -0,0 +1,43 @@
+import {
+  isConsoleSessionToken,
+  isPersonalAccessToken,
+  SeamHttp,
+  SeamHttpWithoutWorkspace,
+} from '@seamapi/http/connect'
+
+import { getConfigStore } from './get-config-store.js'
+import { getServer } from './get-server.js'
+
+export const getSeam = async (): Promise<SeamHttp> => {
+  const config = getConfigStore()
+
+  const token = config.get(`${getServer()}.pat`) as string
+
+  const workspaceId = config.get('current_workspace_id') as string
+
+  const options = { endpoint: getServer() }
+
+  if (isPersonalAccessToken(token)) {
+    return SeamHttp.fromPersonalAccessToken(token, workspaceId, options)
+  }
+
+  if (isConsoleSessionToken(token)) {
+    return SeamHttp.fromConsoleSessionToken(token, workspaceId, options)
+  }
+
+  return SeamHttp.fromApiKey(token, options)
+}
+
+export const getSeamMultiWorkspace = async (): Promise<
+  SeamHttpWithoutWorkspace | SeamHttp
+> => {
+  const config = getConfigStore()
+  const token = config.get(`${getServer()}.pat`) as string
+  const options = { endpoint: getServer() }
+
+  if (isPersonalAccessToken(token)) {
+    return SeamHttpWithoutWorkspace.fromPersonalAccessToken(token, options)
+  }
+
+  return getSeam()
+}

package/src/lib/get-server.ts

@@ -0,0 +1,9 @@
+import { getConfigStore } from './get-config-store.js'
+
+export const getServer = (): string => {
+  const config = getConfigStore()
+
+  const server = config.get('server')
+
+  return typeof server === 'string' ? server : 'https://connect.getseam.com'
+}

package/src/lib/interact-for-access-code.ts

@@ -0,0 +1,25 @@
+import { getSeam } from './get-seam.js'
+import { interactForDevice } from './interact-for-device.js'
+import { interactForResource } from './interact-for-resource.js'
+
+export const interactForAccessCode = async ({
+  device_id,
+}: {
+  device_id?: string
+}) => {
+  const seam = await getSeam()
+
+  if (!device_id) {
+    device_id = await interactForDevice()
+  }
+
+  return interactForResource({
+    resourceName: 'access_code',
+    fetchResources: () => seam.accessCodes.list({ device_id }),
+    toChoice: (accessCode) => ({
+      title: accessCode.name ?? '<No Name>',
+      value: accessCode.access_code_id,
+      description: `${accessCode.type} ${accessCode.access_code_id}`,
+    }),
+  })
+}

package/src/lib/interact-for-acs-entrance.ts

@@ -0,0 +1,16 @@
+import { getSeam } from './get-seam.js'
+import { interactForResource } from './interact-for-resource.js'
+
+export const interactForAcsEntrance = async () => {
+  const seam = await getSeam()
+
+  return interactForResource({
+    resourceName: 'ACS entrance',
+    fetchResources: () => seam.acs.entrances.list(),
+    toChoice: (entrance) => ({
+      title: entrance.display_name ?? '<No Name>',
+      value: entrance.acs_entrance_id,
+      description: entrance.acs_entrance_id,
+    }),
+  })
+}

package/src/lib/interact-for-acs-system.ts

@@ -0,0 +1,17 @@
+import { getSeam } from './get-seam.js'
+import { interactForResource } from './interact-for-resource.js'
+
+export const interactForAcsSystem = async (message?: string) => {
+  const seam = await getSeam()
+
+  return interactForResource({
+    resourceName: 'ACS system',
+    fetchResources: () => seam.acs.systems.list(),
+    message,
+    toChoice: (system) => ({
+      title: `${system.name} ${system.external_type_display_name}`,
+      value: system.acs_system_id,
+      description: system.acs_system_id,
+    }),
+  })
+}

package/src/lib/interact-for-acs-user.ts

@@ -0,0 +1,21 @@
+import { getSeam } from './get-seam.js'
+import { interactForAcsSystem } from './interact-for-acs-system.js'
+import { interactForResource } from './interact-for-resource.js'
+
+export const interactForAcsUser = async () => {
+  const seam = await getSeam()
+
+  const acs_system_id = await interactForAcsSystem(
+    'What acs_system does the acs_user belong to?',
+  )
+
+  return interactForResource({
+    resourceName: 'ACS user',
+    fetchResources: () => seam.acs.users.list({ acs_system_id }),
+    toChoice: (user) => ({
+      title: `${user.display_name} ${user.email_address}`,
+      value: user.acs_user_id,
+      description: user.acs_user_id,
+    }),
+  })
+}

package/src/lib/interact-for-action-attempt-poll.ts

@@ -0,0 +1,35 @@
+import type { ActionAttemptsGetResponse } from '@seamapi/http/connect'
+import prompts from 'prompts'
+
+import { getSeam } from './get-seam.js'
+import { withLoading } from './util/with-loading.js'
+
+export const interactForActionAttemptPoll = async (
+  action_attempt: ActionAttemptsGetResponse['action_attempt'],
+) => {
+  if (action_attempt.status === 'pending') {
+    const { poll_for_action_attempt } = await prompts({
+      name: 'poll_for_action_attempt',
+      message: "Would you like to poll the action attempt until it's ready?",
+      type: 'toggle',
+      initial: true,
+      active: 'yes',
+      inactive: 'no',
+    })
+
+    if (poll_for_action_attempt) {
+      const seam = await getSeam()
+      const { action_attempt_id } = action_attempt
+
+      const updated_action_attempt = await withLoading(
+        'Polling action attempt...',
+        () =>
+          seam.actionAttempts.get(
+            { action_attempt_id },
+            { waitForActionAttempt: { pollingInterval: 240, timeout: 10_000 } },
+          ),
+      )
+      console.dir(updated_action_attempt, { depth: null })
+    }
+  }
+}

package/src/lib/interact-for-array.ts

@@ -0,0 +1,61 @@
+import prompts from 'prompts'
+
+export const interactForArray = async (
+  array: string[],
+  message: string,
+): Promise<string[]> => {
+  const updatedArray = [...array]
+
+  const displayList = () => {
+    console.log(`${message} Current list:`)
+    if (updatedArray.length > 0) {
+      updatedArray.forEach((item, index) => {
+        console.log(`${index + 1}: ${item}`)
+      })
+    } else {
+      console.log('The list is currently empty.')
+    }
+  }
+
+  let action: string
+  do {
+    displayList()
+
+    const response = await prompts({
+      type: 'select',
+      name: 'action',
+      message: 'Choose an action:',
+      choices: [
+        { title: 'Add an item', value: 'add' },
+        { title: 'Remove an item', value: 'remove' },
+        { title: 'Finish editing', value: 'done' },
+      ],
+    })
+
+    action = response.action
+
+    if (action === 'add') {
+      const { newItem } = await prompts({
+        type: 'text',
+        name: 'newItem',
+        message: 'Enter the new item:',
+      })
+      if (newItem) {
+        updatedArray.push(newItem)
+      }
+    } else if (action === 'remove') {
+      const { index } = await prompts({
+        type: 'number',
+        name: 'index',
+        message: 'Enter the index of the item to remove:',
+        validate: (value) =>
+          value > 0 && value <= updatedArray.length ? true : 'Invalid index',
+      })
+      if (index) {
+        updatedArray.splice(index - 1, 1)
+      }
+    }
+  } while (action !== 'done')
+
+  return updatedArray
+}

package/src/lib/interact-for-blueprint-object.ts

@@ -0,0 +1,274 @@
+import type { Parameter } from '@seamapi/blueprint'
+import prompts from 'prompts'
+
+import { interactForAccessCode } from './interact-for-access-code.js'
+import { interactForAcsEntrance } from './interact-for-acs-entrance.js'
+import { interactForAcsSystem } from './interact-for-acs-system.js'
+import { interactForAcsUser } from './interact-for-acs-user.js'
+import { interactForArray } from './interact-for-array.js'
+import { interactForConnectedAccount } from './interact-for-connected-account.js'
+import { interactForCustomMetadata } from './interact-for-custom-metadata.js'
+import { interactForDevice } from './interact-for-device.js'
+import { interactForTimestamp } from './interact-for-timestamp.js'
+import { interactForUserIdentity } from './interact-for-user-identity.js'
+import type { ContextHelpers } from './types.js'
+import { ellipsis } from './util/ellipsis.js'
+
+const ergonomicPropOrder = [
+  'name',
+  'connected_account_id',
+  'device_id',
+  'access_code_id',
+  'user_identity_id',
+  'code',
+  'starts_at',
+  'ends_at',
+]
+
+export const interactForBlueprintObject = async (
+  args: {
+    command: string[]
+    parameters: Parameter[]
+    params: Record<string, any>
+    isSubProperty?: boolean
+    subPropertyPath?: string
+  },
+  ctx: ContextHelpers,
+): Promise<any> => {
+  // Clone args and args params so that we can mutate it
+  args = { ...args, params: { ...args.params } }
+
+  const properties = Object.fromEntries(
+    args.parameters.map((parameter) => [parameter.name, parameter]),
+  )
+  const required = args.parameters
+    .filter((parameter) => parameter.isRequired)
+    .map((parameter) => parameter.name)
+
+  const haveAllRequiredParams = required.every((k) => args.params[k])
+
+  const should_auto_submit =
+    !ctx.is_interactive && haveAllRequiredParams && !args.isSubProperty
+  if (should_auto_submit) {
+    return args.params
+  }
+
+  const propSortScore = (prop: string) => {
+    if (required.includes(prop)) return 100 - ergonomicPropOrder.indexOf(prop)
+    if (args.params[prop] !== undefined) {
+      return 50 - Object.keys(args.params).indexOf(prop)
+    }
+    return ergonomicPropOrder.indexOf(prop)
+  }
+
+  const cmdPath = `/${args.command.join('/').replace(/-/g, '_')}`
+  const parameterSelectionMessage = args.isSubProperty
+    ? `Editing "${args.subPropertyPath}"`
+    : `[${cmdPath}] Parameters`
+
+  console.log('')
+  const { paramToEdit } = await prompts({
+    name: 'paramToEdit',
+    message: parameterSelectionMessage,
+    type: 'autocomplete',
+    choices: [
+      ...(haveAllRequiredParams && !args.isSubProperty
+        ? [
+            {
+              value: 'done',
+              title: `[Make API Call] ${cmdPath}`,
+            },
+          ]
+        : []),
+      ...(haveAllRequiredParams && args.isSubProperty
+        ? [
+            {
+              title: `[Save]`,
+              value: 'done',
+            },
+          ]
+        : []),
+      ...Object.keys(properties)
+        .map((k) => {
+          return {
+            title: k + (required.includes(k) ? '*' : ''),
+            value: k,
+            description:
+              args.params[k] !== undefined
+                ? typeof args.params[k] === 'object'
+                  ? ellipsis(JSON.stringify(args.params[k]), 60)
+                  : `[${args.params[k]}]`
+                : undefined,
+          }
+        })
+        .sort((a, b) => propSortScore(b.value) - propSortScore(a.value)),
+      ...(args.isSubProperty
+        ? [
+            {
+              title: `[Leave Empty]`,
+              value: 'empty',
+            },
+          ]
+        : []),
+      {
+        title: `[Back]`,
+        value: 'back',
+      },
+    ],
+  })
+
+  if (paramToEdit === 'empty') {
+    return undefined
+  }
+
+  if (paramToEdit === 'done') {
+    // TODO check for required
+    return args.params
+  }
+
+  if (paramToEdit === 'back') {
+    if (args.subPropertyPath) {
+      return args.params
+    }
+
+    return '[Back]'
+  }
+
+  const prop = properties[paramToEdit]
+
+  if (paramToEdit === 'device_id') {
+    args.params[paramToEdit] = await interactForDevice()
+    return interactForBlueprintObject(args, ctx)
+  } else if (paramToEdit === 'access_code_id') {
+    args.params[paramToEdit] = await interactForAccessCode(args.params as any)
+    return interactForBlueprintObject(args, ctx)
+  } else if (paramToEdit === 'connected_account_id') {
+    const connected_account_id = await interactForConnectedAccount()
+    args.params[paramToEdit] = connected_account_id
+    return interactForBlueprintObject(args, ctx)
+  } else if (
+    paramToEdit === 'user_identity_id' ||
+    paramToEdit === 'user_identity_ids'
+  ) {
+    const user_identity_id = await interactForUserIdentity()
+    args.params[paramToEdit] =
+      paramToEdit === 'user_identity_ids'
+        ? [user_identity_id]
+        : user_identity_id
+    return interactForBlueprintObject(args, ctx)
+  } else if (paramToEdit.endsWith('acs_system_id')) {
+    args.params[paramToEdit] = await interactForAcsSystem()
+    return interactForBlueprintObject(args, ctx)
+  } else if (paramToEdit.endsWith('acs_user_id')) {
+    args.params[paramToEdit] = await interactForAcsUser()
+    return interactForBlueprintObject(args, ctx)
+  } else if (paramToEdit.endsWith('acs_entrance_id')) {
+    args.params['acs_entrance_id'] = await interactForAcsEntrance()
+    return interactForBlueprintObject(args, ctx)
+  } else if (
+    paramToEdit.endsWith('_at') ||
+    paramToEdit === 'since' ||
+    paramToEdit.endsWith('_before') ||
+    paramToEdit.endsWith('_after')
+  ) {
+    args.params[paramToEdit] = await interactForTimestamp()
+    return interactForBlueprintObject(args, ctx)
+  } else if (paramToEdit === 'custom_metadata') {
+    args.params[paramToEdit] = await interactForCustomMetadata(
+      args.params[paramToEdit] || {},
+    )
+    return interactForBlueprintObject(args, ctx)
+  }
+
+  if (prop) {
+    if (['string', 'id', 'datetime'].includes(prop.format)) {
+      let value
+      if (prop.format === 'datetime') {
+        value = await interactForTimestamp()
+      } else {
+        value = (
+          await prompts({
+            name: 'value',
+            message: `${paramToEdit}:`,
+            type: 'text',
+          })
+        ).value
+      }
+      args.params[paramToEdit] = value
+      return interactForBlueprintObject(args, ctx)
+    } else if (prop.format === 'enum') {
+      const value = (
+        await prompts({
+          name: 'value',
+          message: `${paramToEdit}:`,
+          type: 'select',
+          choices: prop.values.map((v) => ({
+            title: v.name,
+            value: v.name,
+          })),
+        })
+      ).value
+      args.params[paramToEdit] = value
+      return interactForBlueprintObject(args, ctx)
+    } else if (prop.format === 'boolean') {
+      const { value } = await prompts({
+        name: 'value',
+        message: `${paramToEdit}:`,
+        type: 'toggle',
+        initial: true,
+        active: 'true',
+        inactive: 'false',
+      })
+
+      args.params[paramToEdit] = value
+
+      return interactForBlueprintObject(args, ctx)
+    } else if (prop.format === 'list' && prop.itemFormat === 'enum') {
+      const value = (
+        await prompts({
+          name: 'value',
+          message: `${paramToEdit}:`,
+          type: 'autocompleteMultiselect',
+          choices: prop.itemEnumValues.map((v) => ({
+            title: v.name,
+            value: v.name,
+          })),
+        })
+      ).value
+      args.params[paramToEdit] = value
+      return interactForBlueprintObject(args, ctx)
+    } else if (prop.format === 'list') {
+      args.params[paramToEdit] = await interactForArray(
+        args.params[paramToEdit] || [],
+        `Edit the list for ${paramToEdit}`,
+      )
+      return interactForBlueprintObject(args, ctx)
+    } else if (prop.format === 'object') {
+      args.params[paramToEdit] = await interactForBlueprintObject(
+        {
+          command: args.command,
+          params: {},
+          parameters: prop.parameters,
+          isSubProperty: true,
+          subPropertyPath: paramToEdit,
+        },
+        ctx,
+      )
+      return interactForBlueprintObject(args, ctx)
+    } else if (prop.format === 'number') {
+      const { value } = await prompts({
+        name: 'value',
+        message: `${paramToEdit}:`,
+        type: 'number',
+      })
+
+      args.params[paramToEdit] = value
+
+      return interactForBlueprintObject(args, ctx)
+    }
+  }
+
+  throw new Error(
+    `Didn't know how to handle Blueprint parameter for property: "${paramToEdit}"`,
+  )
+}

package/src/lib/interact-for-command-params.ts

@@ -0,0 +1,22 @@
+import { getCommandBlueprintDef } from './get-command-blueprint-def.js'
+import { interactForBlueprintObject } from './interact-for-blueprint-object.js'
+import type { ContextHelpers } from './types.js'
+
+export const interactForCommandParams = async (
+  args: {
+    command: string[]
+    params: Record<string, any>
+  },
+  ctx: ContextHelpers,
+): Promise<any> => {
+  const endpoint = getCommandBlueprintDef(args.command, ctx)
+
+  return interactForBlueprintObject(
+    {
+      command: args.command,
+      params: args.params,
+      parameters: endpoint.request.parameters,
+    },
+    ctx,
+  )
+}