phecda-server 1.2.4 → 1.4.0

package/dist/index.js

@@ -34,23 +34,30 @@ var __publicField = (obj, key, value) => {
 var src_exports = {};
 __export(src_exports, {
   $S: () => $S,
+  BadGatewayException: () => BadGatewayException,
   BadRequestException: () => BadRequestException,
+  Base: () => Base,
   BaseParam: () => BaseParam,
   Body: () => Body,
+  ConflictException: () => ConflictException,
   Controller: () => Controller,
   Delete: () => Delete,
   Factory: () => Factory,
   ForbiddenException: () => ForbiddenException,
+  FrameworkException: () => FrameworkException,
   Get: () => Get,
   Guard: () => Guard,
   Header: () => Header,
   HttpException: () => HttpException,
   Inject: () => Inject,
   Interceptor: () => Interceptor,
+  InvalidInputException: () => InvalidInputException,
   MQ: () => MQ,
+  Meta: () => Meta,
   Middle: () => Middle,
   NotFoundException: () => NotFoundException,
   Param: () => Param,
+  PayloadLargeException: () => PayloadLargeException,
   Pcompiler: () => Pcompiler,
   Pcontext: () => Pcontext,
   Pmeta: () => Pmeta,
@@ -60,9 +67,12 @@ __export(src_exports, {
   RabbitMqContext: () => RabbitMqContext,
   Route: () => Route,
   ServerContext: () => ServerContext,
+  ServiceUnavailableException: () => ServiceUnavailableException,
+  TimeoutException: () => TimeoutException,
+  UnauthorizedException: () => UnauthorizedException,
   UndefinedException: () => UndefinedException,
+  UnsupportedMediaTypeException: () => UnsupportedMediaTypeException,
   ValidateException: () => ValidateException,
-  WrongMetaException: () => WrongMetaException,
   addGuard: () => addGuard,
   addInterceptor: () => addInterceptor,
   addMiddleware: () => addMiddleware,
@@ -136,6 +146,8 @@ var defaultPipe = {
         args[i].arg = ret.data;
       } else {
         args[i].arg = reflect[i](arg);
+        if (reflect[i] === Number && Object.is(args[i].arg, NaN))
+          throw new ValidateException(`parameter ${Number(i) + 1} should be a number`);
       }
     }
     return args.map((item) => item.arg);
@@ -166,14 +178,6 @@ var BadRequestException = class extends HttpException {
 };
 __name(BadRequestException, "BadRequestException");
 
-// src/exception/wrong-meta.ts
-var WrongMetaException = class extends HttpException {
-  constructor(message) {
-    super(message, 500, "Meta is not correct");
-  }
-};
-__name(WrongMetaException, "WrongMetaException");
-
 // src/exception/not-found.ts
 var NotFoundException = class extends HttpException {
   constructor(message) {
@@ -182,6 +186,78 @@ var NotFoundException = class extends HttpException {
 };
 __name(NotFoundException, "NotFoundException");
 
+// src/exception/conflict.ts
+var ConflictException = class extends HttpException {
+  constructor(message) {
+    super(message, 409, "Conflict");
+  }
+};
+__name(ConflictException, "ConflictException");
+
+// src/exception/bad-gateway.ts
+var BadGatewayException = class extends HttpException {
+  constructor(message) {
+    super(message, 400, "Bad Gatrway");
+  }
+};
+__name(BadGatewayException, "BadGatewayException");
+
+// src/exception/invalid-input.ts
+var InvalidInputException = class extends HttpException {
+  constructor(message) {
+    super(message, 502, "Invalid Input");
+  }
+};
+__name(InvalidInputException, "InvalidInputException");
+
+// src/exception/media-type.ts
+var UnsupportedMediaTypeException = class extends HttpException {
+  constructor(message) {
+    super(message, 415, "Unsupported Media Type");
+  }
+};
+__name(UnsupportedMediaTypeException, "UnsupportedMediaTypeException");
+
+// src/exception/payload-large.ts
+var PayloadLargeException = class extends HttpException {
+  constructor(message) {
+    super(message, 413, "Payload Too Large");
+  }
+};
+__name(PayloadLargeException, "PayloadLargeException");
+
+// src/exception/timeout.ts
+var TimeoutException = class extends HttpException {
+  constructor(message) {
+    super(message, 408, "Request Timeout");
+  }
+};
+__name(TimeoutException, "TimeoutException");
+
+// src/exception/unauthorized.ts
+var UnauthorizedException = class extends HttpException {
+  constructor(message) {
+    super(message, 401, "Unauthorized");
+  }
+};
+__name(UnauthorizedException, "UnauthorizedException");
+
+// src/exception/unavailable-service.ts
+var ServiceUnavailableException = class extends HttpException {
+  constructor(message) {
+    super(message, 503, "Service Unavailable");
+  }
+};
+__name(ServiceUnavailableException, "ServiceUnavailableException");
+
+// src/exception/framework.ts
+var FrameworkException = class extends HttpException {
+  constructor(message) {
+    super(`[phecda-server] ${message}`, 500, "Framework Error");
+  }
+};
+__name(FrameworkException, "FrameworkException");
+
 // src/filter.ts
 var serverFilter = /* @__PURE__ */ __name((e) => {
   if (!(e instanceof HttpException))
@@ -230,7 +306,7 @@ var _Pcontext = class {
     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}`);
+          throw new FrameworkException(`can't find guard named ${guard}`);
         if (!await _Pcontext.guardsRecord[guard](this.data, isMerge))
           throw new ForbiddenException(`Guard exception--${guard}`);
       }
@@ -241,7 +317,7 @@ var _Pcontext = class {
     for (const interceptor of interceptors) {
       if (this.history.record(interceptor, "interceptor")) {
         if (!(interceptor in _Pcontext.interceptorsRecord))
-          throw new WrongMetaException(`can't find guard named ${interceptor}`);
+          throw new FrameworkException(`can't find guard named ${interceptor}`);
         const post = await _Pcontext.interceptorsRecord[interceptor](this.data, isMerge);
         if (post)
           ret.push(post);
@@ -300,13 +376,16 @@ 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}`);
+        throw new FrameworkException(`can't find middleware named ${m}`);
       return _ServerContext.middlewareRecord[m];
     });
   }
   async usePipe(args, reflect) {
     return _ServerContext.pipe.transform?.(args, reflect);
   }
+  static useFilter(arg, data) {
+    return _ServerContext.filter(arg, data);
+  }
   useFilter(arg) {
     return _ServerContext.filter(arg, this.data);
   }
@@ -334,13 +413,16 @@ 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}`);
+        throw new FrameworkException(`can't find middleware named ${m}`);
       return _RabbitMqContext.middlewareRecord[m];
     });
   }
   async usePipe(args, reflect) {
     return _RabbitMqContext.pipe.transform?.(args, reflect);
   }
+  static useFilter(arg, data) {
+    return _RabbitMqContext.filter(arg, data);
+  }
   useFilter(arg) {
     return _RabbitMqContext.filter(arg, this.data);
   }
@@ -359,6 +441,12 @@ function useMqFilter(filter) {
 }
 __name(useMqFilter, "useMqFilter");
 
+// src/types.ts
+var Base = class {
+  context;
+};
+__name(Base, "Base");
+
 // src/compiler.ts
 var Pcompiler = class {
   content = "";
@@ -375,28 +463,17 @@ var Pcompiler = class {
     }
     return content;
   }
-  addMethod(className, methodName, route = "", requestType = "", params = []) {
+  addMethod(args) {
+    const { route: { route = "/", type = "get" } = {}, name, method, params, tag } = args;
     const url = route.replace(/\/\:([^\/]*)/g, "");
-    if (!this.classMap[className])
-      this.classMap[className] = {};
-    this.classMap[className][methodName] = `
-    ${methodName}(${genParams(params)}){
-const ret={tag:"${className}-${methodName}",body:{},query:{},params:{},realParam:'',method:"${requestType}",url:"${url}"}
+    if (!this.classMap[name])
+      this.classMap[name] = {};
+    this.classMap[name][method] = `
+    ${method}(${genParams(params)}){
+const ret={tag:"${tag}-${method}",body:{},query:{},params:{},realParam:'',method:"${type}",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
     }
     `;
@@ -404,10 +481,9 @@ return ret
 };
 __name(Pcompiler, "Pcompiler");
 function genParams(decorators) {
-  let index = 0;
-  return decorators.reduce((p) => {
-    return `${`${p}arg${index++}`},`;
-  }, "");
+  return decorators.map((_, i) => {
+    return `${`arg${i}`}`;
+  }).join(",");
 }
 __name(genParams, "genParams");
 
@@ -424,7 +500,7 @@ __name(resolveDep, "resolveDep");
 
 // src/common.ts
 var SERIES_SYMBOL = "__symbol_series__";
-var REQ_SYMBOL = "__symbol_req__";
+var MERGE_SYMBOL = "__symbol_req__";
 
 // src/server/express.ts
 function bindApp(app, { meta, moduleMap }, options = {}) {
@@ -436,12 +512,14 @@ function bindApp(app, { meta, moduleMap }, options = {}) {
     ...options
   };
   const methodMap = {};
+  const contextMeta = {};
   for (const i of meta) {
-    const { name, method, route: route2, header } = i.data;
-    const instance = moduleMap.get(name);
-    const tag = `${name}-${method}`;
-    Pcontext.metaRecord[tag] = i;
-    let { guards, reflect, interceptors, params, middlewares } = Pcontext.metaDataRecord[tag] ? Pcontext.metaDataRecord[tag] : Pcontext.metaDataRecord[tag] = parseMeta(i);
+    const { name, method, route: route2, header, tag } = i.data;
+    const instance = moduleMap.get(tag);
+    const methodTag = `${tag}-${method}`;
+    contextMeta[methodTag] = i;
+    Pcontext.metaRecord[methodTag] = i;
+    let { guards, reflect, interceptors, params, middlewares } = Pcontext.metaDataRecord[methodTag] ? Pcontext.metaDataRecord[methodTag] : Pcontext.metaDataRecord[methodTag] = parseMeta(i);
     guards = [
       ...globalGuards,
       ...guards
@@ -451,16 +529,16 @@ function bindApp(app, { meta, moduleMap }, options = {}) {
       ...interceptors
     ];
     const handler = instance[method].bind(instance);
-    methodMap[tag] = handler;
+    methodMap[methodTag] = handler;
     Pcontext.instanceRecord[name] = instance;
     if (route2) {
       app[route2.type](route2.route, ...ServerContext.useMiddleware(middlewares), async (req, res) => {
         const contextData = {
           request: req,
-          tag,
+          meta: i,
           response: res
         };
-        const context = new ServerContext(tag, contextData);
+        const context = new ServerContext(methodTag, contextData);
         try {
           for (const name2 in header)
             res.set(name2, header[name2]);
@@ -472,7 +550,7 @@ function bindApp(app, { meta, moduleMap }, options = {}) {
               validate
             };
           }), reflect);
-          instance.meta = contextData;
+          instance.context = contextData;
           const ret = await context.usePost(await handler(...args));
           if (isObject(ret))
             res.json(ret);
@@ -487,16 +565,20 @@ function bindApp(app, { meta, moduleMap }, options = {}) {
     }
   }
   app.post(route, (req, _res, next) => {
-    req[REQ_SYMBOL] = true;
+    req[MERGE_SYMBOL] = true;
     next();
   }, ...ServerContext.useMiddleware(proMiddle), async (req, res) => {
+    const { body: { category, data } } = req;
     const contextData = {
       request: req,
-      response: res
+      response: res,
+      meta: contextMeta
     };
+    if (!Array.isArray(data))
+      return res.json(await ServerContext.useFilter(new BadRequestException("data format should be an array"), contextData));
+    contextData.tags = data.map((item) => item.tag);
     const context = new ServerContext(route, contextData);
     const ret = [];
-    const { body: { category, data } } = req;
     if (category === "series") {
       for (const item of data) {
         const { tag } = item;
@@ -505,7 +587,7 @@ function bindApp(app, { meta, moduleMap }, options = {}) {
         const instance = moduleMap.get(name);
         try {
           if (!params)
-            throw new NotFoundException(`"${tag}" doesn't exist`);
+            throw new BadRequestException(`"${tag}" doesn't exist`);
           await context.useGuard(guards, true);
           await context.useInterceptor(interceptors, true);
           const args = await context.usePipe(params.map(({ type, key, validate }) => {
@@ -522,7 +604,7 @@ function bindApp(app, { meta, moduleMap }, options = {}) {
               validate
             };
           }), reflect);
-          instance.meta = contextData;
+          instance.context = contextData;
           ret.push(await context.usePost(await methodMap[tag](...args)));
         } catch (e) {
           const m = Pcontext.metaRecord[tag];
@@ -541,7 +623,7 @@ function bindApp(app, { meta, moduleMap }, options = {}) {
           const instance = moduleMap.get(name);
           try {
             if (!params)
-              throw new NotFoundException(`"${tag}" doesn't exist`);
+              throw new BadRequestException(`"${tag}" doesn't exist`);
             await context.useGuard(guards, true);
             await context.useInterceptor(interceptors, true);
             const args = await context.usePipe(params.map(({ type, key, validate }) => {
@@ -551,7 +633,7 @@ function bindApp(app, { meta, moduleMap }, options = {}) {
                 validate
               };
             }), reflect);
-            instance.meta = contextData;
+            instance.context = contextData;
             resolve(await context.usePost(await methodMap[tag](...args)));
           } catch (e) {
             const m = Pcontext.metaRecord[tag];
@@ -563,7 +645,7 @@ function bindApp(app, { meta, moduleMap }, options = {}) {
         res.json(ret2);
       });
     }
-    res.json(await context.useFilter(new NotFoundException("category should be 'parallel' or 'series'")));
+    res.json(await context.useFilter(new BadRequestException("category should be 'parallel' or 'series'")));
   });
 }
 __name(bindApp, "bindApp");
@@ -604,35 +686,36 @@ async function Factory(Modules) {
   return {
     moduleMap,
     meta,
-    output: (p) => import_fs.default.writeFileSync(p, JSON.stringify(meta.map((item) => item.data)))
+    output: (p = "pmeta.js") => import_fs.default.writeFileSync(p, JSON.stringify(meta.map((item) => item.data)))
   };
 }
 __name(Factory, "Factory");
 async function buildNestModule(Module, map, meta) {
   const paramtypes = getParamtypes(Module);
   let instance;
-  const name = Module.prototype._namespace?.__TAG__ || Module.name;
-  if (map.has(name)) {
-    instance = map.get(name);
+  const tag = Module.prototype?.__TAG__ || Module.name;
+  if (map.has(tag)) {
+    instance = map.get(tag);
     if (!instance)
       throw new Error(`exist Circular Module dep--${Module}`);
     return instance;
   }
-  map.set(name, void 0);
+  map.set(tag, void 0);
   if (paramtypes) {
+    const paramtypesInstances = [];
     for (const i in paramtypes)
-      paramtypes[i] = await buildNestModule(paramtypes[i], map, meta);
-    instance = new Module(...paramtypes);
+      paramtypesInstances[i] = await buildNestModule(paramtypes[i], map, meta);
+    instance = new Module(...paramtypesInstances);
   } else {
     instance = new Module();
   }
-  meta.push(...getMetaFromInstance(instance, Module.name));
+  meta.push(...getMetaFromInstance(instance, Module.name, tag));
   await (0, import_phecda_core2.registerAsync)(instance);
-  map.set(name, instance);
+  map.set(tag, instance);
   return instance;
 }
 __name(buildNestModule, "buildNestModule");
-function getMetaFromInstance(instance, name) {
+function getMetaFromInstance(instance, name, tag) {
   const vars = (0, import_phecda_core2.getExposeKey)(instance).filter((item) => item !== "__CLASS");
   const baseState = (0, import_phecda_core2.getState)(instance, "__CLASS") || {};
   initState(baseState);
@@ -641,6 +724,7 @@ function getMetaFromInstance(instance, name) {
     if (baseState.route && state.route)
       state.route.route = baseState.route.route + state.route.route;
     state.name = name;
+    state.tag = tag;
     state.method = i;
     const params = [];
     for (const i2 of state.params || []) {
@@ -860,6 +944,17 @@ function Header(name, value) {
   };
 }
 __name(Header, "Header");
+function Meta(key, value) {
+  return (target, k) => {
+    (0, import_phecda_core6.setModalVar)(target, k);
+    (0, import_phecda_core6.mergeState)(target, k, {
+      meta: {
+        [key]: value
+      }
+    });
+  };
+}
+__name(Meta, "Meta");
 
 // src/index.ts
 __reExport(src_exports, require("phecda-core"), module.exports);
@@ -1018,23 +1113,30 @@ __name(createMqReq, "createMqReq");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   $S,
+  BadGatewayException,
   BadRequestException,
+  Base,
   BaseParam,
   Body,
+  ConflictException,
   Controller,
   Delete,
   Factory,
   ForbiddenException,
+  FrameworkException,
   Get,
   Guard,
   Header,
   HttpException,
   Inject,
   Interceptor,
+  InvalidInputException,
   MQ,
+  Meta,
   Middle,
   NotFoundException,
   Param,
+  PayloadLargeException,
   Pcompiler,
   Pcontext,
   Pmeta,
@@ -1044,9 +1146,12 @@ __name(createMqReq, "createMqReq");
   RabbitMqContext,
   Route,
   ServerContext,
+  ServiceUnavailableException,
+  TimeoutException,
+  UnauthorizedException,
   UndefinedException,
+  UnsupportedMediaTypeException,
   ValidateException,
-  WrongMetaException,
   addGuard,
   addInterceptor,
   addMiddleware,