@cloudbase/cli 2.3.1 → 2.3.3

package/lib/function/base.js

@@ -0,0 +1,222 @@
+"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.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 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 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(`${name} 获取信息失败：${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)(`[${func.name}] 更新云函数配置成功！`);
+            }
+            catch (e) {
+                throw new error_1.CloudBaseError(`${func.name} 更新配置失败：${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(`[${functionName}] 调用失败：\n${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)(`[${func.name}] 调用成功\n响应结果：\n`);
+                    console.log(result);
+                }
+                return result;
+            }
+            catch (e) {
+                throw new error_1.CloudBaseError(`${func.name} 函数调用失败：${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('参数缺失');
+        }
+        yield scfService.request('CopyFunction', {
+            FunctionName: functionName,
+            NewFunctionName: newFunctionName,
+            Namespace: envId,
+            TargetNamespace: targetEnvId || envId,
+            Override: force ? true : false,
+            CodeSecret: codeSecret
+        });
+    });
+}
+exports.copyFunction = copyFunction;

package/lib/function/code.js

@@ -0,0 +1,52 @@
+"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.downloadFunctionCode = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const unzipper_1 = __importDefault(require("unzipper"));
+const utils_1 = require("../utils");
+const scfService = utils_1.CloudApiService.getInstance('scf');
+function downloadFunctionCode(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { destPath, envId, functionName, codeSecret, unzip = false } = options;
+        (0, utils_1.checkFullAccess)(destPath, true);
+        const { Url } = yield scfService.request('GetFunctionAddress', {
+            FunctionName: functionName,
+            Namespace: envId,
+            CodeSecret: codeSecret
+        });
+        const res = yield (0, utils_1.fetchStream)(Url);
+        const zipPath = path_1.default.join(destPath, `${functionName}.zip`);
+        const dest = fs_1.default.createWriteStream(zipPath);
+        res.body.pipe(dest);
+        return new Promise(resolve => {
+            dest.on('close', () => {
+                if (!unzip) {
+                    resolve();
+                    return;
+                }
+                const unzipStream = unzipper_1.default.Extract({
+                    path: destPath
+                });
+                fs_1.default.createReadStream(zipPath).pipe(unzipStream);
+                unzipStream.on('close', () => {
+                    (0, utils_1.delSync)([zipPath]);
+                    resolve();
+                });
+            });
+        });
+    });
+}
+exports.downloadFunctionCode = downloadFunctionCode;

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/create.js

@@ -0,0 +1,71 @@
+"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.batchCreateFunctions = exports.createFunction = void 0;
+const utils_1 = require("../utils");
+const error_1 = require("../error");
+const base_1 = require("./base");
+function createFunction(options) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        const { envId, accessPath, codeSecret, force = false, functionPath, base64Code = '', functionRootPath = '' } = options;
+        const func = Object.assign(Object.assign({}, (_a = options === null || options === void 0 ? void 0 : options.func) === null || _a === void 0 ? void 0 : _a.config), options.func);
+        accessPath && (func.path = accessPath);
+        const funcName = func.name;
+        const scfService = yield (0, base_1.getFunctionService)(envId);
+        func.isWaitInstall = true;
+        try {
+            yield scfService.createFunction({
+                func,
+                force,
+                base64Code,
+                codeSecret,
+                functionPath,
+                functionRootPath
+            });
+        }
+        catch (e) {
+            if (e.message && !force) {
+                throw new error_1.CloudBaseError(`[${funcName}] 部署失败，${e.message}`, {
+                    code: e.code,
+                    original: e
+                });
+            }
+            throw e;
+        }
+    });
+}
+exports.createFunction = createFunction;
+function batchCreateFunctions(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { functions, functionRootPath = '', envId, force, codeSecret, log = false } = options;
+        const promises = functions.map((func) => (() => __awaiter(this, void 0, void 0, function* () {
+            const loading = (0, utils_1.loadingFactory)();
+            try {
+                log && loading.start(`[${func.name}] 函数部署中...`);
+                yield createFunction({
+                    func,
+                    envId,
+                    force,
+                    codeSecret,
+                    functionRootPath
+                });
+                log && loading.succeed(`[${func.name}] 函数部署成功`);
+            }
+            catch (e) {
+                log && loading.fail(`[${func.name}] 函数部署失败`);
+                throw new error_1.CloudBaseError(e.message);
+            }
+        }))());
+        yield Promise.all(promises);
+    });
+}
+exports.batchCreateFunctions = batchCreateFunctions;

package/lib/function/delete.js

@@ -0,0 +1,52 @@
+"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.batchDeleteFunctions = exports.deleteFunction = void 0;
+const logger_1 = require("../logger");
+const error_1 = require("../error");
+const utils_1 = require("../utils");
+const gateway_1 = require("../gateway");
+const scfService = utils_1.CloudApiService.getInstance('scf');
+function deleteFunction({ functionName, envId }) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        const res = yield (0, gateway_1.queryGateway)({
+            envId,
+            name: functionName
+        });
+        if (((_a = res === null || res === void 0 ? void 0 : res.APISet) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+            yield (0, gateway_1.deleteGateway)({
+                envId,
+                name: functionName
+            });
+        }
+        yield scfService.request('DeleteFunction', {
+            FunctionName: functionName,
+            Namespace: envId
+        });
+    });
+}
+exports.deleteFunction = deleteFunction;
+function batchDeleteFunctions({ names, envId }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const promises = names.map(name => (() => __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield deleteFunction({ functionName: name, envId });
+                (0, logger_1.successLog)(`[${name}] 函数删除成功！`);
+            }
+            catch (e) {
+                throw new error_1.CloudBaseError(e.message);
+            }
+        }))());
+        yield Promise.all(promises);
+    });
+}
+exports.batchDeleteFunctions = batchDeleteFunctions;

package/lib/function/index.js

@@ -0,0 +1,27 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./create"), exports);
+__exportStar(require("./trigger"), exports);
+__exportStar(require("./code"), exports);
+__exportStar(require("./base"), exports);
+__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/layer/attach.js

@@ -0,0 +1,64 @@
+"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.unAttachLayer = exports.attachLayer = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const base_1 = require("../base");
+const utils_1 = require("../../utils");
+const error_1 = require("../../error");
+const scfService = new utils_1.CloudApiService('scf');
+function attachLayer(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { envId, functionName, layerName, layerVersion, codeSecret } = options;
+        let { Layers } = yield (0, base_1.getFunctionDetail)({
+            envId,
+            codeSecret,
+            functionName
+        });
+        Layers = Layers.map(item => lodash_1.default.pick(item, ['LayerName', 'LayerVersion']));
+        Layers.push({
+            LayerName: layerName,
+            LayerVersion: layerVersion
+        });
+        const res = yield scfService.request('UpdateFunctionConfiguration', {
+            Layers,
+            Namespace: envId,
+            FunctionName: functionName
+        });
+        return res;
+    });
+}
+exports.attachLayer = attachLayer;
+function unAttachLayer(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { envId, functionName, layerName, layerVersion, codeSecret } = options;
+        let { Layers } = yield (0, base_1.getFunctionDetail)({
+            envId,
+            codeSecret,
+            functionName
+        });
+        Layers = Layers.map(item => lodash_1.default.pick(item, ['LayerName', 'LayerVersion']));
+        const index = Layers.findIndex(item => item.LayerName === layerName && item.LayerVersion === layerVersion);
+        if (index === -1) {
+            throw new error_1.CloudBaseError('层不存在');
+        }
+        Layers.splice(index, 1);
+        return scfService.request('UpdateFunctionConfiguration', {
+            Layers,
+            Namespace: envId,
+            FunctionName: functionName
+        });
+    });
+}
+exports.unAttachLayer = unAttachLayer;

package/lib/function/layer/create.js

@@ -0,0 +1,61 @@
+"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.createLayer = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const toolbox_1 = require("@cloudbase/toolbox");
+const utils_1 = require("../../utils");
+const scfService = new utils_1.CloudApiService('scf');
+function createLayer(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { contentPath = '', layerName, base64Content = '', runtimes = [] } = options;
+        (0, utils_1.checkFullAccess)(contentPath);
+        const validRuntime = ['Nodejs8.9', 'Php7', 'Java8', 'Nodejs12.16'];
+        if (runtimes.some(item => validRuntime.indexOf(item) === -1)) {
+            throw new toolbox_1.CloudBaseError(`Invalid runtime value. Now only support: ${validRuntime.join(', ')}`);
+        }
+        let base64;
+        if (base64Content) {
+            base64 = base64Content;
+        }
+        else if ((0, utils_1.isDirectory)(contentPath)) {
+            const dirName = path_1.default.parse(contentPath).name;
+            const dest = path_1.default.join(process.cwd(), `cli-${dirName}.zip`);
+            if ((0, utils_1.checkFullAccess)(dest)) {
+                (0, utils_1.delSync)(dest);
+            }
+            yield (0, toolbox_1.zipDir)(contentPath, dest);
+            const fileBuffer = yield fs_1.default.promises.readFile(dest);
+            base64 = fileBuffer.toString('base64');
+            (0, utils_1.delSync)(dest);
+        }
+        else {
+            const fileType = path_1.default.extname(contentPath);
+            if (fileType !== '.zip') {
+                throw new toolbox_1.CloudBaseError('文件类型不正确，目前只支持 ZIP 文件！');
+            }
+            const fileBuffer = yield fs_1.default.promises.readFile(contentPath);
+            base64 = fileBuffer.toString('base64');
+        }
+        return scfService.request('PublishLayerVersion', {
+            LayerName: layerName,
+            CompatibleRuntimes: runtimes,
+            Content: {
+                ZipFile: base64
+            }
+        });
+    });
+}
+exports.createLayer = createLayer;

package/lib/function/layer/delete.js

@@ -0,0 +1,24 @@
+"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.deleteLayer = void 0;
+const utils_1 = require("../../utils");
+const scfService = new utils_1.CloudApiService('scf');
+function deleteLayer(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { name, version } = options;
+        return scfService.request('DeleteLayerVersion', {
+            LayerName: name,
+            LayerVersion: version
+        });
+    });
+}
+exports.deleteLayer = deleteLayer;