@tremho/mist-lift 1.1.2 → 1.1.4-pre-release.1

package/src/commands/builtin/BuiltInHandler.ts

@@ -1,47 +1,47 @@
-import { StageWebrootZip } from './StageWebrootZip'
-import { DeployBuiltInZip } from './DeployBuiltInZip'
-import { GetWebrootServePaths } from '../../lib/openAPI/WebrootFileSupport'
-
-import fs from 'fs'
-import path from 'path'
-
-export async function DeployWebrootBuiltIn
-(
-): Promise<void> {
-  const wrZip = await StageWebrootZip()
-  // console.log("Deploy Webroot Builtin from "+wrZip)
-  await DeployBuiltInZip('Webroot', wrZip)
-  // remove temp zip when done
-  fs.rmSync(wrZip, { recursive: true })
-}
-
-export async function DeployRootFileserves
-(
-): Promise<void> {
-  // console.log("Deploy Root Fileserves")
-  // Get root paths
-  const roots = GetWebrootServePaths()
-  // for each, deploy under the name of each
-  const fileserveZip = path.join(__dirname, 'prebuilt-zips', 'FileServe.zip')
-  const all: Array<Promise<any>> = []
-  for (let root of roots) {
-    root = root.trim()
-    let name = 'fileserve_' + root
-    while (name.includes('/')) {
-      name = name.replace('/', '')
-    }
-    all.push(DeployBuiltInZip(name, fileserveZip))
-  }
-  // console.log('wait all');
-  await Promise.all(all)
-  // console.log('all complete');
-}
-
-export async function DeployApiBuiltin
-(
-): Promise<any> {
-  console.log('Deploy API Builtin')
-  // get the prebuilt zip location
-  const apiZip = path.join(__dirname, 'prebuilt-zips', 'API.zip')
-  await DeployBuiltInZip('api', apiZip)
-}
+import { StageWebrootZip } from './StageWebrootZip'
+import { DeployBuiltInZip } from './DeployBuiltInZip'
+import { GetWebrootServePaths } from '../../lib/openAPI/WebrootFileSupport'
+
+import fs from 'fs'
+import path from 'path'
+
+export async function DeployWebrootBuiltIn
+(
+): Promise<void> {
+  const wrZip = await StageWebrootZip()
+  // console.log("Deploy Webroot Builtin from "+wrZip)
+  await DeployBuiltInZip('Webroot', wrZip)
+  // remove temp zip when done
+  fs.rmSync(wrZip, { recursive: true })
+}
+
+export async function DeployRootFileserves
+(
+): Promise<void> {
+  // console.log("Deploy Root Fileserves")
+  // Get root paths
+  const roots = GetWebrootServePaths()
+  // for each, deploy under the name of each
+  const fileserveZip = path.join(__dirname, 'prebuilt-zips', 'FileServe.zip')
+  const all: Array<Promise<any>> = []
+  for (let root of roots) {
+    root = root.trim()
+    let name = 'fileserve_' + root
+    while (name.includes('/')) {
+      name = name.replace('/', '')
+    }
+    all.push(DeployBuiltInZip(name, fileserveZip))
+  }
+  // console.log('wait all');
+  await Promise.all(all)
+  // console.log('all complete');
+}
+
+export async function DeployApiBuiltin
+(
+): Promise<any> {
+  console.log('Deploy API Builtin')
+  // get the prebuilt zip location
+  const apiZip = path.join(__dirname, 'prebuilt-zips', 'API.zip')
+  await DeployBuiltInZip('api', apiZip)
+}

package/src/commands/builtin/DeployBuiltInZip.ts

@@ -1,25 +1,25 @@
-
-import * as path from 'path'
-import { deployPackage } from '../deploy'
-
-export async function DeployBuiltInZip
-(
-  name: string,
-  zipPath: string
-): Promise<void> {
-  // console.log(">> Deploying "+name)
-  await deployPackage(name, zipPath)
-}
-
-export async function DeployFileserve
-(
-  root: string
-): Promise<void> {
-  // rootName is without slash
-  if (root !== '') {
-    const rootName = root.replace('/', '')
-    const name = 'fileserve_' + rootName
-    const zipPath = path.join(__dirname, 'prebuilt-zips', 'FileServe.zip')
-    await DeployBuiltInZip(name, zipPath)
-  }
-}
+
+import * as path from 'path'
+import { deployPackage } from '../deploy'
+
+export async function DeployBuiltInZip
+(
+  name: string,
+  zipPath: string
+): Promise<void> {
+  // console.log(">> Deploying "+name)
+  await deployPackage(name, zipPath)
+}
+
+export async function DeployFileserve
+(
+  root: string
+): Promise<void> {
+  // rootName is without slash
+  if (root !== '') {
+    const rootName = root.replace('/', '')
+    const name = 'fileserve_' + rootName
+    const zipPath = path.join(__dirname, 'prebuilt-zips', 'FileServe.zip')
+    await DeployBuiltInZip(name, zipPath)
+  }
+}

