@cloudbase/manager-node 4.2.0 → 4.2.1

package/src/cam/index.ts

@@ -0,0 +1,106 @@
+import { CloudService } from '../utils'
+import { CloudBaseContext } from '../context'
+import {
+    IServiceVersion,
+    IRoleListRes,
+    ICreateRoleRes,
+    IResponseInfo,
+    IGetRoleRes
+} from '../interfaces'
+
+export class CamService {
+    static camServiceVersion: IServiceVersion = {
+        service: 'cam',
+        version: '2019-01-16'
+    }
+    private camService: CloudService
+
+    constructor(context: CloudBaseContext) {
+        this.camService = new CloudService(
+            context,
+            CamService.camServiceVersion.service,
+            CamService.camServiceVersion.version
+        )
+    }
+
+    /**
+     * 查询账户角色列表
+     * @param {number} page
+     * @param {number} rp
+     * @returns {Promise<IRoleListRes>}
+     * @memberof CamService
+     */
+    public async describeRoleList(page: number, rp: number): Promise<IRoleListRes> {
+        return this.camService.request<IRoleListRes>('DescribeRoleList', {
+            Page: page,
+            Rp: rp
+        })
+    }
+
+    /**
+     * 获取角色详情
+     * @param {string} roleName
+     * @returns {Promise<IGetRoleRes>}
+     * @memberof CamService
+     */
+    public async getRole(roleName: string): Promise<IGetRoleRes> {
+        return this.camService.request<IGetRoleRes>('GetRole', {
+            RoleName: roleName
+        })
+    }
+
+    /**
+     * 创建角色
+     * @param {{
+     *         RoleName: string
+     *         PolicyDocument: string
+     *         Description: string
+     *     }} param
+     * @returns {Promise<ICreateRoleRes>}
+     * @memberof CamService
+     */
+    public async createRole(param: {
+        RoleName: string
+        PolicyDocument: string
+        Description: string
+    }): Promise<ICreateRoleRes> {
+        return this.camService.request<ICreateRoleRes>('CreateRole', param)
+    }
+
+    /**
+     * 绑定角色策略
+     * @param {{
+     *         PolicyId: number
+     *         AttachRoleName: string
+     *     }} param
+     * @returns {Promise<IResponseInfo>}
+     * @memberof CamService
+     */
+    public async attachRolePolicy(param: {
+        PolicyId: number
+        AttachRoleName: string
+    }): Promise<IResponseInfo> {
+        return this.camService.request<IResponseInfo>('AttachRolePolicy', param)
+    }
+
+    public async attachRolePolicies(param: {
+        RoleId?: number
+        RoleName?: string
+        PolicyId?: number[]
+        PolicyName?: string[]
+    }): Promise<IResponseInfo> {
+        return this.camService.request<IResponseInfo>('AttachRolePolicies', param)
+    }
+
+    /**
+     * 删除角色
+     * @param {string} roleName
+     * @returns {Promise<IResponseInfo>}
+     * @memberof CamService
+     */
+    public async deleteRole(roleName: string): Promise<IResponseInfo> {
+        return this.camService.request<IResponseInfo>('DeleteRole', {
+            RoleName: roleName
+        })
+    }
+}

package/src/cloudBaseRun/index.ts

@@ -0,0 +1,40 @@
+import { Environment } from '../environment'
+import { CloudService, preLazy, upperCaseObjKey } from '../utils'
+import { IModifyServerFlowOption } from './types'
+import { IResponseInfo } from '../interfaces'
+
+export class CloudBaseRunService {
+    private tcbService: CloudService
+    private environment: Environment
+
+    constructor(environment: Environment) {
+        this.environment = environment
+        this.tcbService = new CloudService(environment.cloudBaseContext, 'tcb', '2018-06-08')
+    }
+
+    // 修改容器内版本流量配置
+    @preLazy()
+    public async modifyServerFlow(
+        options: IModifyServerFlowOption
+    ): Promise<{
+        Result: string // succ代表成功
+        RequestId: string // 请求ID
+    }> {
+        const { envId } = this.getEnvInfo()
+
+        return this.tcbService.request('ModifyCloudBaseRunServerFlowConf', {
+            EnvId: envId,
+            ServerName: options.serverName,
+            VersionFlowItems: upperCaseObjKey(options.versionFlowItems)
+            // TrafficType: options.trafficType
+        })
+    }
+
+    private getEnvInfo() {
+        const envConfig = this.environment.lazyEnvironmentConfig
+
+        return {
+            envId: envConfig.EnvId
+        }
+    }
+}

