@cloudbase/manager-node 4.2.4 → 4.2.5

package/lib/utils/index.js

@@ -0,0 +1,103 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upperCaseObjKey = exports.upperCaseStringFisrt = exports.sleep = exports.rsaEncrypt = exports.getEnvVar = exports.getRuntime = exports.compressToZip = void 0;
+const fs_1 = __importDefault(require("fs"));
+const archiver_1 = __importDefault(require("archiver"));
+const crypto_1 = __importDefault(require("crypto"));
+const constant_1 = require("../constant");
+var uuid_1 = require("./uuid");
+Object.defineProperty(exports, "guid6", { enumerable: true, get: function () { return uuid_1.guid6; } });
+__exportStar(require("./cloud-api-request"), exports);
+__exportStar(require("./auth"), exports);
+__exportStar(require("./cloudbase-request"), exports);
+__exportStar(require("./http-request"), exports);
+__exportStar(require("./envLazy"), exports);
+__exportStar(require("./fs"), exports);
+async function compressToZip(option) {
+    const { dirPath, outputPath, ignore, pattern = '**/*' } = option;
+    return new Promise((resolve, reject) => {
+        const output = fs_1.default.createWriteStream(outputPath);
+        const archive = archiver_1.default('zip');
+        output.on('close', function () {
+            resolve({
+                zipPath: outputPath,
+                size: Math.ceil(archive.pointer() / 1024)
+            });
+        });
+        archive.on('error', function (err) {
+            reject(err);
+        });
+        archive.pipe(output);
+        // append files from a glob pattern
+        archive.glob(pattern, {
+            // 目标路径
+            cwd: dirPath,
+            ignore: ignore,
+            dot: true
+        });
+        archive.finalize();
+    });
+}
+exports.compressToZip = compressToZip;
+function getRuntime() {
+    return process.env[constant_1.ENV_NAME.ENV_RUNENV];
+}
+exports.getRuntime = getRuntime;
+function getEnvVar(envName) {
+    return process.env[envName];
+}
+exports.getEnvVar = getEnvVar;
+function rsaEncrypt(data) {
+    const buffer = Buffer.from(data);
+    const encrypted = crypto_1.default.publicEncrypt({
+        key: constant_1.PUBLIC_RSA_KEY,
+        padding: crypto_1.default.constants.RSA_PKCS1_PADDING
+    }, buffer);
+    return encrypted.toString('base64');
+}
+exports.rsaEncrypt = rsaEncrypt;
+function sleep(time) {
+    return new Promise(resolve => {
+        setTimeout(() => {
+            resolve();
+        }, time);
+    });
+}
+exports.sleep = sleep;
+function upperCaseStringFisrt(str) {
+    return str.slice(0, 1).toUpperCase().concat(str.slice(1));
+}
+exports.upperCaseStringFisrt = upperCaseStringFisrt;
+function upperCaseObjKey(object) {
+    const type = Object.prototype.toString.call(object).slice(8, -1);
+    if (type === 'Object') {
+        let newObj = {};
+        // eslint-disable-next-line guard-for-in
+        for (let key in object) {
+            newObj[upperCaseStringFisrt(key)] = upperCaseObjKey(object[key]);
+        }
+        return newObj;
+    }
+    if (type === 'Array') {
+        let newArr = [];
+        for (let item of object) {
+            newArr.push(upperCaseObjKey(item));
+        }
+        return newArr;
+    }
+    return object;
+}
+exports.upperCaseObjKey = upperCaseObjKey;