package/src/commands/builtin/StageWebrootZip.ts

@@ -1,36 +1,36 @@
-import { MakePublicApiDoc } from './ApiDocMaker'
-
-import * as path from 'path'
-import * as fs from 'fs'
-import { resolvePaths } from '../../lib/pathResolve'
-import { recurseDirectory } from '../../lib/DirectoryUtils'
-import { FolderToZip, UnzipToFolder } from '../../lib/utils'
-
-export async function StageWebrootZip
-(
-): Promise<string> {
-  // console.log(">> staging webroot to zip")
-  const projectPaths = resolvePaths()
-  // make a public yaml
-  await MakePublicApiDoc() // writes apidoc.yaml to docs
-  const builtinPath = path.join(__dirname, 'prebuilt-zips', 'Webroot.zip')
-  const exdir = path.join(projectPaths.basePath, '.package_temp')
-  await UnzipToFolder(builtinPath, exdir)
-  const webroot = path.join(projectPaths.basePath, 'webroot')
-  const packageTemp = path.join(projectPaths.basePath, '.package_temp')
-  const zipFilesPath = path.join(packageTemp, 'Webroot', '__files__')
-  await recurseDirectory(webroot, (filepath, stats) => {
-    const relPath = filepath.substring(webroot.length)
-    if (stats.isDirectory()) {
-      fs.mkdirSync(zipFilesPath + relPath, { recursive: true })
-    } else {
-      fs.copyFileSync(filepath, zipFilesPath + relPath)
-    }
-    return false
-  })
-  const webrootZip = path.join(projectPaths.basePath, 'a.zip')
-
-  await FolderToZip(path.join(packageTemp, 'Webroot'), webrootZip)
-  // return path to this zip
-  return webrootZip
-}
+import { MakePublicApiDoc } from './ApiDocMaker'
+
+import * as path from 'path'
+import * as fs from 'fs'
+import { resolvePaths } from '../../lib/pathResolve'
+import { recurseDirectory } from '../../lib/DirectoryUtils'
+import { FolderToZip, UnzipToFolder } from '../../lib/utils'
+
+export async function StageWebrootZip
+(
+): Promise<string> {
+  // console.log(">> staging webroot to zip")
+  const projectPaths = resolvePaths()
+  // make a public yaml
+  await MakePublicApiDoc() // writes apidoc.yaml to docs
+  const builtinPath = path.join(__dirname, 'prebuilt-zips', 'Webroot.zip')
+  const exdir = path.join(projectPaths.basePath, '.package_temp')
+  await UnzipToFolder(builtinPath, exdir)
+  const webroot = path.join(projectPaths.basePath, 'webroot')
+  const packageTemp = path.join(projectPaths.basePath, '.package_temp')
+  const zipFilesPath = path.join(packageTemp, 'Webroot', '__files__')
+  await recurseDirectory(webroot, (filepath, stats) => {
+    const relPath = filepath.substring(webroot.length)
+    if (stats.isDirectory()) {
+      fs.mkdirSync(zipFilesPath + relPath, { recursive: true })
+    } else {
+      fs.copyFileSync(filepath, zipFilesPath + relPath)
+    }
+    return false
+  })
+  const webrootZip = path.join(projectPaths.basePath, 'a.zip')
+
+  await FolderToZip(path.join(packageTemp, 'Webroot'), webrootZip)
+  // return path to this zip
+  return webrootZip
+}

package/src/commands/create.ts

