@cloudbase/cli 2.0.12-alpha.1 → 2.0.13

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

@@ -1,45 +0,0 @@
-
-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

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

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

@@ -1,58 +0,0 @@
-
-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

@@ -1,47 +0,0 @@
-
-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/config-update.ts

@@ -1,76 +0,0 @@
-import inquirer from 'inquirer'
-import { Command, ICommand } from '../common'
-import { CloudBaseError } from '../../error'
-import { InjectParams, CmdContext, ArgsParams, Log, Logger } from '../../decorators'
-import { batchUpdateFunctionConfig, updateFunctionConfig } from '../../function'
-
-@ICommand()
-export class ConfigUpdate extends Command {
-    get options() {
-        return {
-            cmd: 'fn',
-            childCmd: {
-                cmd: 'config',
-                desc: '函数配置管理'
-            },
-            childSubCmd: 'update [name]',
-            deprecateCmd: 'functions:config:update [name]',
-            options: [
-                {
-                    flags: '-e, --envId <envId>',
-                    desc: '环境 Id'
-                }
-            ],
-            desc: '更新云函数配置'
-        }
-    }
-
-    @InjectParams()
-    async execute(@CmdContext() ctx, @ArgsParams() params, @Log() log: Logger) {
-        const {
-            envId,
-            config: { functions }
-        } = ctx
-        const name = params?.[0]
-        let isBathUpdate = false
-
-        // 不指定云函数名称，更新配置文件中所有函数的配置
-        if (!name) {
-            const { isBatch } = await inquirer.prompt({
-                type: 'confirm',
-                name: 'isBatch',
-                message: '无云函数名称，是否需要更新配置文件中的【全部云函数】的配置？',
-                default: false
-            })
-
-            isBathUpdate = isBatch
-
-            if (!isBathUpdate) {
-                throw new CloudBaseError('请指定云函数名称！')
-            }
-        }
-
-        if (isBathUpdate) {
-            await batchUpdateFunctionConfig({
-                envId,
-                functions,
-                log: true
-            })
-            return
-        }
-
-        const functionItem = functions.find((item) => item.name === name)
-
-        if (!functionItem) {
-            throw new CloudBaseError('未找到相关函数配置，请检查函数名是否正确')
-        }
-
-        await updateFunctionConfig({
-            envId,
-            functionName: name,
-            config: functionItem
-        })
-
-        log.success(`[${name}] 更新云函数配置成功！`)
-    }
-}

package/src/commands/functions/copy.ts

@@ -1,62 +0,0 @@
-import { Command, ICommand } from '../common'
-import { CloudBaseError } from '../../error'
-import { copyFunction } from '../../function'
-import { InjectParams, EnvId, ArgsOptions, ArgsParams, Log, Logger } from '../../decorators'
-
-@ICommand()
-export class FunctionCopy extends Command {
-    get options() {
-        return {
-            cmd: 'fn',
-            childCmd: 'copy <name> [newFunctionName]',
-            deprecateCmd: 'functions:copy <name> [newFunctionName]',
-            options: [
-                {
-                    flags: '-e, --envId <envId>',
-                    desc: '环境 Id'
-                },
-                {
-                    flags: '-t, --target <targetEnvId>',
-                    desc: '目标环境 Id'
-                },
-                // {
-                //     flags: '--code-secret <codeSecret>',
-                //     desc: '代码加密的函数的 CodeSecret'
-                // },
-                {
-                    flags: '--force',
-                    desc: '如果目标环境下存在同名函数，覆盖原函数'
-                }
-            ],
-            desc: '拷贝云函数'
-        }
-    }
-
-    @InjectParams()
-    async execute(
-        @EnvId() envId,
-        @ArgsOptions() options,
-        @ArgsParams() params,
-        @Log() log: Logger
-    ) {
-        const name = params?.[0]
-        const newFunctionName = params?.[1]
-
-        const { force, codeSecret, targetEnvId } = options
-
-        if (!name) {
-            throw new CloudBaseError('请指定函数名称！')
-        }
-
-        await copyFunction({
-            force,
-            envId,
-            codeSecret,
-            functionName: name,
-            newFunctionName: newFunctionName || name,
-            targetEnvId: targetEnvId || envId
-        })
-
-        log.success('拷贝函数成功')
-    }
-}

