@cloudbase/cli 2.0.12 → 2.1.0

package/src/function/base.ts

@@ -1,253 +0,0 @@
-import CloudBase from '@cloudbase/manager-node'
-import { CloudApiService, checkAndGetCredential, getProxy } from '../utils'
-import { successLog } from '../logger'
-import {
-    IListFunctionOptions,
-    IFunctionLogOptions,
-    IUpdateFunctionConfigOptions,
-    IFunctionBatchOptions,
-    InvokeFunctionOptions
-} from '../types'
-import { CloudBaseError } from '../error'
-import { getVpcs, getSubnets } from './vpc'
-import { getRegion } from '@cloudbase/toolbox'
-
-export interface IBaseOptions {
-    envId: string
-    functionName: string
-}
-
-export interface ICopyFunctionOptions {
-    envId: string
-    functionName: string
-    newFunctionName: string
-    targetEnvId: string
-    force?: boolean
-    copyConfig?: boolean
-    codeSecret?: string
-}
-
-const scfService = CloudApiService.getInstance('scf')
-export interface IDetailOptions extends IBaseOptions {
-    codeSecret?: string
-}
-
-export async function getFunctionService(envId: string) {
-    const region = await getRegion()
-    const { secretId, secretKey, token } = await checkAndGetCredential(true)
-
-    const app = new CloudBase({
-        region,
-        token,
-        envId,
-        secretId,
-        secretKey,
-        proxy: getProxy()
-    })
-    return app.functions
-}
-
-// 列出函数
-export async function listFunction(
-    options: IListFunctionOptions
-): Promise<Record<string, string>[]> {
-    const { limit = 20, offset = 0, envId } = options
-    const res: any = await scfService.request('ListFunctions', {
-        Namespace: envId,
-        Limit: limit,
-        Offset: offset
-    })
-    const { Functions = [] } = res
-    const data: Record<string, string>[] = []
-    Functions.forEach(func => {
-        const { FunctionId, FunctionName, Runtime, AddTime, ModTime, Status } = func
-        data.push({
-            FunctionId,
-            FunctionName,
-            Runtime,
-            AddTime,
-            ModTime,
-            Status
-        })
-    })
-
-    return data
-}
-
-// 获取云函数详细信息
-export async function getFunctionDetail(options: IDetailOptions): Promise<Record<string, any>> {
-    const { functionName, envId, codeSecret } = options
-
-    const res = await scfService.request('GetFunction', {
-        FunctionName: functionName,
-        Namespace: envId,
-        ShowCode: 'TRUE',
-        CodeSecret: codeSecret
-    })
-
-    const data: Record<string, any> = res
-
-    // 获取 VPC 信息
-    const { VpcId = '', SubnetId = '' } = data.VpcConfig || {}
-    if (VpcId && SubnetId) {
-        try {
-            const vpcs = await getVpcs()
-            const subnets = await getSubnets(VpcId)
-            const vpc = vpcs.find(item => item.VpcId === VpcId)
-            const subnet = subnets.find(item => item.SubnetId === SubnetId)
-            data.VpcConfig = {
-                vpc,
-                subnet
-            }
-        } catch (e) {
-            // 无法获取到 VPC 配置，只展示 id 信息
-            data.VpcConfig = {
-                vpc: VpcId,
-                subnet: SubnetId
-            }
-        }
-    }
-    return data
-}
-
-// 批量获取函数信息
-export async function batchGetFunctionsDetail({
-    names,
-    envId,
-    codeSecret
-}): Promise<Record<string, string>[]> {
-    const data: Record<string, string>[] = []
-    const promises = names.map(name =>
-        (async () => {
-            try {
-                const info = await getFunctionDetail({
-                    envId,
-                    codeSecret,
-                    functionName: name
-                })
-                data.push(info)
-            } catch (e) {
-                throw new CloudBaseError(`${name} 获取信息失败：${e.message}`)
-            }
-        })()
-    )
-
-    await Promise.all(promises)
-
-    return data
-}
-
-// 获取函数日志
-export async function getFunctionLog(
-    options: IFunctionLogOptions
-): Promise<Record<string, string>[]> {
-    const { envId } = options
-
-    const params = {
-        Namespace: envId
-    }
-
-    Object.keys(options).forEach(key => {
-        if (key === 'envId') return
-        const keyFirstCharUpperCase = key.charAt(0).toUpperCase() + key.slice(1)
-        params[keyFirstCharUpperCase] = options[key]
-    })
-
-    const { Data = [] }: any = await scfService.request('GetFunctionLogs', params)
-    return Data
-}
-
-// 更新函数配置
-export async function updateFunctionConfig(options: IUpdateFunctionConfigOptions): Promise<void> {
-    const { functionName, config, envId } = options
-
-    const functionService = await getFunctionService(envId)
-    await functionService.updateFunctionConfig({
-        name: functionName,
-        ...config
-    })
-}
-
-// 批量更新函数配置
-export async function batchUpdateFunctionConfig(options: IFunctionBatchOptions): Promise<void> {
-    const { functions, envId, log } = options
-    const promises = functions.map(func =>
-        (async () => {
-            try {
-                await updateFunctionConfig({
-                    functionName: func.name,
-                    config: func,
-                    envId
-                })
-                log && successLog(`[${func.name}] 更新云函数配置成功！`)
-            } catch (e) {
-                throw new CloudBaseError(`${func.name} 更新配置失败：${e.message}`)
-            }
-        })()
-    )
-
-    await Promise.all(promises)
-}
-
-// 调用函数
-export async function invokeFunction(options: InvokeFunctionOptions) {
-    const { functionName, envId, params = {} } = options
-
-    const _params = {
-        FunctionName: functionName,
-        Namespace: envId,
-        ClientContext: JSON.stringify(params),
-        LogType: 'Tail'
-    }
-
-    try {
-        const { Result } = await scfService.request('Invoke', _params)
-        return Result
-    } catch (e) {
-        throw new CloudBaseError(`[${functionName}] 调用失败：\n${e.message}`)
-    }
-}
-
-// 批量触发云函数
-export async function batchInvokeFunctions(options: IFunctionBatchOptions) {
-    const { functions, envId, log = false } = options
-
-    const promises = functions.map(func =>
-        (async () => {
-            try {
-                const result = await invokeFunction({
-                    functionName: func.name,
-                    params: func.params,
-                    envId
-                })
-                if (log) {
-                    successLog(`[${func.name}] 调用成功\n响应结果：\n`)
-                    console.log(result)
-                }
-                return result
-            } catch (e) {
-                throw new CloudBaseError(`${func.name} 函数调用失败：${e.message}`)
-            }
-        })()
-    )
-
-    return Promise.all(promises)
-}
-
-// 复制云函数
-export async function copyFunction(options: ICopyFunctionOptions) {
-    const { envId, functionName, newFunctionName, targetEnvId, force, codeSecret } = options
-
-    if (!envId || !functionName || !newFunctionName) {
-        throw new CloudBaseError('参数缺失')
-    }
-
-    await scfService.request('CopyFunction', {
-        FunctionName: functionName,
-        NewFunctionName: newFunctionName,
-        Namespace: envId,
-        TargetNamespace: targetEnvId || envId,
-        Override: force ? true : false,
-        CodeSecret: codeSecret
-    })
-}

