phecda-server 5.0.2 → 5.1.0

package/dist/chunk-XNTMYLK6.js

@@ -0,0 +1,76 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// src/common.ts
+var UNMOUNT_SYMBOL = "__PS_UNMOUNT__";
+var ERROR_SYMBOL = "__PS_ERROR__";
+var IS_HMR = process.env.NODE_ENV === "development";
+var IS_ONLY_GENERATE = !!process.env.PS_GENERATE;
+var IS_STRICT = !!process.env.PS_STRICT;
+var LOG_LEVEL = Number(process.env.PS_LOG_LEVEL || 0);
+var PS_EXIT_CODE;
+(function(PS_EXIT_CODE2) {
+  PS_EXIT_CODE2[PS_EXIT_CODE2["RELAUNCH"] = 2] = "RELAUNCH";
+  PS_EXIT_CODE2[PS_EXIT_CODE2["CODE"] = 4] = "CODE";
+})(PS_EXIT_CODE || (PS_EXIT_CODE = exports.PS_EXIT_CODE = {}));
+
+// src/utils.ts
+var _picocolors = require('picocolors'); var _picocolors2 = _interopRequireDefault(_picocolors);
+var time;
+var internalLogger = console;
+function setLogger(logger) {
+  internalLogger = logger;
+}
+__name(setLogger, "setLogger");
+function log(msg, level = "log") {
+  const logLevel = {
+    info: 0,
+    log: 1,
+    warn: 2,
+    error: 3
+  }[level];
+  if (logLevel < LOG_LEVEL)
+    return;
+  const color = {
+    error: "red",
+    info: "gray",
+    warn: "yellow",
+    log: "green"
+  }[level];
+  const date = new Date();
+  const current = Date.now();
+  const interval = time && current - time ? `+${current - time}` : "";
+  time = current;
+  internalLogger[level](`${_picocolors2.default.magenta("[phecda-server]")} ${_picocolors2.default.gray(`${date.getHours()}:${date.getMinutes()}:${date.getSeconds()}`)} ${_picocolors2.default[color](msg)} ${_picocolors2.default.gray(interval)}`);
+}
+__name(log, "log");
+function Mix(InternalClass, ExtendClass) {
+  return class extends InternalClass {
+    constructor(...args) {
+      super();
+      Object.assign(this, new ExtendClass(...args));
+    }
+  };
+}
+__name(Mix, "Mix");
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.__name = __name; exports.__publicField = __publicField; exports.UNMOUNT_SYMBOL = UNMOUNT_SYMBOL; exports.ERROR_SYMBOL = ERROR_SYMBOL; exports.IS_HMR = IS_HMR; exports.IS_ONLY_GENERATE = IS_ONLY_GENERATE; exports.IS_STRICT = IS_STRICT; exports.LOG_LEVEL = LOG_LEVEL; exports.PS_EXIT_CODE = PS_EXIT_CODE; exports.setLogger = setLogger; exports.log = log; exports.Mix = Mix;
+//# sourceMappingURL=chunk-XNTMYLK6.js.map

