phecda-server 5.2.4 → 5.2.5

package/dist/{chunk-VYDBNZJ2.mjs → chunk-2NTXVYQC.mjs}

@@ -1,10 +1,5 @@
 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__";
@@ -34,8 +29,7 @@ function log(msg, level = "log") {
     warn: 2,
     error: 3
   }[level];
-  if (logLevel < LOG_LEVEL)
-    return;
+  if (logLevel < LOG_LEVEL) return;
   const color = {
     error: "red",
     info: "gray",
@@ -61,7 +55,6 @@ __name(Mix, "Mix");
 
 export {
   __name,
-  __publicField,
   UNMOUNT_SYMBOL,
   ERROR_SYMBOL,
   IS_HMR,

package/dist/{chunk-Q4AGVGVA.mjs → chunk-2O6X54P5.mjs}

@@ -4,9 +4,8 @@ import {
   IS_STRICT,
   LOG_LEVEL,
   __name,
-  __publicField,
   log
-} from "./chunk-VYDBNZJ2.mjs";
+} from "./chunk-2NTXVYQC.mjs";
 
 // src/helper.ts
 import pc from "picocolors";
@@ -19,6 +18,9 @@ import { isPhecda, plainToClass, transformInstance } from "phecda-core";
 
 // src/exception/base.ts
 var Exception = class extends Error {
+  static {
+    __name(this, "Exception");
+  }
   message;
   status;
   description;
@@ -37,34 +39,32 @@ var Exception = class extends Error {
     };
   }
 };
-__name(Exception, "Exception");
 
 // src/exception/validate.ts
 var ValidateException = class extends Exception {
+  static {
+    __name(this, "ValidateException");
+  }
   constructor(message) {
     super(message, 400, "Validate exception");
   }
 };