package/src/function/code.ts

@@ -1,55 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-import unzipper from 'unzipper'
-import { CloudApiService, fetchStream, delSync, checkFullAccess } from '../utils'
-
-interface IFunctionCodeOptions {
-    envId: string
-    destPath: string
-    functionName: string
-    codeSecret?: string
-    unzip?: boolean
-}
-
-const scfService = CloudApiService.getInstance('scf')
-
-// 下载函数代码
-export async function downloadFunctionCode(options: IFunctionCodeOptions) {
-    const { destPath, envId, functionName, codeSecret, unzip = false } = options
-
-    // 检验路径是否存在
-    checkFullAccess(destPath, true)
-
-    // 获取下载链接
-    const { Url } = await scfService.request('GetFunctionAddress', {
-        FunctionName: functionName,
-        Namespace: envId,
-        CodeSecret: codeSecret
-    })
-
-    // 下载文件
-    const res = await fetchStream(Url)
-    const zipPath = path.join(destPath, `${functionName}.zip`)
-    const dest = fs.createWriteStream(zipPath)
-    res.body.pipe(dest)
-    return new Promise<void>(resolve => {
-        // 解压文件
-        dest.on('close', () => {
-            // 不解压 ZIP 文件
-            if (!unzip) {
-                resolve()
-                return
-            }
-
-            const unzipStream = unzipper.Extract({
-                path: destPath
-            })
-            fs.createReadStream(zipPath).pipe(unzipStream)
-            unzipStream.on('close', () => {
-                // 删除 ZIP 文件
-                delSync([zipPath])
-                resolve()
-            })
-        })
-    })
-}