@@ -1,52 +1,52 @@
-/** Handles fucntion creation via the create command */
-
-import * as fs from 'fs'
-import * as path from 'path'
-import * as ac from 'ansi-colors'
-import { resolvePaths } from '../lib/pathResolve'
-import { camelCase } from '../lib/CaseUtils'
-import { helpCreate } from './help'
-
-/// Create command
-export function doCreate (
-  funcName?: string // name of function to create
-): void {
-  if (funcName === '' || funcName === undefined) {
-    helpCreate()
-  } else {
-    console.log(ac.green.bold('Creating new function named ') + funcName)
-
-    const projectPaths = resolvePaths()
-    if (!projectPaths.verified) {
-      console.log(ac.bold.magenta('current directory is not at project root'))
-      return
-    }
-    const funcPath = path.join(projectPaths.functionPath, funcName)
-    if (!fs.existsSync(funcPath)) fs.mkdirSync(funcPath)
-    const dataDir = path.join(__dirname, '..', '..', 'templateData')
-
-    const testdirname = camelCase(funcName) + '-tests'
-    if (!fs.existsSync(path.join(funcPath, testdirname))) fs.mkdirSync(path.join(funcPath, testdirname))
-    if (!fs.existsSync(path.join(funcPath, 'src'))) fs.mkdirSync(path.join(funcPath, 'src'))
-
-    let localsrc = fs.readFileSync(path.join(dataDir, 'function-local-ts')).toString()
-    while (localsrc.includes('$$FUNCTION_NAME$$')) {
-      localsrc = localsrc.replace('$$FUNCTION_NAME$$', funcName)
-    }
-    fs.writeFileSync(path.join(funcPath, 'src', 'local.ts'), localsrc)
-    let defsrc = fs.readFileSync(path.join(dataDir, 'function-definition-template')).toString()
-    while (defsrc.includes('$$FUNCTION_NAME$$')) {
-      defsrc = defsrc.replace('$$FUNCTION_NAME$$', funcName)
-    }
-    const defpathMap = '/' + funcName.toLowerCase()
-    defsrc = defsrc.replace('$$PATHMAP$$', defpathMap)
-    fs.writeFileSync(path.join(funcPath, 'src', 'definition.json'), defsrc)
-    let mainsrc = fs.readFileSync(path.join(dataDir, 'function-main-ts')).toString()
-    while (mainsrc.includes('$$TemplateName$$')) {
-      mainsrc = mainsrc.replace('$$TemplateName$$', funcName)
-    }
-    fs.writeFileSync(path.join(funcPath, 'src', 'main.ts'), mainsrc)
-    fs.copyFileSync(path.join(dataDir, 'function-test-template'), path.join(funcPath, testdirname, 'Sanity.test.ts'))
-    fs.copyFileSync(path.join(dataDir, 'function-runmain-mjs'), path.join(funcPath, 'runmain.mjs'))
-  }
-}
+/** Handles fucntion creation via the create command */
+
+import * as fs from 'fs'
+import * as path from 'path'
+import * as ac from 'ansi-colors'
+import { resolvePaths } from '../lib/pathResolve'
+import { camelCase } from '../lib/CaseUtils'
+import { helpCreate } from './help'
+
+/// Create command
+export function doCreate (
+  funcName?: string // name of function to create
+): void {
+  if (funcName === '' || funcName === undefined) {
+    helpCreate()
+  } else {
+    console.log(ac.green.bold('Creating new function named ') + funcName)
+
+    const projectPaths = resolvePaths()
+    if (!projectPaths.verified) {
+      console.log(ac.bold.magenta('current directory is not at project root'))
+      return
+    }
+    const funcPath = path.join(projectPaths.functionPath, funcName)
+    if (!fs.existsSync(funcPath)) fs.mkdirSync(funcPath)
+    const dataDir = path.join(__dirname, '..', '..', 'templateData')
+
+    const testdirname = camelCase(funcName) + '-tests'
+    if (!fs.existsSync(path.join(funcPath, testdirname))) fs.mkdirSync(path.join(funcPath, testdirname))
+    if (!fs.existsSync(path.join(funcPath, 'src'))) fs.mkdirSync(path.join(funcPath, 'src'))
+
+    let localsrc = fs.readFileSync(path.join(dataDir, 'function-local-ts')).toString()
+    while (localsrc.includes('$$FUNCTION_NAME$$')) {
+      localsrc = localsrc.replace('$$FUNCTION_NAME$$', funcName)
+    }
+    fs.writeFileSync(path.join(funcPath, 'src', 'local.ts'), localsrc)
+    let defsrc = fs.readFileSync(path.join(dataDir, 'function-definition-template')).toString()
+    while (defsrc.includes('$$FUNCTION_NAME$$')) {
+      defsrc = defsrc.replace('$$FUNCTION_NAME$$', funcName)
+    }
+    const defpathMap = '/' + funcName.toLowerCase()
+    defsrc = defsrc.replace('$$PATHMAP$$', defpathMap)
+    fs.writeFileSync(path.join(funcPath, 'src', 'definition.json'), defsrc)
+    let mainsrc = fs.readFileSync(path.join(dataDir, 'function-main-ts')).toString()
+    while (mainsrc.includes('$$TemplateName$$')) {
+      mainsrc = mainsrc.replace('$$TemplateName$$', funcName)
+    }
+    fs.writeFileSync(path.join(funcPath, 'src', 'main.ts'), mainsrc)
+    fs.copyFileSync(path.join(dataDir, 'function-test-template'), path.join(funcPath, testdirname, 'Sanity.test.ts'))
+    fs.copyFileSync(path.join(dataDir, 'function-runmain-mjs'), path.join(funcPath, 'runmain.mjs'))
+  }
+}

