@cloudbase/cli 1.12.0 → 1.12.1-beta

package/lib/commands/functions/version/publish.js

@@ -0,0 +1,70 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PublishFunctionVersion = void 0;
+const common_1 = require("../../common");
+const utils_1 = require("../../../utils");
+const function_1 = require("../../../function");
+const decorators_1 = require("../../../decorators");
+let PublishFunctionVersion = class PublishFunctionVersion extends common_1.Command {
+    get options() {
+        return {
+            cmd: 'fn',
+            childCmd: 'publish-version <name> [description]',
+            options: [
+                {
+                    flags: '-e, --envId <envId>',
+                    desc: '环境 Id'
+                }
+            ],
+            desc: '发布函数新版本'
+        };
+    }
+    execute(ctx, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const name = params === null || params === void 0 ? void 0 : params[0];
+            const description = params === null || params === void 0 ? void 0 : params[1];
+            const { envId } = ctx;
+            const loading = (0, utils_1.loadingFactory)();
+            loading.start(`发布函数 [${name}] 新版本中...`);
+            yield (0, function_1.publishVersion)({
+                envId,
+                functionName: name,
+                description
+            });
+            loading.succeed(`发布函数 [${name}] 新版本成功！`);
+        });
+    }
+};
+__decorate([
+    (0, decorators_1.InjectParams)(),
+    __param(0, (0, decorators_1.CmdContext)()),
+    __param(1, (0, decorators_1.ArgsParams)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], PublishFunctionVersion.prototype, "execute", null);
+PublishFunctionVersion = __decorate([
+    (0, common_1.ICommand)()
+], PublishFunctionVersion);
+exports.PublishFunctionVersion = PublishFunctionVersion;

package/lib/constant.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ALL_COMMANDS = exports.STATUS_TEXT = exports.REQUEST_TIMEOUT = exports.DefaultCloudBaseConfig = exports.DefaultFunctionDeployConfig = exports.ConfigItems = void 0;
+exports.ConcurrencyTaskStatus = exports.StatusMap = exports.ALL_COMMANDS = exports.STATUS_TEXT = exports.REQUEST_TIMEOUT = exports.DefaultCloudBaseConfig = exports.DefaultFunctionDeployConfig = exports.ConfigItems = void 0;
 class ConfigItems {
 }
 exports.ConfigItems = ConfigItems;
@@ -51,6 +51,12 @@ exports.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',
@@ -77,3 +83,19 @@ exports.ALL_COMMANDS = [
     'run standalonegateway turn on',
     'run standalonegateway turn off',
 ];
+exports.StatusMap = {
+    Active: '部署完成',
+    Creating: '创建中',
+    CreateFailed: '创建失败',
+    Updating: '更新中',
+    UpdateFailed: '更新失败',
+    Publishing: '函数版本发布中',
+    PublishFailed: '函数版本发布失败',
+    Deleting: '函数删除中',
+    DeleteFailed: '函数删除失败'
+};
+exports.ConcurrencyTaskStatus = {
+    Done: '已完成',
+    InProgress: '进行中',
+    Failed: '失败'
+};

package/lib/function/alias.js

@@ -0,0 +1,53 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFunctionAliasConfig = exports.setFunctionAliasConfig = void 0;
+const error_1 = require("../error");
+const base_1 = require("./base");
+function setFunctionAliasConfig(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { envId, functionName, name, functionVersion, description, routingConfig } = options;
+        const scfService = yield (0, base_1.getFunctionService)(envId);
+        try {
+            yield scfService.updateFunctionAliasConfig({
+                functionName,
+                name,
+                functionVersion,
+                description,
+                routingConfig
+            });
+        }
+        catch (e) {
+            throw new error_1.CloudBaseError(`[${functionName}] 设置函数流量配置失败： ${e.message}`, {
+                code: e.code
+            });
+        }
+    });
+}
+exports.setFunctionAliasConfig = setFunctionAliasConfig;
+function getFunctionAliasConfig(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { envId, functionName, name } = options;
+        const scfService = yield (0, base_1.getFunctionService)(envId);
+        try {
+            return scfService.getFunctionAlias({
+                functionName,
+                name
+            });
+        }
+        catch (e) {
+            throw new error_1.CloudBaseError(`[${functionName}] 查询函数别名配置失败： ${e.message}`, {
+                code: e.code
+            });
+        }
+    });
+}
+exports.getFunctionAliasConfig = getFunctionAliasConfig;

package/lib/function/concurrency.js

