@cloudbase/utilities 2.5.7-beta.0 → 2.5.20-beta.0

package/src/global.d.ts

@@ -0,0 +1,3 @@
+declare module 'crypto-js/hmac-sha256';
+declare module 'crypto-js/enc-base64';
+declare module 'crypto-js/enc-utf8';

package/src/helpers/decorators.ts

@@ -0,0 +1,228 @@
+import { printGroupLog } from '../libs/util'
+import { IS_DEBUG_MODE } from '../constants'
+
+interface ICatchErrorsDecoratorOptions {
+  mode?: 'sync' | 'async';
+  customInfo?: {
+    className?: string;
+    methodName?: string;
+  };
+  title?: string;
+  messages?: string[];
+}
+// firefox的stack格式与chrome不同
+let isFirefox = false
+if (typeof navigator !== 'undefined' && navigator.userAgent) {
+  isFirefox = navigator.userAgent.indexOf('Firefox') !== -1
+}
+/**
+ * decorate在stack中一般都特定的规范
+ */
+const REG_STACK_DECORATE = isFirefox
+  ? /(\.js\/)?__decorate(\$\d+)?<@.*\d$/
+  : /(\/\w+\.js\.)?__decorate(\$\d+)?\s*\(.*\)$/
+const REG_STACK_LINK = /https?:\/\/.+:\d*\/.*\.js:\d+:\d+/
+/**
+ * debug模式强化日志信息
+ * @param options
+ */
+export function catchErrorsDecorator(options: ICatchErrorsDecoratorOptions) {
+  const { mode = 'async', customInfo = {}, title, messages = [] } = options
+
+  return function (
+    target: any,
+    methodName: string,
+    descriptor: TypedPropertyDescriptor<Function>
+  ) {
+    // 生产环境禁用
+    if (!IS_DEBUG_MODE) {
+      return
+    }
+    const className = customInfo.className || target.constructor.name
+    const fnName = customInfo.methodName || methodName
+    const fn = descriptor.value
+
+    // 被decorator装饰的源码link
+    // 在descriptor.value外部此处创建的stack层次可触达源码
+    // 而descriptor.value内部有可能由于stack太深无法触达
+    const sourceLink = getSourceLink(new Error())
+
+    if (mode === 'sync') {
+      descriptor.value = function (...args: any[]) {
+        // 此处的stack作用主要是为了获取被decorator装饰的源码class和method名称
+        const innerErr: any = getRewritedError({
+          err: new Error(),
+          className,
+          methodName: fnName,
+          sourceLink,
+        })
+        try {
+          return fn.apply(this, args)
+        } catch (err) {
+          let failErr = err
+          const { message: errMsg, error, error_description: errorDescription } = err
+          const logs: any = {
+            title: title || `${className}.${fnName} failed`,
+            content: [{
+              type: 'error',
+              body: err,
+            }],
+          }
+          // 只特殊处理SDK业务逻辑抛出的错误-JSON string
+          if (errMsg && /^\{.*\}$/.test(errMsg)) {
+            const msg = JSON.parse(errMsg)
+            logs.subtitle = errMsg
+            if (msg.code) {
+              if (innerErr) {
+                innerErr.code = msg.code
+                innerErr.msg = msg.msg
+              } else {
+                err.code = msg.code
+                err.message = msg.msg
+              }
+              failErr = innerErr || err
+              logs.content = messages.map(msg => ({
+                type: 'info',
+                body: msg,
+              }))
+            }
+          }
+
+          // oauth 错误特殊处理
+          if (error && errorDescription) {
+            logs.subtitle = errorDescription
+            if (innerErr) {
+              innerErr.code = error
+              innerErr.msg = errorDescription
+            } else {
+              err.code = error
+              err.message = errorDescription
+            }
+            failErr = innerErr || err
+            logs.content = messages.map(msg => ({
+              type: 'info',
+              body: msg,
+            }))
+          }
+          printGroupLog(logs)
+          throw failErr
+        }
+      }
+    } else {
+      descriptor.value = async function (...args: any[]) {
+        const innerErr: any = getRewritedError({
+          err: new Error(),
+          className,
+          methodName: fnName,
+          sourceLink,
+        })
+
+        try {
+          return await fn.apply(this, args)
+        } catch (err) {
+          let failErr = err
+          const { message: errMsg, error, error_description: errorDescription } = err
+          const logs: any = {
+            title: title || `${className}.${fnName} failed`,
+            content: [{
+              type: 'error',
+              body: err,
+            }],
+          }
+          // 只特殊处理SDK业务逻辑抛出的错误-JSON string
+          if (errMsg && /^\{.*\}$/.test(errMsg)) {
+            const msg = JSON.parse(errMsg)
+            logs.subtitle = msg
+            if (msg.code) {
+              if (innerErr) {
+                innerErr.code = msg.code
+                innerErr.message = msg.msg
+              } else {
+                err.code = msg.code
+                err.message = msg.msg
+              }
+              failErr = innerErr || err
+              logs.content = messages.map(msg => ({
+                type: 'info',
+                body: msg,
+              }))
+            }
+          }
+
+          // oauth 错误特殊处理
+          if (error && errorDescription) {
+            logs.subtitle = errorDescription
+            if (innerErr) {
+              innerErr.code = error
+              innerErr.msg = errorDescription
+            } else {
+              err.code = error
+              err.message = errorDescription
+            }
+            failErr = innerErr || err
+            logs.content = messages.map(msg => ({
+              type: 'info',
+              body: msg,
+            }))
+          }
+          printGroupLog(logs)
+          throw failErr
+        }
+      }
+    }
+  }
+}
+
+/**
+ * 在原始堆栈中查找装饰器条目并返回源码链接link
+ * @param err
+ */
+function getSourceLink(err: Error) {
+  let sourceLink = ''
+  const outterErrStacks = err.stack.split('\n')
+  const indexOfDecorator = outterErrStacks.findIndex(str => REG_STACK_DECORATE.test(str))
+
+  if (indexOfDecorator !== -1) {
+    const match = REG_STACK_LINK.exec(outterErrStacks[indexOfDecorator + 1] || '')
+
+    sourceLink = match ? match[0] : ''
+  }
+  return sourceLink
+}
+
+/**
+ * 在原始堆栈中查找装饰器条目，剔除其后的无用堆栈，并将链接替换为源码link
+ * @param options
+ */
+function getRewritedError(options: {
+  err: Error;
+  className: string;
+  methodName: string;
+  sourceLink: string;
+}) {
+  const { err, className, methodName, sourceLink } = options
+  // 找不到源码link返回null，后续逻辑将打印原堆栈信息
+  if (!sourceLink) {
+    return null
+  }
+
+  const innerErrStack = err.stack.split('\n')
+  const REG_STACK_INNER_METHOD = isFirefox
+    ? /^catchErrorsDecorator\/<\/descriptor.value@.*\d$/
+    : new RegExp(`${className}\\.descriptor.value\\s*\\[as\\s${methodName}\\]\\s*\\(.*\\)$`)
+  const REG_STACK_INNER_METHOD_WITHOUT_LINK = isFirefox
+    ? /^catchErrorsDecorator\/<\/descriptor.value/
+    : new RegExp(`${className}\\.descriptor.value\\s*\\[as\\s${methodName}\\]`)
+  const indexOfSource = innerErrStack.findIndex(str => REG_STACK_INNER_METHOD.test(str))
+  let innerErr: Error
+  if (indexOfSource !== -1) {
+    // @ts-ignore
+    const realErrStack = innerErrStack.filter((v, i) => i > indexOfSource)
+    realErrStack.unshift(innerErrStack[indexOfSource]
+      .replace(REG_STACK_INNER_METHOD_WITHOUT_LINK, `${className}.${methodName}`)
+      .replace(REG_STACK_LINK, sourceLink))
+    innerErr = new Error()
+    innerErr.stack = `${isFirefox ? '@debugger' : 'Error'}\n${realErrStack.join('\n')}`
+  }
+  return innerErr
+}