package/lib/utils/parallel.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncTaskParallelController = void 0;
+/**
+ * 异步任务并发控制器，以一定的并发数执行所有任务
+ * 不具备队列性质，异步任务随机执行
+ * 单个任务异常，错误会返回，单不会退出执行
+ * 所有任务执行
+ */
+class AsyncTaskParallelController {
+    constructor(maxParallel, checkInterval = 20) {
+        this.tasks = [];
+        this.maxParallel = Number(maxParallel) || 20;
+        this.checkInterval = checkInterval;
+    }
+    loadTasks(tasks) {
+        this.tasks.push(...tasks);
+        this.totalTasks = this.tasks.length;
+    }
+    push(task) {
+        this.tasks.push(task);
+        this.totalTasks = this.tasks.length;
+    }
+    // 开始执行任务
+    async run() {
+        // 存储任务执行结果
+        const results = [];
+        // 记录已经运行的任务
+        const taskHasRun = [];
+        // 记录任务是否执行完成
+        const taskDone = [];
+        // 当前正在运行的任务数量
+        let runningTask = 0;
+        return new Promise(resolve => {
+            // 使用定时器，不阻塞线程
+            const timer = setInterval(() => {
+                // 全部任务运行完成
+                const taskDoneLength = taskDone.filter(item => item).length;
+                if (runningTask === 0 && taskDoneLength === this.totalTasks) {
+                    clearInterval(timer);
+                    resolve(results);
+                }
+                // 当前运行任务数超过最大并发，不再执行新的任务
+                if (runningTask >= this.maxParallel) {
+                    return;
+                }
+                // 遍历任务列表，开始执行还没有执行的任务
+                this.tasks.forEach((task, index) => {
+                    if (!taskHasRun[index] && runningTask < this.maxParallel) {
+                        runningTask++;
+                        taskHasRun[index] = 1;
+                        task()
+                            .then(res => {
+                            results[index] = res;
+                        })
+                            .catch(err => {
+                            results[index] = err;
+                        })
+                            .then(() => {
+                            runningTask--;
+                            taskDone[index] = 1;
+                        });
+                    }
+                });
+            }, this.checkInterval);
+        });
+    }
+}
+exports.AsyncTaskParallelController = AsyncTaskParallelController;

package/lib/utils/runenv.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkIsInScf = void 0;
+function checkIsInScf() {
+    // TENCENTCLOUD_RUNENV
+    return process.env.TENCENTCLOUD_RUNENV === 'SCF';
+}
+exports.checkIsInScf = checkIsInScf;

package/lib/utils/uuid.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uuidv4 = exports.guid6 = void 0;
+// 环境 uuid
+function guid6() {
+    return Math.floor((1 + Math.random()) * 0x1000000)
+        .toString(16)
+        .substring(1);
+}
+exports.guid6 = guid6;
+function uuidv4() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+        const r = (Math.random() * 16) | 0;
+        const v = c === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+exports.uuidv4 = uuidv4;

package/package.json

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

package/types/access/index.d.ts

@@ -0,0 +1,38 @@
+import { Environment } from '../environment';
+import { ICreateAccessOptions, IApi, IUpdateOptions, IService, IDeleteOptions, IGetOptions, IDomainOptions } from './types';
+import { IResponseInfo } from '../interfaces';
+export declare class AccessService {
+    private tcbService;
+    private environment;
+    constructor(environment: Environment);
+    createAccess(options: ICreateAccessOptions): Promise<{
+        APIId: string;
+        RequestId: string;
+    }>;
+    getDomainList(): Promise<{
+        RequestId: string;
+        DefaultDomain: string;
+        EnableService: boolean;
+        ServiceSet: IService[];
+    }>;
+    getAccessList(options?: IGetOptions): Promise<{
+        RequestId: string;
+        APISet: IApi[];
+        Total: number;
+        Limit: number;
+        Offset: number;
+        EnableService: boolean;
+    }>;
+    switchAuth(auth: boolean): Promise<{
+        Count: number;
+        RequestId: string;
+    }>;
+    switchPathAuth(options: IUpdateOptions): Promise<{
+        Count: number;
+        RequestId: string;
+    }>;
+    deleteAccess(options: IDeleteOptions): Promise<IResponseInfo>;
+    addCustomDomain(options: IDomainOptions): Promise<IResponseInfo>;
+    deleteCustomDomain(domain: string): Promise<IResponseInfo>;
+    private getEnvInfo;
+}