package/src/commands/functions/delete.ts

@@ -1,79 +0,0 @@
-import inquirer from 'inquirer'
-
-import { Command, ICommand } from '../common'
-import { CloudBaseError } from '../../error'
-import { loadingFactory } from '../../utils'
-import { deleteFunction, batchDeleteFunctions } from '../../function'
-import { InjectParams, CmdContext, ArgsParams } from '../../decorators'
-
-@ICommand()
-export class DeleteFunction extends Command {
-    get options() {
-        return {
-            cmd: 'fn',
-            childCmd: 'delete [name]',
-            deprecateCmd: 'functions:delete [name]',
-            options: [
-                {
-                    flags: '-e, --envId <envId>',
-                    desc: '环境 Id'
-                }
-            ],
-            desc: '删除云函数'
-        }
-    }
-
-    @InjectParams()
-    async execute(@CmdContext() ctx, @ArgsParams() params) {
-        const name = params?.[0]
-        const {
-            envId,
-            config: { functions }
-        } = ctx
-
-        let isBatchDelete = false
-
-        // 不指定云函数名称，默认删除所有函数
-        if (!name) {
-            const answer = await inquirer.prompt({
-                type: 'confirm',
-                name: 'isBatch',
-                message: '无云函数名称，是否需要删除配置文件中的全部云函数？',
-                default: false
-            })
-
-            // 危险操作，再次确认
-            if (answer.isBatch) {
-                const { reConfirm } = await inquirer.prompt({
-                    type: 'confirm',
-                    name: 'reConfirm',
-                    message: '确定要删除配置文件中的全部云函数？',
-                    default: false
-                })
-                isBatchDelete = reConfirm
-            }
-
-            if (!isBatchDelete) {
-                throw new CloudBaseError('请指定需要删除的云函数名称！')
-            }
-        }
-
-        if (isBatchDelete) {
-            const names: string[] = functions.map((item) => item.name)
-            return batchDeleteFunctions({
-                names,
-                envId
-            })
-        }
-
-        const loading = loadingFactory()
-        loading.start(`删除函数 [${name}] 中...`)
-
-        await deleteFunction({
-            envId,
-            functionName: name
-        })
-
-        loading.succeed(`删除函数 [${name}] 成功！`)
-    }
-}

package/src/commands/functions/deploy.ts