package/src/helpers/index.ts

@@ -0,0 +1 @@
+export * from './decorators'

package/src/index.ts

@@ -0,0 +1,22 @@
+import * as constants from './constants'
+import * as adapters from './adapters'
+import * as cache from './libs/cache'
+import * as events from './libs/events'
+import * as utils from './libs/util'
+import * as helpers from './helpers'
+
+import jwtDecode from 'jwt-decode'
+
+const jwt = {
+  decode: jwtDecode,
+}
+
+export {
+  constants,
+  adapters,
+  cache,
+  events,
+  utils,
+  helpers,
+  jwt,
+}

package/src/libs/cache.ts

@@ -0,0 +1,192 @@
+import { StorageInterface, AbstractStorage, SDKAdapterInterface } from '@cloudbase/adapter-interface'
+import { ICloudbaseCache, ICacheConfig } from '@cloudbase/types/cache'
+import { KV, Persistence, ICloudbasePlatformInfo } from '@cloudbase/types'
+import { printWarn } from './util'
+import { ERRORS, getSdkName } from '../constants'
+
+/**
+ * persitence=none时登录态保存在内存中
+ */
+class TcbCacheObject extends AbstractStorage {
+  private readonly root: any;
+  constructor(root: any) {
+    super()
+    this.root = root
+    if (!root.tcbCacheObject) {
+      root.tcbCacheObject = {}
+    }
+  }
+  public setItem(key: string, value: any) {
+    this.root.tcbCacheObject[key] = value
+  }
+  public getItem(key: string) {
+    return this.root.tcbCacheObject[key]
+  }
+  public removeItem(key: string) {
+    delete this.root.tcbCacheObject[key]
+  }
+  public clear() {
+    delete this.root.tcbCacheObject
+  }
+}
+/**
+ * 工厂函数
+ */
+function createStorage(persistence: Persistence, adapter: SDKAdapterInterface): StorageInterface {
+  switch (persistence) {
+    case 'local':
+      if (!adapter.localStorage) {
+        printWarn(ERRORS.INVALID_PARAMS, 'localStorage is not supported on current platform')
+        // 不支持localstorage的平台降级为none
+        return new TcbCacheObject(adapter.root)
+      }
+      return adapter.localStorage
+    case 'none':
+      return new TcbCacheObject(adapter.root)
+    default:
+      if (!adapter.localStorage) {
+        printWarn(ERRORS.INVALID_PARAMS, 'localStorage is not supported on current platform')
+        // 不支持localstorage的平台降级为none
+        return new TcbCacheObject(adapter.root)
+      }
+      return adapter.localStorage
+  }
+}
+
+export class CloudbaseCache implements ICloudbaseCache {
+  public keys: KV<string> = {};
+
+  private persistenceTag: Persistence;
+  private platformInfo: ICloudbasePlatformInfo;
+  private storage: StorageInterface;
+
+  constructor(config: ICacheConfig) {
+    const { persistence, platformInfo = {}, keys = {} } = config
+    this.platformInfo = platformInfo
+    if (!this.storage) {
+      this.persistenceTag = this.platformInfo.adapter.primaryStorage || persistence
+      this.storage = createStorage(this.persistenceTag, this.platformInfo.adapter)
+      this.keys = keys
+    }
+  }
+  /**
+   * @getter storage模式-同步/异步
+   */
+  get mode() {
+    return this.storage.mode || 'sync'
+  }
+  get persistence(): Persistence {
+    return this.persistenceTag
+  }
+
+  public setStore(key: string, value: any, version?: any) {
+    if (this.mode === 'async') {
+      printWarn(ERRORS.INVALID_OPERATION, 'current platform\'s storage is asynchronous, please use setStoreAsync insteed')
+      return
+    }
+    if (!this.storage) {
+      return
+    }
+
+    try {
+      const val = {
+        version: version || 'localCachev1',
+        content: value,
+      }
+      this.storage.setItem(key, JSON.stringify(val))
+    } catch (e) {
+      throw new Error(JSON.stringify({
+        code: ERRORS.OPERATION_FAIL,
+        msg: `[${getSdkName()}][${ERRORS.OPERATION_FAIL}]setStore failed`,
+        info: e,
+      }))
+    }
+
+    return
+  }
+  public async setStoreAsync(key: string, value: any, version?: any) {
+    if (!this.storage) {
+      return
+    }
+
+    try {
+      const val = {
+        version: version || 'localCachev1',
+        content: value,
+      }
+      await this.storage.setItem(key, JSON.stringify(val))
+    } catch (e) {
+      return
+    }
+
+    return
+  }
+  public getStore(key: string, version?: string) {
+    if (this.mode === 'async') {
+      printWarn(ERRORS.INVALID_OPERATION, 'current platform\'s storage is asynchronous, please use getStoreAsync insteed')
+      return
+    }
+    try {
+      // 测试用例使用
+      if (typeof process !== 'undefined' && process.env?.tcb_token) {
+        return process.env.tcb_token
+      }
+
+      if (!this.storage) {
+        return ''
+      }
+    } catch (e) {
+      return ''
+    }
+
+    version = version || 'localCachev1'
+
+    const content = this.storage.getItem(key)
+    if (!content) {
+      return ''
+    }
+
+    if (content.indexOf(version) >= 0) {
+      const d = JSON.parse(content)
+      return d.content
+    }
+    return ''
+  }
+  public async getStoreAsync(key: string, version?: string) {
+    try {
+      // 测试用例使用
+      if (typeof process !== 'undefined' && process.env?.tcb_token) {
+        return process.env.tcb_token
+      }
+
+      if (!this.storage) {
+        return ''
+      }
+    } catch (e) {
+      return ''
+    }
+
+    version = version || 'localCachev1'
+
+    const content = await this.storage.getItem(key)
+    if (!content) {
+      return ''
+    }
+
+    if (content.indexOf(version) >= 0) {
+      const d = JSON.parse(content)
+      return d.content
+    }
+    return ''
+  }
+  public removeStore(key: string) {
+    if (this.mode === 'async') {
+      printWarn(ERRORS.INVALID_OPERATION, 'current platform\'s storage is asynchronous, please use removeStoreAsync insteed')
+      return
+    }
+    this.storage.removeItem(key)
+  }
+  public async removeStoreAsync(key: string) {
+    await this.storage.removeItem(key)
+  }
+}