package/src/function/concurrency.ts

@@ -1,57 +0,0 @@
-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/create.ts

@@ -1,78 +0,0 @@
-import { loadingFactory } from '../utils'
-import { CloudBaseError } from '../error'
-import { getFunctionService } from './base'
-import { ICreateFunctionOptions, ICloudFunction } from '../types'
-
-// 创建云函数
-export async function createFunction(options: ICreateFunctionOptions): Promise<void> {
-    const {
-        envId,
-        accessPath,
-        codeSecret,
-        force = false,
-        functionPath,
-        base64Code = '',
-        functionRootPath = ''
-    } = options
-
-    // 兼容处理 config
-    const func: ICloudFunction & { path?: string } = {
-        ...options?.func?.config,
-        ...options.func
-    }
-
-    // 覆盖默认的路径
-    accessPath && (func.path = accessPath)
-
-    const funcName = func.name
-
-    const scfService = await getFunctionService(envId)
-
-    func.isWaitInstall = true
-
-    try {
-        await scfService.createFunction({
-            func,
-            force,
-            base64Code,
-            codeSecret,
-            functionPath,
-            functionRootPath
-        })
-    } catch (e) {
-        // 不强制覆盖，抛出错误
-        if (e.message && !force) {
-            throw new CloudBaseError(`[${funcName}] 部署失败，${e.message}`, {
-                code: e.code,
-                original: e
-            })
-        }
-        throw e
-    }
-}
-
-// 批量创建云函数
-export async function batchCreateFunctions(options: ICreateFunctionOptions): Promise<void> {
-    const { functions, functionRootPath = '', envId, force, codeSecret, log = false } = options
-    const promises = functions.map((func) =>
-        (async () => {
-            const loading = loadingFactory()
-            try {
-                log && loading.start(`[${func.name}] 函数部署中...`)
-                await createFunction({
-                    func,
-                    envId,
-                    force,
-                    codeSecret,
-                    functionRootPath
-                })
-                log && loading.succeed(`[${func.name}] 函数部署成功`)
-            } catch (e) {
-                log && loading.fail(`[${func.name}] 函数部署失败`)
-                throw new CloudBaseError(e.message)
-            }
-        })()
-    )
-
-    await Promise.all(promises)
-}

package/src/function/delete.ts

@@ -1,42 +0,0 @@
-import { successLog } from '../logger'
-import { CloudBaseError } from '../error'
-import { CloudApiService } from '../utils'
-import { queryGateway, deleteGateway } from '../gateway'
-
-const scfService = CloudApiService.getInstance('scf')
-
-// 删除函数
-export async function deleteFunction({ functionName, envId }): Promise<void> {
-    // 检测是否绑定了 API 网关
-    const res = await queryGateway({
-        envId,
-        name: functionName
-    })
-    // 删除绑定的 API 网关
-    if (res?.APISet?.length > 0) {
-        await deleteGateway({
-            envId,
-            name: functionName
-        })
-    }
-    await scfService.request('DeleteFunction', {
-        FunctionName: functionName,
-        Namespace: envId
-    })
-}
-
-// 批量删除云函数
-export async function batchDeleteFunctions({ names, envId }): Promise<void> {
-    const promises = names.map(name =>
-        (async () => {
-            try {
-                await deleteFunction({ functionName: name, envId })
-                successLog(`[${name}] 函数删除成功！`)
-            } catch (e) {
-                throw new CloudBaseError(e.message)
-            }
-        })()
-    )
-
-    await Promise.all(promises)
-}

package/src/function/index.ts

@@ -1,11 +0,0 @@
-export * from './create'
-export * from './trigger'
-export * from './code'
-export * from './base'
-export * from './delete'
-export * from './update'
-export * from './layer'
-export * from './vpc'
-export * from './version'
-export * from './concurrency'
-export * from './alias'

package/src/function/layer/attach.ts