package/dist/chunk-XNTMYLK6.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/common.ts","../src/utils.ts"],"names":["UNMOUNT_SYMBOL","ERROR_SYMBOL","IS_HMR","process","env","NODE_ENV","IS_ONLY_GENERATE","PS_GENERATE","IS_STRICT","PS_STRICT","LOG_LEVEL","Number","PS_LOG_LEVEL","PS_EXIT_CODE","RELAUNCH","CODE","pc","time","internalLogger","console","setLogger","logger","log","msg","level","logLevel","info","warn","error","color","date","Date","current","now","interval","magenta","gray","getHours","getMinutes","getSeconds","Mix","InternalClass","ExtendClass","constructor","args","Object","assign"],"mappings":";;;;;;;;;AACO,IAAMA,iBAAiB;AAIvB,IAAMC,eAAe;AAErB,IAAMC,SAASC,QAAQC,IAAIC,aAAa;AACxC,IAAMC,mBAAmB,CAAC,CAACH,QAAQC,IAAIG;AACvC,IAAMC,YAAY,CAAC,CAACL,QAAQC,IAAIK;AAChC,IAAMC,YAAYC,OAAOR,QAAQC,IAAIQ,gBAAgB,CAAA;IAErD;UAAKC,eAAY;AAAZA,EAAAA,cAAAA,cACVC,cAAW,KAAXA;AADUD,EAAAA,cAAAA,cAEVE,UAAO,KAAPA;GAFUF,iBAAAA,eAAAA,CAAAA,EAAAA;;;ACZZ,OAAOG,QAAQ;AAIf,IAAIC;AAEJ,IAAIC,iBAA0DC;AAIvD,SAASC,UAAUC,QAAiD;AACzEH,mBAAiBG;AACnB;AAFgBD;AAIT,SAASE,IAAIC,KAAaC,QAAkB,OAAO;AACxD,QAAMC,WAAW;IACfC,MAAM;IACNJ,KAAK;IACLK,MAAM;IACNC,OAAO;EACT,EAAEJ;AAEF,MAAIC,WAAWf;AACb;AAEF,QAAMmB,QAAS;IAAED,OAAO;IAAOF,MAAM;IAAQC,MAAM;IAAUL,KAAK;EAAQ,EAAYE;AACtF,QAAMM,OAAO,IAAIC,KAAAA;AACjB,QAAMC,UAAUD,KAAKE,IAAG;AACxB,QAAMC,WAAYjB,QAAQe,UAAUf,OAAQ,IAAIe,UAAUf,SAAS;AACnEA,SAAOe;AAEPd,iBAAeM,OAAO,GAAGR,GAAGmB,QAAQ,iBAAA,KAAsBnB,GAAGoB,KAAK,GAAGN,KAAKO,SAAQ,KAAMP,KAAKQ,WAAU,KAAMR,KAAKS,WAAU,GAAI,KAAKvB,GAAGa,OAAON,GAAAA,KAAQP,GAAGoB,KAAKF,QAAAA,GAAW;AAC5K;AAlBgBZ;AAoBT,SAASkB,IAA8DC,eAAmBC,aAAiB;AAChH,SAAO,cAAcD,cAAAA;IACnBE,eAAeC,MAAW;AACxB,YAAK;AACLC,aAAOC,OAAO,MAAM,IAAIJ,YAAAA,GAAeE,IAAAA,CAAAA;IACzC;EACF;AACF;AAPgBJ","sourcesContent":["// export const MERGE_SYMBOL = '__PS_MERGE__'// is parallel request in http\r\nexport const UNMOUNT_SYMBOL = '__PS_UNMOUNT__'// property that include unmount callbacks\r\n// export const MODULE_SYMBOL = '__PS_MODULE__'// req[MODULE_SYMBOL]=modulemap\r\n// export const META_SYMBOL = '__PS_META__'// req[META_SYMBOL]=meta\r\n// export const PS_SYMBOL = '__PS__'// (app/router)[PS_SYMBOL]=Factory(...)\r\nexport const ERROR_SYMBOL = '__PS_ERROR__'// only use in paralle request\r\n\r\nexport const IS_HMR = process.env.NODE_ENV === 'development'\r\nexport const IS_ONLY_GENERATE = !!process.env.PS_GENERATE// work for ci; only generate code\r\nexport const IS_STRICT = !!process.env.PS_STRICT// throw error if depends on an aop module which is not imported\r\nexport const LOG_LEVEL = Number(process.env.PS_LOG_LEVEL || 0)// internal logger\r\n\r\nexport enum PS_EXIT_CODE {\r\n  RELAUNCH = 2,\r\n  CODE = 4,\r\n}\r\n","import pc from 'picocolors'\r\nimport type { AbConstruct, Construct } from 'phecda-core'\r\nimport { LOG_LEVEL } from './common'\r\n\r\nlet time: number\r\n\r\nlet internalLogger: Record<LogLevel, (msg: string) => void> = console\r\n\r\ntype LogLevel = 'error' | 'info' | 'warn' | 'log'\r\n\r\nexport function setLogger(logger: Record<LogLevel, (msg: string) => void>) {\r\n  internalLogger = logger\r\n}\r\n\r\nexport function log(msg: string, level: LogLevel = 'log') {\r\n  const logLevel = {\r\n    info: 0,\r\n    log: 1,\r\n    warn: 2,\r\n    error: 3,\r\n  }[level]\r\n\r\n  if (logLevel < LOG_LEVEL)\r\n    return\r\n\r\n  const color = ({ error: 'red', info: 'gray', warn: 'yellow', log: 'green' } as const)[level]\r\n  const date = new Date()\r\n  const current = Date.now()\r\n  const interval = (time && current - time) ? `+${current - time}` : ''\r\n  time = current\r\n\r\n  internalLogger[level](`${pc.magenta('[phecda-server]')} ${pc.gray(`${date.getHours()}:${date.getMinutes()}:${date.getSeconds()}`)} ${pc[color](msg)} ${pc.gray(interval)}`)\r\n}\r\n\r\nexport function Mix<C1 extends Construct | AbConstruct, C2 extends Construct>(InternalClass: C1, ExtendClass: C2) {\r\n  return class extends InternalClass {\r\n    constructor(...args: any) {\r\n      super()\r\n      Object.assign(this, new ExtendClass(...args))\r\n    }\r\n  } as new (...args: ConstructorParameters<C2>) => InstanceType<C1> & InstanceType<C2>\r\n}\r\n"]}