package/src/libs/events.ts

@@ -0,0 +1,154 @@
+import { isString, isInstanceOf } from './util'
+import { Listeners, ICloudbaseEventEmitter } from '@cloudbase/types/events'
+
+
+/**
+ * @private
+ * @function _addEventListener - 添加监听
+ * @param {string} name - event名称
+ * @param {Function} listener - 响应函数
+ * @param {Listeners} listeners - 已存响应函数集合
+ */
+function customeAddEventListener(name: string, listener: Function, listeners: Listeners) {
+  listeners[name] = listeners[name] || []
+  listeners[name].push(listener)
+}
+/**
+ * @private
+ * @function _removeEventListener - 移除监听
+ * @param {string} name - event名称
+ * @param {Function} listener - 响应函数
+ * @param {Listeners} listeners - 已存响应函数集合
+ */
+function customRemoveEventListener(name: string, listener: Function, listeners: Listeners) {
+  if (listeners?.[name]) {
+    const index = listeners[name].indexOf(listener)
+    if (index !== -1) {
+      listeners[name].splice(index, 1)
+    }
+  }
+}
+interface IEvent {
+  name: string;
+  target: any;
+  data: any;
+}
+/**
+ * 自定义事件
+ * @class CloudbaseEvent
+ * @param {string} name - 类型
+ * @param {any} data - 数据
+ */
+export class CloudbaseEvent implements IEvent {
+  public readonly name: string;
+  public target: any;
+  public data: any;
+
+  constructor(name: string, data: any) {
+    this.data = data || null
+    this.name = name
+  }
+}
+/**
+ * 自定义错误事件
+ * @class IErrorEvent
+ * @extends CloudbaseEvent
+ * @param {Error} error - 错误信息对象
+ * @param {any} data  - 数据
+ */
+export class IErrorEvent extends CloudbaseEvent {
+  public readonly error: Error;
+  constructor(error: Error, data?: any) {
+    super('error', { error, data })
+    this.error = error
+  }
+}
+
+/**
+ * @class CloudbaseEventEmitter
+ */
+export class CloudbaseEventEmitter implements ICloudbaseEventEmitter {
+  /**
+   * @private
+   * @readonly
+   * @property {Listeners} listeners - 响应函数集合
+   * @default `{}`
+   */
+  private readonly listeners: Listeners = {};
+
+  /**
+   * @public
+   * @method on - 添加监听
+   * @param {string} name - event名称
+   * @param {Function} listener - 响应函数
+   * @return `this`
+   */
+  public on(name: string, listener: Function): this {
+    customeAddEventListener(name, listener, this.listeners)
+    return this
+  }
+  /**
+   * @public
+   * @method off - 移除监听
+   * @param {string} name - event名称
+   * @param {Function} listener - 响应函数
+   * @return `this`
+   */
+  public off(name: string, listener: Function): this {
+    customRemoveEventListener(name, listener, this.listeners)
+    return this
+  }
+  /**
+   * @public
+   * @method fire - 触发事件
+   * @param {string|CloudbaseEvent} event - event
+   * @return `this`
+   */
+  public fire(event: string | CloudbaseEvent, data?: any): this {
+    // 打印错误信息
+    if (isInstanceOf(event, IErrorEvent)) {
+      console.error((event as IErrorEvent).error)
+      return this
+    }
+
+    const ev: CloudbaseEvent = isString(event) ? new CloudbaseEvent(event as string, data || {}) : event as CloudbaseEvent
+
+    const { name } = ev
+
+    if (this.listens(name)) {
+      ev.target = this
+
+      const handlers = this.listeners[name] ? [...this.listeners[name]] : []
+      for (const fn of handlers) {
+        fn.call(this, ev)
+      }
+    }
+
+    return this
+  }
+
+  /**
+   * @private
+   * @method listens - 判断是否监听了name事件
+   * @param {string} name - event名称
+   * @return `boolean`
+   */
+  private listens(name: string): boolean {
+    return this.listeners[name] && this.listeners[name].length > 0
+  }
+}
+
+
+const eventEmitter = new CloudbaseEventEmitter()
+
+export function addEventListener(event: string, callback: Function) {
+  eventEmitter.on(event, callback)
+}
+
+export function activateEvent(event: string, data: any = {}) {
+  eventEmitter.fire(event, data)
+}
+
+export function removeEventListener(event: string, callback: Function) {
+  eventEmitter.off(event, callback)
+}