@cloudbase/cli 2.0.3 → 2.0.5

package/src/function/concurrency.ts

@@ -1,57 +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
-        })
-    }
-}
-
+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 +1,78 @@
-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)
-}
+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 +1,42 @@
-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)
-}
+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 +1,11 @@
-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 './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 +1,68 @@
-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
-    })
-}
+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 +1,63 @@
-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
-        }
-    })
-}
+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
+        }
+    })
+}