@cloudbase/manager-node 4.1.0 → 4.1.1

package/src/env/index.ts

@@ -1,362 +0,0 @@
-import COS from 'cos-nodejs-sdk-v5'
-import Util from 'util'
-import { Environment } from '../environment'
-import {
-    IResponseInfo,
-    AuthDomain,
-    EnvInfo,
-    LoginConfigItem,
-    ICheckTcbServiceRes,
-    ICreatePostpayRes
-} from '../interfaces'
-import { CloudBaseError } from '../error'
-import { rsaEncrypt, CloudService, preLazy } from '../utils'
-
-type SOURCE = 'miniapp' | 'qcloud'
-
-interface IDeleteDomainRes {
-    RequestId: string
-    Deleted: number
-}
-
-interface IAuthDomainsRes {
-    RequestId: string
-    Domains: AuthDomain[]
-}
-
-interface IListEnvRes {
-    RequestId: string
-    EnvList: EnvInfo[]
-}
-
-interface IEnvLoginConfigRes {
-    RequestId: string
-    ConfigList: LoginConfigItem[]
-}
-
-interface IInitParam {
-    Channel?: string
-    Source?: string
-}
-
-export class EnvService {
-    private environment: Environment
-    private envId: string
-    private cloudService: CloudService
-    private envType?: string
-
-    constructor(environment: Environment) {
-        this.environment = environment
-        this.envId = environment.getEnvId()
-        this.envType = environment.getEnvType()
-        this.cloudService = new CloudService(environment.cloudBaseContext, 'tcb', '2018-06-08')
-    }
-
-    /**
-     * 列出所有环境
-     * @returns {Promise<IListEnvRes>}
-     */
-    async listEnvs(): Promise<IListEnvRes> {
-        return this.cloudService.request('DescribeEnvs')
-    }
-
-    /**
-     * 拉取安全域名列表
-     * @returns {Promise<IAuthDomainsRes>}
-     */
-    public async getEnvAuthDomains(): Promise<IAuthDomainsRes> {
-        return this.cloudService.request('DescribeAuthDomains', {
-            EnvId: this.envId
-        })
-    }
-
-    /**
-     * 添加环境安全域名
-     * @param {string[]} domains 域名字符串数组
-     * @returns {Promise<IResponseInfo>}
-     */
-    @preLazy()
-    public async createEnvDomain(domains: string[]): Promise<IResponseInfo> {
-        const res = await this.cloudService.request<IResponseInfo>('CreateAuthDomain', {
-            EnvId: this.envId,
-            Domains: domains
-        })
-        // 添加 COS CORS 域名
-        const promises = domains.map(async domain => {
-            this.modifyCosCorsDomain(domain)
-        })
-        await Promise.all(promises)
-        return res
-    }
-
-    /**
-     * 删除环境安全域名
-     * @param {string[]} domainIds 域名字符串数组
-     * @returns {Promise<IDeleteDomainRes>}
-     */
-    @preLazy()
-    public async deleteEnvDomain(domains: string[]): Promise<IDeleteDomainRes> {
-        // 根据域名获取域名 Id
-        const { Domains } = await this.getEnvAuthDomains()
-        const domainIds = Domains.filter(item => domains.includes(item.Domain)).map(item => item.Id)
-        const res = await this.cloudService.request<IDeleteDomainRes>('DeleteAuthDomain', {
-            EnvId: this.envId,
-            DomainIds: domainIds
-        })
-        // 删除 COS CORS 域名
-        const promises = domains.map(async domain => {
-            this.modifyCosCorsDomain(domain, true)
-        })
-        await Promise.all(promises)
-        return res
-    }
-
-    /**
-     * 检查tcb服务是否开通
-     * @returns {Promise<ICheckTcbServiceRes>}
-     * @memberof CamService
-     */
-    public async checkTcbService(): Promise<ICheckTcbServiceRes> {
-        return this.cloudService.request<ICheckTcbServiceRes>('CheckTcbService', {})
-    }
-
-    /**
-     * 初始化TCB
-     * @returns {Promise<IResponseInfo>}
-     * @memberof EnvService
-     */
-    public async initTcb(param: IInitParam): Promise<IResponseInfo> {
-        let initParam = {}
-        if (param) {
-            initParam = { ...param }
-        }
-
-        return this.cloudService.request<IResponseInfo>('InitTcb', initParam)
-    }
-
-    /**
-     * 开通后付费套餐
-     * @param {string} envId
-     * @param {SOURCE} [source]
-     * @returns {Promise<ICreatePostpayRes>}
-     * @memberof EnvService
-     */
-    public async CreatePostpayPackage(envId: string, source?: SOURCE): Promise<ICreatePostpayRes> {
-        const realSource = source ? source : 'qcloud'
-        return this.cloudService.request<ICreatePostpayRes>('CreatePostpayPackage', {
-            EnvId: envId,
-            Source: realSource
-        })
-    }
-
-    /**
-     * 销毁环境
-     * @param {string} envId
-     * @returns {Promise<IResponseInfo>}
-     * @memberof EnvService
-     */
-    public async destroyEnv(envId: string): Promise<IResponseInfo> {
-        return this.cloudService.request<IResponseInfo>('DestroyEnv', {
-            EnvId: envId
-        })
-    }
-
-    /**
-     * 获取环境信息
-     * @returns {Promise<IEnvInfoRes>}
-     */
-    public async getEnvInfo(): Promise<{
-        EnvInfo: EnvInfo
-        RequestId: string
-    }> {
-        // NOTE: DescribeEnv 接口废弃，需要使用 DescribeEnvs 接口
-        const params: any = {
-            EnvId: this.envId
-        }
-
-        if (this.envType === 'run') {
-            params.EnvType = 'run'
-        }
-
-        const { EnvList, RequestId } = await this.cloudService.request('DescribeEnvs', params)
-
-        return {
-            EnvInfo: EnvList?.length ? EnvList[0] : {},
-            RequestId
-        }
-    }
-
-    /**
-     * 修改环境名称
-     * @param {string} alias 环境名称
-     * @returns {Promise<IResponseInfo>}
-     */
-    public async updateEnvInfo(alias: string): Promise<IResponseInfo> {
-        return this.cloudService.request('ModifyEnv', {
-            EnvId: this.envId,
-            Alias: alias
-        })
-    }
-
-    /**
-     * 拉取登录配置列表
-     * @returns {Promise<IEnvLoginConfigRes>}
-     */
-    async getLoginConfigList(): Promise<IEnvLoginConfigRes> {
-        return this.cloudService.request('DescribeLoginConfigs', {
-            EnvId: this.envId
-        })
-    }
-
-    /**
-     * 创建登录方式
-     * 'WECHAT-OPEN'：微信开放平台
-     * 'WECHAT-PUBLIC'：微信公众平台
-     * @param {('WECHAT-OPEN' | 'WECHAT-PUBLIC')} platform 'WECHAT-OPEN' | 'WECHAT-PUBLIC'
-     * @param {string} appId 微信 appId
-     * @param {string} appSecret 微信 appSecret
-     * @returns {Promise<IResponseInfo>}
-     */
-    async createLoginConfig(
-        platform: 'WECHAT-OPEN' | 'WECHAT-PUBLIC' | 'QQ' | 'ANONYMOUS' | 'USERNAME',
-        appId: string,
-        appSecret?: string
-    ): Promise<IResponseInfo> {
-        let finalAppSecret = appSecret
-
-        if (platform === 'ANONYMOUS') {
-            finalAppSecret = 'anonymous'
-        }
-
-        return this.cloudService.request('CreateLoginConfig', {
-            EnvId: this.envId,
-            // 平台， “QQ" "WECHAT-OPEN" "WECHAT-PUBLIC"
-            Platform: platform,
-            PlatformId: appId,
-            PlatformSecret: finalAppSecret ? rsaEncrypt(finalAppSecret) : undefined,
-            Status: 'ENABLE'
-        })
-    }
-
-    /**
-     * 更新登录方式配置
-     * @param {string} configId 配置 Id，从配置列表中获取
-     * @param {string} [status='ENABLE'] 是否启用 'ENABLE', 'DISABLE' ，可选
-     * @param {string} [appId=''] 微信 appId，可选
-     * @param {string} [appSecret=''] 微信 appSecret，可选
-     * @returns {Promise<IResponseInfo>}
-     */
-    /* eslint-disable-next-line */
-    async updateLoginConfig(
-        configId: string,
-        status = 'ENABLE',
-        appId = '',
-        appSecret = ''
-    ): Promise<IResponseInfo> {
-        const validStatus = ['ENABLE', 'DISABLE']
-        let finalAppSecret = appSecret
-
-        if (!validStatus.includes(status)) {
-            throw new CloudBaseError(
-                `Invalid status value: ${status}. Only support 'ENABLE', 'DISABLE'`
-            )
-        }
-        const params: any = {
-            EnvId: this.envId,
-            ConfigId: configId,
-            Status: status
-        }
-
-        if (appId === 'anonymous') {
-            finalAppSecret = 'anonymous'
-        }
-
-        appId && (params.PlatformId = appId)
-        finalAppSecret && (params.PlatformSecret = rsaEncrypt(finalAppSecret))
-
-        return this.cloudService.request('UpdateLoginConfig', params)
-    }
-
-    // 创建自定义登录私钥
-    public async createCustomLoginKeys(): Promise<{
-        PrivateKey: string // 自定义签名私钥
-        KeyID: string // 私钥id
-        RequestId: string // 请求ID
-    }> {
-        return this.cloudService.request<{
-            PrivateKey: string // 自定义签名私钥
-            KeyID: string // 私钥id
-            RequestId: string // 请求ID
-        }>('CreateCustomLoginKeys', {
-            EnvId: this.envId
-        })
-    }
-
-    // 获取 COS CORS 域名
-    private async getCOSDomains() {
-        const cos = this.getCos()
-        const getBucketCors = Util.promisify(cos.getBucketCors).bind(cos)
-        const { bucket, region } = this.getStorageConfig()
-
-        const res = await getBucketCors({
-            Bucket: bucket,
-            Region: region
-        })
-        return res.CORSRules
-    }
-
-    // 添加 COS CORS 域名，和 Web 端行为保持一致
-    private async modifyCosCorsDomain(domain: string, deleted = false) {
-        const cos = this.getCos()
-        const putBucketCors = Util.promisify(cos.putBucketCors).bind(cos)
-        const { bucket, region } = this.getStorageConfig()
-
-        // 去掉原有此域名CORS配置
-        let corsRules = await this.getCOSDomains()
-        corsRules = corsRules.filter(item => {
-            return !(
-                item.AllowedOrigins &&
-                item.AllowedOrigins.length === 2 &&
-                item.AllowedOrigins[0] === `http://${domain}` &&
-                item.AllowedOrigins[1] === `https://${domain}`
-            )
-        })
-
-        if (!deleted) {
-            corsRules.push({
-                AllowedOrigin: [`http://${domain}`, `https://${domain}`],
-                AllowedMethod: ['GET', 'POST', 'PUT', 'DELETE', 'HEAD'],
-                AllowedHeader: ['*'],
-                ExposeHeader: ['Etag', 'Date'],
-                MaxAgeSeconds: '5'
-            })
-        }
-
-        await putBucketCors({
-            Bucket: bucket,
-            Region: region,
-            CORSRules: corsRules
-        })
-    }
-
-    private getCos() {
-        const { secretId, secretKey, token } = this.environment.getAuthConfig()
-
-        return new COS({
-            SecretId: secretId,
-            SecretKey: secretKey,
-            SecurityToken: token
-        })
-    }
-
-    private getStorageConfig() {
-        const envConfig = this.environment.lazyEnvironmentConfig
-        const storageConfig = envConfig?.Storages?.[0]
-        const { Region, Bucket } = storageConfig
-        return {
-            env: envConfig.EnvId,
-            region: Region,
-            bucket: Bucket
-        }
-    }
-}