-__name(ValidateException, "ValidateException");
 
 // src/pipe.ts
 var defaultPipe = /* @__PURE__ */ __name(({ arg, reflect, index }) => {
   if (isPhecda(reflect)) {
     const instance = plainToClass(reflect, arg);
     const err = transformInstance(instance);
-    if (err.length > 0)
-      throw new ValidateException(err[0]);
+    if (err.length > 0) throw new ValidateException(err[0]);
     arg = instance;
   } else {
-    if (arg === void 0 && !reflect)
-      return void 0;
+    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`);
+      if (reflect === Number && Object.is(arg, NaN)) throw new ValidateException(`parameter ${Number(index) + 1} should be a number`);
     }
   }
   return arg;
@@ -72,145 +72,185 @@ var defaultPipe = /* @__PURE__ */ __name(({ arg, reflect, index }) => {
 
 // src/exception/undefine.ts
 var UndefinedException = class extends Exception {
+  static {
+    __name(this, "UndefinedException");
+  }
   constructor(message) {
     super(message, 500, "Undefined error");
   }
 };
-__name(UndefinedException, "UndefinedException");
 
 // src/exception/forbidden.ts
 var ForbiddenException = class extends Exception {
+  static {
+    __name(this, "ForbiddenException");
+  }
   constructor(message) {
     super(message, 403, "Forbidden resource");
   }
 };
-__name(ForbiddenException, "ForbiddenException");
 
 // src/exception/bad-request.ts
 var BadRequestException = class extends Exception {
+  static {
+    __name(this, "BadRequestException");
+  }
   constructor(message) {
     super(message, 400, "Bad Request");
   }
 };
-__name(BadRequestException, "BadRequestException");
 
 // src/exception/not-found.ts
 var NotFoundException = class extends Exception {
+  static {
+    __name(this, "NotFoundException");
+  }
   constructor(message) {
     super(message, 404, "Not Found");
   }
 };
-__name(NotFoundException, "NotFoundException");
 
 // src/exception/conflict.ts
 var ConflictException = class extends Exception {
+  static {
+    __name(this, "ConflictException");
+  }
   constructor(message) {
     super(message, 409, "Conflict");
   }
 };
-__name(ConflictException, "ConflictException");
 
 // src/exception/bad-gateway.ts
 var BadGatewayException = class extends Exception {
+  static {
+    __name(this, "BadGatewayException");
+  }
   constructor(message) {
     super(message, 502, "Bad Gatrway");
   }
 };
-__name(BadGatewayException, "BadGatewayException");
 
 // src/exception/invalid-input.ts
 var InvalidInputException = class extends Exception {
+  static {
+    __name(this, "InvalidInputException");
+  }
   constructor(message) {
     super(message, 502, "Invalid Input");
   }
 };
-__name(InvalidInputException, "InvalidInputException");
 
 // src/exception/media-type.ts
 var UnsupportedMediaTypeException = class extends Exception {
+  static {
+    __name(this, "UnsupportedMediaTypeException");
+  }
   constructor(message) {
     super(message, 415, "Unsupported Media Type");
   }
 };
-__name(UnsupportedMediaTypeException, "UnsupportedMediaTypeException");
 
 // src/exception/payload-large.ts
 var PayloadLargeException = class extends Exception {
+  static {
+    __name(this, "PayloadLargeException");
+  }
   constructor(message) {
     super(message, 413, "Payload Too Large");
   }
 };
-__name(PayloadLargeException, "PayloadLargeException");
 
 // src/exception/timeout.ts
 var TimeoutException = class extends Exception {
+  static {
+    __name(this, "TimeoutException");
+  }
   constructor(message) {
     super(message, 408, "Request Timeout");
   }
 };
-__name(TimeoutException, "TimeoutException");
 
 // src/exception/unauthorized.ts
 var UnauthorizedException = class extends Exception {
+  static {
+    __name(this, "UnauthorizedException");
+  }
   constructor(message) {
     super(message, 401, "Unauthorized");
   }
 };
-__name(UnauthorizedException, "UnauthorizedException");
 
 // src/exception/unavailable-service.ts
 var ServiceUnavailableException = class extends Exception {
+  static {
+    __name(this, "ServiceUnavailableException");
+  }
   constructor(message) {
     super(message, 503, "Service Unavailable");
   }
 };
-__name(ServiceUnavailableException, "ServiceUnavailableException");
 
 // src/exception/framework.ts
 var FrameworkException = class extends Exception {
+  static {
+    __name(this, "FrameworkException");
+  }
   constructor(message) {
     super(`[phecda-server] ${message}`, 500, "Framework Error");
   }
 };
-__name(FrameworkException, "FrameworkException");
 
 // src/exception/timer.ts
 var TimerException = class extends Exception {
+  static {
+    __name(this, "TimerException");
+  }
   constructor(message) {
     super(message, 0, "Timer Error");
   }
 };
-__name(TimerException, "TimerException");
 
 // src/exception/worker.ts
 var WorkerException = class extends Exception {
+  static {
+    __name(this, "WorkerException");
+  }
   constructor(message) {
     super(message, 0, "Worker Error");
   }
 };
-__name(WorkerException, "WorkerException");
 
 // src/filter.ts
 var defaultFilter = /* @__PURE__ */ __name((e) => {
   if (!(e instanceof Exception)) {
     log(e.message, "error");
-    if (LOG_LEVEL <= 0)
-      console.error(e.stack);
+    if (LOG_LEVEL <= 0) console.error(e.stack);
     e = new UndefinedException(e.message || e);
   } else {
     log(`[${e.constructor.name}] ${e.message}`, "error");
-    if (LOG_LEVEL <= 0)
-      console.error(e.stack);
+    if (LOG_LEVEL <= 0) console.error(e.stack);
   }
   return e.data;
 }, "defaultFilter");
 
 // src/context.ts
 var debug = Debug("phecda-server(Context)");
-var _Context = class {
+var Context = class _Context {
+  static {
+    __name(this, "Context");
+  }
   data;
   method;
   params;
+  static filterRecord = {
+    default: defaultFilter
+  };
+  static pipeRecord = {
+    default: defaultPipe
+  };
+  static guardRecord = {};
+  static interceptorRecord = {};
+  static pluginRecord = {};
   postInterceptors;
   constructor(data) {
     this.data = data;
@@ -230,8 +270,7 @@ var _Context = class {
         ...globalInterceptors,
         ...interceptors
       ]);
-      if (i1 !== void 0)
-        return successCb(i1);
+      if (i1 !== void 0) return successCb(i1);
       const args = await this.usePipe(params.map((param) => {
         return {
           arg: resolveDep(this.data[param.type], param.key),
@@ -246,8 +285,7 @@ var _Context = class {
       }
       const returnData = await instance[func](...args);
       const i2 = await this.usePostInterceptor(returnData);
-      if (i2 !== void 0)
-        return successCb(i2);
+      if (i2 !== void 0) return successCb(i2);
       return successCb(returnData);
     } catch (e) {
       const err = await this.useFilter(e, filter || globalFilter);
@@ -281,39 +319,31 @@ var _Context = class {
   async useGuard(guards) {
     for (const guard of new Set(guards)) {
       if (!(guard in _Context.guardRecord)) {
-        if (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`);
+        if (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}]`);
+      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;
+      if (ret !== void 0) return ret;
     }
   }
   async useInterceptor(interceptors) {
     const cb = [];
     for (const interceptor of new Set(interceptors)) {
       if (!(interceptor in _Context.interceptorRecord)) {
-        if (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`);
+        if (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;
+        if (typeof interceptRet === "function") cb.push(interceptRet);
+        else return interceptRet;
       }
     }
     this.postInterceptors = cb;