@@ -0,0 +1,69 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteProvisionedConcurrencyConfig = exports.getProvisionedConcurrencyConfig = exports.setProvisionedConcurrencyConfig = void 0;
+const error_1 = require("../error");
+const base_1 = require("./base");
+function setProvisionedConcurrencyConfig(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { envId, functionName, qualifier, versionProvisionedConcurrencyNum } = options;
+        const scfService = yield (0, base_1.getFunctionService)(envId);
+        try {
+            yield scfService.setProvisionedConcurrencyConfig({
+                functionName,
+                qualifier,
+                versionProvisionedConcurrencyNum
+            });
+        }
+        catch (e) {
+            throw new error_1.CloudBaseError(`[${functionName}] 设置函数预置并发失败： ${e.message}`, {
+                code: e.code
+            });
+        }
+    });
+}
+exports.setProvisionedConcurrencyConfig = setProvisionedConcurrencyConfig;
+function getProvisionedConcurrencyConfig(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { envId, functionName, qualifier } = options;
+        const scfService = yield (0, base_1.getFunctionService)(envId);
+        try {
+            return scfService.getProvisionedConcurrencyConfig({
+                functionName,
+                qualifier,
+            });
+        }
+        catch (e) {
+            throw new error_1.CloudBaseError(`[${functionName}] 查看函数预置并发信息失败： ${e.message}`, {
+                code: e.code
+            });
+        }
+    });
+}
+exports.getProvisionedConcurrencyConfig = getProvisionedConcurrencyConfig;
+function deleteProvisionedConcurrencyConfig(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { envId, functionName, qualifier } = options;
+        const scfService = yield (0, base_1.getFunctionService)(envId);
+        try {
+            yield scfService.deleteProvisionedConcurrencyConfig({
+                functionName,
+                qualifier
+            });
+        }
+        catch (e) {
+            throw new error_1.CloudBaseError(`[${functionName}] 删除函数预置并发失败： ${e.message}`, {
+                code: e.code
+            });
+        }
+    });
+}
+exports.deleteProvisionedConcurrencyConfig = deleteProvisionedConcurrencyConfig;

package/lib/function/index.js

@@ -18,3 +18,6 @@ __exportStar(require("./delete"), exports);
 __exportStar(require("./update"), exports);
 __exportStar(require("./layer"), exports);
 __exportStar(require("./vpc"), exports);
+__exportStar(require("./version"), exports);
+__exportStar(require("./concurrency"), exports);
+__exportStar(require("./alias"), exports);

package/lib/function/version.js

@@ -0,0 +1,51 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listFunctionVersions = exports.publishVersion = void 0;
+const error_1 = require("../error");
+const base_1 = require("./base");
+function publishVersion(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { envId, functionName, description = '' } = options;
+        const scfService = yield (0, base_1.getFunctionService)(envId);
+        try {
+            yield scfService.publishVersion({
+                functionName,
+                description
+            });
+        }
+        catch (e) {
+            throw new error_1.CloudBaseError(`[${functionName}] 函数发布新版本失败： ${e.message}`, {
+                code: e.code
+            });
+        }
+    });
+}
+exports.publishVersion = publishVersion;
+function listFunctionVersions(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { envId, functionName, offset = 0, limit = 20 } = options;
+        const scfService = yield (0, base_1.getFunctionService)(envId);
+        try {
+            return scfService.listVersionByFunction({
+                functionName,
+                offset,
+                limit
+            });
+        }
+        catch (e) {
+            throw new error_1.CloudBaseError(`[${functionName}] 查看寒函数版本列表失败： ${e.message}`, {
+                code: e.code
+            });
+        }
+    });
+}
+exports.listFunctionVersions = listFunctionVersions;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cloudbase/cli",
-    "version": "1.12.0",
+    "version": "1.12.1-beta",
     "description": "cli tool for cloudbase",
     "main": "lib/index.js",
     "scripts": {
@@ -21,13 +21,18 @@
         "tcb": "bin/tcb.js",
         "cloudbase": "bin/cloudbase.js"
     },
+    "husky": {
+        "hooks": {
+            "pre-commit": "npm run build && git add ."
+        }
+    },
     "author": "cwuyiqing@gmail.com",
     "license": "ISC",
     "dependencies": {
         "@cloudbase/cloud-api": "^0.4.0",
         "@cloudbase/framework-core": "^1.6.1",
         "@cloudbase/lowcode-cli": "^0.12.2",
-        "@cloudbase/manager-node": "3.11.1-beta",
+        "@cloudbase/manager-node": "3.12.0",
         "@cloudbase/toolbox": "^0.7.2",
         "@sentry/node": "^5.10.2",
         "address": "^1.1.2",
@@ -67,6 +72,7 @@
         "@types/lodash": "^4.14.149",
         "@types/node": "^12.12.38",
         "@types/node-fetch": "^2.5.4",
+        "@types/react": "^17.0.37",
         "@types/semver": "^7.3.9",
         "@types/webpack-dev-server": "^3.11.1",
         "@typescript-eslint/eslint-plugin": "^4.8.1",

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 {