package/types/access/types.d.ts

@@ -0,0 +1,42 @@
+export interface ICreateAccessOptions {
+    path: string;
+    name: string;
+    type?: 1 | 2;
+    auth?: boolean;
+}
+export interface IApi {
+    ServiceId: string;
+    APIId: string;
+    Path: string;
+    Type: number;
+    Name: string;
+    CreateTime: number;
+    EnvId: string;
+    EnableAuth: boolean;
+}
+export interface IUpdateOptions {
+    apiIds: string[];
+    auth: boolean;
+}
+export interface IService {
+    ServiceId: string;
+    Domain: string;
+    OpenTime: number;
+    Status?: number;
+}
+export interface IDeleteOptions {
+    name?: string;
+    type?: number;
+    apiId?: string;
+    path?: string;
+}
+export interface IGetOptions {
+    path?: string;
+    name?: string;
+    limit?: number;
+    offset?: number;
+}
+export interface IDomainOptions {
+    domain: string;
+    certId?: string;
+}

package/types/billing/index.d.ts

@@ -0,0 +1,21 @@
+import { CloudBaseContext } from '../context';
+import { IServiceVersion, IGoodItem, IGenerateDealsRes, IPayDealsRes } from '../interfaces';
+export declare class BillingService {
+    static billServiceVersion: IServiceVersion;
+    private billService;
+    constructor(context: CloudBaseContext);
+    /**
+     * 创建订单
+     * @param {Array<IGoodItem>} goods
+     * @returns {Promise<IGenerateDealsRes>}
+     * @memberof BillingService
+     */
+    GenerateDeals(goods: Array<IGoodItem>): Promise<IGenerateDealsRes>;
+    /**
+     * 支付订单
+     * @param {Array<string>} orderIds
+     * @returns {Promise<IPayDealsRes>}
+     * @memberof BillingService
+     */
+    PayDeals(orderIds: Array<string>): Promise<IPayDealsRes>;
+}

package/types/cam/index.d.ts

@@ -0,0 +1,63 @@
+import { CloudBaseContext } from '../context';
+import { IServiceVersion, IRoleListRes, ICreateRoleRes, IResponseInfo, IGetRoleRes } from '../interfaces';
+export declare class CamService {
+    static camServiceVersion: IServiceVersion;
+    private camService;
+    constructor(context: CloudBaseContext);
+    /**
+     * 查询账户角色列表
+     * @param {number} page
+     * @param {number} rp
+     * @returns {Promise<IRoleListRes>}
+     * @memberof CamService
+     */
+    describeRoleList(page: number, rp: number): Promise<IRoleListRes>;
+    /**
+     * 获取角色详情
+     * @param {string} roleName
+     * @returns {Promise<IGetRoleRes>}
+     * @memberof CamService
+     */
+    getRole(roleName: string): Promise<IGetRoleRes>;
+    /**
+     * 创建角色
+     * @param {{
+     *         RoleName: string
+     *         PolicyDocument: string
+     *         Description: string
+     *     }} param
+     * @returns {Promise<ICreateRoleRes>}
+     * @memberof CamService
+     */
+    createRole(param: {
+        RoleName: string;
+        PolicyDocument: string;
+        Description: string;
+    }): Promise<ICreateRoleRes>;
+    /**
+     * 绑定角色策略
+     * @param {{
+     *         PolicyId: number
+     *         AttachRoleName: string
+     *     }} param
+     * @returns {Promise<IResponseInfo>}
+     * @memberof CamService
+     */
+    attachRolePolicy(param: {
+        PolicyId: number;
+        AttachRoleName: string;
+    }): Promise<IResponseInfo>;
+    attachRolePolicies(param: {
+        RoleId?: number;
+        RoleName?: string;
+        PolicyId?: number[];
+        PolicyName?: string[];
+    }): Promise<IResponseInfo>;
+    /**
+     * 删除角色
+     * @param {string} roleName
+     * @returns {Promise<IResponseInfo>}
+     * @memberof CamService
+     */
+    deleteRole(roleName: string): Promise<IResponseInfo>;
+}