@@ -322,8 +352,7 @@ var _Context = class {
     const ret = [];
     for (const m of new Set(plugins)) {
       if (!(m in _Context.pluginRecord)) {
-        if (IS_STRICT)
-          throw new FrameworkException(`can't find middleware named '${m}'`);
+        if (IS_STRICT) throw new FrameworkException(`can't find middleware named '${m}'`);
         continue;
       }
       const plugin = _Context.pluginRecord[m](framework);
@@ -332,59 +361,41 @@ var _Context = class {
     return ret;
   }
 };
-var Context = _Context;
-__name(Context, "Context");
-__publicField(Context, "filterRecord", {
-  default: defaultFilter
-});
-__publicField(Context, "pipeRecord", {
-  default: defaultPipe
-});
-__publicField(Context, "guardRecord", {});
-__publicField(Context, "interceptorRecord", {});
-__publicField(Context, "pluginRecord", {});
 function addPlugin(key, handler) {
-  if (Context.pluginRecord[key] && Context.pluginRecord[key] !== handler)
-    log(`overwrite Plugin "${String(key)}"`, "warn");
+  if (Context.pluginRecord[key] && Context.pluginRecord[key] !== handler) log(`overwrite Plugin "${String(key)}"`, "warn");
   Context.pluginRecord[key] = handler;
 }
 __name(addPlugin, "addPlugin");
 function addPipe(key, handler) {
-  if (Context.pipeRecord[key] && Context.pipeRecord[key] !== handler)
-    log(`overwrite Pipe "${String(key)}"`, "warn");
+  if (Context.pipeRecord[key] && Context.pipeRecord[key] !== handler) log(`overwrite Pipe "${String(key)}"`, "warn");
   Context.pipeRecord[key] = handler;
 }
 __name(addPipe, "addPipe");
 function addFilter(key, handler) {
-  if (Context.filterRecord[key] && Context.filterRecord[key] !== handler)
-    log(`overwrite Filter "${String(key)}"`, "warn");
+  if (Context.filterRecord[key] && Context.filterRecord[key] !== handler) log(`overwrite Filter "${String(key)}"`, "warn");
   Context.filterRecord[key] = handler;
 }
 __name(addFilter, "addFilter");
 function addGuard(key, handler) {
-  if (Context.guardRecord[key] && Context.guardRecord[key] !== handler)
-    log(`overwrite Guard "${String(key)}"`, "warn");
+  if (Context.guardRecord[key] && Context.guardRecord[key] !== handler) log(`overwrite Guard "${String(key)}"`, "warn");
   Context.guardRecord[key] = handler;
 }
 __name(addGuard, "addGuard");
 function addInterceptor(key, handler) {
-  if (Context.interceptorRecord[key] && Context.interceptorRecord[key] !== handler)
-    log(`overwrite Interceptor "${String(key)}"`, "warn");
+  if (Context.interceptorRecord[key] && Context.interceptorRecord[key] !== handler) log(`overwrite Interceptor "${String(key)}"`, "warn");
   Context.interceptorRecord[key] = handler;
 }
 __name(addInterceptor, "addInterceptor");
 
 // src/hmr.ts
 function HMR(cb) {
-  if (IS_HMR)
-    globalThis.__PS_HMR__?.push(cb);
+  if (IS_HMR) globalThis.__PS_HMR__?.push(cb);
 }
 __name(HMR, "HMR");
 
 // src/server/helper.ts
 function resolveDep(ret, key) {
-  if (key)
-    return ret?.[key];
+  if (key) return ret?.[key];
   return ret;
 }
 __name(resolveDep, "resolveDep");
@@ -396,10 +407,8 @@ function argToReq(params, args, headers) {
     headers
   };
   params.forEach((param) => {
-    if (param.key)
-      req[param.type][param.key] = args[param.index];
-    else
-      req[param.type] = args[param.index];
+    if (param.key) req[param.type][param.key] = args[param.index];
+    else req[param.type] = args[param.index];
   });
   return req;
 }