@@ -1,68 +0,0 @@
-import _ from 'lodash'
-import { getFunctionDetail } from '../base'
-import { CloudApiService } from '../../utils'
-import { CloudBaseError } from '../../error'
-
-const scfService = new CloudApiService('scf')
-
-export interface IAttachOptions {
-    envId: string
-    layerName: string
-    layerVersion: number
-    functionName: string
-    codeSecret?: string
-}
-
-// 函数绑定文件层
-export async function attachLayer(options: IAttachOptions): Promise<void> {
-    const { envId, functionName, layerName, layerVersion, codeSecret } = options
-
-    let { Layers } = await getFunctionDetail({
-        envId,
-        codeSecret,
-        functionName
-    })
-
-    Layers = Layers.map(item => _.pick(item, ['LayerName', 'LayerVersion']))
-    // 新加的文件层添加到最后
-    Layers.push({
-        LayerName: layerName,
-        LayerVersion: layerVersion
-    })
-    const res = await scfService.request('UpdateFunctionConfiguration', {
-        Layers,
-        Namespace: envId,
-        FunctionName: functionName
-    })
-    return res
-}
-
-// 函数解绑文件层
-export async function unAttachLayer(options: IAttachOptions): Promise<void> {
-    const { envId, functionName, layerName, layerVersion, codeSecret } = options
-
-    let { Layers } = await getFunctionDetail({
-        envId,
-        codeSecret,
-        functionName
-    })
-
-    Layers = Layers.map(item => _.pick(item, ['LayerName', 'LayerVersion']))
-
-    const index = Layers.findIndex(
-        item => item.LayerName === layerName && item.LayerVersion === layerVersion
-    )
-
-    if (index === -1) {
-        throw new CloudBaseError('层不存在')
-    }
-
-    // 删除指定的层
-    Layers.splice(index, 1)
-
-    return scfService.request('UpdateFunctionConfiguration', {
-        Layers,
-        Namespace: envId,
-        FunctionName: functionName
-    })
-}

package/src/function/layer/create.ts

@@ -1,63 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-import { CloudBaseError, zipDir } from '@cloudbase/toolbox'
-import { CloudApiService, checkFullAccess, isDirectory, delSync } from '../../utils'
-
-const scfService = new CloudApiService('scf')
-
-export interface IFunctionLayerOptions {
-    contentPath?: string
-    base64Content?: string
-    layerName: string
-    // 支持的运行时
-    runtimes: string[]
-}
-
-// 创建文件层
-export async function createLayer(options: IFunctionLayerOptions): Promise<void> {
-    const { contentPath = '', layerName, base64Content = '', runtimes = [] } = options
-
-    checkFullAccess(contentPath)
-
-    const validRuntime = ['Nodejs8.9', 'Php7', 'Java8']
-    if (runtimes.some(item => validRuntime.indexOf(item) === -1)) {
-        throw new CloudBaseError(
-            `Invalid runtime value. Now only support: ${validRuntime.join(', ')}`
-        )
-    }
-
-    let base64
-
-    if (base64Content) {
-        base64 = base64Content
-    } else if (isDirectory(contentPath)) {
-        // 压缩文件夹
-        const dirName = path.parse(contentPath).name
-        const dest = path.join(process.cwd(), `cli-${dirName}.zip`)
-        // ZIP 文件存在，删除 ZIP 文件
-        if (checkFullAccess(dest)) {
-            delSync(dest)
-        }
-        await zipDir(contentPath, dest)
-        // 转换成 base64
-        const fileBuffer = await fs.promises.readFile(dest)
-        base64 = fileBuffer.toString('base64')
-        delSync(dest)
-    } else {
-        const fileType = path.extname(contentPath)
-        if (fileType !== '.zip') {
-            throw new CloudBaseError('文件类型不正确，目前只支持 ZIP 文件！')
-        }
-        const fileBuffer = await fs.promises.readFile(contentPath)
-        base64 = fileBuffer.toString('base64')
-    }
-
-    return scfService.request('PublishLayerVersion', {
-        LayerName: layerName,
-        CompatibleRuntimes: runtimes,
-        Content: {
-            // 最大支持 20M
-            ZipFile: base64
-        }
-    })
-}

package/src/function/layer/delete.ts

@@ -1,21 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-import { CloudBaseError } from '../../error'
-import { CloudApiService } from '../../utils'
-
-const scfService = new CloudApiService('scf')
-
-export interface ILayerDeleteOptions {
-    name: string
-    version: number
-}
-
-// 创建文件层
-export async function deleteLayer(options: ILayerDeleteOptions): Promise<void> {
-    const { name, version } = options
-
-    return scfService.request('DeleteLayerVersion', {
-        LayerName: name,
-        LayerVersion: version
-    })
-}