package/types/cloudBaseRun/index.d.ts

@@ -0,0 +1,12 @@
+import { Environment } from '../environment';
+import { IModifyServerFlowOption } from './types';
+export declare class CloudBaseRunService {
+    private tcbService;
+    private environment;
+    constructor(environment: Environment);
+    modifyServerFlow(options: IModifyServerFlowOption): Promise<{
+        Result: string;
+        RequestId: string;
+    }>;
+    private getEnvInfo;
+}

package/types/cloudBaseRun/types.d.ts

@@ -0,0 +1,21 @@
+export interface IModifyServerFlowOption {
+    serverName: string;
+    versionFlowItems?: ICloudBaseRunVersionFlowItem[];
+    trafficType?: string;
+}
+export interface ICloudBaseRunVersionFlowItem {
+    versionName: string;
+    flowRatio: number;
+    urlParam?: IObjectKV;
+    priority?: number;
+    isDefaultPriority?: boolean;
+}
+export interface IObjectKV {
+    key: string;
+    value: string;
+}
+export interface IClouBaseRunKVPriority {
+    key: string;
+    value: string;
+    priority: number;
+}

package/types/common/index.d.ts

@@ -0,0 +1,18 @@
+import { Environment } from '../environment';
+interface ICommonApiServiceOption {
+    Action: string;
+    Param: Record<string, any>;
+}
+export declare class CommonService {
+    private commonService;
+    private environment;
+    constructor(environment: Environment, serviceType: string, serviceVersion: string);
+    /**
+     * 公共方法调用
+     * @param {ICommonApiServiceParam} param
+     * @returns {Promise<any>}
+     * @memberof CommonService
+     */
+    call(options: ICommonApiServiceOption): Promise<any>;
+}
+export {};

package/types/constant.d.ts

@@ -0,0 +1,44 @@
+export declare const ENV_NAME: {
+    ENV_SECRETID: string;
+    ENV_SECRETKEY: string;
+    ENV_SESSIONTOKEN: string;
+    ENV_TCB_ENV_ID: string;
+    ENV_RUNENV: string;
+    ENV_RUNENV_SCF: string;
+};
+export declare const SDK_VERSION = "TCB-NODE-MANAGER/1.0.O";
+export declare const RUN_ENV: {
+    SCF: string;
+};
+export declare const ENDPOINT: {
+    TCB: string;
+    SCF: string;
+    COS: string;
+    FLEXDB: string;
+};
+export declare const SERVICE_TYPE: {
+    TCB: string;
+};
+export declare const ERROR: {
+    MISS_SECRET_INFO_IN_ENV: string;
+    MISS_SECRET_INFO_IN_ARGS: string;
+    CURRENT_ENVIRONMENT_IS_NULL: string;
+    ENV_ID_NOT_EXISTS: string;
+};
+export declare const PUBLIC_RSA_KEY = "\n-----BEGIN PUBLIC KEY-----\nMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC0ZLB0ZpWWFsHPnDDw++Nc2wI3\nnl2uyOrIJ5FUfxt4GAmt1Faf5pgMxAnL9exEUrrUDUX8Ri1R0KyfnHQQwCvKt8T8\nbgILIJe9UB8e9dvFqgqH2oA8Vqwi0YqDcvFLFJk2BJbm/0QYtZ563FumW8LEXAgu\nUeHi/0OZN9vQ33jWMQIDAQAB\n-----END PUBLIC KEY-----\n";
+export declare const ROLE_NAME: {
+    TCB: string;
+};
+export declare const SCF_STATUS: {
+    ACTIVE: string;
+    CREATING: string;
+    UPDATING: string;
+    CREATE_FAILED: string;
+};
+export declare const USE_INTERNAL_ENDPOINT: boolean;
+export declare const enum COS_ENDPOINT {
+    INTERNAL = "{Bucket}.cos-internal.{Region}.tencentcos.cn",
+    PUBLIC = "{Bucket}.cos.{Region}.tencentcos.cn"
+}
+export declare const COS_SDK_PROTOCOL: string;
+export declare const COS_SDK_KEEPALIVE: string;