@@ -431,14 +440,11 @@ function createControllerMetaMap(meta, filter) {
     metaMap.clear();
     for (const item of meta) {
       const { tag, func } = item.data;
-      if (!filter(item))
-        continue;
-      if (metaMap.has(tag))
-        metaMap.get(tag)[func] = item;
-      else
-        metaMap.set(tag, {
-          [func]: item
-        });
+      if (!filter(item)) continue;
+      if (metaMap.has(tag)) metaMap.get(tag)[func] = item;
+      else metaMap.set(tag, {
+        [func]: item
+      });
     }
   }
   __name(handleMeta, "handleMeta");
@@ -472,18 +478,15 @@ function detectAopDep(meta, { guards, interceptors, plugins } = {}, controller =
     });
     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}"`);
+        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);
+      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);
+        if (i.pipe) pipeSet.add(i.pipe);
       });
     });
     const missPlugins = [
@@ -501,16 +504,11 @@ function detectAopDep(meta, { guards, interceptors, plugins } = {}, controller =
     const missFilters = [
       ...filterSet
     ].filter((i) => !Context.filterRecord[i]);
-    if (missPlugins.length)
-      log(`${pc.white(`Plugin [${missPlugins.join(",")}]`)} doesn't exist`, "warn");
-    if (missGuards.length)
-      log(`${pc.magenta(`Guard [${missGuards.join(",")}]`)} doesn't exist`, "warn");
-    if (missInterceptors.length)
-      log(`${pc.cyan(`Interceptor [${missInterceptors.join(",")}]`)} doesn't exist`, "warn");
-    if (missPipes.length)
-      log(`${pc.blue(`Pipe [${missPipes.join(",")}]`)} doesn't exist`, "warn");
-    if (missFilters.length)
-      log(`${pc.red(`Filter [${missFilters.join(",")}]`)} doesn't exist`, "warn");
+    if (missPlugins.length) log(`${pc.white(`Plugin [${missPlugins.join(",")}]`)} doesn't exist`, "warn");
+    if (missGuards.length) log(`${pc.magenta(`Guard [${missGuards.join(",")}]`)} doesn't exist`, "warn");
+    if (missInterceptors.length) log(`${pc.cyan(`Interceptor [${missInterceptors.join(",")}]`)} doesn't exist`, "warn");
+    if (missPipes.length) log(`${pc.blue(`Pipe [${missPipes.join(",")}]`)} doesn't exist`, "warn");
+    if (missFilters.length) log(`${pc.red(`Filter [${missFilters.join(",")}]`)} doesn't exist`, "warn");
     warningSet.forEach((warn) => log(warn, "warn"));
   }
   __name(handleMeta, "handleMeta");