package/src/commands/deploy.ts

@@ -1,161 +1,161 @@
-
-import {
-  LambdaClient,
-  CreateFunctionCommand,
-  DeleteFunctionCommand,
-  AddPermissionCommand
-} from '@aws-sdk/client-lambda'
-
-import md5 from 'md5'
-
-import path from 'path'
-import fs from 'fs'
-import { resolvePaths } from '../lib/pathResolve'
-
-import * as ac from 'ansi-colors'
-
-import { recurseDirectory } from '../lib/DirectoryUtils'
-import { getProjectName, getProjectVersion } from '../lib/LiftVersion'
-import { delay } from '../lib/utils'
-import { doPackageAsync } from './package'
-import { getAWSCredentials, getSettings, RuntimeType } from '../lib/LiftConfig'
-
-let projectPaths: { basePath: string, buildPath: string, functionPath: string, packagePath: string, verified: boolean }
-
-let deploymentRecord: any = {} // a map of last deployment times
-
-// package then deploy
-export async function doDeployAsync (
-  args: string[]
-): Promise<number> {
-  projectPaths = resolvePaths()
-  if (!projectPaths.verified) {
-    console.log(ac.bold.magenta('current directory is not at project root'))
-    return -1
-  }
-  const deploymentRecordPath = path.join(projectPaths.basePath, '.deployed')
-  try { deploymentRecord = JSON.parse(fs.readFileSync(deploymentRecordPath).toString()) } catch {}
-
-  const funcsToDeploy: string[] = []
-  const options: string[] = []
-  for (const arg of args) {
-    if (arg.charAt(0) === '-') {
-      options.push(arg.toLowerCase())
-    } else funcsToDeploy.push(arg)
-  }
-
-  if (!options.includes('--no-package')) {
-    const ret = await doPackageAsync(args)
-    if (ret !== 0) return ret
-    else await delay(2500)
-  }
-
-  if (options.includes('--clean')) {
-    deploymentRecord = {}
-  }
-
-  if (funcsToDeploy.length === 0) {
-    let firstDepth = 0
-    recurseDirectory(projectPaths.functionPath, (filepath, stats) => {
-      const depth = filepath.split(path.sep).length
-      if (firstDepth === 0) firstDepth = depth
-      if (stats.isDirectory() && depth === firstDepth) {
-        funcsToDeploy.push(path.basename(filepath))
-      }
-      return false
-    })
-  }
-
-  for (const funcName of funcsToDeploy) {
-    const zipFile = path.join(projectPaths.basePath, 'MistLift_Zips', funcName + '.zip')
-    if (fs.existsSync(zipFile)) {
-      const zipTime = fs.statSync(zipFile).mtime
-      if (zipTime.getTime() > (deploymentRecord[funcName] ?? 0)) {
-        await deployPackage(funcName)
-        deploymentRecord[funcName] = Date.now()
-      }
-    } else {
-      console.error('deploy: ' + zipFile + ac.red.bold(` ${funcName} does not exist`))
-      return -1
-    }
-  }
-
-  try { fs.writeFileSync(deploymentRecordPath, JSON.stringify(deploymentRecord)) } catch {}
-
-  return 0
-}
-
-// ------------
-
-export async function deployPackage (
-  funcName: string,
-  zipFile?: string
-): Promise<void> {
-  // first off, anchor a base directory
-  zipFile ??= path.join(projectPaths.basePath, 'MistLift_Zips', funcName + '.zip')
-
-  // funcname gets decorated with current instance identifier
-  const idsrc = md5((getProjectName() ?? '') + (getProjectVersion()?.toString() ?? ''))
-  const dFuncName = funcName + '_' + idsrc
-
-  // See if function exists
-  const client: any = new LambdaClient(getAWSCredentials())
-  const command: any = new DeleteFunctionCommand({
-    FunctionName: dFuncName
-  })
-  client.send(command).then((response: any) => {
-  }).catch((e: any) => {
-  })
-
-  // console.log(ac.green.italic("deploying ")+ac.green.bold(funcName)+"...")
-
-  try {
-    const response: any = await CreateCloudFunction(dFuncName, zipFile)
-    const parts = response.FunctionArn.split(':')
-    const principal = parts[4]
-    await AddPermissions(client, dFuncName, principal)
-    console.log(ac.green.bold(`Successfully deployed ${funcName}`))
-  } catch (e: any) {
-    console.error(ac.red.bold.italic('Error deploying ' + funcName), e)
-  }
-}
-async function CreateCloudFunction (
-  funcName: string,
-  zipFile: string
-
-): Promise<any> {
-  const settings = getSettings()
-  const nodeRuntime: RuntimeType | undefined = settings.awsNodeRuntime
-  const serviceRole: string = settings.awsServiceRoleARN ?? ''
-  const zipFileBase64: Uint8Array = fs.readFileSync(zipFile)
-  const client: any = new LambdaClient(getAWSCredentials())
-  const command: any = new CreateFunctionCommand({
-    FunctionName: funcName,
-    Runtime: nodeRuntime,
-    Role: serviceRole,
-    Handler: 'runmain.handler',
-    Code: {
-      ZipFile: zipFileBase64
-    }
-  })
-  const resp = await client.send(command) // response
-  return resp
-}
-
-async function AddPermissions (
-  client: LambdaClient,
-  funcName: string,
-  principal: string
-): Promise<any> {
-  const region = getSettings().awsPreferredRegion ?? ''
-  const WSApi = '/' + funcName.toLowerCase()
-  const command: any = new AddPermissionCommand({
-    FunctionName: funcName,
-    StatementId: 'InvokePermission',
-    Action: 'lambda:invokeFunction',
-    Principal: 'apigateway.amazonaws.com',
-    SourceArn: `arn:aws:execute-api:${region}:${principal}:${WSApi}`
-  })
-  const resp = await client.send(command)
-  return resp
-}
+
+import {
+  LambdaClient,
+  CreateFunctionCommand,
+  DeleteFunctionCommand,
+  AddPermissionCommand
+} from '@aws-sdk/client-lambda'
+
+import md5 from 'md5'
+
+import path from 'path'
+import fs from 'fs'
+import { resolvePaths } from '../lib/pathResolve'
+
+import * as ac from 'ansi-colors'
+
+import { recurseDirectory } from '../lib/DirectoryUtils'
+import { getProjectName, getProjectVersion } from '../lib/LiftVersion'
+import { delay } from '../lib/utils'
+import { doPackageAsync } from './package'
+import { getAWSCredentials, getSettings, RuntimeType } from '../lib/LiftConfig'
+
+let projectPaths: { basePath: string, buildPath: string, functionPath: string, packagePath: string, verified: boolean }
+
+let deploymentRecord: any = {} // a map of last deployment times
+
+// package then deploy
+export async function doDeployAsync (
+  args: string[]
+): Promise<number> {
+  projectPaths = resolvePaths()
+  if (!projectPaths.verified) {
+    console.log(ac.bold.magenta('current directory is not at project root'))
+    return -1
+  }
+  const deploymentRecordPath = path.join(projectPaths.basePath, '.deployed')
+  try { deploymentRecord = JSON.parse(fs.readFileSync(deploymentRecordPath).toString()) } catch {}
+
+  const funcsToDeploy: string[] = []
+  const options: string[] = []
+  for (const arg of args) {
+    if (arg.charAt(0) === '-') {
+      options.push(arg.toLowerCase())
+    } else funcsToDeploy.push(arg)
+  }
+
+  if (!options.includes('--no-package')) {
+    const ret = await doPackageAsync(args)
+    if (ret !== 0) return ret
+    else await delay(2500)
+  }
+
+  if (options.includes('--clean')) {
+    deploymentRecord = {}
+  }
+
+  if (funcsToDeploy.length === 0) {
+    let firstDepth = 0
+    recurseDirectory(projectPaths.functionPath, (filepath, stats) => {
+      const depth = filepath.split(path.sep).length
+      if (firstDepth === 0) firstDepth = depth
+      if (stats.isDirectory() && depth === firstDepth) {
+        funcsToDeploy.push(path.basename(filepath))
+      }
+      return false
+    })
+  }
+
+  for (const funcName of funcsToDeploy) {
+    const zipFile = path.join(projectPaths.basePath, 'MistLift_Zips', funcName + '.zip')
+    if (fs.existsSync(zipFile)) {
+      const zipTime = fs.statSync(zipFile).mtime
+      if (zipTime.getTime() > (deploymentRecord[funcName] ?? 0)) {
+        await deployPackage(funcName)
+        deploymentRecord[funcName] = Date.now()
+      }
+    } else {
+      console.error('deploy: ' + zipFile + ac.red.bold(` ${funcName} does not exist`))
+      return -1
+    }
+  }
+
+  try { fs.writeFileSync(deploymentRecordPath, JSON.stringify(deploymentRecord)) } catch {}
+
+  return 0
+}
+
+// ------------
+
+export async function deployPackage (
+  funcName: string,
+  zipFile?: string
+): Promise<void> {
+  // first off, anchor a base directory
+  zipFile ??= path.join(projectPaths.basePath, 'MistLift_Zips', funcName + '.zip')
+
+  // funcname gets decorated with current instance identifier
+  const idsrc = md5((getProjectName() ?? '') + (getProjectVersion()?.toString() ?? ''))
+  const dFuncName = funcName + '_' + idsrc
+
+  // See if function exists
+  const client: any = new LambdaClient(getAWSCredentials())
+  const command: any = new DeleteFunctionCommand({
+    FunctionName: dFuncName
+  })
+  client.send(command).then((response: any) => {
+  }).catch((e: any) => {
+  })
+
+  // console.log(ac.green.italic("deploying ")+ac.green.bold(funcName)+"...")
+
+  try {
+    const response: any = await CreateCloudFunction(dFuncName, zipFile)
+    const parts = response.FunctionArn.split(':')
+    const principal = parts[4]
+    await AddPermissions(client, dFuncName, principal)
+    console.log(ac.green.bold(`Successfully deployed ${funcName}`))
+  } catch (e: any) {
+    console.error(ac.red.bold.italic('Error deploying ' + funcName), e)
+  }
+}
+async function CreateCloudFunction (
+  funcName: string,
+  zipFile: string
+
+): Promise<any> {
+  const settings = getSettings()
+  const nodeRuntime: RuntimeType | undefined = settings.awsNodeRuntime
+  const serviceRole: string = settings.awsServiceRoleARN ?? ''
+  const zipFileBase64: Uint8Array = fs.readFileSync(zipFile)
+  const client: any = new LambdaClient(getAWSCredentials())
+  const command: any = new CreateFunctionCommand({
+    FunctionName: funcName,
+    Runtime: nodeRuntime,
+    Role: serviceRole,
+    Handler: 'runmain.handler',
+    Code: {
+      ZipFile: zipFileBase64
+    }
+  })
+  const resp = await client.send(command) // response
+  return resp
+}
+
+async function AddPermissions (
+  client: LambdaClient,
+  funcName: string,
+  principal: string
+): Promise<any> {
+  const region = getSettings().awsPreferredRegion ?? ''
+  const WSApi = '/' + funcName.toLowerCase()
+  const command: any = new AddPermissionCommand({
+    FunctionName: funcName,
+    StatementId: 'InvokePermission',
+    Action: 'lambda:invokeFunction',
+    Principal: 'apigateway.amazonaws.com',
+    SourceArn: `arn:aws:execute-api:${region}:${principal}:${WSApi}`
+  })
+  const resp = await client.send(command)
+  return resp
+}