phecda-server 1.3.0 → 1.4.1

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,
@@ -168,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) {
@@ -184,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))
@@ -232,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}`);
       }
@@ -243,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);
@@ -302,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);
   }
@@ -336,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);
   }
@@ -361,10 +441,16 @@ function useMqFilter(filter) {
 }
 __name(useMqFilter, "useMqFilter");
 
+// src/types.ts
+var Base = class {
+  context;
+};
+__name(Base, "Base");
+
 // src/compiler.ts
 var Pcompiler = class {
-  content = "";
   classMap = {};
+  name;
   constructor() {
   }
   getContent() {
@@ -377,9 +463,17 @@ var Pcompiler = class {
     }
     return content;
   }
+  createRequest() {
+    let content = "import {useC} from 'phecda-server'\n";
+    for (const name in this.classMap)
+      content += `export const {${Object.keys(this.classMap[name]).join(",")}}=useC(${name})
+`;
+    return content;
+  }
   addMethod(args) {
     const { route: { route = "/", type = "get" } = {}, name, method, params, tag } = args;
     const url = route.replace(/\/\:([^\/]*)/g, "");
+    this.name = name;
     if (!this.classMap[name])
       this.classMap[name] = {};
     this.classMap[name][method] = `
@@ -414,7 +508,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 = {}) {
@@ -426,10 +520,12 @@ function bindApp(app, { meta, moduleMap }, options = {}) {
     ...options
   };
   const methodMap = {};
+  const contextMeta = {};
   for (const i of meta) {
     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 = [
@@ -447,7 +543,7 @@ function bindApp(app, { meta, moduleMap }, options = {}) {
       app[route2.type](route2.route, ...ServerContext.useMiddleware(middlewares), async (req, res) => {
         const contextData = {
           request: req,
-          methodTag,
+          meta: i,
           response: res
         };
         const context = new ServerContext(methodTag, contextData);
@@ -462,7 +558,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);
@@ -477,16 +573,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;
@@ -495,7 +595,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 }) => {
@@ -512,7 +612,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];
@@ -531,7 +631,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 }) => {
@@ -541,7 +641,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];
@@ -553,7 +653,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");
@@ -852,6 +952,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);
@@ -1010,23 +1121,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,
@@ -1036,9 +1154,12 @@ __name(createMqReq, "createMqReq");
   RabbitMqContext,
   Route,
   ServerContext,
+  ServiceUnavailableException,
+  TimeoutException,
+  UnauthorizedException,
   UndefinedException,
+  UnsupportedMediaTypeException,
   ValidateException,
-  WrongMetaException,
   addGuard,
   addInterceptor,
   addMiddleware,