package/types/context.d.ts

@@ -0,0 +1,17 @@
+export declare class CloudBaseContext {
+    readonly secretId: string;
+    readonly secretKey: string;
+    readonly token: string;
+    readonly proxy: string;
+    readonly envId: string;
+    readonly region: string;
+    readonly envType: string;
+    constructor({ secretId, secretKey, token, proxy, region, envType }: {
+        secretId?: string;
+        secretKey?: string;
+        token?: string;
+        proxy?: string;
+        region?: string;
+        envType?: string;
+    });
+}

package/types/database/index.d.ts

@@ -0,0 +1,66 @@
+import { IServiceVersion, IExistsRes, CreateIndex, DropIndex, IndexInfo, TableInfo, Pager, IResponseInfo, CollectionDispension } from '../interfaces/';
+import { Environment } from '../environment';
+interface IDatabaseConfig {
+    Tag: string;
+}
+interface IIndexiesInfo {
+    CreateIndexes?: Array<CreateIndex>;
+    DropIndexes?: Array<DropIndex>;
+}
+interface ITableInfo extends IResponseInfo {
+    Indexes?: Array<IndexInfo>;
+    IndexNum?: number;
+}
+interface IMgoQueryInfo {
+    MgoLimit?: number;
+    MgoOffset?: number;
+}
+interface ICollectionInfo extends IResponseInfo {
+    Collections: Array<TableInfo>;
+    Pager: Pager;
+}
+interface ICollectionExistInfo extends IResponseInfo {
+    IsCreated: boolean;
+    ExistsResult: IExistsRes;
+}
+interface IDistributionInfo extends IResponseInfo {
+    Collections: CollectionDispension;
+    Count: number;
+    Total: number;
+}
+interface IDatabaseMigrateQueryInfo extends IResponseInfo {
+    Status: string;
+    RecordSuccess: number;
+    RecordFail: number;
+    ErrorMsg: string;
+    FileUrl: string;
+}
+interface IDatabaseImportAndExportInfo extends IResponseInfo {
+    JobId: number;
+}
+export declare class DatabaseService {
+    static tcbServiceVersion: IServiceVersion;
+    static flexdbServiceVersion: IServiceVersion;
+    private environment;
+    private envId;
+    private dbOpService;
+    private collOpService;
+    private DEFAULT_MGO_OFFSET;
+    private DEFAULT_MGO_LIMIT;
+    constructor(environment: Environment);
+    getCurrEnvironment(): Environment;
+    getDatabaseConfig(): IDatabaseConfig;
+    checkCollectionExists(collectionName: string): Promise<IExistsRes>;
+    createCollection(collectionName: string): Promise<any>;
+    deleteCollection(collectionName: string): Promise<any>;
+    updateCollection(collectionName: string, indexiesInfo: IIndexiesInfo): Promise<any>;
+    describeCollection(collectionName: string): Promise<ITableInfo>;
+    listCollections(options?: IMgoQueryInfo): Promise<ICollectionInfo>;
+    createCollectionIfNotExists(collectionName: string): Promise<ICollectionExistInfo>;
+    checkIndexExists(collectionName: string, indexName: string): Promise<IExistsRes>;
+    distribution(): Promise<IDistributionInfo>;
+    migrateStatus(jobId: number): Promise<IDatabaseMigrateQueryInfo>;
+    import(collectionName: string, file: any, options: any): Promise<IDatabaseImportAndExportInfo>;
+    export(collectionName: string, file: any, options: any): Promise<IDatabaseImportAndExportInfo>;
+}
+export {};

package/types/debug.d.ts

@@ -0,0 +1 @@
+export {};