@cloudbase/cli 2.11.6 → 2.11.7

package/lib/decorators/injectParams.js

@@ -0,0 +1,58 @@
+"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.InjectParams = void 0;
+const constants_1 = require("./constants");
+function InjectParams() {
+    return function (target, key, descriptor) {
+        const rawFunc = descriptor.value;
+        const paramMetadata = Reflect.getMetadata(constants_1.PARAM_METADATA, target[key]);
+        if (paramMetadata) {
+            descriptor.value = function (...args) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const ctx = args[0] || {};
+                    for (const paramKey in paramMetadata) {
+                        if (Object.prototype.hasOwnProperty.call(paramMetadata, paramKey)) {
+                            const { getter, index } = paramMetadata[paramKey];
+                            switch (paramKey) {
+                                case constants_1.ParamTypes.CmdContext:
+                                    args[index] = ctx;
+                                    break;
+                                case constants_1.ParamTypes.Config:
+                                    args[index] = ctx.config;
+                                    break;
+                                case constants_1.ParamTypes.ArgsParams:
+                                    args[index] = ctx.params;
+                                    break;
+                                case constants_1.ParamTypes.ArgsOptions:
+                                    args[index] = ctx.options;
+                                    break;
+                                case constants_1.ParamTypes.EnvId:
+                                    args[index] = ctx.envId;
+                                    break;
+                                case constants_1.ParamTypes.IsPrivateEnv:
+                                    args[index] = ctx.hasPrivateSettings;
+                                    break;
+                                default: {
+                                    const injectValue = yield getter(target);
+                                    args[index] = injectValue;
+                                }
+                            }
+                        }
+                    }
+                    return rawFunc.apply(this, args);
+                });
+            };
+        }
+        return descriptor;
+    };
+}
+exports.InjectParams = InjectParams;

package/lib/decorators/params/common.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createParamDecorator = void 0;
+const constants_1 = require("../constants");
+const createParamDecorator = (paramtype, getter) => {
+    return () => {
+        return (target, key, index) => {
+            const data = Reflect.getMetadata(constants_1.PARAM_METADATA, target[key]) || {};
+            Reflect.defineMetadata(constants_1.PARAM_METADATA, Object.assign(Object.assign({}, data), { [paramtype]: {
+                    index,
+                    getter
+                } }), target[key]);
+        };
+    };
+};
+exports.createParamDecorator = createParamDecorator;

package/lib/decorators/params/index.js

@@ -0,0 +1,34 @@
+"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.IsPrivateEnv = exports.Config = exports.EnvId = exports.ArgsParams = exports.ArgsOptions = exports.CmdContext = exports.Log = exports.Credential = void 0;
+const common_1 = require("./common");
+const constants_1 = require("../constants");
+const utils_1 = require("../../utils");
+const EmptyValue = () => { };
+exports.Credential = (0, common_1.createParamDecorator)(constants_1.ParamTypes.Credential, () => __awaiter(void 0, void 0, void 0, function* () {
+    const credential = yield utils_1.authSupevisor.getLoginState();
+    return credential;
+}));
+exports.Log = (0, common_1.createParamDecorator)(constants_1.ParamTypes.Log, () => {
+    const args = (0, utils_1.getArgs)();
+    const verbose = process.VERBOSE || args.verbose;
+    const log = new utils_1.Logger({
+        verbose
+    });
+    return log;
+});
+exports.CmdContext = (0, common_1.createParamDecorator)(constants_1.ParamTypes.CmdContext, EmptyValue);
+exports.ArgsOptions = (0, common_1.createParamDecorator)(constants_1.ParamTypes.ArgsOptions, EmptyValue);
+exports.ArgsParams = (0, common_1.createParamDecorator)(constants_1.ParamTypes.ArgsParams, EmptyValue);
+exports.EnvId = (0, common_1.createParamDecorator)(constants_1.ParamTypes.EnvId, EmptyValue);
+exports.Config = (0, common_1.createParamDecorator)(constants_1.ParamTypes.Config, EmptyValue);
+exports.IsPrivateEnv = (0, common_1.createParamDecorator)(constants_1.ParamTypes.IsPrivateEnv, EmptyValue);

package/lib/env/domain.js

@@ -0,0 +1,42 @@
+"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.deleteEnvDomain = exports.createEnvDomain = exports.getEnvAuthDomains = void 0;
+const net_1 = require("../utils/net");
+const tcbService = net_1.CloudApiService.getInstance('tcb');
+function getEnvAuthDomains({ envId }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { Domains = [] } = yield tcbService.request('DescribeAuthDomains', {
+            EnvId: envId
+        });
+        return Domains;
+    });
+}
+exports.getEnvAuthDomains = getEnvAuthDomains;
+function createEnvDomain({ envId, domains }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield tcbService.request('CreateAuthDomain', {
+            EnvId: envId,
+            Domains: domains
+        });
+    });
+}
+exports.createEnvDomain = createEnvDomain;
+function deleteEnvDomain({ envId, domainIds }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { Deleted } = yield tcbService.request('DeleteAuthDomain', {
+            EnvId: envId,
+            DomainIds: domainIds
+        });
+        return Deleted;
+    });
+}
+exports.deleteEnvDomain = deleteEnvDomain;

