@cloudbase/cli 1.9.8-beta → 1.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cloudbase/cli",
-    "version": "1.9.8-beta",
+    "version": "1.10.0",
     "description": "cli tool for cloudbase",
     "main": "lib/index.js",
     "scripts": {
@@ -26,15 +26,15 @@
     "dependencies": {
         "@cloudbase/cloud-api": "^0.4.0",
         "@cloudbase/framework-core": "^1.6.1",
-        "@cloudbase/lowcode-cli": "^0.12.0",
-        "@cloudbase/manager-node": "3.11.1-beta",
+        "@cloudbase/lowcode-cli": "^0.12.2",
+        "@cloudbase/manager-node": "3.12.0",
         "@cloudbase/toolbox": "^0.7.2",
         "@sentry/node": "^5.10.2",
         "address": "^1.1.2",
         "axios": "^0.21.1",
         "chalk": "^2.4.2",
         "cli-table3": "^0.5.1",
-        "commander": "^6.1.0",
+        "commander": "7",
         "del": "^5.1.0",
         "didyoumean": "^1.2.1",
         "enquirer": "^2.3.6",
@@ -53,6 +53,7 @@
         "progress": "^2.0.3",
         "query-string": "^6.8.1",
         "reflect-metadata": "^0.1.13",
+        "semver": "^7.3.5",
         "tar-fs": "^2.0.1",
         "terminal-link": "^2.1.1",
         "unzipper": "^0.10.10",
@@ -66,6 +67,7 @@
         "@types/lodash": "^4.14.149",
         "@types/node": "^12.12.38",
         "@types/node-fetch": "^2.5.4",
+        "@types/semver": "^7.3.9",
         "@types/webpack-dev-server": "^3.11.1",
         "@typescript-eslint/eslint-plugin": "^4.8.1",
         "@typescript-eslint/parser": "^4.8.1",

package/src/commands/common.ts

@@ -1,7 +1,7 @@
 import chalk from 'chalk'
 import * as Sentry from '@sentry/node'
 import { EventEmitter } from 'events'
-import { program, Command as Commander } from 'commander'
+import { program, Command as Commander, Option } from 'commander'
 import { CloudBaseError } from '../error'
 import { ICommandContext } from '../types'
 import {
@@ -16,6 +16,7 @@ import {
 interface ICommandOption {
     flags: string
     desc: string
+    hideHelp?: boolean
 }
 
 export interface ICommandOptions {
@@ -87,6 +88,7 @@ export abstract class Command extends EventEmitter {
         } else {
             // 新命令或原有的旧命令格式
             instance = program.command(cmd) as Commander
+            // @ts-expect-error 这里是用来自定义commander fallback 帮助信息
             instance._helpDescription = '输出帮助信息'
             instance.addHelpCommand('help [command]', '查看命令帮助信息')
             cmdMap.set(cmd, instance)
@@ -110,6 +112,7 @@ export abstract class Command extends EventEmitter {
                 instance = cmdMap.get(cmdKey)
             } else {
                 instance = instance.command(cmdName) as Commander
+                // @ts-expect-error 这里是用来自定义commander fallback 帮助信息
                 instance._helpDescription = '查看命令帮助信息'
                 desc && instance.description(desc)
                 cmdMap.set(cmdKey, instance)
@@ -137,11 +140,16 @@ export abstract class Command extends EventEmitter {
 
     private createProgram(instance: Commander, deprecate: boolean, newCmd?: string) {
         const { cmd, desc, options, requiredEnvId = true, withoutAuth = false } = this.options
-
-        instance.storeOptionsAsProperties(false).passCommandToAction(false)
-
+        instance.storeOptionsAsProperties(false)
         options.forEach((option) => {
-            instance.option(option.flags, option.desc)
+            
+            const { hideHelp } = option
+            if(hideHelp) {
+                instance.addOption(new Option(option.flags, option.desc).hideHelp())
+            } else {
+                instance.option(option.flags, option.desc)
+            }
+            
         })
 
         instance.description(desc)
@@ -178,7 +186,7 @@ export abstract class Command extends EventEmitter {
             }
 
             // 处理前
-            this.emit('preHandle', ctx, args)
+            this.emit('preHandle', ctx, args.slice(0, -1))
             await this.preHandle()
 
             // 废弃警告

package/src/commands/functions/alias/getRoute.ts

@@ -0,0 +1,76 @@
+
+import { Command, ICommand } from '../../common'
+import { loadingFactory, printHorizontalTable } from '../../../utils'
+import { getFunctionAliasConfig } from '../../../function'
+import { InjectParams, CmdContext, ArgsParams, ArgsOptions } from '../../../decorators'
+
+
+function parseRoutingConfigValue(expression: string) {
+    const commaIndex = expression.indexOf(',')
+    const valueExpression = expression.substring(commaIndex + 1, expression.length - 1)
+    return valueExpression
+}
+
+@ICommand()
+export class getFunctionRoutingConfig extends Command {
+    get options() {
+        return {
+            cmd: 'fn',
+            childCmd: 'get-route <name>',
+            options: [
+                {
+                    flags: '-e, --envId <envId>',
+                    desc: '环境 Id'
+                }
+            ],
+            desc: '查看函数版本流量配置'
+        }
+    }
+
+    @InjectParams()
+    async execute(@CmdContext() ctx, @ArgsParams() params) {
+        const name = params?.[0]
+
+        const {
+            envId
+        } = ctx
+
+        const loading = loadingFactory()
+        loading.start(`查询函数 [${name}] 版本流量配置中...`)
+
+        const aliasRes = await getFunctionAliasConfig({
+            envId,
+            functionName: name,
+            name: '$DEFAULT'
+        })
+
+        const routingConfig = aliasRes?.RoutingConfig?.AddtionVersionMatchs
+        let finalConfig = []
+        if (routingConfig.length === 1) {
+            finalConfig.push({
+                version: routingConfig[0].Version,
+                value: parseRoutingConfigValue(routingConfig[0].Expression)
+            })
+        } else if (routingConfig.length === 2) {
+            finalConfig.push({
+                version: routingConfig[0].Version,
+                value: parseRoutingConfigValue(routingConfig[0].Expression)
+            }, {
+                version: routingConfig[1].Version,
+                value: 100 - Number(parseRoutingConfigValue(routingConfig[0].Expression))
+            })
+        }
+
+        loading.stop()
+
+        const head: string[] = ['版本', '流量比例']
+
+        const tableData = finalConfig.map((item) => [
+            item.version,
+            item.value
+        ])
+
+        printHorizontalTable(head, tableData)
+
+    }
+}

package/src/commands/functions/alias/index.ts

@@ -0,0 +1,2 @@
+export * from './setRoute'
+export * from './getRoute'

package/src/commands/functions/alias/setRoute.ts

@@ -0,0 +1,82 @@
+
+import { Command, ICommand } from '../../common'
+import { CloudBaseError } from '../../../error'
+import { loadingFactory } from '../../../utils'
+import { setFunctionAliasConfig } from '../../../function'
+import { InjectParams, CmdContext, ArgsParams, ArgsOptions } from '../../../decorators'
+
+
+@ICommand()
+export class setFunctionRoutingConfig extends Command {
+    get options() {
+        return {
+            cmd: 'fn',
+            childCmd: 'config-route <name> <version1> <traffic1> [version2] [traffic2]',
+            options: [
+                {
+                    flags: '-e, --envId <envId>',
+                    desc: '环境 Id'
+                }
+            ],
+            desc: '设置函数版本流量配置'
+        }
+    }
+
+    @InjectParams()
+    async execute(@CmdContext() ctx, @ArgsParams() params) {
+        const name = params?.[0]
+        const version1 = params?.[1]
+        const traffic1 = Number(params?.[2])
+
+        const version2 = params?.[3]
+        const traffic2 = Number(params?.[4])
+
+        // 校验
+
+        // 1. version2 及 traffic2 必须同时存在
+        if ((version2 === undefined && traffic2 !== undefined) || (version2 !== undefined && traffic2 === undefined)) {
+            throw new CloudBaseError('version2 和 traffic2 必须同时设置')
+        }
+
+        if (traffic1 !== undefined && traffic2 !== undefined) {
+            if (traffic1 + traffic2 !== 100) {
+                throw new CloudBaseError('traffic1 和 traffic2 同时设置时，需保证总和 100')
+            }
+        }
+
+        const {
+            envId
+        } = ctx
+
+        const loading = loadingFactory()
+        loading.start(`设置函数 [${name}] 版本流量配置中...`)
+
+        let routingConfigParams = {
+            AddtionVersionMatchs: [{
+                Expression: `[0,${traffic1})`,
+                Key: "invoke.headers.X-Tcb-Route-Key",
+                Method: "range",
+                Version: version1
+            }]
+        }
+
+        if (version2 !== undefined) {
+            routingConfigParams.AddtionVersionMatchs.push({
+                Expression: `[${traffic1},${100})`,
+                Key: "invoke.headers.X-Tcb-Route-Key",
+                Method: "range",
+                Version: version2
+            })
+        }
+
+        await setFunctionAliasConfig({
+            envId,
+            functionName: name,
+            name: '$DEFAULT',
+            functionVersion: '$LATEST',
+            routingConfig: routingConfigParams
+        })
+
+        loading.succeed(`设置函数 [${name}] 版本流量配置成功！`)
+    }
+}

package/src/commands/functions/concurrency/delete.ts

@@ -0,0 +1,45 @@
+
+import { Command, ICommand } from '../../common'
+import { CloudBaseError } from '../../../error'
+import { loadingFactory } from '../../../utils'
+import { deleteProvisionedConcurrencyConfig } from '../../../function'
+import { InjectParams, CmdContext, ArgsParams, ArgsOptions } from '../../../decorators'
+
+
+@ICommand()
+export class deleteProvisionedConcurrency extends Command {
+    get options() {
+        return {
+            cmd: 'fn',
+            childCmd: 'delete-provisioned-concurrency <name> <version>',
+            options: [
+                {
+                    flags: '-e, --envId <envId>',
+                    desc: '环境 Id'
+                }
+            ],
+            desc: '删除函数版本预置并发配置'
+        }
+    }
+
+    @InjectParams()
+    async execute(@CmdContext() ctx, @ArgsParams() params) {
+        const name = params?.[0]
+        const version = params?.[1]
+
+        const {
+            envId
+        } = ctx
+
+        const loading = loadingFactory()
+        loading.start(`删除函数 [${name}] 预置并发配置中...`)
+
+        await deleteProvisionedConcurrencyConfig({
+            envId,
+            functionName: name,
+            qualifier: version
+        })
+
+        loading.succeed(`删除函数 [${name}] 预置并发配置成功！`)
+    }
+}

package/src/commands/functions/concurrency/index.ts

@@ -0,0 +1,3 @@
+export * from './delete'
+export * from './list'
+export * from './set'

package/src/commands/functions/concurrency/list.ts

@@ -0,0 +1,58 @@
+
+import { Command, ICommand } from '../../common'
+import { CloudBaseError } from '../../../error'
+import { loadingFactory, printHorizontalTable } from '../../../utils'
+import { getProvisionedConcurrencyConfig } from '../../../function'
+import { InjectParams, CmdContext, ArgsParams, ArgsOptions } from '../../../decorators'
+import { StatusMap, ConcurrencyTaskStatus } from '../../../constant'
+
+
+@ICommand()
+export class getProvisionedConcurrency extends Command {
+    get options() {
+        return {
+            cmd: 'fn',
+            childCmd: 'get-provisioned-concurrency <name> [version]',
+            options: [
+                {
+                    flags: '-e, --envId <envId>',
+                    desc: '环境 Id'
+                }
+            ],
+            desc: '获取函数版本预置并发配置'
+        }
+    }
+
+    @InjectParams()
+    async execute(@CmdContext() ctx, @ArgsParams() params, @ArgsOptions() options) {
+        const name = params?.[0]
+        const version = params?.[1]
+
+        const {
+            envId
+        } = ctx
+
+        const loading = loadingFactory()
+        loading.start(`拉取函数 [${name}] 预置并发配置中...`)
+
+        const res = await getProvisionedConcurrencyConfig({
+            envId,
+            functionName: name,
+            qualifier: version
+        })
+
+        loading.stop()
+
+        const head: string[] = ['设置并发数', '已完成并发数', '预置任务状态', '状态说明', '版本号']
+
+        const tableData = res.Allocated.map((item) => [
+            item.AllocatedProvisionedConcurrencyNum,
+            item.AvailableProvisionedConcurrencyNum,
+            ConcurrencyTaskStatus[item.Status] || '无',
+            item.StatusReason,
+            item.Qualifier
+        ])
+
+        printHorizontalTable(head, tableData)
+    }
+}

package/src/commands/functions/concurrency/set.ts

@@ -0,0 +1,47 @@
+
+import { Command, ICommand } from '../../common'
+import { CloudBaseError } from '../../../error'
+import { loadingFactory } from '../../../utils'
+import { setProvisionedConcurrencyConfig } from '../../../function'
+import { InjectParams, CmdContext, ArgsParams, ArgsOptions } from '../../../decorators'
+
+
+@ICommand()
+export class setProvisionedConcurrency extends Command {
+    get options() {
+        return {
+            cmd: 'fn',
+            childCmd: 'set-provisioned-concurrency <name> <version> <concurrency>',
+            options: [
+                {
+                    flags: '-e, --envId <envId>',
+                    desc: '环境 Id'
+                }
+            ],
+            desc: '设置函数版本预置并发'
+        }
+    }
+
+    @InjectParams()
+    async execute(@CmdContext() ctx, @ArgsParams() params) {
+        const name = params?.[0]
+        const version = params?.[1]
+        const concurrency = Number(params?.[2] || 0)
+
+        const {
+            envId
+        } = ctx
+
+        const loading = loadingFactory()
+        loading.start(`配置函数 [${name}] 预置并发中...`)
+
+        await setProvisionedConcurrencyConfig({
+            envId,
+            functionName: name,
+            qualifier: version,
+            versionProvisionedConcurrencyNum: concurrency
+        })
+
+        loading.succeed(`配置函数 [${name}] 预置并发成功！`)
+    }
+}

package/src/commands/functions/index.ts

@@ -11,3 +11,6 @@ export * from './trigger-create'
 export * from './trigger-delete'
 export * from './code-update'
 export * from './code-download'
+export * from './version'
+export * from './concurrency'
+export * from './alias'

package/src/commands/functions/list.ts

@@ -3,14 +3,7 @@ import { CloudBaseError } from '../../error'
 import { listFunction } from '../../function'
 import { printHorizontalTable, loadingFactory } from '../../utils'
 import { InjectParams, EnvId, ArgsOptions } from '../../decorators'
-
-const StatusMap = {
-    Active: '部署完成',
-    Creating: '创建中',
-    CreateFailed: '创建失败',
-    Updating: '更新中',
-    UpdateFailed: '更新失败'
-}
+import { StatusMap } from '../../constant'
 
 @ICommand()
 export class ListFunction extends Command {

package/src/commands/functions/version/index.ts

@@ -0,0 +1,2 @@
+export * from './publish'
+export * from './list'

package/src/commands/functions/version/list.ts

@@ -0,0 +1,73 @@
+
+import { Command, ICommand } from '../../common'
+import { CloudBaseError } from '../../../error'
+import { loadingFactory, printHorizontalTable } from '../../../utils'
+import { listFunctionVersions } from '../../../function'
+import { InjectParams, CmdContext, ArgsParams, ArgsOptions } from '../../../decorators'
+import { StatusMap } from '../../../constant'
+
+
+@ICommand()
+export class ListFunctionVersion extends Command {
+    get options() {
+        return {
+            cmd: 'fn',
+            childCmd: 'list-function-versions <name>',
+            options: [
+                {
+                    flags: '-e, --envId <envId>',
+                    desc: '环境 Id'
+                },
+                { flags: '-l, --limit <limit>', desc: '返回数据长度，默认值为 20' },
+                {
+                    flags: '-o, --offset <offset>',
+                    desc: '数据偏移量，默认值为 0'
+                }
+            ],
+            desc: '展示函数版本列表'
+        }
+    }
+
+    @InjectParams()
+    async execute(@CmdContext() ctx, @ArgsParams() params, @ArgsOptions() options) {
+        const name = params?.[0]
+        let { limit = 20, offset = 0 } = options
+        limit = Number(limit)
+        offset = Number(offset)
+        if (!Number.isInteger(limit) || !Number.isInteger(offset)) {
+            throw new CloudBaseError('limit 和 offset 必须为整数')
+        }
+
+        if (limit < 0 || offset < 0) {
+            throw new CloudBaseError('limit 和 offset 必须为大于 0 的整数')
+        }
+
+        const {
+            envId
+        } = ctx
+
+        const loading = loadingFactory()
+        loading.start(`拉取函数 [${name}] 版本列表中...`)
+
+        const res = await listFunctionVersions({
+            envId,
+            functionName: name,
+            offset,
+            limit
+        })
+
+        loading.stop()
+
+        const head: string[] = ['版本', '描述', '创建时间', '修改时间', '状态']
+
+        const tableData = res.Versions.map((item) => [
+            item.Version,
+            item.Description,
+            item.AddTime,
+            item.ModTime,
+            StatusMap[item.Status]
+        ])
+
+        printHorizontalTable(head, tableData)
+    }
+}

package/src/commands/functions/version/publish.ts

@@ -0,0 +1,43 @@
+
+import { Command, ICommand } from '../../common'
+import { CloudBaseError } from '../../../error'
+import { loadingFactory } from '../../../utils'
+import { publishVersion } from '../../../function'
+import { InjectParams, CmdContext, ArgsParams } from '../../../decorators'
+
+@ICommand()
+export class PublishFunctionVersion extends Command {
+    get options() {
+        return {
+            cmd: 'fn',
+            childCmd: 'publish-version <name> [description]',
+            options: [
+                {
+                    flags: '-e, --envId <envId>',
+                    desc: '环境 Id'
+                }
+            ],
+            desc: '发布函数新版本'
+        }
+    }
+
+    @InjectParams()
+    async execute(@CmdContext() ctx, @ArgsParams() params) {
+        const name = params?.[0]
+        const description = params?.[1]
+        const {
+            envId
+        } = ctx
+
+        const loading = loadingFactory()
+        loading.start(`发布函数 [${name}] 新版本中...`)
+
+        await publishVersion({
+            envId,
+            functionName: name,
+            description
+        })
+
+        loading.succeed(`发布函数 [${name}] 新版本成功！`)
+    }
+}

package/src/commands/lowcode/comps.ts

@@ -14,11 +14,13 @@ import {
     graceDebugComps,
     gracePublishComps,
     IPublishCompsInfo,
+    publishVersion
 } from '@cloudbase/lowcode-cli'
 import { exec } from 'child_process'
 import { prompt } from 'enquirer'
 import fse from 'fs-extra'
 import { promisify } from 'util'
+import * as semver from 'semver'
 
 const cloudService = CloudApiService.getInstance('lowcode')
 const DEFAULE_TEMPLATE_PATH = 'https://comp-public-1303824488.cos.ap-shanghai.myqcloud.com/lcc/template.zip'
@@ -176,6 +178,11 @@ export class LowCodePublishComps extends Command {
                 {
                     flags: '--verbose',
                     desc: '是否打印详细日志'
+                },
+                {
+                    flags: '--admin',
+                    desc: '是否使用admin接口',
+                    hideHelp: true
                 }
             ],
             desc: '发布组件库',
@@ -184,14 +191,16 @@ export class LowCodePublishComps extends Command {
     }
 
     @InjectParams()
-    async execute(@CmdContext() ctx, @Log() log?: Logger) {
+    async execute(@CmdContext() ctx, @Log() log: Logger, @ArgsOptions() options: any) {
         // 有RC配置, 使用新接口
+
         const config = ctx.config.lowcodeCustomComponents
         if (config) {
             await gracePublishComps({
                 ...config,
                 context: config.context || process.cwd(),
-                logger: log
+                logger: log,
+                isAdmin: Boolean(options.admin)
             })
             log.success('组件库 - 已同步到云端，请到低码控制台发布该组件库！')
             return
@@ -224,6 +233,86 @@ export class LowCodePublishComps extends Command {
     }
 }
 
+@ICommand()
+export class LowCodePublishVersionComps extends Command {
+    get options() {
+        return {
+            cmd: 'lowcode',
+            childCmd: 'publishVersion',
+            options: [
+                {
+                    flags: '--verbose',
+                    desc: '是否打印详细日志'
+                },
+                {
+                    flags: '--comment <comment>',
+                    desc: '版本备注',
+                },
+                {
+                    flags: '--tag <version>',
+                    desc: '版本号'
+                },
+                {
+                    flags: '--admin',
+                    desc: '是否使用admin接口',
+                    hideHelp: true
+                }
+            ],
+            desc: '发布组件库版本',
+            requiredEnvId: false
+        }
+    }
+
+    @InjectParams()
+    async execute(@CmdContext() ctx, @ArgsOptions() options, @Log() log?: Logger) {
+        // 有RC配置, 使用新接口
+        const {tag, comment, admin} = options
+        if(!comment) {
+            log.error('请使用 --comment 填写版本注释')
+            return
+        }
+        if(!tag) {
+            log.error('请使用 --tag 填写符合semver的版本号')
+            return
+        }
+        if(!semver.valid(tag)) {
+            log.error('组件库版本不符合semver标准')
+            return
+        }
+        const config = ctx.config.lowcodeCustomComponents
+
+        if(!config) {
+            log.error('组件库 - 请添加组件库配置到cloudbaserc.json 以使用该命令')
+        }
+        
+        const res = await publishVersion({
+            ...config,
+            context: config.context || process.cwd(),
+            logger: log,
+            isAdmin: options.admin
+        }, comment, tag)
+        if(res.data.code === 200) {
+            log.success('组件库 - 已发布新版本！')
+            return
+        }
+        if (res.data.code === 100) {
+            log.error('组件库 - 无待发布版本')
+            return
+        }
+        if (res.data.code === 201) {
+            log.error('组件库 - comment 重复， 请使用有意义的comment')
+            return
+        } else {
+            if(res.data.msg) {
+                log.error(`组件库 - ${res.data.msg} RequestId: ${res.requestId}`)
+            } else {
+                log.error('组件库 - 未知错误')
+            }
+            return
+        }
+    }
+}
+
 async function _download(compsPath, compsName) {
     await execWithLoading(
         async () => {

package/src/constant.ts

@@ -68,6 +68,12 @@ export const ALL_COMMANDS = [
     'fn trigger create',
     'fn trigger delete',
     'fn invoke',
+    'fn publish-version',
+    'fn list-function-versions',
+    'fn put-provisioned-concurrency',
+    'fn get-provisioned-concurrency',
+    'fn delete-provisioned-concurrency',
+    'fn config-route',
     'functions run',
     'storage upload',
     'storage download',
@@ -94,3 +100,21 @@ export const ALL_COMMANDS = [
     'run standalonegateway turn on',
     'run standalonegateway turn off',
 ]
+
+export const StatusMap = {
+    Active: '部署完成',
+    Creating: '创建中',
+    CreateFailed: '创建失败',
+    Updating: '更新中',
+    UpdateFailed: '更新失败',
+    Publishing: '函数版本发布中',
+    PublishFailed: '函数版本发布失败',
+    Deleting: '函数删除中',
+    DeleteFailed: '函数删除失败'
+}
+
+export const ConcurrencyTaskStatus = {
+    Done: '已完成',
+    InProgress: '进行中',
+    Failed: '失败'
+}

package/src/function/alias.ts

@@ -0,0 +1,43 @@
+import { CloudBaseError } from '../error'
+import { IUpdateFunctionAliasConfig, IGetFunctionAlias, IGetFunctionAliasRes } from '../types'
+import { getFunctionService } from './base'
+
+// 设置函数流量配置信息（ALIAS 配置）
+export async function setFunctionAliasConfig(options: IUpdateFunctionAliasConfig) {
+    const { envId, functionName, name, functionVersion, description, routingConfig } = options
+
+    const scfService = await getFunctionService(envId)
+
+    try {
+        await scfService.updateFunctionAliasConfig({
+            functionName,
+            name,
+            functionVersion,
+            description,
+            routingConfig
+        })
+    } catch (e) {
+        throw new CloudBaseError(`[${functionName}] 设置函数流量配置失败： ${e.message}`, {
+            code: e.code
+        })
+    }
+}
+
+// 查询函数别名配置信息
+export async function getFunctionAliasConfig(options: IGetFunctionAlias): Promise<IGetFunctionAliasRes> {
+    const { envId, functionName, name } = options
+
+    const scfService = await getFunctionService(envId)
+
+    try {
+        return scfService.getFunctionAlias({
+            functionName,
+            name
+        })
+    } catch (e) {
+        throw new CloudBaseError(`[${functionName}] 查询函数别名配置失败： ${e.message}`, {
+            code: e.code
+        })
+    }
+}
+

package/src/function/concurrency.ts

@@ -0,0 +1,57 @@
+import { CloudBaseError } from '../error'
+import { ISetProvisionedConcurrencyConfig, IGetProvisionedConcurrencyConfig, IGetProvisionedConcurrencyRes, IFunctionVersionsRes } from '../types'
+import { getFunctionService } from './base'
+
+// 设置函数预置并发
+export async function setProvisionedConcurrencyConfig(options: ISetProvisionedConcurrencyConfig) {
+    const { envId, functionName, qualifier, versionProvisionedConcurrencyNum } = options
+
+    const scfService = await getFunctionService(envId)
+
+    try {
+        await scfService.setProvisionedConcurrencyConfig({
+            functionName,
+            qualifier,
+            versionProvisionedConcurrencyNum
+        })
+    } catch (e) {
+        throw new CloudBaseError(`[${functionName}] 设置函数预置并发失败： ${e.message}`, {
+            code: e.code
+        })
+    }
+}
+
+// 查看函数预置并发
+export async function getProvisionedConcurrencyConfig(options: IGetProvisionedConcurrencyConfig): Promise<IGetProvisionedConcurrencyRes> {
+    const { envId, functionName, qualifier } = options
+    const scfService = await getFunctionService(envId)
+
+    try {
+        return scfService.getProvisionedConcurrencyConfig({
+            functionName,
+            qualifier,
+        })
+    } catch (e) {
+        throw new CloudBaseError(`[${functionName}] 查看函数预置并发信息失败： ${e.message}`, {
+            code: e.code
+        })
+    }
+}
+
+// 删除函数预置并发
+export async function deleteProvisionedConcurrencyConfig(options: IGetProvisionedConcurrencyConfig): Promise<void> {
+    const { envId, functionName, qualifier } = options
+    const scfService = await getFunctionService(envId)
+
+    try {
+        await scfService.deleteProvisionedConcurrencyConfig({
+            functionName,
+            qualifier
+        })
+    } catch (e) {
+        throw new CloudBaseError(`[${functionName}] 删除函数预置并发失败： ${e.message}`, {
+            code: e.code
+        })
+    }
+}
+

package/src/function/index.ts

@@ -5,4 +5,7 @@ export * from './base'
 export * from './delete'
 export * from './update'
 export * from './layer'
-export * from './vpc'
+export * from './vpc'
+export * from './version'
+export * from './concurrency'
+export * from './alias'

package/src/function/version.ts

@@ -0,0 +1,39 @@
+import { CloudBaseError } from '../error'
+import { IPublishVersionParams, IListFunctionVersionParams, IFunctionVersionsRes } from '../types'
+import { getFunctionService } from './base'
+
+// 发布云函数新版本
+export async function publishVersion(options: IPublishVersionParams) {
+    const { envId, functionName, description = '' } = options
+
+    const scfService = await getFunctionService(envId)
+
+    try {
+        await scfService.publishVersion({
+            functionName,
+            description
+        })
+    } catch (e) {
+        throw new CloudBaseError(`[${functionName}] 函数发布新版本失败： ${e.message}`, {
+            code: e.code
+        })
+    }
+}
+
+// 查看函数所有版本
+export async function listFunctionVersions(options: IListFunctionVersionParams): Promise<IFunctionVersionsRes> {
+    const { envId, functionName, offset = 0, limit = 20 } = options
+    const scfService = await getFunctionService(envId)
+
+    try {
+        return scfService.listVersionByFunction({
+            functionName,
+            offset,
+            limit
+        })
+    } catch (e) {
+        throw new CloudBaseError(`[${functionName}] 查看寒函数版本列表失败： ${e.message}`, {
+            code: e.code
+        })
+    }
+}

package/src/types.ts

@@ -435,4 +435,99 @@ export interface ITurnOffStandaloneGateway {
 export interface IDestroyStandaloneGateway {
     envId: string,
     gatewayName: string
+}
+
+export interface IPublishVersionParams {
+    envId: string
+    functionName: string
+    description?: string
+}
+export interface IListFunctionVersionParams {
+    envId: string
+    functionName: string
+    offset?: number
+    limit?: number
+    order?: string
+    orderBy?: string
+}
+
+export interface IFunctionVersion {
+    Version: string
+    Description: string
+    AddTime: string
+    ModTime: string
+    Status: string //
+}
+
+export interface IFunctionVersionsRes {
+    FunctionVersion: string[]
+    Versions: IFunctionVersion[]
+    TotalCount: number
+}
+
+export interface ISetProvisionedConcurrencyConfig {
+    envId: string
+    functionName: string
+    qualifier: string
+    versionProvisionedConcurrencyNum: number
+}
+
+export interface IGetProvisionedConcurrencyConfig {
+    functionName: string
+    qualifier?: string
+    envId: string
+}
+
+export interface IGetProvisionedConcurrencyRes {
+    UnallocatedConcurrencyNum: number
+    Allocated: IVersionProvisionedConcurrencyInfo[]
+}
+
+export interface IVersionProvisionedConcurrencyInfo {
+    AllocatedProvisionedConcurrencyNum: number // 设置的预置并发数。
+    AvailableProvisionedConcurrencyNum: number // 当前已完成预置的并发数。
+    Status: string // 预置任务状态，Done表示已完成，InProgress表示进行中，Failed表示部分或全部失败。
+    StatusReason: string // 对预置任务状态Status的说明。
+    Qualifier: string // 版本号
+}
+
+export interface IUpdateFunctionAliasConfig {
+    envId: string
+    functionName: string // 函数名
+    name: string // 函数别名 如$DEFAULT
+    functionVersion: string // 函数版本
+    description?: string // 别名描述
+    routingConfig?: IRoutingConfig
+}
+
+export interface IRoutingConfig {
+    AdditionalVersionWeights?: IVersionWeight[]
+    AddtionVersionMatchs?: IVersionMatch[]
+}
+
+export interface IVersionMatch {
+    Version: string // 函数版本名称
+    Key: string // 匹配规则的key，调用时通过传key来匹配规则路由到指定版本 header方式：key填写"invoke.headers.User"，并在 invoke 调用函数时传参 RoutingKey：{"User":"value"}规则匹配调用
+    Method: string // 匹配方式。取值范围：range：范围匹配 exact：字符串精确匹配
+    Expression: string //
+}
+
+export interface IVersionWeight {
+    Version: string
+    Weight: number
+}
+
+export interface IGetFunctionAlias {
+    envId: string
+    functionName: string // 函数名称
+    name: string // 别名
+}
+
+export interface IGetFunctionAliasRes {
+    FunctionVersion: string
+    Name: string
+    RoutingConfig: IRoutingConfig
+    Description: string
+    AddTime: string
+    ModTime: string
 }