package/src/environment.ts

@@ -1,156 +0,0 @@
-import { DatabaseService } from './database'
-import { FunctionService } from './function'
-import { StorageService } from './storage'
-
-import { EnvService } from './env'
-import { CommonService } from './common'
-
-import { CloudBaseContext } from './context'
-import { CloudBaseError } from './error'
-import { RUN_ENV, ENV_NAME, ERROR } from './constant'
-import { getRuntime, getEnvVar } from './utils'
-import { HostingService } from './hosting'
-import { ThirdService } from './third'
-import { AccessService } from './access'
-import { UserService } from './user'
-import { CloudBaseRunService } from './cloudBaseRun'
-import { EnvInfo } from './interfaces'
-
-export class Environment {
-    public inited = false
-    public cloudBaseContext: CloudBaseContext
-    public lazyEnvironmentConfig: EnvInfo
-    private envId: string
-    private envType?: string
-
-    private functionService: FunctionService
-    private databaseService: DatabaseService
-    private storageService: StorageService
-    private envService: EnvService
-    private hostingService: HostingService
-    private thirdService: ThirdService
-    private accessService: AccessService
-    private userService: UserService
-    private cloudBaseRunService: CloudBaseRunService
-
-    constructor(context: CloudBaseContext, envId: string) {
-        this.envId = envId
-        this.cloudBaseContext = context
-        this.envType = context.envType
-
-        // 拉取当前环境 的环境信息 todo
-        this.functionService = new FunctionService(this)
-        this.databaseService = new DatabaseService(this)
-        this.storageService = new StorageService(this)
-        this.envService = new EnvService(this)
-        this.hostingService = new HostingService(this)
-        this.thirdService = new ThirdService(this)
-        this.accessService = new AccessService(this)
-        this.userService = new UserService(this)
-        this.cloudBaseRunService = new CloudBaseRunService(this)
-    }
-
-    async lazyInit(): Promise<any> {
-        if (!this.inited) {
-            const envConfig = this.envService
-            return envConfig.getEnvInfo().then(envInfo => {
-                this.lazyEnvironmentConfig = envInfo.EnvInfo
-                if (!this.lazyEnvironmentConfig.EnvId) {
-                    throw new CloudBaseError(`Environment ${this.envId} not found`)
-                }
-
-                this.inited = true
-                return this.lazyEnvironmentConfig
-            })
-        } else {
-            return this.lazyEnvironmentConfig
-        }
-    }
-
-    public getEnvId(): string {
-        return this.envId
-    }
-
-    public getEnvType(): string {
-        return this.envType
-    }
-
-    public getStorageService(): StorageService {
-        return this.storageService
-    }
-
-    public getDatabaseService(): DatabaseService {
-        return this.databaseService
-    }
-
-    public getFunctionService(): FunctionService {
-        return this.functionService
-    }
-
-    public getEnvService(): EnvService {
-        return this.envService
-    }
-
-    public getHostingService(): HostingService {
-        return this.hostingService
-    }
-
-    public getThirdService(): ThirdService {
-        return this.thirdService
-    }
-
-    public getAccessService(): AccessService {
-        return this.accessService
-    }
-
-    public getUserService(): UserService {
-        return this.userService
-    }
-
-    public getCloudBaseRunService(): CloudBaseRunService {
-        return this.cloudBaseRunService
-    }
-
-    public getCommonService(serviceType = 'tcb', serviceVersion): CommonService {
-        return new CommonService(this, serviceType, serviceVersion)
-    }
-
-    public getServicesEnvInfo(): Promise<any> {
-        const envConfig = this.envService
-        return envConfig.getEnvInfo().then(envInfo => {
-            return envInfo.EnvInfo
-        })
-    }
-
-    public getAuthConfig() {
-        let { secretId, secretKey, token, proxy, region } = this.cloudBaseContext
-        const envId = this.getEnvId()
-
-        if (!secretId || !secretKey) {
-            // 未主动传入密钥，从环境变量中读取
-            const envSecretId = getEnvVar(ENV_NAME.ENV_SECRETID)
-            const envSecretKey = getEnvVar(ENV_NAME.ENV_SECRETKEY)
-            const envToken = getEnvVar(ENV_NAME.ENV_SESSIONTOKEN)
-            if (!envSecretId || !envSecretKey) {
-                if (getRuntime() === RUN_ENV.SCF) {
-                    throw new Error('missing authoration key, redeploy the function')
-                } else {
-                    throw new Error('missing secretId or secretKey of tencent cloud')
-                }
-            } else {
-                secretId = envSecretId
-                secretKey = envSecretKey
-                token = envToken
-            }
-        }
-
-        return {
-            envId,
-            secretId,
-            secretKey,
-            token,
-            proxy,
-            region
-        }
-    }
-}

