@cloudbase/manager-node 3.11.0 → 3.12.1

package/lib/function/index.js

@@ -628,6 +628,121 @@ class FunctionService {
             LayerVersion: version
         });
     }
+    /**
+     * 设置预置并发
+     * @private
+     * @param {IProvisionedConcurrencyConfig} concurrencyConfig
+     * @returns
+     * @memberof FunctionService
+     */
+    async setProvisionedConcurrencyConfig(concurrencyConfig) {
+        const { namespace } = this.getFunctionConfig();
+        const { functionName: FunctionName, qualifier: Qualifier, versionProvisionedConcurrencyNum: VersionProvisionedConcurrencyNum } = concurrencyConfig;
+        return this.scfService.request('PutProvisionedConcurrencyConfig', {
+            FunctionName,
+            Qualifier,
+            VersionProvisionedConcurrencyNum,
+            Namespace: namespace
+        });
+    }
+    /**
+     * 获取函数预置并发详情
+     * @private
+     * @param {IGetProvisionedConcurrencyConfig} concurrencyConfig
+     * @returns {Promise<IGetProvisionedConcurrencyRes>}
+     * @memberof FunctionService
+     */
+    async getProvisionedConcurrencyConfig(concurrencyConfig) {
+        const { namespace } = this.getFunctionConfig();
+        const { functionName: FunctionName, qualifier: Qualifier } = concurrencyConfig;
+        return this.scfService.request('GetProvisionedConcurrencyConfig', {
+            FunctionName,
+            Qualifier,
+            Namespace: namespace
+        });
+    }
+    /**
+     * 删除预置并发
+     * @private
+     * @param {IGetProvisionedConcurrencyConfig} concurrencyConfig
+     * @returns {Promise<IResponseInfo>}
+     * @memberof FunctionService
+     */
+    async deleteProvisionedConcurrencyConfig(concurrencyConfig) {
+        const { namespace } = this.getFunctionConfig();
+        const { functionName: FunctionName, qualifier: Qualifier } = concurrencyConfig;
+        return this.scfService.request('DeleteProvisionedConcurrencyConfig', {
+            FunctionName,
+            Qualifier,
+            Namespace: namespace
+        });
+    }
+    /**
+     * 发布新版本
+     * @param {IPublishVersionParams} publishParams
+     * @returns {Promise<IPublishVersionRes>}
+     * @memberof FunctionService
+     */
+    async publishVersion(publishParams) {
+        const { namespace } = this.getFunctionConfig();
+        const { functionName: FunctionName, description: Description } = publishParams;
+        return this.scfService.request('PublishVersion', {
+            FunctionName,
+            Description,
+            Namespace: namespace
+        });
+    }
+    /**
+     * 查询函数版本详情
+     * @param {IListFunctionVersionParams} listVersionParams
+     * @returns {Promise<IFunctionVersionsRes>}
+     * @memberof FunctionService
+     */
+    async listVersionByFunction(listVersionParams) {
+        const { namespace } = this.getFunctionConfig();
+        const { functionName: FunctionName, offset: Offset, limit: Limit, order: Order, orderBy: OrderBy } = listVersionParams;
+        return this.scfService.request('ListVersionByFunction', {
+            FunctionName,
+            Namespace: namespace,
+            Offset,
+            Limit,
+            Order,
+            OrderBy
+        });
+    }
+    /**
+     *
+     * @param {IUpdateFunctionAliasConfig} updateVersionConfigParams
+     * @returns {Promise<IResponseInfo>}
+     * @memberof FunctionService
+     */
+    async updateFunctionAliasConfig(updateVersionConfigParams) {
+        const { namespace } = this.getFunctionConfig();
+        const { functionName: FunctionName, name: Name, functionVersion: FunctionVersion, routingConfig: RoutingConfig, description: Description } = updateVersionConfigParams;
+        return this.scfService.request('UpdateAlias', {
+            FunctionName,
+            Name,
+            Namespace: namespace,
+            FunctionVersion,
+            RoutingConfig,
+            Description
+        });
+    }
+    /**
+     * 查询函数别名详情
+     * @param {IGetFunctionAlias} params
+     * @returns {Promise<IGetFunctionAliasRes>}
+     * @memberof FunctionService
+     */
+    async getFunctionAlias(params) {
+        const { namespace } = this.getFunctionConfig();
+        const { functionName: FunctionName, name: Name } = params;
+        return this.scfService.request('GetAlias', {
+            FunctionName,
+            Name,
+            Namespace: namespace
+        });
+    }
     async createAccessPath(name, path) {
         const access = this.environment.getAccessService();
         try {
@@ -856,6 +971,27 @@ __decorate([
 __decorate([
     utils_1.preLazy()
 ], FunctionService.prototype, "getLayerVersion", null);
+__decorate([
+    utils_1.preLazy()
+], FunctionService.prototype, "setProvisionedConcurrencyConfig", null);
+__decorate([
+    utils_1.preLazy()
+], FunctionService.prototype, "getProvisionedConcurrencyConfig", null);
+__decorate([
+    utils_1.preLazy()
+], FunctionService.prototype, "deleteProvisionedConcurrencyConfig", null);
+__decorate([
+    utils_1.preLazy()
+], FunctionService.prototype, "publishVersion", null);
+__decorate([
+    utils_1.preLazy()
+], FunctionService.prototype, "listVersionByFunction", null);
+__decorate([
+    utils_1.preLazy()
+], FunctionService.prototype, "updateFunctionAliasConfig", null);
+__decorate([
+    utils_1.preLazy()
+], FunctionService.prototype, "getFunctionAlias", null);
 __decorate([
     utils_1.preLazy()
 ], FunctionService.prototype, "createAccessPath", null);

package/lib/storage/index.js

@@ -382,27 +382,32 @@ class StorageService {
      * @returns {Promise<(NodeJS.ReadableStream | string)[]>}
      */
     async downloadDirectory(options) {
-        const { cloudPath, localPath } = options;
+        const { cloudPath, localPath, parallel = 20 } = options;
         const resolveLocalPath = path_1.default.resolve(localPath);
         utils_1.checkFullAccess(resolveLocalPath, true);
         const cloudDirectoryKey = this.getCloudKey(cloudPath);
         const files = await this.walkCloudDir(cloudDirectoryKey);
-        const promises = files.map(async (file) => {
-            const fileRelativePath = file.Key.replace(cloudDirectoryKey, '');
-            // 空路径和文件夹跳过
-            if (!fileRelativePath || /\/$/g.test(fileRelativePath)) {
-                return;
-            }
-            const localFilePath = path_1.default.join(resolveLocalPath, fileRelativePath);
-            // 创建文件的父文件夹
-            const fileDir = path_1.default.dirname(localFilePath);
-            await make_dir_1.default(fileDir);
-            return this.downloadFile({
-                cloudPath: file.Key,
-                localPath: localFilePath
-            });
+        const promises = files.map(file => async () => {
+            return this.downloadWithFilePath({ file, cloudDirectoryKey, resolveLocalPath });
         });
-        return Promise.all(promises);
+        const asyncTaskController = new parallel_1.AsyncTaskParallelController(parallel, 50);
+        asyncTaskController.loadTasks(promises);
+        let res = await asyncTaskController.run();
+        const errorIndexArr = [];
+        res.map((item, index) => /Error/gi.test(Object.prototype.toString.call(item)) && errorIndexArr.push(index));
+        // 重试逻辑
+        if (errorIndexArr.length) {
+            const errorFiles = errorIndexArr.map(errorIndex => files[errorIndex]);
+            asyncTaskController.loadTasks(errorFiles.map(file => async () => {
+                return this.downloadWithFilePath({ file, cloudDirectoryKey, resolveLocalPath });
+            }));
+            res = await asyncTaskController.run();
+        }
+        const errorResultArr = this.determineDownLoadResultIsError(res);
+        if (errorResultArr.length) {
+            throw errorResultArr[0];
+        }
+        return res;
     }
     /**
      * 列出文件夹下的文件
@@ -889,27 +894,73 @@ class StorageService {
     async uploadFilesWithRetry({ uploadFiles, options, times, interval, failedFiles }) {
         const { files, onFileFinish } = options;
         const tempFailedFiles = [];
+        let curError = null;
         const res = await uploadFiles(Object.assign(Object.assign({}, options), { files: failedFiles.length
                 ? files.filter(file => failedFiles.includes(file.Key))
                 : files, onFileFinish: (...args) => {
                 const error = args[0];
                 const fileInfo = args[2];
                 if (error) {
+                    curError = error;
                     tempFailedFiles.push(fileInfo.Key);
                 }
                 onFileFinish === null || onFileFinish === void 0 ? void 0 : onFileFinish.apply(null, args);
             } }));
-        if (!(tempFailedFiles === null || tempFailedFiles === void 0 ? void 0 : tempFailedFiles.length) || times <= 0)
+        // if (!tempFailedFiles?.length || times <= 0) return res
+        if (!(tempFailedFiles === null || tempFailedFiles === void 0 ? void 0 : tempFailedFiles.length)) {
             return res;
-        if (times > 0) {
-            setTimeout(() => this.uploadFilesWithRetry({
-                uploadFiles,
-                options,
-                times: times - 1,
-                interval,
-                failedFiles: tempFailedFiles
-            }), interval);
         }
+        else {
+            if (times > 0) {
+                return await new Promise((resolve, reject) => {
+                    setTimeout(() => this.uploadFilesWithRetry({
+                        uploadFiles,
+                        options,
+                        times: times - 1,
+                        interval,
+                        failedFiles: tempFailedFiles
+                    }).then(res => resolve(res))
+                        .catch(err => reject(err)), interval);
+                });
+            }
+            else {
+                if (curError) {
+                    throw curError;
+                }
+            }
+        }
+    }
+    /**
+     * 拼接路径下载单文件
+     * @param file
+     * @param cloudDirectoryKey
+     * @param resolveLocalPath
+     * @returns
+     */
+    async downloadWithFilePath({ file, cloudDirectoryKey, resolveLocalPath }) {
+        const fileRelativePath = file.Key.replace(cloudDirectoryKey, '');
+        // 空路径和文件夹跳过
+        if (!fileRelativePath || /\/$/g.test(fileRelativePath)) {
+            return;
+        }
+        const localFilePath = path_1.default.join(resolveLocalPath, fileRelativePath);
+        // 创建文件的父文件夹
+        const fileDir = path_1.default.dirname(localFilePath);
+        await make_dir_1.default(fileDir);
+        return this.downloadFile({
+            cloudPath: file.Key,
+            localPath: localFilePath
+        });
+    }
+    /**
+     * 根据下载结果返回错误列表
+     * @param res
+     * @returns
+     */
+    determineDownLoadResultIsError(res) {
+        const resultErrorArr = [];
+        res.map(item => /Error/gi.test(Object.prototype.toString.call(item)) && resultErrorArr.push(item));
+        return resultErrorArr;
     }
 }
 __decorate([

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cloudbase/manager-node",
-    "version": "3.11.0",
+    "version": "3.12.1",
     "description": "The node manage service api for cloudbase.",
     "main": "lib/index.js",
     "scripts": {

package/src/function/index.ts

@@ -126,6 +126,107 @@ export interface IGetLayerVersionRes extends IResponseInfo {
     Status: string // 	层的具体版本当前状态
 }
 
+export interface ISetProvisionedConcurrencyConfig {
+    functionName: string
+    qualifier: string
+    versionProvisionedConcurrencyNum: number
+}
+
+export interface IGetProvisionedConcurrencyConfig {
+    functionName: string
+    qualifier?: string
+}
+
+export interface IVersionProvisionedConcurrencyInfo {
+    AllocatedProvisionedConcurrencyNum: number // 设置的预置并发数。
+    AvailableProvisionedConcurrencyNum: number // 当前已完成预置的并发数。
+    Status: string // 预置任务状态，Done表示已完成，InProgress表示进行中，Failed表示部分或全部失败。
+    StatusReason: string // 对预置任务状态Status的说明。
+    Qualifier: string // 版本号
+}
+export interface IGetProvisionedConcurrencyRes extends IResponseInfo {
+    UnallocatedConcurrencyNum: number
+    Allocated: IVersionProvisionedConcurrencyInfo[]
+}
+
+export interface IPublishVersionParams {
+    functionName: string
+    description?: string
+}
+
+export interface IPublishVersionRes extends IResponseInfo {
+    FunctionVersion: string
+    CodeSize: number
+    MemorySize: number
+    Description: string
+    Handler: string
+    Timeout: number
+    Runtime: string
+    Namespace: string
+}
+
+
+export interface IListFunctionVersionParams {
+    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 extends IResponseInfo {
+    FunctionVersion: string[]
+    Versions: IFunctionVersion[]
+    TotalCount: number
+}
+
+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 IRoutingConfig {
+    AdditionalVersionWeights?: IVersionWeight[]
+    AddtionVersionMatchs?: IVersionMatch[]
+}
+
+export interface IUpdateFunctionAliasConfig {
+    functionName: string // 函数名
+    name: string // 函数别名 如$DEFAULT
+    functionVersion: string // 函数版本
+    description?: string // 别名描述
+    routingConfig?: IRoutingConfig
+}
+
+export interface IGetFunctionAlias {
+    functionName: string // 函数名称
+    name: string // 别名
+}
+
+export interface IGetFunctionAliasRes extends IResponseInfo {
+    FunctionVersion: string
+    Name: string
+    RoutingConfig: IRoutingConfig
+    Description: string
+    AddTime: string
+    ModTime: string
+}
+
 // 是否为 Node 函数
 function isNodeFunction(runtime: string) {
     // 不严格限制
@@ -913,6 +1014,142 @@ export class FunctionService {
         })
     }
 
+    /**
+     * 设置预置并发
+     * @private
+     * @param {IProvisionedConcurrencyConfig} concurrencyConfig
+     * @returns
+     * @memberof FunctionService
+     */
+    @preLazy()
+    public async setProvisionedConcurrencyConfig(concurrencyConfig: ISetProvisionedConcurrencyConfig): Promise<IResponseInfo> {
+        const { namespace } = this.getFunctionConfig()
+        const { functionName: FunctionName, qualifier: Qualifier, versionProvisionedConcurrencyNum: VersionProvisionedConcurrencyNum } = concurrencyConfig
+
+        return this.scfService.request('PutProvisionedConcurrencyConfig', {
+            FunctionName,
+            Qualifier,
+            VersionProvisionedConcurrencyNum,
+            Namespace: namespace
+        })
+    }
+
+    /**
+     * 获取函数预置并发详情
+     * @private
+     * @param {IGetProvisionedConcurrencyConfig} concurrencyConfig
+     * @returns {Promise<IGetProvisionedConcurrencyRes>}
+     * @memberof FunctionService
+     */
+    @preLazy()
+    public async getProvisionedConcurrencyConfig(concurrencyConfig: IGetProvisionedConcurrencyConfig): Promise<IGetProvisionedConcurrencyRes> {
+        const { namespace } = this.getFunctionConfig()
+        const { functionName: FunctionName, qualifier: Qualifier } = concurrencyConfig
+
+        return this.scfService.request('GetProvisionedConcurrencyConfig', {
+            FunctionName,
+            Qualifier,
+            Namespace: namespace
+        })
+    }
+
+    /**
+     * 删除预置并发
+     * @private
+     * @param {IGetProvisionedConcurrencyConfig} concurrencyConfig
+     * @returns {Promise<IResponseInfo>}
+     * @memberof FunctionService
+     */
+    @preLazy()
+    public async deleteProvisionedConcurrencyConfig(concurrencyConfig: IGetProvisionedConcurrencyConfig): Promise<IResponseInfo> {
+        const { namespace } = this.getFunctionConfig()
+        const { functionName: FunctionName, qualifier: Qualifier } = concurrencyConfig
+
+        return this.scfService.request('DeleteProvisionedConcurrencyConfig', {
+            FunctionName,
+            Qualifier,
+            Namespace: namespace
+        })
+    }
+
+    /**
+     * 发布新版本
+     * @param {IPublishVersionParams} publishParams
+     * @returns {Promise<IPublishVersionRes>}
+     * @memberof FunctionService
+     */
+    @preLazy()
+    public async publishVersion(publishParams: IPublishVersionParams): Promise<IPublishVersionRes> {
+        const { namespace } = this.getFunctionConfig()
+        const { functionName: FunctionName, description: Description } = publishParams
+
+        return this.scfService.request('PublishVersion', {
+            FunctionName,
+            Description,
+            Namespace: namespace
+        })
+    }
+
+    /**
+     * 查询函数版本详情
+     * @param {IListFunctionVersionParams} listVersionParams
+     * @returns {Promise<IFunctionVersionsRes>}
+     * @memberof FunctionService
+     */
+    @preLazy()
+    public async listVersionByFunction(listVersionParams: IListFunctionVersionParams): Promise<IFunctionVersionsRes> {
+        const { namespace } = this.getFunctionConfig()
+        const { functionName: FunctionName, offset: Offset, limit: Limit, order: Order, orderBy: OrderBy } = listVersionParams
+
+        return this.scfService.request('ListVersionByFunction', {
+            FunctionName,
+            Namespace: namespace,
+            Offset,
+            Limit,
+            Order,
+            OrderBy
+        })
+    }
+
+    /**
+     *
+     * @param {IUpdateFunctionAliasConfig} updateVersionConfigParams
+     * @returns {Promise<IResponseInfo>}
+     * @memberof FunctionService
+     */
+    @preLazy()
+    public async updateFunctionAliasConfig(updateVersionConfigParams: IUpdateFunctionAliasConfig): Promise<IResponseInfo> {
+        const { namespace } = this.getFunctionConfig()
+        const { functionName: FunctionName, name: Name, functionVersion: FunctionVersion, routingConfig: RoutingConfig, description: Description } = updateVersionConfigParams
+
+        return this.scfService.request('UpdateAlias', {
+            FunctionName,
+            Name,
+            Namespace: namespace,
+            FunctionVersion,
+            RoutingConfig,
+            Description
+        })
+    }
+
+    /**
+     * 查询函数别名详情
+     * @param {IGetFunctionAlias} params
+     * @returns {Promise<IGetFunctionAliasRes>}
+     * @memberof FunctionService
+     */
+    @preLazy()
+    public async getFunctionAlias(params: IGetFunctionAlias): Promise<IGetFunctionAliasRes> {
+        const { namespace } = this.getFunctionConfig()
+        const { functionName: FunctionName, name: Name } = params
+
+        return this.scfService.request('GetAlias', {
+            FunctionName,
+            Name,
+            Namespace: namespace
+        })
+    }
+
     @preLazy()
     private async createAccessPath(name: string, path: string) {
         const access = this.environment.getAccessService()

package/src/storage/index.ts

@@ -62,7 +62,6 @@ export interface IFilesOptions extends IOptions {
     ignore?: string | string[]
     // 文件列表
     files: { localPath: string; cloudPath?: string }[]
-
     // 重试次数
     retryCount?: number
     // 重试时间间隔(毫秒)
@@ -146,8 +145,8 @@ export class StorageService {
      */
     @preLazy()
     public async uploadFiles(options: IFilesOptions): Promise<void> {
-        const { files, onProgress, parallel, onFileFinish, ignore, retryCount,
-            retryInterval } = options
+        const { files, onProgress, parallel, onFileFinish, ignore, retryCount, retryInterval } =
+            options
         const { bucket, region } = this.getStorageConfig()
 
         return this.uploadFilesCustom({
@@ -455,7 +454,6 @@ export class StorageService {
 
         const cos = this.getCos(parallel)
         const uploadFiles = Util.promisify(cos.uploadFiles).bind(cos)
-
         const params = {
             files: fileList,
             SliceSize: BIG_FILE_SIZE,
@@ -567,32 +565,42 @@ export class StorageService {
     public async downloadDirectory(options: {
         cloudPath: string
         localPath?: string
+        parallel?: number
     }): Promise<(NodeJS.ReadableStream | string)[]> {
-        const { cloudPath, localPath } = options
+        const { cloudPath, localPath, parallel = 20 } = options
         const resolveLocalPath = path.resolve(localPath)
 
         checkFullAccess(resolveLocalPath, true)
 
         const cloudDirectoryKey = this.getCloudKey(cloudPath)
         const files = await this.walkCloudDir(cloudDirectoryKey)
-
-        const promises = files.map(async file => {
-            const fileRelativePath = file.Key.replace(cloudDirectoryKey, '')
-            // 空路径和文件夹跳过
-            if (!fileRelativePath || /\/$/g.test(fileRelativePath)) {
-                return
-            }
-            const localFilePath = path.join(resolveLocalPath, fileRelativePath)
-            // 创建文件的父文件夹
-            const fileDir = path.dirname(localFilePath)
-            await makeDir(fileDir)
-            return this.downloadFile({
-                cloudPath: file.Key,
-                localPath: localFilePath
-            })
+        const promises = files.map(file => async () => {
+            return this.downloadWithFilePath({ file, cloudDirectoryKey, resolveLocalPath })
         })
+        const asyncTaskController = new AsyncTaskParallelController(parallel, 50)
+        asyncTaskController.loadTasks(promises)
+        let res = await asyncTaskController.run()
+        const errorIndexArr = []
 
-        return Promise.all(promises)
+        res.map(
+            (item, index) =>
+                /Error/gi.test(Object.prototype.toString.call(item)) && errorIndexArr.push(index)
+        )
+        // 重试逻辑
+        if (errorIndexArr.length) {
+            const errorFiles = errorIndexArr.map(errorIndex => files[errorIndex])
+            asyncTaskController.loadTasks(
+                errorFiles.map(file => async () => {
+                    return this.downloadWithFilePath({ file, cloudDirectoryKey, resolveLocalPath })
+                })
+            )
+            res = await asyncTaskController.run()
+        }
+        const errorResultArr = this.determineDownLoadResultIsError(res)
+        if (errorResultArr.length) {
+            throw errorResultArr[0]
+        }
+        return res
     }
 
     /**
@@ -1190,6 +1198,7 @@ export class StorageService {
     private async uploadFilesWithRetry({ uploadFiles, options, times, interval, failedFiles }) {
         const { files, onFileFinish } = options
         const tempFailedFiles = []
+        let curError: any = null
         const res = await uploadFiles({
             ...options,
             files: failedFiles.length
@@ -1199,24 +1208,74 @@ export class StorageService {
                 const error = args[0]
                 const fileInfo = (args as any)[2]
                 if (error) {
+                    curError = error
                     tempFailedFiles.push(fileInfo.Key)
                 }
                 onFileFinish?.apply(null, args)
             }
         })
-        if (!tempFailedFiles?.length || times <= 0) return res
-        if (times > 0) {
-            setTimeout(
-                () =>
-                    this.uploadFilesWithRetry({
-                        uploadFiles,
-                        options,
-                        times: times - 1,
-                        interval,
-                        failedFiles: tempFailedFiles
-                    }),
-                interval
-            )
+        // if (!tempFailedFiles?.length || times <= 0) return res
+
+        if (!tempFailedFiles?.length) {
+            return res
+        } else {
+            if (times > 0) {
+                return await new Promise((resolve, reject) => {
+                    setTimeout(
+                        () =>
+                            this.uploadFilesWithRetry({
+                                uploadFiles,
+                                options,
+                                times: times - 1,
+                                interval,
+                                failedFiles: tempFailedFiles
+                            }).then(res => resolve(res))
+                                .catch(err => reject(err)),
+                        interval
+                    )
+                })
+            } else {
+                if (curError) {
+                    throw curError
+                }
+            }
+        }
+    }
+
+    /**
+     * 拼接路径下载单文件
+     * @param file
+     * @param cloudDirectoryKey
+     * @param resolveLocalPath
+     * @returns
+     */
+    private async downloadWithFilePath({ file, cloudDirectoryKey, resolveLocalPath }) {
+        const fileRelativePath = file.Key.replace(cloudDirectoryKey, '')
+        // 空路径和文件夹跳过
+        if (!fileRelativePath || /\/$/g.test(fileRelativePath)) {
+            return
         }
+        const localFilePath = path.join(resolveLocalPath, fileRelativePath)
+        // 创建文件的父文件夹
+        const fileDir = path.dirname(localFilePath)
+        await makeDir(fileDir)
+        return this.downloadFile({
+            cloudPath: file.Key,
+            localPath: localFilePath
+        })
+    }
+
+    /**
+     * 根据下载结果返回错误列表
+     * @param res
+     * @returns
+     */
+    private determineDownLoadResultIsError(res) {
+        const resultErrorArr = []
+        res.map(
+            item =>
+                /Error/gi.test(Object.prototype.toString.call(item)) && resultErrorArr.push(item)
+        )
+        return resultErrorArr
     }
 }

package/types/function/index.d.ts

@@ -87,6 +87,92 @@ export interface IGetLayerVersionRes extends IResponseInfo {
     LayerName: string;
     Status: string;
 }
+export interface ISetProvisionedConcurrencyConfig {
+    functionName: string;
+    qualifier: string;
+    versionProvisionedConcurrencyNum: number;
+}
+export interface IGetProvisionedConcurrencyConfig {
+    functionName: string;
+    qualifier?: string;
+}
+export interface IVersionProvisionedConcurrencyInfo {
+    AllocatedProvisionedConcurrencyNum: number;
+    AvailableProvisionedConcurrencyNum: number;
+    Status: string;
+    StatusReason: string;
+    Qualifier: string;
+}
+export interface IGetProvisionedConcurrencyRes extends IResponseInfo {
+    UnallocatedConcurrencyNum: number;
+    Allocated: IVersionProvisionedConcurrencyInfo[];
+}
+export interface IPublishVersionParams {
+    functionName: string;
+    description?: string;
+}
+export interface IPublishVersionRes extends IResponseInfo {
+    FunctionVersion: string;
+    CodeSize: number;
+    MemorySize: number;
+    Description: string;
+    Handler: string;
+    Timeout: number;
+    Runtime: string;
+    Namespace: string;
+}
+export interface IListFunctionVersionParams {
+    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 extends IResponseInfo {
+    FunctionVersion: string[];
+    Versions: IFunctionVersion[];
+    TotalCount: number;
+}
+export interface IVersionMatch {
+    Version: string;
+    Key: string;
+    Method: string;
+    Expression: string;
+}
+export interface IVersionWeight {
+    Version: string;
+    Weight: number;
+}
+export interface IRoutingConfig {
+    AdditionalVersionWeights?: IVersionWeight[];
+    AddtionVersionMatchs?: IVersionMatch[];
+}
+export interface IUpdateFunctionAliasConfig {
+    functionName: string;
+    name: string;
+    functionVersion: string;
+    description?: string;
+    routingConfig?: IRoutingConfig;
+}
+export interface IGetFunctionAlias {
+    functionName: string;
+    name: string;
+}
+export interface IGetFunctionAliasRes extends IResponseInfo {
+    FunctionVersion: string;
+    Name: string;
+    RoutingConfig: IRoutingConfig;
+    Description: string;
+    AddTime: string;
+    ModTime: string;
+}
 export declare class FunctionService {
     private environment;
     private vpcService;
@@ -210,6 +296,58 @@ export declare class FunctionService {
     listLayerVersions(options: IVersionListOptions): Promise<IListLayerVersionsRes>;
     listLayers(options: ILayerListOptions): Promise<IListLayerRes>;
     getLayerVersion(options: ILayerOptions): Promise<IGetLayerVersionRes>;
+    /**
+     * 设置预置并发
+     * @private
+     * @param {IProvisionedConcurrencyConfig} concurrencyConfig
+     * @returns
+     * @memberof FunctionService
+     */
+    setProvisionedConcurrencyConfig(concurrencyConfig: ISetProvisionedConcurrencyConfig): Promise<IResponseInfo>;
+    /**
+     * 获取函数预置并发详情
+     * @private
+     * @param {IGetProvisionedConcurrencyConfig} concurrencyConfig
+     * @returns {Promise<IGetProvisionedConcurrencyRes>}
+     * @memberof FunctionService
+     */
+    getProvisionedConcurrencyConfig(concurrencyConfig: IGetProvisionedConcurrencyConfig): Promise<IGetProvisionedConcurrencyRes>;
+    /**
+     * 删除预置并发
+     * @private
+     * @param {IGetProvisionedConcurrencyConfig} concurrencyConfig
+     * @returns {Promise<IResponseInfo>}
+     * @memberof FunctionService
+     */
+    deleteProvisionedConcurrencyConfig(concurrencyConfig: IGetProvisionedConcurrencyConfig): Promise<IResponseInfo>;
+    /**
+     * 发布新版本
+     * @param {IPublishVersionParams} publishParams
+     * @returns {Promise<IPublishVersionRes>}
+     * @memberof FunctionService
+     */
+    publishVersion(publishParams: IPublishVersionParams): Promise<IPublishVersionRes>;
+    /**
+     * 查询函数版本详情
+     * @param {IListFunctionVersionParams} listVersionParams
+     * @returns {Promise<IFunctionVersionsRes>}
+     * @memberof FunctionService
+     */
+    listVersionByFunction(listVersionParams: IListFunctionVersionParams): Promise<IFunctionVersionsRes>;
+    /**
+     *
+     * @param {IUpdateFunctionAliasConfig} updateVersionConfigParams
+     * @returns {Promise<IResponseInfo>}
+     * @memberof FunctionService
+     */
+    updateFunctionAliasConfig(updateVersionConfigParams: IUpdateFunctionAliasConfig): Promise<IResponseInfo>;
+    /**
+     * 查询函数别名详情
+     * @param {IGetFunctionAlias} params
+     * @returns {Promise<IGetFunctionAliasRes>}
+     * @memberof FunctionService
+     */
+    getFunctionAlias(params: IGetFunctionAlias): Promise<IGetFunctionAliasRes>;
     private createAccessPath;
     private getCodeParams;
     private getTempCosInfo;

package/types/storage/index.d.ts

@@ -151,6 +151,7 @@ export declare class StorageService {
     downloadDirectory(options: {
         cloudPath: string;
         localPath?: string;
+        parallel?: number;
     }): Promise<(NodeJS.ReadableStream | string)[]>;
     /**
      * 列出文件夹下的文件
@@ -305,5 +306,19 @@ export declare class StorageService {
      * @returns
      */
     private uploadFilesWithRetry;
+    /**
+     * 拼接路径下载单文件
+     * @param file
+     * @param cloudDirectoryKey
+     * @param resolveLocalPath
+     * @returns
+     */
+    private downloadWithFilePath;
+    /**
+     * 根据下载结果返回错误列表
+     * @param res
+     * @returns
+     */
+    private determineDownLoadResultIsError;
 }
 export {};