phecda-server 1.0.1 → 1.1.0

package/dist/index.mjs

@@ -6,6 +6,9 @@ var __publicField = (obj, key, value) => {
   return value;
 };
 
+// src/pipe.ts
+import { isPhecda, plainToClass } from "phecda-core";
+
 // src/exception/base.ts
 var HttpException = class extends Error {
   message;
@@ -28,27 +31,36 @@ var HttpException = class extends Error {
 };
 __name(HttpException, "HttpException");
 
-// src/exception/wrong-meta.ts
-var WrongMetaException = class extends HttpException {
+// src/exception/validate.ts
+var ValidateException = class extends HttpException {
   constructor(message) {
-    super(message, 500, "Meta is not correct");
+    super(message, 400, "Validate exception");
   }
 };
-__name(WrongMetaException, "WrongMetaException");
+__name(ValidateException, "ValidateException");
 
-// src/history.ts
-var Phistroy = class {
-  guard = [];
-  interceptor = [];
-  record(name, type) {
-    if (!this[type].includes(name)) {
-      this[type].push(name);
-      return true;
+// src/pipe.ts
+var defaultPipe = {
+  async transform(args, reflect) {
+    for (const i in args) {
+      const { validate, arg } = args[i];
+      if (validate === false)
+        continue;
+      if (validate && !(arg?.constructor === reflect[i])) {
+        throw new ValidateException(`${arg} is not ${reflect[i].name}`);
+      } else {
+        if (isPhecda(reflect[i])) {
+          const ret = await plainToClass(reflect[i], arg, {
+            transform: false
+          });
+          if (ret.err.length > 0)
+            throw new ValidateException(ret.err[0]);
+        }
+      }
     }
-    return false;
+    return args.map((item) => item.arg);
   }
 };
-__name(Phistroy, "Phistroy");
 
 // src/exception/undefine.ts
 var UndefinedException = class extends HttpException {
@@ -58,14 +70,6 @@ var UndefinedException = class extends HttpException {
 };
 __name(UndefinedException, "UndefinedException");
 
-// src/exception/validate.ts
-var ValidateException = class extends HttpException {
-  constructor(message) {
-    super(message, 400, "Validate exception");
-  }
-};
-__name(ValidateException, "ValidateException");
-
 // src/exception/forbidden.ts
 var ForbiddenException = class extends HttpException {
   constructor(message) {
@@ -82,41 +86,50 @@ var BadRequestException = class extends HttpException {
 };
 __name(BadRequestException, "BadRequestException");
 
-// src/pipe.ts
-import { isPhecda, plainToClass } from "phecda-core";
-var defaultPipe = {
-  async transform(args, reflect) {
-    for (const i in args) {
-      const { validate, arg } = args[i];
-      if (validate === false)
-        continue;
-      if (validate && !(arg?.constructor === reflect[i])) {
-        throw new ValidateException(`${arg} is not ${reflect[i].name}`);
-      } else {
-        if (isPhecda(reflect[i])) {
-          const ret = await plainToClass(reflect[i], arg, {
-            transform: false
-          });
-          if (ret.err.length > 0)
-            throw new ValidateException(ret.err[0]);
-        }
-      }
+// src/filter.ts
+var serverFilter = /* @__PURE__ */ __name((e) => {
+  if (!(e instanceof HttpException))
+    e = new UndefinedException(e.message || e);
+  return e.data;
+}, "serverFilter");
+var rabbitMqFilter = /* @__PURE__ */ __name((e, data) => {
+  const { channel, message } = data;
+  channel.reject(message, true);
+}, "rabbitMqFilter");
+
+// src/exception/wrong-meta.ts
+var WrongMetaException = class extends HttpException {
+  constructor(message) {
+    super(message, 500, "Meta is not correct");
+  }
+};
+__name(WrongMetaException, "WrongMetaException");
+
+// src/history.ts
+var Phistroy = class {
+  guard = [];
+  interceptor = [];
+  record(name, type) {
+    if (!this[type].includes(name)) {
+      this[type].push(name);
+      return true;
     }
-    return args.map((item) => item.arg);
+    return false;
   }
 };
+__name(Phistroy, "Phistroy");
 
-// src/context.ts
+// src/context/base.ts
 var _Pcontext = class {
   key;
-  request;
+  data;
   method;
   params;
   post;
   history;
-  constructor(key, request) {
+  constructor(key, data) {
     this.key = key;
-    this.request = request;
+    this.data = data;
     this.history = new Phistroy();
   }
   static registerGuard(key, handler) {
@@ -125,19 +138,12 @@ var _Pcontext = class {
   static registerInterceptor(key, handler) {
     _Pcontext.interceptorsRecord[key] = handler;
   }
-  static useMiddleware(middlewares) {
-    return middlewares.map((m) => {
-      if (!(m in _Pcontext.middlewareRecord))
-        throw new WrongMetaException(`can't find middleware named ${m}`);
-      return _Pcontext.middlewareRecord[m];
-    });
-  }
   async useGuard(guards, isMerge = false) {
     for (const guard of guards) {
       if (this.history.record(guard, "guard")) {
         if (!(guard in _Pcontext.guardsRecord))
           throw new WrongMetaException(`can't find guard named ${guard}`);
-        if (!await _Pcontext.guardsRecord[guard](this.request, isMerge))
+        if (!await _Pcontext.guardsRecord[guard](this.data, isMerge))
           throw new ForbiddenException(`Guard exception--${guard}`);
       }
     }
@@ -148,7 +154,7 @@ var _Pcontext = class {
       if (this.history.record(interceptor, "interceptor")) {
         if (!(interceptor in _Pcontext.interceptorsRecord))
           throw new WrongMetaException(`can't find guard named ${interceptor}`);
-        const post = await _Pcontext.interceptorsRecord[interceptor](this.request, isMerge);
+        const post = await _Pcontext.interceptorsRecord[interceptor](this.data, isMerge);
         if (post)
           ret.push(post);
       }
@@ -156,20 +162,19 @@ var _Pcontext = class {
     this.post = ret;
   }
   async usePost(data) {
+    if (!this.post)
+      return data;
     for (const cb of this.post)
       data = await cb(data) | data;
     return data;
   }
-  async usePipe(args, reflect) {
-    return _Pcontext.pipe.transform(args, reflect);
-  }
 };
 var Pcontext = _Pcontext;
 __name(Pcontext, "Pcontext");
-__publicField(Pcontext, "pipe", defaultPipe);
 __publicField(Pcontext, "metaRecord", {});
+__publicField(Pcontext, "metaDataRecord", {});
+__publicField(Pcontext, "instanceRecord", {});
 __publicField(Pcontext, "guardsRecord", {});
-__publicField(Pcontext, "middlewareRecord", {});
 __publicField(Pcontext, "interceptorsRecord", {});
 function addGuard(key, handler) {
   Pcontext.registerGuard(key, handler);
@@ -179,10 +184,10 @@ function addInterceptor(key, handler) {
   Pcontext.registerInterceptor(key, handler);
 }
 __name(addInterceptor, "addInterceptor");
-function usePipe(pipe) {
-  Pcontext.pipe = pipe;
+function getInstance(tag) {
+  return Pcontext.instanceRecord[tag];
 }
-__name(usePipe, "usePipe");
+__name(getInstance, "getInstance");
 function parseMeta(meta) {
   const { data: { params, guards, interceptors, middlewares }, reflect } = meta;
   return {
@@ -202,6 +207,66 @@ function parseMeta(meta) {
 }
 __name(parseMeta, "parseMeta");
 
+// src/context/server.ts
+var _ServerContext = class extends Pcontext {
+  static useMiddleware(middlewares) {
+    return middlewares.map((m) => {
+      if (!(m in _ServerContext.middlewareRecord))
+        throw new WrongMetaException(`can't find middleware named ${m}`);
+      return _ServerContext.middlewareRecord[m];
+    });
+  }
+  async usePipe(args, reflect) {
+    return _ServerContext.pipe.transform?.(args, reflect);
+  }
+  useFilter(arg) {
+    return _ServerContext.filter(arg, this.data);
+  }
+};
+var ServerContext = _ServerContext;
+__name(ServerContext, "ServerContext");
+__publicField(ServerContext, "pipe", defaultPipe);
+__publicField(ServerContext, "filter", serverFilter);
+__publicField(ServerContext, "middlewareRecord", {});
+function useServerPipe(pipe) {
+  ServerContext.pipe = pipe;
+}
+__name(useServerPipe, "useServerPipe");
+function useServerFilter(filter) {
+  ServerContext.filter = filter;
+}
+__name(useServerFilter, "useServerFilter");
+
+// src/context/micro.ts
+var _RabbitMqContext = class extends Pcontext {
+  static useMiddleware(middlewares) {
+    return middlewares.map((m) => {
+      if (!(m in _RabbitMqContext.middlewareRecord))
+        throw new WrongMetaException(`can't find middleware named ${m}`);
+      return _RabbitMqContext.middlewareRecord[m];
+    });
+  }
+  async usePipe(args, reflect) {
+    return _RabbitMqContext.pipe.transform?.(args, reflect);
+  }
+  useFilter(arg) {
+    return _RabbitMqContext.filter(arg, this.data);
+  }
+};
+var RabbitMqContext = _RabbitMqContext;
+__name(RabbitMqContext, "RabbitMqContext");
+__publicField(RabbitMqContext, "pipe", defaultPipe);
+__publicField(RabbitMqContext, "filter", rabbitMqFilter);
+__publicField(RabbitMqContext, "middlewareRecord", {});
+function useMqPipe(pipe) {
+  RabbitMqContext.pipe = pipe;
+}
+__name(useMqPipe, "useMqPipe");
+function useMqFilter(filter) {
+  RabbitMqContext.filter = filter;
+}
+__name(useMqFilter, "useMqFilter");
+
 // src/compiler.ts
 var Pcompiler = class {
   content = "";
@@ -224,10 +289,22 @@ var Pcompiler = class {
       this.classMap[className] = {};
     this.classMap[className][methodName] = `
     ${methodName}(${genParams(params)}){
-const ret={name:"${className}-${methodName}",body:{},query:{},params:{},realParam:'',method:"${requestType}",url:"${url}"}
-${params.reduce((p, c, i) => `${p}ret.${c.type}.${c.key}=arg${i}
+const ret={tag:"${className}-${methodName}",body:{},query:{},params:{},realParam:'',method:"${requestType}",url:"${url}"}
+${params.filter((item) => item.key).reduce((p, c, i) => `${p}ret.${c.type}.${c.key}=arg${i}
 ${c.type === "params" ? `ret.realParam+='/'+arg${i}
 ` : ""}`, "")}
+return ret
+    }
+    `;
+  }
+  addMqMethod(className, methodName, exchange = "", routeKey = "", queue = "", params = []) {
+    if (!this.classMap[className])
+      this.classMap[className] = {};
+    this.classMap[className][methodName] = `
+    ${methodName}(${genParams(params)}){
+const ret={tag:"${className}-${methodName}",exchange:"${exchange}",routeKey:"${routeKey}",queue:"${queue}",args:{}}
+${params.reduce((p, c, i) => `${p}ret.args.${c.key}=arg${i}
+`, "")}
 return ret
     }
     `;
@@ -265,7 +342,7 @@ __name(NotFoundException, "NotFoundException");
 var SERIES_SYMBOL = "__symbol_series__";
 var REQ_SYMBOL = "__symbol_req__";
 
-// src/express.ts
+// src/server/express.ts
 function bindApp(app, { meta, moduleMap }, options = {}) {
   const { globalGuards, globalInterceptors, route, middlewares: proMiddle } = {
     route: "/__PHECDA_SERVER__",
@@ -279,7 +356,8 @@ function bindApp(app, { meta, moduleMap }, options = {}) {
     const { name, method, route: route2, header } = i.data;
     const instance = moduleMap.get(name);
     const tag = `${name}-${method}`;
-    let { guards, reflect, interceptors, params, middlewares } = Pcontext.metaRecord[tag] = parseMeta(i);
+    Pcontext.metaRecord[tag] = i;
+    let { guards, reflect, interceptors, params, middlewares } = Pcontext.metaDataRecord[tag] ? Pcontext.metaDataRecord[tag] : Pcontext.metaDataRecord[tag] = parseMeta(i);
     guards = [
       ...globalGuards,
       ...guards
@@ -290,12 +368,16 @@ function bindApp(app, { meta, moduleMap }, options = {}) {
     ];
     const handler = instance[method].bind(instance);
     methodMap[tag] = handler;
+    Pcontext.instanceRecord[name] = instance;
     if (route2) {
-      app[route2.type](route2.route, ...Pcontext.useMiddleware(middlewares), async (req, res) => {
+      app[route2.type](route2.route, ...ServerContext.useMiddleware(middlewares), async (req, res) => {
+        const contextData = {
+          request: req,
+          tag,
+          response: res
+        };
+        const context = new ServerContext(tag, contextData);
         try {
-          const context = new Pcontext(`${name}-${method}`, req);
-          instance.ctx = context;
-          instance.request = req;
           for (const name2 in header)
             res.set(name2, header[name2]);
           await context.useGuard(guards);
@@ -306,15 +388,16 @@ function bindApp(app, { meta, moduleMap }, options = {}) {
               validate
             };
           }), reflect);
+          instance.meta = contextData;
           const ret = await context.usePost(await handler(...args));
           if (isObject(ret))
             res.json(ret);
           else
             res.send(String(ret));
         } catch (e) {
-          if (!(e instanceof HttpException))
-            e = new UndefinedException(e.message || e);
-          res.status(e.status).json(e.data);
+          i.handlers.forEach((handler2) => handler2.error?.(e));
+          const err = await context.useFilter(e);
+          res.status(err.status).json(err);
         }
       });
     }
@@ -322,22 +405,24 @@ function bindApp(app, { meta, moduleMap }, options = {}) {
   app.post(route, (req, _res, next) => {
     req[REQ_SYMBOL] = true;
     next();
-  }, ...Pcontext.useMiddleware(proMiddle), async (req, res) => {
-    const context = new Pcontext(route, req);
+  }, ...ServerContext.useMiddleware(proMiddle), async (req, res) => {
+    const contextData = {
+      request: req,
+      response: res
+    };
+    const context = new ServerContext(route, contextData);
     const ret = [];
-    try {
-      const { body } = req;
-      for (const i in body) {
-        const { name: tag } = body[i];
-        const [name] = tag.split("-");
-        const { guards, reflect, interceptors, params } = Pcontext.metaRecord[tag];
-        const instance = moduleMap.get(name);
-        instance.ctx = context;
-        instance.request = req;
+    const { body } = req;
+    for (const i in body) {
+      const { tag } = body[i];
+      const [name] = tag.split("-");
+      const { guards, reflect, interceptors, params } = Pcontext.metaDataRecord[tag];
+      const instance = moduleMap.get(name);
+      try {
         if (!params)
           throw new NotFoundException(`"${tag}" doesn't exist`);
-        await context.useGuard(guards);
-        await context.useInterceptor(interceptors);
+        await context.useGuard(guards, true);
+        await context.useInterceptor(interceptors, true);
         const args = await context.usePipe(params.map(({ type, key, validate }) => {
           const arg = resolveDep(body[i][type], key);
           if (typeof arg === "string" && arg.startsWith(SERIES_SYMBOL)) {
@@ -352,13 +437,13 @@ function bindApp(app, { meta, moduleMap }, options = {}) {
             validate
           };
         }), reflect);
+        instance.meta = contextData;
         ret.push(await context.usePost(await methodMap[tag](...args)));
+      } catch (e) {
+        const m = Pcontext.metaRecord[tag];
+        m.handlers.forEach((handler) => handler.error?.(e));
+        ret.push(await context.useFilter(e));
       }
-    } catch (e) {
-      if (!(e instanceof HttpException))
-        e = new UndefinedException(e.message || e);
-      console.error(e.stack);
-      ret.push(e.data);
     }
     res.json(ret);
   });
@@ -367,31 +452,34 @@ __name(bindApp, "bindApp");
 
 // src/core.ts
 import "reflect-metadata";
-import { getModelState, getState } from "phecda-core";
+import { getExposeKey, getHandler, getState, registerAsync } from "phecda-core";
 
 // src/meta.ts
 var Pmeta = class {
   data;
+  handlers;
   reflect;
-  constructor(data, reflect) {
+  constructor(data, handlers, reflect) {
     this.data = data;
+    this.handlers = handlers;
     this.reflect = reflect;
   }
 };
 __name(Pmeta, "Pmeta");
 
 // src/core.ts
-function Factory(Modules) {
+async function Factory(Modules) {
   const moduleMap = /* @__PURE__ */ new Map();
   const meta = [];
-  Modules.forEach((Module) => buildNestModule(Module, moduleMap, meta));
+  for (const Module of Modules)
+    await buildNestModule(Module, moduleMap, meta);
   return {
     moduleMap,
     meta
   };
 }
 __name(Factory, "Factory");
-function buildNestModule(Module, map, meta) {
+async function buildNestModule(Module, map, meta) {
   const paramtypes = getParamtypes(Module);
   let instance;
   const name = Module.name;
@@ -403,21 +491,24 @@ function buildNestModule(Module, map, meta) {
   }
   map.set(name, void 0);
   if (paramtypes) {
-    instance = new Module(...paramtypes.map((item) => buildNestModule(item, map, meta)));
+    for (const i in paramtypes)
+      paramtypes[i] = await buildNestModule(paramtypes[i], map, meta);
+    instance = new Module(...paramtypes);
   } else {
     instance = new Module();
   }
   meta.push(...getMetaFromInstance(instance, name));
+  await registerAsync(instance);
   map.set(name, instance);
   return instance;
 }
 __name(buildNestModule, "buildNestModule");
 function getMetaFromInstance(instance, name) {
-  const vars = getModelState(instance).filter((item) => item !== "__CLASS");
+  const vars = getExposeKey(instance).filter((item) => item !== "__CLASS");
   const baseState = getState(instance, "__CLASS") || {};
   initState(baseState);
   return vars.map((i) => {
-    const state = getState(instance, i);
+    const state = getState(instance, i) || {};
     if (baseState.route && state.route)
       state.route.route = baseState.route.route + state.route.route;
     state.name = name;
@@ -449,7 +540,7 @@ function getMetaFromInstance(instance, name) {
         ...state.interceptors
       ])
     ];
-    return new Pmeta(state, getParamtypes(instance, i) || []);
+    return new Pmeta(state, getHandler(instance, i), getParamtypes(instance, i) || []);
   });
 }
 __name(getMetaFromInstance, "getMetaFromInstance");
@@ -470,7 +561,7 @@ function initState(state) {
 __name(initState, "initState");
 
 // src/decorators/index.ts
-import { mergeState as mergeState3, setModalVar as setModalVar3 } from "phecda-core";
+import { mergeState as mergeState4, setModalVar as setModalVar4 } from "phecda-core";
 
 // src/decorators/param.ts
 import { mergeState, setModalVar } from "phecda-core";
@@ -588,14 +679,30 @@ function Interceptor(interceptorKey) {
 }
 __name(Interceptor, "Interceptor");
 
+// src/decorators/micro.ts
+import { mergeState as mergeState3, setModalVar as setModalVar3 } from "phecda-core";
+function MQ(queue, routeKey, options) {
+  return (target, k) => {
+    setModalVar3(target, k);
+    mergeState3(target, k, {
+      mq: {
+        queue,
+        routeKey,
+        options
+      }
+    });
+  };
+}
+__name(MQ, "MQ");
+
 // src/decorators/index.ts
-function Inject() {
+function Inject(_target) {
 }
 __name(Inject, "Inject");
 function Header(name, value) {
   return (target, k) => {
-    setModalVar3(target, k);
-    mergeState3(target, k, {
+    setModalVar4(target, k);
+    mergeState4(target, k, {
       header: {
         name,
         value
@@ -636,6 +743,83 @@ function Server(localPath) {
   };
 }
 __name(Server, "Server");
+
+// src/index.ts
+export * from "phecda-core";
+
+// src/config.ts
+var Pconfig = {
+  rabbitmq: {
+    guard: false,
+    interceptor: false
+  }
+};
+
+// src/micro-services/rabbitmq.ts
+async function bindMQ(ch, { meta, moduleMap }) {
+  for (const item of meta) {
+    const { route, name, method, mq: { routeKey, queue: queueName, options } = {} } = item.data;
+    const tag = `${name}-${method}`;
+    Pcontext.metaRecord[tag] = item;
+    const { guards, reflect, interceptors, params } = Pcontext.metaDataRecord[tag] ? Pcontext.metaDataRecord[tag] : Pcontext.metaDataRecord[tag] = parseMeta(item);
+    const instance = moduleMap.get(name);
+    const handler = instance[method].bind(instance);
+    Pcontext.instanceRecord[name] = instance;
+    if (route) {
+      const { queue } = await ch.assertQueue(route.route);
+      if (queueName && routeKey)
+        await ch.bindQueue(queue, queueName, routeKey);
+      ch.consume(route.route, async (msg) => {
+        if (msg !== null) {
+          const content = msg.content.toString();
+          const data = params.length > 0 ? JSON.parse(content) : content;
+          const contextMeta = {
+            message: msg,
+            content,
+            channel: ch
+          };
+          const context = new RabbitMqContext(tag, contextMeta);
+          try {
+            if (Pconfig.rabbitmq.guard)
+              await context.useGuard(guards);
+            if (Pconfig.rabbitmq.interceptor)
+              await context.useInterceptor(interceptors);
+            const args = await context.usePipe(params.map(({ key, validate }) => {
+              return {
+                arg: resolveDep(data, key),
+                validate
+              };
+            }), reflect);
+            instance.meta = contextMeta;
+            await context.usePost(await handler(...args));
+            ch.ack(msg);
+          } catch (e) {
+            item.handlers.forEach((handler2) => handler2.error?.(e));
+            context.useFilter(e);
+          }
+        } else {
+        }
+      }, options);
+    }
+  }
+}
+__name(bindMQ, "bindMQ");
+async function createPub(ch, method, type) {
+  const { exchange, routeKey, queue } = method();
+  if (exchange)
+    await ch.assertExchange(exchange, type);
+  else
+    await ch.assertQueue(queue);
+  return async (arg) => {
+    const { args } = method(arg);
+    const msg = Buffer.from(JSON.stringify(args));
+    if (exchange)
+      await ch.publish(exchange, routeKey, msg);
+    else
+      await ch.sendToQueue(queue, msg);
+  };
+}
+__name(createPub, "createPub");
 export {
   BadRequestException,
   BaseParam,
@@ -650,6 +834,7 @@ export {
   HttpException,
   Inject,
   Interceptor,
+  MQ,
   Param,
   Pcompiler,
   Pcontext,
@@ -657,15 +842,23 @@ export {
   Post,
   Put,
   Query,
+  RabbitMqContext,
   Route,
   Server,
+  ServerContext,
   UndefinedException,
   ValidateException,
   addGuard,
   addInterceptor,
   bindApp,
+  bindMQ,
+  createPub,
   defaultPipe,
+  getInstance,
   parseMeta,
-  usePipe
+  useMqFilter,
+  useMqPipe,
+  useServerFilter,
+  useServerPipe
 };
 //# sourceMappingURL=index.mjs.map