@cloudbase/manager-node 4.2.3 → 4.2.5

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
-    }
-}