package/lib/env/index.js

@@ -0,0 +1,80 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+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.getEnvLimit = exports.updateEnvInfo = exports.listEnvs = exports.getEnvInfo = exports.initTcb = void 0;
+const net_1 = require("../utils/net");
+__exportStar(require("./domain"), exports);
+__exportStar(require("./login"), exports);
+const tcbService = net_1.CloudApiService.getInstance('tcb');
+function initTcb(skey) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const res = yield tcbService.request('InitTcb', {
+            Skey: skey
+        });
+        return res;
+    });
+}
+exports.initTcb = initTcb;
+function getEnvInfo(envId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { EnvList } = yield tcbService.request('DescribeEnvs', {
+            EnvId: envId
+        });
+        return (EnvList === null || EnvList === void 0 ? void 0 : EnvList.length) ? EnvList[0] : {};
+    });
+}
+exports.getEnvInfo = getEnvInfo;
+function listEnvs(options = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { source } = options;
+        const res = yield tcbService.request('DescribeEnvs', {
+            IsVisible: false,
+            Channels: ['dcloud']
+        });
+        let { EnvList = [] } = res;
+        if (source && Array.isArray(source)) {
+            EnvList = EnvList.filter((item) => source.includes(item.Source));
+        }
+        return EnvList;
+    });
+}
+exports.listEnvs = listEnvs;
+function updateEnvInfo({ envId, alias }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield tcbService.request('ModifyEnv', {
+            EnvId: envId,
+            Alias: alias
+        });
+    });
+}
+exports.updateEnvInfo = updateEnvInfo;
+function getEnvLimit(source = 'qcloud') {
+    return __awaiter(this, void 0, void 0, function* () {
+        return tcbService.request('DescribeEnvLimit', {
+            Source: source
+        });
+    });
+}
+exports.getEnvLimit = getEnvLimit;

package/lib/env/login.js

@@ -0,0 +1,78 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateLoginConfig = exports.createLoginConfig = exports.getLoginConfigList = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const net_1 = require("../utils/net");
+const error_1 = require("../error");
+const publicRsaKey = `
+-----BEGIN PUBLIC KEY-----
+MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC0ZLB0ZpWWFsHPnDDw++Nc2wI3
+nl2uyOrIJ5FUfxt4GAmt1Faf5pgMxAnL9exEUrrUDUX8Ri1R0KyfnHQQwCvKt8T8
+bgILIJe9UB8e9dvFqgqH2oA8Vqwi0YqDcvFLFJk2BJbm/0QYtZ563FumW8LEXAgu
+UeHi/0OZN9vQ33jWMQIDAQAB
+-----END PUBLIC KEY-----
+`;
+function rsaEncrypt(data) {
+    const buffer = Buffer.from(data);
+    const encrypted = crypto_1.default.publicEncrypt({
+        key: publicRsaKey,
+        padding: crypto_1.default.constants.RSA_PKCS1_PADDING
+    }, buffer);
+    return encrypted.toString('base64');
+}
+const tcbService = net_1.CloudApiService.getInstance('tcb');
+function getLoginConfigList({ envId }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { ConfigList = [] } = yield tcbService.request('DescribeLoginConfigs', {
+            EnvId: envId
+        });
+        return ConfigList;
+    });
+}
+exports.getLoginConfigList = getLoginConfigList;
+function createLoginConfig({ envId, platform, appId, appSecret }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const validPlatform = ['WECHAT-OPEN', 'WECHAT-PUBLIC', 'ANONYMOUS'];
+        if (!validPlatform.includes(platform)) {
+            throw new error_1.CloudBaseError(`Invalid platform value: ${platform}. Now only support 'WECHAT-OPEN', 'WECHAT-PUBLIC', 'ANONYMOUS`);
+        }
+        const params = {
+            EnvId: envId,
+            Platform: platform,
+            PlatformId: appId,
+            PlatformSecret: rsaEncrypt(appSecret),
+            Status: 'ENABLE'
+        };
+        yield tcbService.request('CreateLoginConfig', params);
+    });
+}
+exports.createLoginConfig = createLoginConfig;
+function updateLoginConfig({ configId, envId, status = 'ENABLE', appId = '', appSecret = '' }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const validStatus = ['ENABLE', 'DISABLE'];
+        if (!validStatus.includes(status)) {
+            throw new error_1.CloudBaseError(`Invalid status value: ${status}. Only support 'ENABLE', 'DISABLE'`);
+        }
+        const params = {
+            EnvId: envId,
+            ConfigId: configId,
+            Status: status
+        };
+        appId && (params.PlatformId = appId);
+        appSecret && (params.PlatformSecret = rsaEncrypt(appSecret));
+        yield tcbService.request('UpdateLoginConfig', params);
+    });
+}
+exports.updateLoginConfig = updateLoginConfig;

