phecda-server 6.0.2 → 7.0.0-alpha.0

package/dist/{chunk-WXFZZZRY.mjs → chunk-P75VKZJY.mjs}

@@ -1,11 +1,10 @@
 import {
   ERROR_SYMBOL,
   IS_HMR,
-  IS_STRICT,
   LOG_LEVEL,
   __name,
   log
-} from "./chunk-UXD62LGG.mjs";
+} from "./chunk-WHJ5FALK.mjs";
 
 // src/helper.ts
 import pc from "picocolors";
@@ -228,143 +227,120 @@ var Context = class _Context {
     default: defaultPipe
   };
   static guardRecord = {};
-  static interceptorRecord = {};
-  static pluginRecord = {};
-  postInterceptors;
+  static addonRecord = {};
   constructor(data) {
     this.data = data;
     if (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, ctxs, filter } } = meta;
-    try {
-      await this.useGuard([
+  static getAop(meta, opts) {
+    const { globalGuards = [], globalFilter = "default", globalPipe = "default" } = opts;
+    const { data: { guards, filter, params } } = meta;
+    return {
+      guards: this.getGuards([
         ...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
+      ]),
+      pipe: this.getPipe(params.map((item) => item.pipe || globalPipe)),
+      filter: this.getFilter(filter || globalFilter)
+    };
+  }
+  async run({ guards, filter, pipe }, successCb, failCb) {
+    const { meta, moduleMap } = this.data;
+    const { paramsType, data: { ctxs, tag, params, func } } = meta;
+    try {
+      let res;
+      const nextHandler = /* @__PURE__ */ __name((index) => {
+        return async () => {
+          if (index === guards.length) {
+            const instance = moduleMap.get(tag);
+            if (ctxs) {
+              ctxs.forEach((ctx) => instance[ctx] = this.data);
+            }
+            const args = await Promise.all(params.map((item, i) => pipe[i]({
+              arg: resolveDep(this.data[item.type], item.key),
+              reflect: paramsType[item.index],
+              ...item
+            }, this.data)));
+            res = await instance[func](...args);
+          } else {
+            let nextPromise;
+            async function next() {
+              return nextPromise = nextHandler(index + 1)().then((ret2) => {
+                if (ret2 !== void 0) {
+                  debug(`The ${index + 1}th guard rewrite the response value.`);
+                  res = ret2;
+                }
+                return res;
+              });
+            }
+            __name(next, "next");
+            const ret = await guards[index](this.data, next);
+            if (ret !== void 0) {
+              res = ret;
+            } else {
+              if (!nextPromise) await next();
+              else await nextPromise;
+            }
+          }
         };
-      }));
-      const instance = moduleMap.get(tag);
-      if (ctxs) {
-        ctxs.forEach((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);
+      }, "nextHandler");
+      await nextHandler(0)();
+      return successCb(res);
     } catch (e) {
-      const err = await this.useFilter(e, filter || globalFilter);
+      const err = await filter(e, this.data);
       return failCb(err);
     }
   }
-  usePipe(args) {
-    return Promise.all(args.map((item) => {
-      if (item.pipe && !_Context.pipeRecord[item.pipe]) {
-        if (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 (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 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`);
-        continue;
-      }
-      if (!await _Context.guardRecord[guard](this.data)) throw new ForbiddenException(`Guard exception--[${guard}]`);
-    }
+  static getPipe(pipe) {
+    return pipe.map((pipe2) => {
+      return _Context.pipeRecord[pipe2] || _Context.pipeRecord.default;
+    });
   }
-  async usePostInterceptor(data) {
-    for (const cb of this.postInterceptors) {
-      const ret = await cb(data);
-      if (ret !== void 0) return ret;
-    }
+  static getFilter(filter = "default") {
+    return _Context.filterRecord[filter] || _Context.filterRecord.default;
   }
-  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`);
-        continue;
-      }
-      const interceptRet = await _Context.interceptorRecord[interceptor](this.data);
-      if (interceptRet !== void 0) {
-        if (typeof interceptRet === "function") cb.push(interceptRet);
-        else return interceptRet;
-      }
+  static getGuards(guards) {
+    const ret = [];
+    for (const guard of new Set(guards)) {
+      if (guard in _Context.guardRecord) ret.push(_Context.guardRecord[guard]);
     }
-    this.postInterceptors = cb;
+    return ret.sort((a, b) => b.priority - a.priority).map((item) => item.value);
   }
-  static usePlugin(plugins, framework) {
+  static applyAddons(addons, router, framework) {
     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}'`);
-        continue;
-      }
-      const plugin = _Context.pluginRecord[m](framework);
-      plugin && ret.push(plugin);
+    for (const a of new Set(addons)) {
+      if (a in _Context.addonRecord) ret.push(_Context.addonRecord[a]);
     }
-    return ret;
+    ret.sort((a, b) => b.priority - a.priority).forEach((item) => item.value(router, framework));
   }
 };
-function addPlugin(key, handler) {
-  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");
-  Context.pipeRecord[key] = handler;
+function addPipe(key, pipe) {
+  if (Context.pipeRecord[key] && Context.pipeRecord[key] !== pipe) log(`overwrite Pipe "${String(key)}"`, "warn");
+  Context.pipeRecord[key] = pipe;
 }
 __name(addPipe, "addPipe");
-function addFilter(key, handler) {
-  if (Context.filterRecord[key] && Context.filterRecord[key] !== handler) log(`overwrite Filter "${String(key)}"`, "warn");
-  Context.filterRecord[key] = handler;
+function addFilter(key, filter) {
+  if (Context.filterRecord[key] && Context.filterRecord[key] !== filter) log(`overwrite Filter "${String(key)}"`, "warn");
+  Context.filterRecord[key] = filter;
 }
 __name(addFilter, "addFilter");
-function addGuard(key, handler) {
-  if (Context.guardRecord[key] && Context.guardRecord[key] !== handler) log(`overwrite Guard "${String(key)}"`, "warn");
-  Context.guardRecord[key] = handler;
+function addGuard(key, guard, priority = 0) {
+  if (Context.guardRecord[key] && Context.guardRecord[key].value !== guard) log(`overwrite Guard "${String(key)}"`, "warn");
+  Context.guardRecord[key] = {
+    value: guard,
+    priority
+  };
 }
 __name(addGuard, "addGuard");
-function addInterceptor(key, handler) {
-  if (Context.interceptorRecord[key] && Context.interceptorRecord[key] !== handler) log(`overwrite Interceptor "${String(key)}"`, "warn");
-  Context.interceptorRecord[key] = handler;
+function addAddon(key, addon, priority = 0) {
+  if (Context.addonRecord[key] && Context.addonRecord[key].value !== addon) log(`overwrite Addon "${String(key)}"`, "warn");
+  Context.addonRecord[key] = {
+    value: addon,
+    priority
+  };
 }
-__name(addInterceptor, "addInterceptor");
+__name(addAddon, "addAddon");
 
 // src/hmr.ts
 function HMR(cb) {
@@ -372,7 +348,7 @@ function HMR(cb) {
 }
 __name(HMR, "HMR");
 
-// src/server/helper.ts
+// src/http/helper.ts
 function resolveDep(ret, key) {
   if (key) return ret?.[key];
   return ret;
@@ -432,60 +408,50 @@ function createControllerMetaMap(meta, filter) {
   return metaMap;
 }
 __name(createControllerMetaMap, "createControllerMetaMap");
-function detectAopDep(meta, { guards, interceptors, plugins } = {}, controller = "http") {
-  const pluginSet = /* @__PURE__ */ new Set();
+function detectAopDep(meta, { guards, addons } = {}, controller = "http") {
+  const addonSet = /* @__PURE__ */ new Set();
   const guardSet = /* @__PURE__ */ new Set();
-  const interceptorSet = /* @__PURE__ */ new Set();
   const pipeSet = /* @__PURE__ */ new Set();
   const filterSet = /* @__PURE__ */ new Set();
   const warningSet = /* @__PURE__ */ new Set();
   function handleMeta() {
-    pluginSet.clear();
+    addonSet.clear();
     guardSet.clear();
-    interceptorSet.clear();
     pipeSet.clear();
     filterSet.clear();
     warningSet.clear();
-    plugins?.forEach((item) => {
-      pluginSet.add(item);
+    addons?.forEach((item) => {
+      addonSet.add(item);
     });
     guards?.forEach((item) => {
       guardSet.add(item);
     });
-    interceptors?.forEach((item) => {
-      interceptorSet.add(item);
-    });
     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.addons.forEach((i) => addonSet.add(i));
       data.params.forEach((i) => {
         if (i.pipe) pipeSet.add(i.pipe);
       });
     });
-    const missPlugins = [
-      ...pluginSet
-    ].filter((i) => !Context.pluginRecord[i]);
+    const missAddons = [
+      ...addonSet
+    ].filter((i) => !Context.addonRecord[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) log(`${pc.white(`Plugin [${missPlugins.join(",")}]`)} doesn't exist`, "warn");
+    if (missAddons.length) log(`${pc.white(`Addon [${missAddons.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"));
@@ -494,9 +460,8 @@ function detectAopDep(meta, { guards, interceptors, plugins } = {}, controller =
   handleMeta();
   HMR(handleMeta);
   return {
-    pluginSet,
+    addonSet,
     guardSet,
-    interceptorSet,
     pipeSet,
     filterSet
   };
@@ -523,11 +488,10 @@ export {
   TimerException,
   WorkerException,
   Context,
-  addPlugin,
   addPipe,
   addFilter,
   addGuard,
-  addInterceptor,
+  addAddon,
   HMR,
   resolveDep,
   argToReq,