package/src/cloudBaseRun/types.ts

@@ -0,0 +1,24 @@
+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/src/common/index.ts

@@ -0,0 +1,54 @@
+import { CloudService, preLazy } from '../utils'
+import { CloudBaseContext } from '../context'
+import { CloudBaseError } from '../error'
+import { Environment } from '../environment'
+
+interface ICommonApiServiceOption {
+    Action: string // 接口名称
+    Param: Record<string, any> // 接口传参
+}
+/**
+ * 公共的云api调用方法 透传用户参数 无业务逻辑处理
+ * @export
+ * @class CommonService
+ */
+
+const ActionVersionMap = {
+    tcb: '2018-06-08',
+    flexdb: '2018-11-27',
+    scf: '2018-04-16',
+    sts: '2018-04-16',
+    cam: '2018-04-16',
+    lowcode: '2021-01-08'
+}
+
+export class CommonService {
+    private commonService: CloudService
+    private environment: Environment
+
+    constructor(environment: Environment, serviceType: string, serviceVersion: string) {
+        this.environment = environment
+        this.commonService = new CloudService(
+            environment.cloudBaseContext,
+            serviceType,
+            serviceVersion || ActionVersionMap[serviceType]
+        )
+    }
+
+    /**
+     * 公共方法调用
+     * @param {ICommonApiServiceParam} param
+     * @returns {Promise<any>}
+     * @memberof CommonService
+     */
+    public async call(options: ICommonApiServiceOption): Promise<any> {
+        const { Action, Param = {} } = options
+        if (!Action) {
+            throw new CloudBaseError('缺少必填参数 Action')
+        }
+
+        const res = await this.commonService.request(Action, { ...Param })
+
+        return res
+    }
+}

package/src/constant.ts

@@ -0,0 +1,56 @@
+// // cloudbase cli 配置的字段名
+// export class ConfigItems {
+//     static credentail = 'credential'
+// }
+
+export const ENV_NAME = {
+    ENV_SECRETID: 'TENCENTCLOUD_SECRETID',
+    ENV_SECRETKEY: 'TENCENTCLOUD_SECRETKEY',
+    ENV_SESSIONTOKEN: 'TENCENTCLOUD_SESSIONTOKEN',
+    ENV_TCB_ENV_ID: 'TENCENTCLOUD_TCB_ENVID',
+    ENV_RUNENV: 'TENCENTCLOUD_RUNENV',
+    ENV_RUNENV_SCF: 'TENCENTCLOUD_RUNENV=SCF'
+}
+
+export const SDK_VERSION = 'TCB-NODE-MANAGER/1.0.O'
+
+export const RUN_ENV = {
+    SCF: 'SCF'
+}
+
+export const ENDPOINT = {
+    TCB: 'tcb.tencentcloudapi.com',
+    SCF: 'scf.tencentcloudapi.com',
+    COS: 'cos.tencentcloudapi.com',
+    FLEXDB: 'flexdb.tencentcloudapi.com'
+}
+
+export const SERVICE_TYPE = {
+    TCB: 'tcb'
+}
+
+export const ERROR = {
+    MISS_SECRET_INFO_IN_ENV: 'MISS_SECRET_INFO_IN_ENV',
+    MISS_SECRET_INFO_IN_ARGS: 'MISS_SECRET_INFO_IN_ARGS',
+    CURRENT_ENVIRONMENT_IS_NULL: 'CURRENT_ENVIRONMENT_IS_NULL',
+    ENV_ID_NOT_EXISTS: 'ENV_ID_NOT_EXISTS'
+}
+
+export const PUBLIC_RSA_KEY = `
+-----BEGIN PUBLIC KEY-----
+MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC0ZLB0ZpWWFsHPnDDw++Nc2wI3
+nl2uyOrIJ5FUfxt4GAmt1Faf5pgMxAnL9exEUrrUDUX8Ri1R0KyfnHQQwCvKt8T8
+bgILIJe9UB8e9dvFqgqH2oA8Vqwi0YqDcvFLFJk2BJbm/0QYtZ563FumW8LEXAgu
+UeHi/0OZN9vQ33jWMQIDAQAB
+-----END PUBLIC KEY-----
+`
+export const ROLE_NAME = {
+    TCB: 'TCB_QcsRole'
+}
+
+export const SCF_STATUS = {
+    ACTIVE: 'Active',
+    CREATING: 'Creating',
+    UPDATING: 'Updating',
+    CREATE_FAILED: 'CreateFailed'
+}