package/src/environmentManager.ts

@@ -1,50 +0,0 @@
-import { Environment } from './environment'
-import { ERROR } from './constant'
-import { CloudBaseContext } from './context'
-
-export class EnvironmentManager {
-    private cloudBaseContext: CloudBaseContext
-
-    private envs: object = {}
-
-    private currentEnv: Environment = null
-
-    constructor(context: CloudBaseContext) {
-        this.cloudBaseContext = context
-    }
-
-    public getCurrentEnv(): Environment {
-        if (!this.currentEnv) {
-            throw new Error(ERROR.CURRENT_ENVIRONMENT_IS_NULL)
-        }
-        return this.currentEnv
-    }
-
-    public add(envId: string): void {
-        if (!this.envs[envId]) {
-            this.envs[envId] = new Environment(this.cloudBaseContext, envId)
-        }
-        if (!this.currentEnv) {
-            this.currentEnv = this.envs[envId]
-        }
-    }
-
-    public remove(envId: string): void {
-        this.envs[envId] = null
-        delete this.envs[envId]
-    }
-
-    public get(envId: string): Environment | null {
-        return this.envs[envId] || null
-    }
-
-    public switchEnv(envId: string): boolean {
-        const env = this.envs[envId]
-        if (env) {
-            this.currentEnv = env
-            return true
-        } else {
-            return false
-        }
-    }
-}

package/src/error.ts

@@ -1,27 +0,0 @@
-interface Options {
-    exit?: number
-    original?: Error | undefined
-    code?: string | number
-    requestId?: string
-    action?: string
-}
-
-export class CloudBaseError extends Error {
-    readonly exit: number
-    readonly message: string
-    readonly name = 'CloudBaseError'
-    readonly original: Error | undefined
-    readonly code: string | number
-    readonly requestId: string
-    readonly action: string
-
-    constructor(message: string, options: Options = {}) {
-        super()
-        const { code = '', action = '', original = null, requestId = '' } = options
-        this.message = action ? `[${action}] ${message}` : message
-        this.original = original
-        this.code = code
-        this.requestId = requestId
-        this.action = action
-    }
-}