package/lib/error.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudBaseError = void 0;
+class CloudBaseError extends Error {
+    constructor(message, options = {}) {
+        super();
+        this.name = 'CloudBaseError';
+        this.message = message;
+        const { code = '', action = '', original = null, requestId = '', meta = {} } = options;
+        this.original = original;
+        this.code = code;
+        this.requestId = requestId;
+        this.action = action;
+        this.meta = meta;
+    }
+}
+exports.CloudBaseError = CloudBaseError;

package/lib/function/alias.js

@@ -0,0 +1,54 @@
+"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");
+const i18n_1 = require("../i18n");
+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((0, i18n_1.t)('[{{name}}] 设置函数流量配置失败： {{error}}', { name: functionName, error: 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((0, i18n_1.t)('[{{name}}] 查询函数别名配置失败： {{error}}', { name: functionName, error: e.message }), {
+                code: e.code
+            });
+        }
+    });
+}
+exports.getFunctionAliasConfig = getFunctionAliasConfig;

package/lib/function/base.js

@@ -0,0 +1,266 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyFunction = exports.batchInvokeFunctions = exports.invokeFunction = exports.batchUpdateFunctionConfig = exports.updateFunctionConfig = exports.getFunctionLog = exports.batchGetFunctionsDetail = exports.getFunctionDetail = exports.listAllFunctions = exports.listFunction = exports.getFunctionService = void 0;
+const manager_node_1 = __importDefault(require("@cloudbase/manager-node"));
+const utils_1 = require("../utils");
+const logger_1 = require("../logger");
+const error_1 = require("../error");
+const vpc_1 = require("./vpc");
+const toolbox_1 = require("@cloudbase/toolbox");
+const i18n_1 = require("../i18n");
+const scfService = utils_1.CloudApiService.getInstance('scf');
+function getFunctionService(envId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const region = yield (0, toolbox_1.getRegion)();
+        const { secretId, secretKey, token } = yield (0, utils_1.checkAndGetCredential)(true);
+        const app = new manager_node_1.default({
+            region,
+            token,
+            envId,
+            secretId,
+            secretKey,
+            proxy: (0, utils_1.getProxy)()
+        });
+        return app.functions;
+    });
+}
+exports.getFunctionService = getFunctionService;
+function listFunction(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { limit = 20, offset = 0, envId } = options;
+        const res = yield scfService.request('ListFunctions', {
+            Namespace: envId,
+            Limit: limit,
+            Offset: offset
+        });
+        const { Functions = [] } = res;
+        const data = [];
+        Functions.forEach(func => {
+            const { FunctionId, FunctionName, Runtime, AddTime, ModTime, Status } = func;
+            data.push({
+                FunctionId,
+                FunctionName,
+                Runtime,
+                AddTime,
+                ModTime,
+                Status
+            });
+        });
+        return data;
+    });
+}
+exports.listFunction = listFunction;
+function listAllFunctions(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const allFunctions = [];
+        let currentOffset = 0;
+        const pageSize = 20;
+        const { envId } = options;
+        while (true) {
+            try {
+                const res = yield scfService.request('ListFunctions', {
+                    Namespace: envId,
+                    Limit: pageSize,
+                    Offset: currentOffset
+                });
+                const { Functions = [], TotalCount } = res;
+                if (Functions.length === 0) {
+                    break;
+                }
+                allFunctions.push(...Functions);
+                if (allFunctions.length >= TotalCount || Functions.length < pageSize) {
+                    break;
+                }
+                currentOffset += pageSize;
+            }
+            catch (error) {
+                throw new error_1.CloudBaseError((0, i18n_1.t)('获取函数列表失败: {{error}}', { error: error.message }));
+            }
+        }
+        const data = [];
+        allFunctions.forEach(func => {
+            const { FunctionId, FunctionName, Runtime, AddTime, ModTime, Status } = func;
+            data.push({
+                FunctionId,
+                FunctionName,
+                Runtime,
+                AddTime,
+                ModTime,
+                Status
+            });
+        });
+        return data;
+    });
+}
+exports.listAllFunctions = listAllFunctions;
+function getFunctionDetail(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { functionName, envId, codeSecret } = options;
+        const res = yield scfService.request('GetFunction', {
+            FunctionName: functionName,
+            Namespace: envId,
+            ShowCode: 'TRUE',
+            CodeSecret: codeSecret
+        });
+        const data = res;
+        const { VpcId = '', SubnetId = '' } = data.VpcConfig || {};
+        if (VpcId && SubnetId) {
+            try {
+                const vpcs = yield (0, vpc_1.getVpcs)();
+                const subnets = yield (0, vpc_1.getSubnets)(VpcId);
+                const vpc = vpcs.find(item => item.VpcId === VpcId);
+                const subnet = subnets.find(item => item.SubnetId === SubnetId);
+                data.VpcConfig = {
+                    vpc,
+                    subnet
+                };
+            }
+            catch (e) {
+                data.VpcConfig = {
+                    vpc: VpcId,
+                    subnet: SubnetId
+                };
+            }
+        }
+        return data;
+    });
+}
+exports.getFunctionDetail = getFunctionDetail;
+function batchGetFunctionsDetail({ names, envId, codeSecret }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const data = [];
+        const promises = names.map(name => (() => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const info = yield getFunctionDetail({
+                    envId,
+                    codeSecret,
+                    functionName: name
+                });
+                data.push(info);
+            }
+            catch (e) {
+                throw new error_1.CloudBaseError((0, i18n_1.t)('{{name}} 获取信息失败：{{error}}', { name, error: e.message }));
+            }
+        }))());
+        yield Promise.all(promises);
+        return data;
+    });
+}
+exports.batchGetFunctionsDetail = batchGetFunctionsDetail;
+function getFunctionLog(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        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 = [] } = yield scfService.request('GetFunctionLogs', params);
+        return Data;
+    });
+}
+exports.getFunctionLog = getFunctionLog;
+function updateFunctionConfig(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { functionName, config, envId } = options;
+        const functionService = yield getFunctionService(envId);
+        yield functionService.updateFunctionConfig(Object.assign({ name: functionName }, config));
+    });
+}
+exports.updateFunctionConfig = updateFunctionConfig;
+function batchUpdateFunctionConfig(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { functions, envId, log } = options;
+        const promises = functions.map(func => (() => __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield updateFunctionConfig({
+                    functionName: func.name,
+                    config: func,
+                    envId
+                });
+                log && (0, logger_1.successLog)((0, i18n_1.t)('[{{name}}] 更新云函数配置成功！', { name: func.name }));
+            }
+            catch (e) {
+                throw new error_1.CloudBaseError((0, i18n_1.t)('{{name}} 更新配置失败：{{error}}', { name: func.name, error: e.message }));
+            }
+        }))());
+        yield Promise.all(promises);
+    });
+}
+exports.batchUpdateFunctionConfig = batchUpdateFunctionConfig;
+function invokeFunction(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { functionName, envId, params = {} } = options;
+        const _params = {
+            FunctionName: functionName,
+            Namespace: envId,
+            ClientContext: JSON.stringify(params),
+            LogType: 'Tail'
+        };
+        try {
+            const { Result } = yield scfService.request('Invoke', _params);
+            return Result;
+        }
+        catch (e) {
+            throw new error_1.CloudBaseError((0, i18n_1.t)('[{{name}}] 调用失败：\n{{error}}', { name: functionName, error: e.message }));
+        }
+    });
+}
+exports.invokeFunction = invokeFunction;
+function batchInvokeFunctions(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { functions, envId, log = false } = options;
+        const promises = functions.map(func => (() => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const result = yield invokeFunction({
+                    functionName: func.name,
+                    params: func.params,
+                    envId
+                });
+                if (log) {
+                    (0, logger_1.successLog)((0, i18n_1.t)('[{{name}}] 调用成功\n响应结果：\n', { name: func.name }));
+                    console.log(result);
+                }
+                return result;
+            }
+            catch (e) {
+                throw new error_1.CloudBaseError((0, i18n_1.t)('{{name}} 函数调用失败：{{error}}', { name: func.name, error: e.message }));
+            }
+        }))());
+        return Promise.all(promises);
+    });
+}
+exports.batchInvokeFunctions = batchInvokeFunctions;
+function copyFunction(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { envId, functionName, newFunctionName, targetEnvId, force, codeSecret } = options;
+        if (!envId || !functionName || !newFunctionName) {
+            throw new error_1.CloudBaseError((0, i18n_1.t)('参数缺失'));
+        }
+        yield scfService.request('CopyFunction', {
+            FunctionName: functionName,
+            NewFunctionName: newFunctionName,
+            Namespace: envId,
+            TargetNamespace: targetEnvId || envId,
+            Override: force ? true : false,
+            CodeSecret: codeSecret
+        });
+    });
+}
+exports.copyFunction = copyFunction;