@@ -1,293 +0,0 @@
-import path from 'path'
-import inquirer from 'inquirer'
-import { getRegion } from '@cloudbase/toolbox'
-import { Command, ICommand } from '../common'
-import { CloudBaseError } from '../../error'
-import { createFunction } from '../../function'
-import { queryGateway, createGateway } from '../../gateway'
-import {
-    logger,
-    random,
-    isDirectory,
-    loadingFactory,
-    genClickableLink,
-    highlightCommand,
-    checkFullAccess,
-    AsyncTaskParallelController
-} from '../../utils'
-import { ICreateFunctionOptions } from '../../types'
-import { DefaultFunctionDeployConfig } from '../../constant'
-import { InjectParams, CmdContext, ArgsParams, Log, Logger } from '../../decorators'
-
-const regionIdMap = {
-    'ap-guangzhou': 1,
-    'ap-shanghai': 4,
-    'ap-beijing': 8
-}
-
-@ICommand()
-export class FunctionDeploy extends Command {
-    get options() {
-        return {
-            cmd: 'fn',
-            childCmd: 'deploy [name]',
-            deprecateCmd: 'functions:deploy [name]',
-            options: [
-                {
-                    flags: '-e, --envId <envId>',
-                    desc: '环境 Id'
-                },
-                {
-                    flags: '--code-secret <codeSecret>',
-                    desc: '传入此参数将保护代码，格式为 36 位大小写字母和数字'
-                },
-                {
-                    flags: '--force',
-                    desc: '如果存在同名函数，上传后覆盖同名函数'
-                },
-                {
-                    flags: '--path <path>',
-                    desc: '自动创建HTTP 访问服务访问路径'
-                },
-                {
-                    flags: '--all',
-                    desc: '部署配置文件中的包含的全部云函数'
-                },
-                {
-                    flags: '--dir <dir>',
-                    desc: '指定云函数的文件夹路径'
-                }
-            ],
-            desc: '部署云函数'
-        }
-    }
-
-    @InjectParams()
-    async execute(@CmdContext() ctx, @ArgsParams() params, @Log() log: Logger) {
-        const { envId, config, options } = ctx
-        const { functions } = config
-        const { force, codeSecret, path: access, all, dir } = options
-        const functionRootPath = path.join(process.cwd(), config.functionRoot)
-        const name = params?.[0]
-
-        if (access && checkFullAccess(access)) {
-            log.warn('--path 参数已更换为HTTP 访问服务路径，请使用 --dir 指定部署函数的文件夹路径')
-        }
-
-        if (access && access[0] !== '/') {
-            throw new CloudBaseError('HTTP 访问服务路径必须以 / 开头')
-        }
-
-        // 当没有指定函数名称或函数路径时，询问处理否部署全部云函数
-        if ((!name && !dir) || all) {
-            return this.deployAllFunction({
-                all,
-                envId,
-                force,
-                access,
-                functions,
-                codeSecret,
-                functionRootPath
-            })
-        }
-
-        // 校验函数路径是否存在
-        if (dir) {
-            checkFullAccess(dir, true)
-            if (!isDirectory(dir)) {
-                throw new CloudBaseError('--dir 参数必须指定为云函数的文件夹路径')
-            }
-        }
-
-        let newFunction
-        if (functions && functions.length > 0) {
-            newFunction = functions.find((item) => item.name === name)
-        }
-
-        // 没有配置，使用默认配置
-        if (!newFunction || !newFunction.name) {
-            log.info('未找到函数发布配置，使用默认配置 => 运行时：Nodejs10.15/在线安装依赖')
-            newFunction = {
-                name,
-                ...DefaultFunctionDeployConfig
-            }
-        }
-
-        const loading = loadingFactory()
-
-        loading.start('云函数部署中...')
-
-        try {
-            await createFunction({
-                force,
-                envId,
-                codeSecret,
-                functionRootPath,
-                func: newFunction,
-                accessPath: access,
-                functionPath: dir
-            })
-            loading.succeed(`[${newFunction.name}] 云函数部署成功！`)
-            // await genApiGateway(envId, name)
-            this.printSuccessTips(envId)
-        } catch (e) {
-            // 询问是否覆盖同名函数
-            loading.stop()
-            await this.handleDeployFail(e, {
-                envId,
-                codeSecret,
-                functionRootPath,
-                func: newFunction,
-                accessPath: access,
-                functionPath: dir
-            })
-        }
-
-        if (access || newFunction.path) {
-            const link = genClickableLink(
-                `https://${envId}.service.tcloudbase.com${access || newFunction.path}`
-            )
-            console.log(`\n云函数HTTP 访问服务访问链接：${link}`)
-        }
-    }
-
-    async deployAllFunction(options: any) {
-        const { functions = [], envId, force, codeSecret, functionRootPath, all, access } = options
-
-        // 指定 all 参数，直接部署全部云函数
-        if (!all) {
-            const { isBatch } = await inquirer.prompt({
-                type: 'confirm',
-                name: 'isBatch',
-                message: '没有指定需要部署的云函数，是否部署配置文件中的全部云函数？',
-                default: false
-            })
-
-            // 用户不部署全部函数，报错
-            if (!isBatch) {
-                throw new CloudBaseError(
-                    '请指定需要部署的云函数的名称或通过 --path 参数指定需要部署的函数的路径！'
-                )
-            }
-        }
-
-        // 批量部署云函数
-        const loading = loadingFactory()
-        const tasks = functions.map((func) => async () => {
-            loading.start('云函数部署中')
-            try {
-                await createFunction({
-                    func,
-                    envId,
-                    force,
-                    codeSecret,
-                    functionRootPath,
-                    accessPath: access
-                })
-                loading.succeed(`[${func.name}] 云函数部署成功`)
-            } catch (e) {
-                loading.stop()
-                await this.handleDeployFail(e, {
-                    func,
-                    envId,
-                    codeSecret,
-                    functionRootPath,
-                    accessPath: access
-                })
-            }
-        })
-
-        if (tasks.length > 5) {
-            logger.info('函数数量较多，将使用队列部署')
-        }
-
-        // 控制函数创建并发
-        const asyncTaskController = new AsyncTaskParallelController(5, 50)
-        asyncTaskController.loadTasks(tasks)
-        const results = await asyncTaskController.run()
-
-        // 输出信息
-        const success = results.filter((_) => !_)
-        logger.success(`成功部署 ${success?.length} 个函数`)
-        // 部署失败
-        const err = results.filter((_) => _)
-        err?.length && logger.error(`${err?.length} 个云函数部署失败`)
-    }
-
-    async handleDeployFail(e: CloudBaseError, options: ICreateFunctionOptions) {
-        const { envId, codeSecret, functionRootPath, func, functionPath, accessPath } = options
-        const loading = loadingFactory()
-
-        if (e.code === 'ResourceInUse.FunctionName' || e.code === 'ResourceInUse.Function') {
-            const { force } = await inquirer.prompt({
-                type: 'confirm',
-                name: 'force',
-                message: `存在同名云函数：[${func.name}]，是否覆盖原函数代码与配置`,
-                default: false
-            })
-
-            if (force) {
-                loading.start('云函数部署中...')
-                try {
-                    await createFunction({
-                        func,
-                        envId,
-                        codeSecret,
-                        accessPath,
-                        force: true,
-                        functionPath,
-                        functionRootPath
-                    })
-                    loading.succeed(`[${func.name}] 云函数部署成功！`)
-                    // await genApiGateway(envId, name)
-                    await this.printSuccessTips(envId)
-                } catch (e) {
-                    loading.stop()
-                    throw e
-                }
-                return
-            }
-        }
-
-        throw e
-    }
-
-    @InjectParams()
-    async printSuccessTips(envId: string, @Log() log?: Logger) {
-        let url = `https://console.cloud.tencent.com/tcb/scf?envId=${envId}`
-        const region = await getRegion()
-        url += `&rid=${regionIdMap[region]}`
-        const link = genClickableLink(url)
-        log.breakLine()
-        log.info(`控制台查看函数详情或创建HTTP 访问服务链接 🔗：${link}`)
-        log.info(`使用 ${highlightCommand('cloudbase functions:list')} 命令查看已部署云函数`)
-    }
-
-    // 创建函数 API 网关
-    async genApiGateway(envId: string, name: string) {
-        const loading = loadingFactory()
-        // 检查是否绑定了 HTTP 网关
-        const res = await queryGateway({
-            name,
-            envId
-        })
-        // 未开启，不生成 HTTP 调用了链接
-        if (res?.EnableService === false) return
-        loading.start('生成云函数HTTP 访问服务中...')
-
-        let path
-        if (res?.APISet?.length > 0) {
-            path = res.APISet[0]?.Path
-        } else {
-            path = `/${random(12)}`
-            await createGateway({
-                envId,
-                name,
-                path
-            })
-        }
-        loading.stop()
-        const link = genClickableLink(`https://${envId}.service.tcloudbase.com${path}`)
-        console.log(`\n云函数HTTP 访问服务链接：${link}`)
-    }
-}