agora-foundation 3.8.2 → 3.9.0-alpha

package/lib/decorator/log/handler.d.ts

@@ -4,5 +4,5 @@ import { InvocationEvent } from '../type';
 type LoggerHolder = {
     logger: Logger;
 };
-export declare const createLogHandler: (holder: LoggerHolder) => (evt: InvocationEvent) => Result;
+export declare const createLogHandler: (holder: LoggerHolder, isErrorCodeByReturnValue?: boolean) => (evt: InvocationEvent) => Result;
 export {};

package/lib/decorator/log/handler.js

@@ -1,84 +1,77 @@
 "use strict";
 
 require("core-js/modules/es.object.define-property.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createLogHandler = void 0;
 require("core-js/modules/es.array.concat.js");
-require("core-js/modules/es.date.to-string.js");
-require("core-js/modules/es.function.name.js");
+require("core-js/modules/es.date.now.js");
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _interceptor = require("../../utilities/interceptor");
-var _misc = require("../../utilities/misc");
 var _type = require("../type");
 var _logSerializer = require("./log-serializer");
-var formatCallLog = function formatCallLog(identifier, args) {
-  var msg = '';
+var InvocationEventTypeToString = (0, _defineProperty2["default"])((0, _defineProperty2["default"])({}, _type.InvocationEventType.API_CALL, '[API Call]'), _type.InvocationEventType.API_RETURN, '[API Return]');
+
+// 方法返回错误码时对应的描述
+var ReasonCodeToString = (0, _defineProperty2["default"])((0, _defineProperty2["default"])({}, -1, 'FAILED'), 0, 'SUCCESS');
+var formatLogHead = function formatLogHead(identifier, tag, args, argsNames) {
+  var elapsed = Date.now() - identifier.startTs;
+  var parameters = '[parameters: []]';
+  var duration = "[duration: ".concat(elapsed, "ms]");
   if (args !== null && args !== void 0 && args.length) {
-    msg += "[parameters: ".concat((0, _logSerializer.serializeArgs)(args), "]");
+    parameters = "[parameters: [".concat((0, _logSerializer.serializeArgs)(args, argsNames), "]]");
   }
-  return "".concat(identifier.methodName, " [API Call]").concat(msg, "[traceId: ").concat(identifier.traceId, "]");
+  return "".concat(identifier.methodName, ": ").concat(tag, " ").concat(parameters, " ").concat(duration);
 };
-
-// const formatReturnLog = (
-//   identifier: { className: string; methodName: string; traceId: string },
-//   elapsed: number,
-//   args?: unknown[],
-//   returnValue?: unknown,
-//   thrown?: Error,
-// ) => {
-//   let msg = '';
-//   if (args?.length) {
-//     msg += `[parameters: ${serializeArgs(args)}]`;
-//   }
-
-//   if (thrown) {
-//     msg += `[throw: ${thrown.name}]`;
-//     msg += `[message: ${thrown.message}]`;
-//   } else if (typeof returnValue !== 'undefined') {
-//     msg += `[return: ${serialize(returnValue)}]`;
-//   }
-
-//   return `${identifier.methodName} [API Call]${msg}[elapsed: ${elapsed}ms]`;
-// };
-
-var createLogHandler = exports.createLogHandler = function createLogHandler(holder) {
+var formatLogReturn = function formatLogReturn(returnValue) {
+  return "[message: { return: ".concat((0, _logSerializer.serialize)(returnValue), " }]");
+};
+var formatLogReason = function formatLogReason(reasonCode) {
+  return "[message: { reason: ".concat(reasonCode, ": ").concat(ReasonCodeToString[reasonCode] || 'UNKNOWN', " }]");
+};
+var formatLogError = function formatLogError(error) {
+  return "[message: { error: { code: ".concat(error.code, ", message: ").concat(error.message, " } }]");
+};
+var printReturnOrReason = function printReturnOrReason(logger, returnValue, getMsg, isShowReasonCode) {
+  if (isShowReasonCode && typeof returnValue === 'number' && returnValue !== 0) {
+    var msgBody = " ".concat(formatLogReason(returnValue));
+    logger.warn(getMsg(msgBody));
+  } else {
+    var _msgBody = " ".concat(formatLogReturn(returnValue));
+    logger.info(getMsg(_msgBody));
+  }
+};
+var createLogHandler = exports.createLogHandler = function createLogHandler(holder, isErrorCodeByReturnValue) {
   return function (evt) {
-    if (evt.type === _type.InvocationEventType.PRE) {
-      var _evt$arguments;
-      evt.context.start = new Date().getTime();
-      evt.context.traceId = (0, _misc.randomString)(5);
-      var msg = formatCallLog({
-        className: evt["class"],
-        methodName: evt.method,
-        traceId: evt.context.traceId
-      }, (_evt$arguments = evt.arguments) !== null && _evt$arguments !== void 0 ? _evt$arguments : []);
-      holder.logger.info(msg);
-    } else {
-      var elapsed = new Date().getTime() - evt.context.start;
-      // const msg = formatReturnLog(
-      //   {
-      //     className: evt.class,
-      //     methodName: evt.method,
-      //     traceId: evt.context.traceId,
-      //   },
-      //   elapsed,
-      //   evt.arguments ?? [],
-      //   evt.return,
-      //   evt.error,
-      // );
-      // if (evt.error) {
-      //   holder.logger.error(msg);
-      // } else {
-      //   holder.logger.info(msg);
-      // }
-
+    var _evt$arguments, _evt$argumentNames;
+    var msgHead = formatLogHead({
+      className: evt["class"],
+      methodName: evt.method,
+      startTs: evt.context.start,
+      isThenable: evt.context.isThenable
+    }, InvocationEventTypeToString[evt.type], (_evt$arguments = evt.arguments) !== null && _evt$arguments !== void 0 ? _evt$arguments : [], (_evt$argumentNames = evt.argumentNames) !== null && _evt$argumentNames !== void 0 ? _evt$argumentNames : []);
+    var msgFoot = " [traceId: ".concat(evt.context.traceId, "]");
+    var getMsg = function getMsg() {
+      var msgBody = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+      return "".concat(msgHead).concat(msgBody).concat(msgFoot);
+    };
+    if (evt.type === _type.InvocationEventType.API_CALL) {
+      if (evt.context.isThenable === true) {
+        // 异步方法只打印调用信息, 在 API_RETURN 时打印返回值等信息
+        holder.logger.info(getMsg());
+      } else {
+        // 同步方法的打印内容包含返回值, 错误码等信息(如果有的话)
+        printReturnOrReason(holder.logger, evt["return"], getMsg, isErrorCodeByReturnValue);
+      }
+    } else if (evt.type === _type.InvocationEventType.API_RETURN) {
       if (evt.error) {
-        var _msg = "".concat(evt.method, " [throw: ").concat(evt.error.name, "][message: ").concat(evt.error.message, "][elapsed: ").concat(elapsed, "ms][traceId: ").concat(evt.context.traceId, "]");
-        holder.logger.error(_msg);
+        var msgBody = " ".concat(formatLogError(evt.error));
+        holder.logger.error(getMsg(msgBody));
       } else {
-        var _msg2 = "".concat(evt.method, " [return: ").concat((0, _logSerializer.serialize)(evt["return"]), "][elapsed: ").concat(elapsed, "ms][traceId: ").concat(evt.context.traceId, "]");
-        holder.logger.info(_msg2);
+        // 异步方法在此处打印返回值, 错误码等信息(如果有的话)
+        printReturnOrReason(holder.logger, evt["return"], getMsg, isErrorCodeByReturnValue);
       }
     }
     return _interceptor.Result.CONTINUE;

package/lib/decorator/log/index.d.ts

@@ -1 +1,26 @@
-export declare const trace: (originalMethod: any, context: ClassMethodDecoratorContext) => void;
+type ClassMethodDecorator = (originalMethod: any, context: ClassMethodDecoratorContext) => undefined;
+/**
+ * @description
+ * 函数入参使用参数范型, 支持以下三种用法:
+ * 1. 直接作为装饰器使用: `@trace method() {}`
+ * 2. 作为工厂函数使用, 支持传入参数名称数组, 标识返回值是否是错误码(可选), 返回装饰器函数 `@trace(['param1', 'param2'], bolean?)`
+ * 3. 作为工厂函数使用, 仅标识返回值是否是错误码, 返回装饰器函数 `@trace(boolean)`
+ * @example
+ * `@trace method() {}`
+ * `@trace(['name1', 'name2']) method(name1: string, name2: number) {}`
+ * `@trace(['name1', 'name2'], true) method(name1: string, name2: number) {}`
+ * `@trace(true) method() {}`
+ */
+declare function trace(originalMethod: any, context: ClassMethodDecoratorContext): undefined;
+/**
+ * @description 仅标识返回值是否是错误码, 返回装饰器函数 `@trace(boolean)`
+ * @param isErrorCodeByReturnValue - 返回值是否是错误码
+ */
+declare function trace(isErrorCodeByReturnValue: boolean): ClassMethodDecorator;
+/**
+ * @description 作为工厂函数使用, 支持传入参数名称数组, 标识返回值是否是错误码(可选), 返回装饰器函数 `@trace(['param1', 'param2'], bolean?)`
+ * @param paramNames - 参数名称数组
+ * @param [isErrorCodeByReturnValue] - 返回值是否是错误码（可选）
+ */
+declare function trace(paramNames: string[], isErrorCodeByReturnValue?: boolean): ClassMethodDecorator;
+export { trace };

package/lib/decorator/log/index.js

@@ -1,10 +1,12 @@
 "use strict";
 
 require("core-js/modules/es.object.define-property.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.trace = void 0;
+exports.trace = trace;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
 require("core-js/modules/es.function.name.js");
 var _proxy = require("../proxy");
 var _handler = require("./handler");
@@ -14,7 +16,7 @@ var _logger = require("../../logger");
  * @param targetOrProto The class or prototype that the method belongs to.
  * @param methodName The name of the method.
  */
-var _trace = function _trace(originalMethod, context) {
+var _trace = function _trace(originalMethod, context, paramNames, isErrorCodeByReturnValue) {
   var methodName = String(context.name);
   if (context.kind === 'method') {
     context.addInitializer(function () {
@@ -26,9 +28,52 @@ var _trace = function _trace(originalMethod, context) {
       if (!this.logger) {
         this.logger = logger;
       }
-      var handler = (0, _handler.createLogHandler)(this);
-      this[context.name] = (0, _proxy.proxyMethod)(this[context.name], this, methodName, handler);
+      var handler = (0, _handler.createLogHandler)(this, isErrorCodeByReturnValue);
+      this[context.name] = (0, _proxy.proxyMethod)(this[context.name], this, methodName, handler, paramNames);
     });
   }
 };
-var trace = exports.trace = _trace;
+
+/**
+ * @description
+ * 函数入参使用参数范型, 支持以下三种用法:
+ * 1. 直接作为装饰器使用: `@trace method() {}`
+ * 2. 作为工厂函数使用, 支持传入参数名称数组, 标识返回值是否是错误码(可选), 返回装饰器函数 `@trace(['param1', 'param2'], bolean?)`
+ * 3. 作为工厂函数使用, 仅标识返回值是否是错误码, 返回装饰器函数 `@trace(boolean)`
+ * @example
+ * `@trace method() {}`
+ * `@trace(['name1', 'name2']) method(name1: string, name2: number) {}`
+ * `@trace(['name1', 'name2'], true) method(name1: string, name2: number) {}`
+ * `@trace(true) method() {}`
+ */
+
+/**
+ * @description 仅标识返回值是否是错误码, 返回装饰器函数 `@trace(boolean)`
+ * @param isErrorCodeByReturnValue - 返回值是否是错误码
+ */
+
+/**
+ * @description 作为工厂函数使用, 支持传入参数名称数组, 标识返回值是否是错误码(可选), 返回装饰器函数 `@trace(['param1', 'param2'], bolean?)`
+ * @param paramNames - 参数名称数组
+ * @param [isErrorCodeByReturnValue] - 返回值是否是错误码（可选）
+ */
+
+function trace() {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+  if (args.length === 2 && (0, _typeof2["default"])(args[1]) === 'object') {
+    // 直接作为装饰器使用
+    _trace(args[0], args[1]);
+  } else if (args.length === 1 && typeof args[0] === 'boolean') {
+    // 作为工厂函数使用, 仅标识返回值是否是错误码
+    return function (originalMethod, context) {
+      _trace(originalMethod, context, undefined, args[0]);
+    };
+  } else {
+    // 作为工厂函数使用, 支持传入参数名称数组, 标识返回值是否是错误码(可选)
+    return function (originalMethod, context) {
+      _trace(originalMethod, context, args[0], args[1]);
+    };
+  }
+}

package/lib/decorator/log/log-serializer.d.ts

@@ -1,2 +1,2 @@
 export declare const serialize: (data: unknown) => string;
-export declare const serializeArgs: (args: unknown[]) => string;
+export declare const serializeArgs: (args: unknown[], argsNames?: string[]) => string;

package/lib/decorator/log/log-serializer.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.serializeArgs = exports.serialize = void 0;
+require("core-js/modules/es.array.concat.js");
 require("core-js/modules/es.array.join.js");
 require("core-js/modules/es.array.map.js");
 require("core-js/modules/es.object.to-string.js");
@@ -17,6 +18,18 @@ var serialize = exports.serialize = function serialize(data) {
   }
   return "".concat((0, _misc.jsonstring)(data));
 };
-var serializeArgs = exports.serializeArgs = function serializeArgs(args) {
-  return "".concat(args.map(serialize).join(' '));
+var serializeArgs = exports.serializeArgs = function serializeArgs(args, argsNames) {
+  if (argsNames) {
+    var lastIndex = args.length - 1;
+    var str = '';
+    for (var i = 0; i < args.length; i++) {
+      var key = argsNames[i] ? "".concat(argsNames[i], ": ") : '';
+      str += "".concat(key).concat(serialize(args[i]));
+      if (i < lastIndex) {
+        str += ', ';
+      }
+    }
+    return str;
+  }
+  return "".concat(args.map(serialize).join(', '));
 };

package/lib/decorator/proxy.d.ts

@@ -1,5 +1,5 @@
 import { AnyFunction, InvocationHandler } from './type';
-export declare const proxyMethod: (method: AnyFunction, proto: any, propertyName: string, handler: InvocationHandler) => (this: any, ...args: any[]) => any;
+export declare const proxyMethod: (method: AnyFunction, proto: any, propertyName: string, handler: InvocationHandler, paramNames?: string[]) => (this: any, ...args: any[]) => any;
 export declare const extendConstructor: (constructor: any, handler: InvocationHandler, extendProps?: any, proxyMethods?: boolean) => {
     new (...args: unknown[]): {
         [x: string]: any;

package/lib/decorator/proxy.js

@@ -10,6 +10,7 @@ require("core-js/modules/es.array.concat.js");
 require("core-js/modules/es.array.for-each.js");
 require("core-js/modules/es.array.index-of.js");
 require("core-js/modules/es.array.push.js");
+require("core-js/modules/es.date.now.js");
 require("core-js/modules/es.function.name.js");
 require("core-js/modules/es.object.define-property.js");
 require("core-js/modules/es.object.get-own-property-descriptor.js");
@@ -29,6 +30,7 @@ var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/ge
 var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _misc = require("../utilities/misc");
 var _type = require("./type");
 function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2["default"])(o), (0, _possibleConstructorReturn2["default"])(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2["default"])(t).constructor) : o.apply(t, e)); }
 function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
@@ -37,22 +39,20 @@ var failQuitely = function failQuitely(func, args) {
     return func.apply(void 0, (0, _toConsumableArray2["default"])(args));
   } catch (e) {}
 };
-var invokeMethod = function invokeMethod(instance, method, proto, propertyName, args, hanlder) {
+var invokeMethod = function invokeMethod(instance, method, proto, propertyName, args, hanlder, paramNames) {
   var context = {};
-  failQuitely(hanlder, [{
-    type: _type.InvocationEventType.PRE,
-    arguments: args,
-    method: propertyName,
-    "class": proto.constructor.__$$className || proto.constructor.name,
-    context: context
-  }]);
+  context.start = Date.now();
+  context.traceId = (0, _misc.randomString)(5);
 
   // provide a way for invoking method regardless it is async or sync function, attach the return value and the error(if it occurred) to the event object
   var returnVal = method.apply(instance, args);
-  var post = function post(val, error) {
+  var isThenable = returnVal && !!returnVal.then;
+  context.isThenable = isThenable;
+  var post = function post(type, val, error) {
     failQuitely(hanlder, [{
-      type: _type.InvocationEventType.POST,
+      type: type,
       arguments: args,
+      argumentNames: paramNames,
       "return": val,
       method: propertyName,
       "class": proto.constructor.__$$className || proto.constructor.name,
@@ -60,7 +60,9 @@ var invokeMethod = function invokeMethod(instance, method, proto, propertyName,
       error: error
     }]);
   };
-  var isThenable = returnVal && !!returnVal.then;
+
+  // 同步/异步函数调用结束时输出日志,（异步函数函数不等待异步结束）
+  post(_type.InvocationEventType.API_CALL, returnVal);
   if (isThenable) {
     // capture async return and potential error
     var rtnTemp, errTemp;
@@ -69,19 +71,17 @@ var invokeMethod = function invokeMethod(instance, method, proto, propertyName,
     })["catch"](function (e) {
       errTemp = e;
     })["finally"](function () {
-      post(rtnTemp, errTemp);
+      post(_type.InvocationEventType.API_RETURN, rtnTemp, errTemp);
     });
-  } else {
-    post(returnVal);
   }
   return returnVal;
 };
-var proxyMethod = exports.proxyMethod = function proxyMethod(method, proto, propertyName, handler) {
+var proxyMethod = exports.proxyMethod = function proxyMethod(method, proto, propertyName, handler, paramNames) {
   return function () {
     for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
       args[_key] = arguments[_key];
     }
-    return invokeMethod(this, method, proto, propertyName, args, handler);
+    return invokeMethod(this, method, proto, propertyName, args, handler, paramNames);
   };
 };
 var getMethods = function getMethods(target) {

package/lib/decorator/type.d.ts

@@ -1,7 +1,7 @@
 import { Interceptor } from '../utilities/interceptor';
 export declare enum InvocationEventType {
-    PRE = 0,
-    POST = 1
+    API_CALL = 0,
+    API_RETURN = 1
 }
 export type InvocationEvent = {
     type: InvocationEventType;
@@ -9,6 +9,7 @@ export type InvocationEvent = {
     class: string;
     method: string;
     arguments?: any[];
+    argumentNames?: string[];
     return?: any;
     error?: Error;
 };

package/lib/decorator/type.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.InvocationEventType = void 0;
 var InvocationEventType = exports.InvocationEventType = /*#__PURE__*/function (InvocationEventType) {
-  InvocationEventType[InvocationEventType["PRE"] = 0] = "PRE";
-  InvocationEventType[InvocationEventType["POST"] = 1] = "POST";
+  InvocationEventType[InvocationEventType["API_CALL"] = 0] = "API_CALL";
+  InvocationEventType[InvocationEventType["API_RETURN"] = 1] = "API_RETURN";
   return InvocationEventType;
 }({}); // make it interceptable

package/lib/utilities/desc-type.d.ts

@@ -3,4 +3,5 @@ export declare const FcrApplicationPlatformDescType: {
     2: string;
     3: string;
     6: string;
+    7: string;
 };

package/lib/utilities/desc-type.js

@@ -8,4 +8,4 @@ Object.defineProperty(exports, "__esModule", {
 exports.FcrApplicationPlatformDescType = void 0;
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _env = require("./env");
-var FcrApplicationPlatformDescType = exports.FcrApplicationPlatformDescType = (0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])({}, _env.FcrApplicationPlatform.WEB_DESKTOP, 'webDesktop'), _env.FcrApplicationPlatform.MACOS, 'macOS'), _env.FcrApplicationPlatform.WINDOWS, 'windows'), _env.FcrApplicationPlatform.WEB_MOBILE, 'webMobile');
+var FcrApplicationPlatformDescType = exports.FcrApplicationPlatformDescType = (0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])({}, _env.FcrApplicationPlatform.WEB_DESKTOP, 'webDesktop'), _env.FcrApplicationPlatform.MACOS, 'macOS'), _env.FcrApplicationPlatform.WINDOWS, 'windows'), _env.FcrApplicationPlatform.WEB_MOBILE, 'webMobile'), _env.FcrApplicationPlatform.HARMONY, 'harmony');

package/lib/utilities/env.d.ts

@@ -3,7 +3,8 @@ export declare enum FcrApplicationPlatform {
     WEB_DESKTOP = 1,
     MACOS = 2,
     WINDOWS = 3,
-    WEB_MOBILE = 6
+    WEB_MOBILE = 6,
+    HARMONY = 7
 }
 export declare const getPlatform: () => FcrApplicationPlatform;
 export declare const isWindows: () => boolean;

package/lib/utilities/env.js

@@ -25,6 +25,7 @@ var FcrApplicationPlatform = exports.FcrApplicationPlatform = /*#__PURE__*/funct
   FcrApplicationPlatform[FcrApplicationPlatform["MACOS"] = 2] = "MACOS";
   FcrApplicationPlatform[FcrApplicationPlatform["WINDOWS"] = 3] = "WINDOWS";
   FcrApplicationPlatform[FcrApplicationPlatform["WEB_MOBILE"] = 6] = "WEB_MOBILE";
+  FcrApplicationPlatform[FcrApplicationPlatform["HARMONY"] = 7] = "HARMONY";
   return FcrApplicationPlatform;
 }({});
 var getPlatform = exports.getPlatform = function getPlatform() {

package/lib/utilities/{agora-error.d.ts → error/agora-error.d.ts}

@@ -1,14 +1,11 @@
-import { positiveIntegerSchema, z } from './schema';
+import { positiveIntegerSchema, z } from '../schema';
+import { DetailErrorCode, ErrorModuleCode, ErrorServiceType } from './error-code';
 type PositiveInteger = z.infer<typeof positiveIntegerSchema>;
 interface CreateCodeParams {
     serviceCode: PositiveInteger;
     moduleCode: PositiveInteger;
     detailCode: PositiveInteger;
 }
-interface AgoraErrorOptions extends CreateCodeParams {
-    message: string;
-    cause: string;
-}
 export declare class AgoraError extends Error {
     private _code;
     private _message;
@@ -16,16 +13,13 @@ export declare class AgoraError extends Error {
     get code(): number;
     get message(): string;
     constructor(params: {
-        message: string;
         code: number;
+        message: string;
         cause?: string;
     });
-    toString(): string;
     static createCode({ serviceCode, moduleCode, detailCode }: CreateCodeParams): number;
-    static createServiceCode(serviceCode: PositiveInteger): number;
-    static createModuleCode(moduleCode: PositiveInteger): number;
-    static createWithOptions(options: AgoraErrorOptions): AgoraError;
-    static createWithError(error: Error): AgoraError;
+    static getServiceType(errorCode: number): ErrorServiceType | undefined;
+    static create(service: ErrorServiceType, module: ErrorModuleCode, errorCode: DetailErrorCode, message: string, cause?: unknown): AgoraError;
     static createWithAny(error: any, message: string): AgoraError;
 }
 export {};

package/lib/utilities/error/agora-error.js

@@ -0,0 +1,148 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+require("core-js/modules/es.reflect.construct.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AgoraError = void 0;
+require("core-js/modules/es.error.cause.js");
+require("core-js/modules/es.error.to-string.js");
+require("core-js/modules/es.array.concat.js");
+require("core-js/modules/es.array.filter.js");
+require("core-js/modules/es.array.find.js");
+require("core-js/modules/es.array.slice.js");
+require("core-js/modules/es.number.constructor.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.object.values.js");
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.filter.js");
+require("core-js/modules/esnext.iterator.find.js");
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _wrapNativeSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/wrapNativeSuper"));
+var _padStart = _interopRequireDefault(require("lodash/padStart"));
+var _padEnd = _interopRequireDefault(require("lodash/padEnd"));
+var _errorCode = require("./error-code");
+function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2["default"])(o), (0, _possibleConstructorReturn2["default"])(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2["default"])(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+var AgoraError = exports.AgoraError = /*#__PURE__*/function (_Error) {
+  function AgoraError(params) {
+    var _this;
+    (0, _classCallCheck2["default"])(this, AgoraError);
+    _this = _callSuper(this, AgoraError, [params.message]);
+    _this._code = params.code;
+    _this._message = params.message;
+    _this._cause = params.cause || '';
+    return _this;
+  }
+  (0, _inherits2["default"])(AgoraError, _Error);
+  return (0, _createClass2["default"])(AgoraError, [{
+    key: "code",
+    get: function get() {
+      return this._code;
+    }
+  }, {
+    key: "message",
+    get: function get() {
+      return this._message;
+    }
+  }], [{
+    key: "createCode",
+    value: function createCode(_ref) {
+      var serviceCode = _ref.serviceCode,
+        moduleCode = _ref.moduleCode,
+        detailCode = _ref.detailCode;
+      // 生成9位数错误代码：前3位是错误类型，中间3位是模块代码，后3位是具体错误代码
+      var errorType = (0, _padEnd["default"])(String(serviceCode), 3, '0'); // 如：'100'
+      var moduleStr = (0, _padStart["default"])(String(moduleCode), 3, '0'); // 如：'020'
+      var errorCode = (0, _padStart["default"])(String(detailCode), 3, '0'); // 如：'001'
+
+      return Number("".concat(errorType).concat(moduleStr).concat(errorCode)); // 如：'100020001'
+    }
+  }, {
+    key: "getServiceType",
+    value: function getServiceType(errorCode) {
+      var str = String(errorCode);
+      if (str.length !== 9) {
+        return undefined;
+      }
+      var servicePrefix = str.slice(0, 3);
+      var serviceTypes = Object.values(_errorCode.ErrorServiceType).filter(function (v) {
+        return typeof v === 'number';
+      });
+      return serviceTypes.find(function (type) {
+        return (0, _padEnd["default"])(String(type), 3, '0') === servicePrefix;
+      });
+    }
+  }, {
+    key: "create",
+    value: function create(service, module, errorCode, message, cause) {
+      var domain = getDomain(service);
+      var fullMessage = "domain: ".concat(domain, ", info: ").concat(message);
+      var fullCode = AgoraError.createCode({
+        serviceCode: service,
+        moduleCode: module,
+        detailCode: errorCode
+      });
+      var causeMessage = '';
+      if (cause instanceof Error) {
+        causeMessage = cause.message;
+      } else if (cause) {
+        causeMessage = String(cause);
+      }
+      return new AgoraError({
+        code: fullCode,
+        message: fullMessage,
+        cause: causeMessage
+      });
+    }
+  }, {
+    key: "createWithAny",
+    value: function createWithAny(error, message) {
+      if (error instanceof AgoraError) {
+        return error;
+      } else {
+        var code = _errorCode.DetailErrorCode.UNDEFINED_ERROR;
+        if (error instanceof Error) {
+          if (error.cause) {
+            message = message + ", error cause: ".concat(error.cause);
+          }
+        }
+        var agoraError = new AgoraError({
+          code: code,
+          message: message
+        });
+        return agoraError;
+      }
+    }
+  }]);
+}(/*#__PURE__*/(0, _wrapNativeSuper2["default"])(Error));
+var getDomain = function getDomain(service) {
+  switch (service) {
+    case _errorCode.ErrorServiceType.RTE_CLIENT:
+      return 'RTE-CLIENT';
+    case _errorCode.ErrorServiceType.RTE_SERVER:
+      return 'RTE-SRV';
+    case _errorCode.ErrorServiceType.NATIVE_RTC:
+      return 'RTC';
+    case _errorCode.ErrorServiceType.WEB_RTC:
+      return 'WebRTC';
+    case _errorCode.ErrorServiceType.RTM_SDK:
+      return 'RTM';
+    case _errorCode.ErrorServiceType.FCR_CLIENT:
+      return 'CORE-CLIENT';
+    case _errorCode.ErrorServiceType.FCR_SERVER:
+      return 'CORE-SRV';
+    case _errorCode.ErrorServiceType.FCR_UI_SCENE:
+      return 'UI-SCENE';
+    case _errorCode.ErrorServiceType.DEMO_SERVER:
+      return 'DEMO-SRV';
+    default:
+      return 'UNDEFINED';
+  }
+};