package/dist/chunk-Y6LI4FDO.js

@@ -0,0 +1,537 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
+
+
+
+
+
+
+
+var _chunkZ4YJHEXTjs = require('./chunk-Z4YJHEXT.js');
+
+// src/exception/base.ts
+var Exception = class extends Error {
+  
+  
+  
+  constructor(message, status = 0, description = "Exception") {
+    super(message);
+    this.message = message;
+    this.status = status;
+    this.description = description;
+  }
+  get data() {
+    return {
+      message: this.message,
+      description: this.description,
+      status: this.status,
+      [_chunkZ4YJHEXTjs.ERROR_SYMBOL]: true
+    };
+  }
+};
+_chunkZ4YJHEXTjs.__name.call(void 0, Exception, "Exception");
+
+// src/exception/validate.ts
+var ValidateException = class extends Exception {
+  constructor(message) {
+    super(message, 400, "Validate exception");
+  }
+};
+_chunkZ4YJHEXTjs.__name.call(void 0, ValidateException, "ValidateException");
+
+// src/pipe.ts
+var _phecdacore = require('phecda-core');
+var defaultPipe = /* @__PURE__ */ _chunkZ4YJHEXTjs.__name.call(void 0, ({ arg, reflect, index }) => {
+  if (_phecdacore.isPhecda.call(void 0, reflect)) {
+    const instance = _phecdacore.plainToClass.call(void 0, reflect, arg);
+    const err = _phecdacore.transformInstance.call(void 0, instance);
+    if (err.length > 0)
+      throw new ValidateException(err[0]);
+    arg = instance;
+  } else {
+    if (arg === void 0 && !reflect)
+      return void 0;
+    if ([
+      Number,
+      Boolean
+    ].includes(reflect)) {
+      arg = reflect(arg);
+      if (reflect === Number && Object.is(arg, NaN))
+        throw new ValidateException(`parameter ${Number(index) + 1} should be a number`);
+    }
+  }
+  return arg;
+}, "defaultPipe");
+
+// src/exception/undefine.ts
+var UndefinedException = class extends Exception {
+  constructor(message) {
+    super(message, 500, "Undefined error");
+  }
+};
+_chunkZ4YJHEXTjs.__name.call(void 0, UndefinedException, "UndefinedException");
+
+// src/exception/forbidden.ts
+var ForbiddenException = class extends Exception {
+  constructor(message) {
+    super(message, 403, "Forbidden resource");
+  }
+};
+_chunkZ4YJHEXTjs.__name.call(void 0, ForbiddenException, "ForbiddenException");
+
+// src/exception/bad-request.ts
+var BadRequestException = class extends Exception {
+  constructor(message) {
+    super(message, 400, "Bad Request");
+  }
+};
+_chunkZ4YJHEXTjs.__name.call(void 0, BadRequestException, "BadRequestException");
+
+// src/exception/not-found.ts
+var NotFoundException = class extends Exception {
+  constructor(message) {
+    super(message, 404, "Not Found");
+  }
+};
+_chunkZ4YJHEXTjs.__name.call(void 0, NotFoundException, "NotFoundException");
+
+// src/exception/conflict.ts
+var ConflictException = class extends Exception {
+  constructor(message) {
+    super(message, 409, "Conflict");
+  }
+};
+_chunkZ4YJHEXTjs.__name.call(void 0, ConflictException, "ConflictException");
+
+// src/exception/bad-gateway.ts
+var BadGatewayException = class extends Exception {
+  constructor(message) {
+    super(message, 502, "Bad Gatrway");
+  }
+};
+_chunkZ4YJHEXTjs.__name.call(void 0, BadGatewayException, "BadGatewayException");
+
+// src/exception/invalid-input.ts
+var InvalidInputException = class extends Exception {
+  constructor(message) {
+    super(message, 502, "Invalid Input");
+  }
+};
+_chunkZ4YJHEXTjs.__name.call(void 0, InvalidInputException, "InvalidInputException");
+
+// src/exception/media-type.ts
+var UnsupportedMediaTypeException = class extends Exception {
+  constructor(message) {
+    super(message, 415, "Unsupported Media Type");
+  }
+};
+_chunkZ4YJHEXTjs.__name.call(void 0, UnsupportedMediaTypeException, "UnsupportedMediaTypeException");
+
+// src/exception/payload-large.ts
+var PayloadLargeException = class extends Exception {
+  constructor(message) {
+    super(message, 413, "Payload Too Large");
+  }
+};
+_chunkZ4YJHEXTjs.__name.call(void 0, PayloadLargeException, "PayloadLargeException");
+
+// src/exception/timeout.ts
+var TimeoutException = class extends Exception {
+  constructor(message) {
+    super(message, 408, "Request Timeout");
+  }
+};
+_chunkZ4YJHEXTjs.__name.call(void 0, TimeoutException, "TimeoutException");
+
+// src/exception/unauthorized.ts
+var UnauthorizedException = class extends Exception {
+  constructor(message) {
+    super(message, 401, "Unauthorized");
+  }
+};
+_chunkZ4YJHEXTjs.__name.call(void 0, UnauthorizedException, "UnauthorizedException");
+
+// src/exception/unavailable-service.ts
+var ServiceUnavailableException = class extends Exception {
+  constructor(message) {
+    super(message, 503, "Service Unavailable");
+  }
+};
+_chunkZ4YJHEXTjs.__name.call(void 0, ServiceUnavailableException, "ServiceUnavailableException");
+
+// src/exception/framework.ts
+var FrameworkException = class extends Exception {
+  constructor(message) {
+    super(`[phecda-server] ${message}`, 500, "Framework Error");
+  }
+};
+_chunkZ4YJHEXTjs.__name.call(void 0, FrameworkException, "FrameworkException");
+
+// src/exception/timer.ts
+var TimerException = class extends Exception {
+  constructor(message) {
+    super(message, 0, "Timer Error");
+  }
+};
+_chunkZ4YJHEXTjs.__name.call(void 0, TimerException, "TimerException");
+
+// src/exception/worker.ts
+var WorkerException = class extends Exception {
+  constructor(message) {
+    super(message, 0, "Worker Error");
+  }
+};
+_chunkZ4YJHEXTjs.__name.call(void 0, WorkerException, "WorkerException");
+
+// src/hmr.ts
+function HMR(cb) {
+  if (_chunkZ4YJHEXTjs.IS_HMR)
+    _optionalChain([globalThis, 'access', _ => _.__PS_HMR__, 'optionalAccess', _2 => _2.push, 'call', _3 => _3(cb)]);
+}
+_chunkZ4YJHEXTjs.__name.call(void 0, HMR, "HMR");
+
+// src/server/helper.ts
+function resolveDep(ret, key) {
+  if (key)
+    return _optionalChain([ret, 'optionalAccess', _4 => _4[key]]);
+  return ret;
+}
+_chunkZ4YJHEXTjs.__name.call(void 0, resolveDep, "resolveDep");
+function argToReq(params, args, headers) {
+  const req = {
+    body: {},
+    query: {},
+    params: {},
+    headers
+  };
+  params.forEach((param) => {
+    if (param.key)
+      req[param.type][param.key] = args[param.index];
+    else
+      req[param.type] = args[param.index];
+  });
+  return req;
+}
+_chunkZ4YJHEXTjs.__name.call(void 0, argToReq, "argToReq");
+
+// src/rpc/helper.ts
+var _os = require('os');
+function genClientQueue(key) {
+  return `PS-${key ? `${key}-` : ""}${_os.hostname.call(void 0, )}-${process.pid}`;
+}
+_chunkZ4YJHEXTjs.__name.call(void 0, genClientQueue, "genClientQueue");
+
+// src/decorators/helper.ts
+function shallowClone(obj) {
+  return {
+    ...obj
+  };
+}
+_chunkZ4YJHEXTjs.__name.call(void 0, shallowClone, "shallowClone");
+function mergeObject(...args) {
+  return Object.assign({}, ...args);
+}
+_chunkZ4YJHEXTjs.__name.call(void 0, mergeObject, "mergeObject");
+function mergeArray(...args) {
+  return args.filter((item) => !!item).flat();
+}
+_chunkZ4YJHEXTjs.__name.call(void 0, mergeArray, "mergeArray");
+
+// src/context.ts
+var _picocolors = require('picocolors'); var _picocolors2 = _interopRequireDefault(_picocolors);
+var _debug = require('debug'); var _debug2 = _interopRequireDefault(_debug);
+
+// src/filter.ts
+var defaultFilter = /* @__PURE__ */ _chunkZ4YJHEXTjs.__name.call(void 0, (e) => {
+  if (!(e instanceof Exception)) {
+    _chunkZ4YJHEXTjs.log.call(void 0, e.message, "error");
+    if (_chunkZ4YJHEXTjs.LOG_LEVEL <= 0)
+      console.error(e.stack);
+    e = new UndefinedException(e.message || e);
+  } else {
+    _chunkZ4YJHEXTjs.log.call(void 0, `[${e.constructor.name}] ${e.message}`, "error");
+    if (_chunkZ4YJHEXTjs.LOG_LEVEL <= 0)
+      console.error(e.stack);
+  }
+  return e.data;
+}, "defaultFilter");
+
+// src/history.ts
+var Histroy = (_class = class {constructor() { _class.prototype.__init.call(this);_class.prototype.__init2.call(this); }
+  __init() {this.guard = []}
+  __init2() {this.interceptor = []}
+  record(name, type) {
+    if (!this[type].includes(name)) {
+      this[type].push(name);
+      return true;
+    }
+    return false;
+  }
+}, _class);
+_chunkZ4YJHEXTjs.__name.call(void 0, Histroy, "Histroy");
+
+// src/context.ts
+var debug = _debug2.default.call(void 0, "phecda-server(Context)");
+var _Context = class {
+  
+  
+  
+  
+  
+  constructor(data) {
+    this.data = data;
+    this.history = new Histroy();
+    if (_chunkZ4YJHEXTjs.IS_HMR)
+      data._context = this;
+  }
+  async run(opts, successCb, failCb) {
+    const { meta, moduleMap } = this.data;
+    const { globalGuards = [], globalFilter, globalInterceptors = [], globalPipe } = opts;
+    const { paramsType, data: { guards, interceptors, params, tag, func, ctx, filter } } = meta;
+    try {
+      await this.useGuard([
+        ...globalGuards,
+        ...guards
+      ]);
+      const i1 = await this.useInterceptor([
+        ...globalInterceptors,
+        ...interceptors
+      ]);
+      if (i1 !== void 0)
+        return successCb(i1);
+      const args = await this.usePipe(params.map((param) => {
+        return {
+          arg: resolveDep(this.data[param.type], param.key),
+          reflect: paramsType[param.index],
+          ...param,
+          pipe: param.pipe || globalPipe
+        };
+      }));
+      const instance = moduleMap.get(tag);
+      if (ctx)
+        instance[ctx] = this.data;
+      const returnData = await instance[func](...args);
+      const i2 = await this.usePostInterceptor(returnData);
+      if (i2 !== void 0)
+        return successCb(i2);
+      return successCb(returnData);
+    } catch (e) {
+      const err = await this.useFilter(e, filter || globalFilter);
+      return failCb(err);
+    }
+  }
+  usePipe(args) {
+    return Promise.all(args.map((item) => {
+      if (item.pipe && !_Context.pipeRecord[item.pipe]) {
+        if (_chunkZ4YJHEXTjs.IS_STRICT) {
+          throw new FrameworkException(`can't find pipe named '${item.pipe}'`);
+        } else {
+          debug(`Can't find pipe named "${item.pipe}" when handling the ${item.index + 1}th argument of the func "${this.data.func}" on module "${this.data.tag}",use default pipe instead`);
+          return _Context.pipeRecord.default(item, this.data);
+        }
+      }
+      return _Context.pipeRecord[item.pipe || "default"](item, this.data);
+    }));
+  }
+  useFilter(arg, filter = "default") {
+    if (!_Context.filterRecord[filter]) {
+      if (_chunkZ4YJHEXTjs.IS_STRICT) {
+        throw new FrameworkException(`can't find filter named "${filter}"`);
+      } else {
+        debug(`Can't find filter named "${filter}" when handling func "${this.data.func}" on module "${this.data.tag}",use default filter instead`);
+        return _Context.filterRecord.default(arg, this.data);
+      }
+    }
+    return _Context.filterRecord[filter](arg, this.data);
+  }
+  async useGuard(guards) {
+    for (const guard of guards) {
+      if (this.history.record(guard, "guard")) {
+        if (!(guard in _Context.guardRecord)) {
+          if (_chunkZ4YJHEXTjs.IS_STRICT)
+            throw new FrameworkException(`Can't find guard named "${guard}"`);
+          else
+            debug(`Can't find guard named "${guard}" when handling func "${this.data.func}" on module "${this.data.tag}",skip it`);
+          continue;
+        }
+        if (!await _Context.guardRecord[guard](this.data))
+          throw new ForbiddenException(`Guard exception--[${guard}]`);
+      }
+    }
+  }
+  async usePostInterceptor(data) {
+    for (const cb of this.postInterceptors) {
+      const ret = await cb(data);
+      if (ret !== void 0)
+        return ret;
+    }
+  }
+  async useInterceptor(interceptors) {
+    const cb = [];
+    for (const interceptor of interceptors) {
+      if (this.history.record(interceptor, "interceptor")) {
+        if (!(interceptor in _Context.interceptorRecord)) {
+          if (_chunkZ4YJHEXTjs.IS_STRICT)
+            throw new FrameworkException(`can't find interceptor named "${interceptor}"`);
+          else
+            debug(`Can't find interceptor named "${interceptor}" when handling func "${this.data.func}" on module "${this.data.tag}",skip it`);
+          continue;
+        }
+        const interceptRet = await _Context.interceptorRecord[interceptor](this.data);
+        if (interceptRet !== void 0) {
+          if (typeof interceptRet === "function")
+            cb.push(interceptRet);
+          else
+            return interceptRet;
+        }
+      }
+    }
+    this.postInterceptors = cb;
+  }
+  static usePlugin(plugins) {
+    const ret = [];
+    for (const m of plugins) {
+      if (!(m in _Context.pluginRecord)) {
+        if (_chunkZ4YJHEXTjs.IS_STRICT)
+          throw new FrameworkException(`can't find middleware named '${m}'`);
+        continue;
+      }
+      ret.push(_Context.pluginRecord[m]);
+    }
+    return ret;
+  }
+};
+var Context = _Context;
+_chunkZ4YJHEXTjs.__name.call(void 0, Context, "Context");
+_chunkZ4YJHEXTjs.__publicField.call(void 0, Context, "filterRecord", {
+  default: defaultFilter
+});
+_chunkZ4YJHEXTjs.__publicField.call(void 0, Context, "pipeRecord", {
+  default: defaultPipe
+});
+_chunkZ4YJHEXTjs.__publicField.call(void 0, Context, "guardRecord", {});
+_chunkZ4YJHEXTjs.__publicField.call(void 0, Context, "interceptorRecord", {});
+_chunkZ4YJHEXTjs.__publicField.call(void 0, Context, "pluginRecord", {});
+function addPlugin(key, handler) {
+  if (Context.pluginRecord[key] && Context.pluginRecord[key] !== handler)
+    _chunkZ4YJHEXTjs.log.call(void 0, `overwrite Plugin "${String(key)}"`, "warn");
+  Context.pluginRecord[key] = handler;
+}
+_chunkZ4YJHEXTjs.__name.call(void 0, addPlugin, "addPlugin");
+function addPipe(key, handler) {
+  if (Context.pipeRecord[key] && Context.pipeRecord[key] !== handler)
+    _chunkZ4YJHEXTjs.log.call(void 0, `overwrite Pipe "${String(key)}"`, "warn");
+  Context.pipeRecord[key] = handler;
+}
+_chunkZ4YJHEXTjs.__name.call(void 0, addPipe, "addPipe");
+function addFilter(key, handler) {
+  if (Context.filterRecord[key] && Context.filterRecord[key] !== handler)
+    _chunkZ4YJHEXTjs.log.call(void 0, `overwrite Filter "${String(key)}"`, "warn");
+  Context.filterRecord[key] = handler;
+}
+_chunkZ4YJHEXTjs.__name.call(void 0, addFilter, "addFilter");
+function addGuard(key, handler) {
+  if (Context.guardRecord[key] && Context.guardRecord[key] !== handler)
+    _chunkZ4YJHEXTjs.log.call(void 0, `overwrite Guard "${String(key)}"`, "warn");
+  Context.guardRecord[key] = handler;
+}
+_chunkZ4YJHEXTjs.__name.call(void 0, addGuard, "addGuard");
+function addInterceptor(key, handler) {
+  if (Context.interceptorRecord[key] && Context.interceptorRecord[key] !== handler)
+    _chunkZ4YJHEXTjs.log.call(void 0, `overwrite Interceptor "${String(key)}"`, "warn");
+  Context.interceptorRecord[key] = handler;
+}
+_chunkZ4YJHEXTjs.__name.call(void 0, addInterceptor, "addInterceptor");
+function detectAopDep(meta, { guards, interceptors, plugins } = {}, controller = "http") {
+  const pluginSet = new Set(plugins);
+  const guardSet = new Set(guards);
+  const interceptorSet = new Set(interceptors);
+  const pipeSet = /* @__PURE__ */ new Set();
+  const filterSet = /* @__PURE__ */ new Set();
+  const warningSet = /* @__PURE__ */ new Set();
+  meta.forEach(({ data }) => {
+    if (data.controller !== controller) {
+      if (data[controller])
+        warningSet.add(`Module "${data.tag === data.name ? data.name : `${data.name}(${data.tag})`}"  should use ${controller} controller to decorate class or remove ${controller} decorator on method "${data.func}"`);
+      return;
+    }
+    if (data.filter)
+      filterSet.add(data.filter);
+    data.interceptors.forEach((i) => interceptorSet.add(i));
+    data.guards.forEach((i) => guardSet.add(i));
+    data.plugins.forEach((i) => pluginSet.add(i));
+    data.params.forEach((i) => {
+      if (i.pipe)
+        pipeSet.add(i.pipe);
+    });
+  });
+  const missPlugins = [
+    ...pluginSet
+  ].filter((i) => !Context.pluginRecord[i]);
+  const missGuards = [
+    ...guardSet
+  ].filter((i) => !Context.guardRecord[i]);
+  const missInterceptors = [
+    ...interceptorSet
+  ].filter((i) => !Context.interceptorRecord[i]);
+  const missPipes = [
+    ...pipeSet
+  ].filter((i) => !Context.pipeRecord[i]);
+  const missFilters = [
+    ...filterSet
+  ].filter((i) => !Context.filterRecord[i]);
+  if (missPlugins.length)
+    _chunkZ4YJHEXTjs.log.call(void 0, `${_picocolors2.default.white(`Plugin [${missPlugins.join(",")}]`)} doesn't exist`, "warn");
+  if (missGuards.length)
+    _chunkZ4YJHEXTjs.log.call(void 0, `${_picocolors2.default.magenta(`Guard [${missGuards.join(",")}]`)} doesn't exist`, "warn");
+  if (missInterceptors.length)
+    _chunkZ4YJHEXTjs.log.call(void 0, `${_picocolors2.default.cyan(`Interceptor [${missInterceptors.join(",")}]`)} doesn't exist`, "warn");
+  if (missPipes.length)
+    _chunkZ4YJHEXTjs.log.call(void 0, `${_picocolors2.default.blue(`Pipe [${missPipes.join(",")}]`)} doesn't exist`, "warn");
+  if (missFilters.length)
+    _chunkZ4YJHEXTjs.log.call(void 0, `${_picocolors2.default.red(`Filter [${missFilters.join(",")}]`)} doesn't exist`, "warn");
+  warningSet.forEach((warn) => _chunkZ4YJHEXTjs.log.call(void 0, warn, "warn"));
+  return {
+    missPlugins,
+    missGuards,
+    missInterceptors,
+    missPipes,
+    missFilters
+  };
+}
+_chunkZ4YJHEXTjs.__name.call(void 0, detectAopDep, "detectAopDep");
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.Exception = Exception; exports.ValidateException = ValidateException; exports.defaultPipe = defaultPipe; exports.UndefinedException = UndefinedException; exports.ForbiddenException = ForbiddenException; exports.BadRequestException = BadRequestException; exports.NotFoundException = NotFoundException; exports.ConflictException = ConflictException; exports.BadGatewayException = BadGatewayException; exports.InvalidInputException = InvalidInputException; exports.UnsupportedMediaTypeException = UnsupportedMediaTypeException; exports.PayloadLargeException = PayloadLargeException; exports.TimeoutException = TimeoutException; exports.UnauthorizedException = UnauthorizedException; exports.ServiceUnavailableException = ServiceUnavailableException; exports.FrameworkException = FrameworkException; exports.TimerException = TimerException; exports.WorkerException = WorkerException; exports.HMR = HMR; exports.resolveDep = resolveDep; exports.argToReq = argToReq; exports.genClientQueue = genClientQueue; exports.shallowClone = shallowClone; exports.mergeObject = mergeObject; exports.mergeArray = mergeArray; exports.Context = Context; exports.addPlugin = addPlugin; exports.addPipe = addPipe; exports.addFilter = addFilter; exports.addGuard = addGuard; exports.addInterceptor = addInterceptor; exports.detectAopDep = detectAopDep;
+//# sourceMappingURL=chunk-Y6LI4FDO.js.map