package/src/context.ts

@@ -0,0 +1,18 @@
+export class CloudBaseContext {
+    public readonly secretId: string
+    public readonly secretKey: string
+    public readonly token: string
+    public readonly proxy: string
+    public readonly envId: string
+    public readonly region: string
+    public readonly envType: string // baas/run/weda/hosting
+
+    constructor({ secretId = '', secretKey = '', token = '', proxy = '', region = '', envType = '' }) {
+        this.secretId = secretId
+        this.secretKey = secretKey
+        this.token = token
+        this.proxy = proxy
+        this.region = region
+        this.envType = envType
+    }
+}

package/src/database/index.ts

@@ -0,0 +1,369 @@
+import path from 'path'
+import {
+    IServiceVersion,
+    IExistsRes,
+    CreateIndex,
+    DropIndex,
+    IndexInfo,
+    TableInfo,
+    Pager,
+    IResponseInfo,
+    CollectionDispension
+} from '../interfaces/'
+import { CloudBaseError } from '../error'
+import { Environment } from '../environment'
+import { CloudService } from '../utils'
+
+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
+}
+
+function preLazy() {
+    return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+        let oldFunc = descriptor.value
+        descriptor.value = async function () {
+            // 检查当前环境对象上是否已加载好环境信息
+            const currentEnvironment = this.environment
+
+            if (!currentEnvironment.inited) {
+                await currentEnvironment.lazyInit()
+            }
+            let result = await oldFunc.apply(this, arguments)
+            return result
+        }
+    }
+}
+
+export class DatabaseService {
+    static tcbServiceVersion: IServiceVersion = {
+        service: 'tcb',
+        version: '2018-06-08'
+    }
+
+    static flexdbServiceVersion: IServiceVersion = {
+        service: 'flexdb',
+        version: '2018-11-27'
+    }
+
+    private environment: Environment
+    private envId: string
+    private dbOpService: CloudService
+    private collOpService: CloudService
+    private DEFAULT_MGO_OFFSET = 0
+    private DEFAULT_MGO_LIMIT = 100
+
+    constructor(environment: Environment) {
+        this.environment = environment
+        this.envId = environment.getEnvId()
+
+        this.dbOpService = new CloudService(
+            environment.cloudBaseContext,
+            DatabaseService.tcbServiceVersion.service,
+            DatabaseService.tcbServiceVersion.version
+        )
+
+        this.collOpService = new CloudService(
+            environment.cloudBaseContext,
+            DatabaseService.flexdbServiceVersion.service,
+            DatabaseService.flexdbServiceVersion.version
+        )
+    }
+
+    public getCurrEnvironment(): Environment {
+        return this.environment
+    }
+
+    public getDatabaseConfig(): IDatabaseConfig {
+        const currEnv = this.environment
+        const { Databases } = currEnv.lazyEnvironmentConfig
+        return {
+            Tag: Databases[0].InstanceId
+        }
+    }
+
+    public async checkCollectionExists(collectionName: string): Promise<IExistsRes> {
+        try {
+            const result = await this.describeCollection(collectionName)
+
+            return {
+                RequestId: result.RequestId,
+                Exists: true
+            }
+        } catch (e) {
+            return {
+                RequestId: e.requestId,
+                Msg: e.message,
+                Exists: false
+            }
+        }
+    }
+
+    @preLazy()
+    public async createCollection(collectionName: string): Promise<any> {
+        let { Tag } = this.getDatabaseConfig()
+
+        const res = await this.collOpService.request('CreateTable', {
+            Tag,
+            TableName: collectionName
+        })
+        return res
+    }
+
+    @preLazy()
+    public async deleteCollection(collectionName: string): Promise<any> {
+        // 先检查当前集合是否存在
+        const existRes = await this.checkCollectionExists(collectionName)
+        if (existRes.Exists) {
+            let { Tag } = this.getDatabaseConfig()
+
+            const res = await this.collOpService.request('DeleteTable', {
+                Tag,
+                TableName: collectionName
+            })
+            return res
+        } else {
+            return existRes
+        }
+    }
+
+    @preLazy()
+    public async updateCollection(
+        collectionName: string,
+        indexiesInfo: IIndexiesInfo
+    ): Promise<any> {
+        let { Tag } = this.getDatabaseConfig()
+
+        const res = await this.collOpService.request('UpdateTable', {
+            Tag,
+            TableName: collectionName,
+            ...indexiesInfo
+        })
+        return res
+    }
+
+    @preLazy()
+    public async describeCollection(collectionName: string): Promise<ITableInfo> {
+        let { Tag } = this.getDatabaseConfig()
+
+        return this.collOpService.request<ITableInfo>('DescribeTable', {
+            Tag,
+            TableName: collectionName
+        })
+    }
+
+    // 获取
+    @preLazy()
+    public async listCollections(
+        options: IMgoQueryInfo = {
+            MgoLimit: this.DEFAULT_MGO_LIMIT,
+            MgoOffset: this.DEFAULT_MGO_OFFSET
+        }
+    ): Promise<ICollectionInfo> {
+        let { Tag } = this.getDatabaseConfig()
+
+        if (options.MgoLimit === undefined) {
+            options.MgoLimit = this.DEFAULT_MGO_LIMIT
+        }
+
+        if (options.MgoOffset === undefined) {
+            options.MgoOffset = this.DEFAULT_MGO_OFFSET
+        }
+
+        const res = await this.collOpService.request<{
+            RequestId: string
+            Pager: Pager
+            Tables?: TableInfo[]
+            Collections: TableInfo[]
+        }>('ListTables', {
+            Tag,
+            ...options
+        })
+
+        if (res.Tables === null) {
+            // 无集合
+            res.Collections = []
+        } else {
+            // 云 API 返回转换为与TCB一致
+            res.Collections = res.Tables.map(item => {
+                item.CollectionName = item.TableName
+                delete item.TableName
+                return item
+            })
+        }
+
+        delete res.Tables
+        return res
+    }
+
+    public async createCollectionIfNotExists(
+        collectionName: string
+    ): Promise<ICollectionExistInfo> {
+        const existRes = await this.checkCollectionExists(collectionName)
+        let res
+        if (!existRes.Exists) {
+            res = await this.createCollection(collectionName)
+            return {
+                RequestId: res.RequestId,
+                IsCreated: true,
+                ExistsResult: existRes
+            }
+        } else {
+            return {
+                RequestId: '',
+                IsCreated: false,
+                ExistsResult: existRes
+            }
+        }
+    }
+
+    // 检查集合中是否存在某索引
+    public async checkIndexExists(collectionName: string, indexName: string): Promise<IExistsRes> {
+        const result = await this.describeCollection(collectionName)
+        let exists = result.Indexes.some(item => {
+            return item.Name === indexName
+        })
+
+        return {
+            RequestId: result.RequestId,
+            Exists: exists
+        }
+    }
+
+    // 查询DB的数据存储分布
+    public async distribution(): Promise<IDistributionInfo> {
+        const res: any = await this.dbOpService.request('DescribeDbDistribution', {
+            EnvId: this.envId
+        })
+
+        return res
+    }
+
+    // 查询DB 迁移进度
+    public async migrateStatus(jobId: number): Promise<IDatabaseMigrateQueryInfo> {
+        const res: IDatabaseMigrateQueryInfo = await this.dbOpService.request(
+            'DatabaseMigrateQueryInfo',
+            {
+                EnvId: this.envId,
+                JobId: jobId
+            }
+        )
+
+        return res
+    }
+
+    // 数据库导入数据
+    public async import(
+        collectionName: string,
+        file: any,
+        options: any
+    ): Promise<IDatabaseImportAndExportInfo> {
+        let filePath
+        let fileType
+        if (file['FilePath']) {
+            let temp = 'tmp/db-imports/'
+            if (options['ObjectKeyPrefix']) {
+                temp = options['ObjectKeyPrefix']
+                delete options['ObjectKeyPrefix']
+            }
+            filePath = path.join(temp, path.basename(file['FilePath']))
+
+            // 调用cos接口 上传文件  todo
+            await this.environment.getStorageService().uploadFile({
+                localPath: file['FilePath'],
+                cloudPath: filePath
+            })
+
+            fileType = path.extname(filePath).substring(1)
+        } else if (file['ObjectKey']) {
+            delete options['ObjectKeyPrefix']
+            filePath = file['ObjectKey']
+            fileType = path.extname(filePath).substring(1)
+        } else {
+            throw new CloudBaseError('Miss file.filePath or file.objectKey')
+        }
+
+        if (file['FileType']) {
+            fileType = file['FileType']
+        }
+
+        return this.dbOpService.request('DatabaseMigrateImport', {
+            CollectionName: collectionName,
+            FilePath: filePath,
+            FileType: fileType,
+            EnvId: this.envId,
+            ...options
+        })
+    }
+
+    // 数据库导出数据
+    public async export(
+        collectionName: string,
+        file: any,
+        options: any
+    ): Promise<IDatabaseImportAndExportInfo> {
+        let filePath
+        let fileType
+
+        if (file['ObjectKey']) {
+            filePath = file['ObjectKey']
+            fileType = path.extname(filePath).substring(1)
+        } else {
+            throw new CloudBaseError('Miss file.filePath or file.objectKey')
+        }
+
+        if (file['FileType']) {
+            fileType = file['FileType']
+        }
+
+        return this.dbOpService.request('DatabaseMigrateExport', {
+            CollectionName: collectionName,
+            FilePath: filePath,
+            FileType: fileType,
+            EnvId: this.envId,
+            ...options
+        })
+    }
+}

package/src/debug.ts

@@ -0,0 +1,34 @@
+import CloudBase from './index'
+// import { cloudBaseConfig } from '../test/config'
+
+// const app = new CloudBase(cloudBaseConfig)
+const app = new CloudBase({})
+
+async function test() {
+    // const hosting = await app.hosting.getInfo()
+    // const { Bucket, Regoin } = hosting[0]
+    // const res = await app.storage.uploadFilesCustom({
+    //     files: [
+    //         {
+    //             localPath: 'test/storage/test_data/data.txt',
+    //             cloudPath: 'test/storage/test_data/data.txt'
+    //         },
+    //         {
+    //             localPath: 'test/storage/test_data/download.txt',
+    //             cloudPath: 'test/storage/test_data/download.txt'
+    //         }
+    //     ],
+    //     region: Regoin,
+    //     bucket: Bucket
+    // })
+
+    const res = await app.hosting.uploadFiles({
+        localPath: '/Users/wuyiqing/Desktop/cloudbase-demo/functions/node-sdk',
+        cloudPath: '',
+        onProgress: console.log
+    })
+
+    console.log(res)
+}
+
+test().catch(console.log)