phecda-server 1.0.0

package/dist/index.js

@@ -0,0 +1,566 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  BadRequestException: () => BadRequestException,
+  BaseParam: () => BaseParam,
+  Body: () => Body,
+  Controller: () => Controller,
+  Delete: () => Delete,
+  Factory: () => Factory,
+  ForbiddenException: () => ForbiddenException,
+  Get: () => Get,
+  Header: () => Header,
+  HttpException: () => HttpException,
+  Inject: () => Inject,
+  Param: () => Param,
+  Pcompiler: () => Pcompiler,
+  Pmeta: () => Pmeta,
+  Post: () => Post,
+  Pserver: () => Pserver,
+  Put: () => Put,
+  Query: () => Query,
+  Route: () => Route,
+  Server: () => Server,
+  UndefinedException: () => UndefinedException,
+  ValidateException: () => ValidateException,
+  addGuard: () => addGuard,
+  addInterceptor: () => addInterceptor,
+  bindApp: () => bindApp,
+  defaultPipe: () => defaultPipe,
+  usePipe: () => usePipe
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/exception/base.ts
+var HttpException = class extends Error {
+  message;
+  status;
+  description;
+  constructor(message, status, description = "Http exception") {
+    super(message);
+    this.message = message;
+    this.status = status;
+    this.description = description;
+  }
+  get data() {
+    return {
+      message: this.message,
+      description: this.description,
+      status: this.status,
+      error: true
+    };
+  }
+};
+__name(HttpException, "HttpException");
+
+// src/exception/undefine.ts
+var UndefinedException = class extends HttpException {
+  constructor(message) {
+    super(message, 500, "Undefined error");
+  }
+};
+__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) {
+    super(message, 403, "Forbidden resource");
+  }
+};
+__name(ForbiddenException, "ForbiddenException");
+
+// src/exception/bad-request.ts
+var BadRequestException = class extends HttpException {
+  constructor(message) {
+    super(message, 400, "Bad Request");
+  }
+};
+__name(BadRequestException, "BadRequestException");
+
+// src/pipe.ts
+var import_phecda_core = require("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 ((0, import_phecda_core.isPhecda)(reflect[i])) {
+          const ret = await (0, import_phecda_core.plainToClass)(reflect[i], arg, {
+            transform: false
+          });
+          if (ret.err.length > 0)
+            throw new ValidateException(ret.err[0]);
+        }
+      }
+    }
+    return args.map((item) => item.arg);
+  }
+};
+
+// src/server.ts
+var _Pserver = class {
+  key;
+  meta;
+  method;
+  params;
+  constructor(key, meta) {
+    this.key = key;
+    this.meta = meta;
+    _Pserver.serverRecord[key] = this;
+  }
+  static registerGuard(key, handler) {
+    _Pserver.guardsRecord[key] = handler;
+  }
+  static registerInterceptor(key, handler) {
+    _Pserver.interceptorsRecord[key] = handler;
+  }
+  async useGuard(req, guards) {
+    for (const guard of guards) {
+      if (!await _Pserver.guardsRecord[guard]?.(req))
+        throw new ForbiddenException(`Guard exception--${guard}`);
+    }
+  }
+  async useInterceptor(req, interceptors) {
+    const ret = [];
+    for (const interceptor of interceptors) {
+      const post = await _Pserver.interceptorsRecord[interceptor]?.(req);
+      if (post)
+        ret.push(post);
+    }
+    return ret;
+  }
+  async usePost(ret, cbs) {
+    for (const cb of cbs)
+      ret = await cb(ret) | ret;
+    return ret;
+  }
+  async usePipe(args, reflect) {
+    return _Pserver.pipe.transform(args, reflect);
+  }
+  methodToHandler(method) {
+    const { data: { params, guards, interceptors }, reflect } = this.meta;
+    return async (req) => {
+      try {
+        await this.useGuard(req, guards);
+        const posts = await this.useInterceptor(req, interceptors);
+        const args = params.map((param) => {
+          const { type, key, validate } = param;
+          return {
+            arg: req[type]?.[key],
+            validate
+          };
+        });
+        const ret = await method(...await this.usePipe(args, reflect));
+        return this.usePost(ret, posts);
+      } catch (e) {
+        console.log(e);
+        if (!(e instanceof HttpException))
+          return new UndefinedException(e.message || e);
+        return e;
+      }
+    };
+  }
+};
+var Pserver = _Pserver;
+__name(Pserver, "Pserver");
+__publicField(Pserver, "pipe", defaultPipe);
+__publicField(Pserver, "guardsRecord", {});
+__publicField(Pserver, "middlewareRecord", {});
+__publicField(Pserver, "interceptorsRecord", {});
+__publicField(Pserver, "serverRecord", {});
+function addGuard(key, handler) {
+  Pserver.registerGuard(key, handler);
+}
+__name(addGuard, "addGuard");
+function addInterceptor(key, handler) {
+  Pserver.registerInterceptor(key, handler);
+}
+__name(addInterceptor, "addInterceptor");
+function usePipe(pipe) {
+  Pserver.pipe = pipe;
+}
+__name(usePipe, "usePipe");
+
+// src/compiler.ts
+var Pcompiler = class {
+  content = "";
+  classMap = {};
+  constructor() {
+  }
+  getContent() {
+    let content = "";
+    for (const name in this.classMap) {
+      content += `
+        export class ${name}{
+            ${Object.values(this.classMap[name]).reduce((p, c) => p + c)}
+            }`;
+    }
+    return content;
+  }
+  addMethod(className, methodName, route = "", requestType = "", params = []) {
+    const url = route.replace(/\/\:([^\/]*)/g, "");
+    if (!this.classMap[className])
+      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}
+${c.type === "params" ? `ret.realParam+='/'+arg${i}
+` : ""}`, "")}
+return ret
+    }
+    `;
+  }
+};
+__name(Pcompiler, "Pcompiler");
+function genParams(decorators) {
+  let index = 0;
+  return decorators.reduce((p) => {
+    return `${`${p}arg${index++}`},`;
+  }, "");
+}
+__name(genParams, "genParams");
+
+// src/utils.ts
+var isUndefined = /* @__PURE__ */ __name((obj) => typeof obj === "undefined", "isUndefined");
+var isNil = /* @__PURE__ */ __name((obj) => isUndefined(obj) || obj === null, "isNil");
+var isObject = /* @__PURE__ */ __name((fn) => !isNil(fn) && typeof fn === "object", "isObject");
+
+// src/express.ts
+function bindApp(app, { meta, moduleMap }, key = "/__PHECDA_SERVER__") {
+  const methodMap = {};
+  for (const i of meta) {
+    const { name, method, route, header } = i.data;
+    const server = new Pserver(`${name}`, i);
+    const instance = moduleMap.get(name);
+    const handler = server.methodToHandler(instance[method].bind(instance));
+    methodMap[`${name}-${method}`] = handler;
+    if (route) {
+      app[route.type](route.route, async (req, res) => {
+        instance.request = req;
+        instance.meta = req.body;
+        const ret = await handler(req);
+        for (const name2 in header)
+          res.set(name2, header[name2]);
+        if (ret instanceof HttpException) {
+          res.status(ret.status).json(ret.data);
+          return;
+        }
+        if (isObject(ret))
+          res.json(ret);
+        else
+          res.send(String(ret));
+      });
+    }
+  }
+  app.post(key, async (req, res) => {
+    const { body } = req;
+    const ret = [];
+    for (const i in body) {
+      const res2 = await methodMap[i](body[i]);
+      ret.push(ret instanceof HttpException ? res2.data : res2);
+    }
+    res.json(ret);
+  });
+}
+__name(bindApp, "bindApp");
+
+// src/core.ts
+var import_reflect_metadata = require("reflect-metadata");
+var import_phecda_core2 = require("phecda-core");
+
+// src/meta.ts
+var Pmeta = class {
+  data;
+  reflect;
+  constructor(data, reflect) {
+    this.data = data;
+    this.reflect = reflect;
+  }
+};
+__name(Pmeta, "Pmeta");
+
+// src/core.ts
+function Factory(Modules) {
+  const moduleMap = /* @__PURE__ */ new Map();
+  const meta = [];
+  Modules.forEach((Module) => buildNestModule(Module, moduleMap, meta));
+  return {
+    moduleMap,
+    meta
+  };
+}
+__name(Factory, "Factory");
+function buildNestModule(Module, map, meta) {
+  const paramtypes = getParamtypes(Module);
+  let instance;
+  const name = Module.name;
+  if (map.has(name)) {
+    instance = map.get(name);
+    if (!instance)
+      throw new Error(`exist Circular Module dep--${Module}`);
+    return instance;
+  }
+  map.set(name, void 0);
+  if (paramtypes) {
+    instance = new Module(...paramtypes.map((item) => buildNestModule(item, map, meta)));
+  } else {
+    instance = new Module();
+  }
+  meta.push(...getMetaFromInstance(instance, name));
+  map.set(name, instance);
+  return instance;
+}
+__name(buildNestModule, "buildNestModule");
+function getMetaFromInstance(instance, name) {
+  const vars = (0, import_phecda_core2.getModelState)(instance).filter((item) => item !== "__CLASS");
+  const baseState = (0, import_phecda_core2.getState)(instance, "__CLASS") || {};
+  initState(baseState);
+  return vars.map((i) => {
+    const state = (0, import_phecda_core2.getState)(instance, i);
+    if (baseState.route && state.route)
+      state.route.route = baseState.route.route + state.route.route;
+    state.name = name;
+    state.method = i;
+    const params = [];
+    for (const i2 of state.params || []) {
+      params.unshift(i2);
+      if (i2.index === 0)
+        break;
+    }
+    state.params = params;
+    initState(state);
+    state.header = Object.assign({}, baseState.header, state.header);
+    state.middlewares = [
+      .../* @__PURE__ */ new Set([
+        ...baseState.middlewares,
+        ...state.middlewares
+      ])
+    ];
+    state.guards = [
+      .../* @__PURE__ */ new Set([
+        ...baseState.guards,
+        ...state.guards
+      ])
+    ];
+    state.interceptors = [
+      .../* @__PURE__ */ new Set([
+        ...baseState.interceptors,
+        ...state.interceptors
+      ])
+    ];
+    return new Pmeta(state, getParamtypes(instance, i) || []);
+  });
+}
+__name(getMetaFromInstance, "getMetaFromInstance");
+function getParamtypes(Module, key) {
+  return Reflect.getMetadata("design:paramtypes", Module, key);
+}
+__name(getParamtypes, "getParamtypes");
+function initState(state) {
+  if (!state.header)
+    state.header = {};
+  if (!state.middlewares)
+    state.middlewares = [];
+  if (!state.guards)
+    state.guards = [];
+  if (!state.interceptors)
+    state.interceptors = [];
+}
+__name(initState, "initState");
+
+// src/decorators/index.ts
+var import_phecda_core5 = require("phecda-core");
+
+// src/decorators/param.ts
+var import_phecda_core3 = require("phecda-core");
+function BaseParam(type, key, validate) {
+  return (target, k, index) => {
+    (0, import_phecda_core3.setModalVar)(target, k);
+    (0, import_phecda_core3.mergeState)(target, k, {
+      params: [
+        {
+          type,
+          key,
+          index,
+          validate
+        }
+      ]
+    });
+  };
+}
+__name(BaseParam, "BaseParam");
+function Body(key, validate) {
+  return BaseParam("body", key, validate);
+}
+__name(Body, "Body");
+function Query(key, validate) {
+  return BaseParam("query", key, validate);
+}
+__name(Query, "Query");
+function Param(key, validate) {
+  return BaseParam("params", key, validate);
+}
+__name(Param, "Param");
+
+// src/decorators/route.ts
+var import_phecda_core4 = require("phecda-core");
+function Route(route, type) {
+  return (target, key) => {
+    if (key) {
+      (0, import_phecda_core4.setModalVar)(target, key);
+      (0, import_phecda_core4.mergeState)(target, key, {
+        route: {
+          route,
+          type
+        }
+      });
+    } else {
+      (0, import_phecda_core4.setModalVar)(target.prototype, "__CLASS");
+      (0, import_phecda_core4.mergeState)(target.prototype, "__CLASS", {
+        route: {
+          route,
+          type
+        }
+      });
+    }
+  };
+}
+__name(Route, "Route");
+function Get(route) {
+  return Route(route, "get");
+}
+__name(Get, "Get");
+function Post(route) {
+  return Route(route, "post");
+}
+__name(Post, "Post");
+function Put(route) {
+  return Route(route, "put");
+}
+__name(Put, "Put");
+function Delete(route) {
+  return Route(route, "delete");
+}
+__name(Delete, "Delete");
+function Controller(route) {
+  return Route(route);
+}
+__name(Controller, "Controller");
+
+// src/decorators/index.ts
+function Inject() {
+}
+__name(Inject, "Inject");
+function Header(name, value) {
+  return (target, k) => {
+    (0, import_phecda_core5.setModalVar)(target, k);
+    (0, import_phecda_core5.mergeState)(target, k, {
+      header: {
+        name,
+        value
+      }
+    });
+  };
+}
+__name(Header, "Header");
+
+// src/vite/index.ts
+var import_path = require("path");
+var import_vite = require("vite");
+function Server(localPath) {
+  let root;
+  let metaPath;
+  return {
+    name: "phecda-server-vite:client",
+    enforce: "pre",
+    configResolved(config) {
+      root = config.root || process.cwd();
+      metaPath = (0, import_vite.normalizePath)((0, import_path.resolve)(root, localPath));
+    },
+    resolveId(id) {
+      if (id.endsWith(".controller"))
+        return metaPath;
+    },
+    transform(code, id) {
+      if (id === metaPath) {
+        const meta = JSON.parse(code);
+        const compiler = new Pcompiler();
+        for (const i of meta)
+          compiler.addMethod(i.name, i.method, i.route?.route, i.route?.type, i.params);
+        return {
+          code: compiler.getContent()
+        };
+      }
+    }
+  };
+}
+__name(Server, "Server");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BadRequestException,
+  BaseParam,
+  Body,
+  Controller,
+  Delete,
+  Factory,
+  ForbiddenException,
+  Get,
+  Header,
+  HttpException,
+  Inject,
+  Param,
+  Pcompiler,
+  Pmeta,
+  Post,
+  Pserver,
+  Put,
+  Query,
+  Route,
+  Server,
+  UndefinedException,
+  ValidateException,
+  addGuard,
+  addInterceptor,
+  bindApp,
+  defaultPipe,
+  usePipe
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/exception/base.ts","../src/exception/undefine.ts","../src/exception/validate.ts","../src/exception/forbidden.ts","../src/exception/bad-request.ts","../src/pipe.ts","../src/server.ts","../src/compiler.ts","../src/utils.ts","../src/express.ts","../src/core.ts","../src/meta.ts","../src/decorators/index.ts","../src/decorators/param.ts","../src/decorators/route.ts","../src/vite/index.ts"],"sourcesContent":["export * from './server'\nexport * from './types'\nexport * from './compiler'\nexport * from './express'\nexport * from './core'\nexport * from './decorators'\nexport * from './vite'\nexport * from './exception'\nexport * from './pipe'\nexport * from './meta'\n","export class HttpException extends Error {\n  constructor(public message: string, public status: number, public description = 'Http exception') {\n    super(message)\n  }\n\n  get data() {\n    return { message: this.message, description: this.description, status: this.status, error: true }\n  }\n}\n","import { HttpException } from './base'\n\nexport class UndefinedException extends HttpException {\n  constructor(message: string) {\n    super(message, 500, 'Undefined error')\n  }\n}\n","import { HttpException } from './base'\n\nexport class ValidateException extends HttpException {\n  constructor(message: string) {\n    super(message, 400, 'Validate exception')\n  }\n}\n","import { HttpException } from './base'\n\nexport class ForbiddenException extends HttpException {\n  constructor(message: string) {\n    super(message, 403, 'Forbidden resource')\n  }\n}\n","import { HttpException } from './base'\n\nexport class BadRequestException extends HttpException {\n  constructor(message: string) {\n    super(message, 400, 'Bad Request')\n  }\n}\n","import { isPhecda, plainToClass } from 'phecda-core'\nimport { ValidateException } from './exception/validate'\n\nexport interface Ppipe {\n  transform(args: { arg: any; validate?: boolean }[], reflect: any[]): Promise<any[]>\n}\n\nexport const defaultPipe = {\n  async transform(args: { arg: any; validate: boolean }[], reflect: any[]) {\n    for (const i in args) {\n      const { validate, arg } = args[i]\n      if (validate === false)\n        continue\n      if (validate && !(arg?.constructor === reflect[i])) {\n        throw new ValidateException(`${arg} is not ${reflect[i].name}`)\n      }\n      else {\n        if (isPhecda(reflect[i])) {\n          const ret = await plainToClass(reflect[i], arg, { transform: false })\n          if (ret.err.length > 0)\n            throw new ValidateException(ret.err[0])\n        }\n      }\n    }\n    return args.map(item => item.arg)\n  },\n} as Ppipe\n","import { ForbiddenException } from './exception'\nimport { HttpException } from './exception/base'\nimport { UndefinedException } from './exception/undefine'\nimport type { Pmeta } from './meta'\nimport type { Ppipe } from './pipe'\nimport { defaultPipe } from './pipe'\n\nexport class Pserver {\n  method: string\n  params: string[]\n  static pipe: Ppipe = defaultPipe\n  static guardsRecord: Record<string, (...params: any) => boolean> = {}\n  static middlewareRecord: Record<string, (...params: any) => boolean> = {}\n  static interceptorsRecord: Record<string, (...params: any) => any | ((...params: any) => any)> = {}\n  static serverRecord: Record<string, Pserver> = {}\n\n  constructor(public key: string, public meta: Pmeta) {\n    Pserver.serverRecord[key] = this\n  }\n\n  static registerGuard(key: string, handler: any) {\n    Pserver.guardsRecord[key] = handler\n  }\n\n  static registerInterceptor(key: string, handler: any) {\n    Pserver.interceptorsRecord[key] = handler\n  }\n\n  async useGuard(req: any, guards: string[]) {\n    for (const guard of guards) {\n      if (!await Pserver.guardsRecord[guard]?.(req))\n        throw new ForbiddenException(`Guard exception--${guard}`)\n    }\n  }\n\n  async useInterceptor(req: any, interceptors: string[]) {\n    const ret = []\n    for (const interceptor of interceptors) {\n      const post = await Pserver.interceptorsRecord[interceptor]?.(req)\n      if (post)\n        ret.push(post)\n    }\n    return ret\n  }\n\n  async usePost(ret: any, cbs: ((...params: any[]) => any)[]) {\n    for (const cb of cbs)\n      ret = (await cb(ret)) | ret\n\n    return ret\n  }\n\n  async usePipe(args: { arg: any; validate?: boolean }[], reflect: any[]) {\n    return Pserver.pipe.transform(args, reflect)\n  }\n\n  methodToHandler(method: (...params: any[]) => any) {\n    const { data: { params, guards, interceptors }, reflect } = this.meta\n\n    return async (req: any) => {\n      try {\n        await this.useGuard(req, guards)\n        const posts = await this.useInterceptor(req, interceptors!)\n        const args = params.map((param) => {\n          const { type, key, validate } = param\n          return { arg: req[type]?.[key], validate }\n        })\n\n        const ret = await method(...await this.usePipe(args, reflect))\n        return this.usePost(ret, posts)\n      }\n      catch (e: any) {\n        console.log(e)\n        if (!(e instanceof HttpException))\n          return new UndefinedException(e.message || e)\n        return e\n      }\n    }\n  }\n}\n\nexport function addGuard(key: string, handler: (...params: any) => boolean) {\n  Pserver.registerGuard(key, handler)\n}\n\nexport function addInterceptor(key: string, handler: (...params: any) => any | ((...params: any) => any)) {\n  Pserver.registerInterceptor(key, handler)\n}\n\nexport function usePipe(pipe: Ppipe) {\n  Pserver.pipe = pipe\n}\n","import type { RequestType } from './types'\n\nexport class Pcompiler {\n  content = ''\n  classMap: Record<string, { [key: string]: string }> = {}\n  constructor() { }\n\n  getContent() {\n    let content = ''\n\n    for (const name in this.classMap) {\n      content += `\n        export class ${name}{\n            ${Object.values(this.classMap[name]).reduce((p, c) => p + c)}\n            }`\n    }\n    return content\n  }\n\n  addMethod(className: string, methodName: string, route = '', requestType: RequestType | '' = '', params: { type: string; key: string; index: number }[] = []) {\n    const url = route.replace(/\\/\\:([^\\/]*)/g, '')\n    if (!this.classMap[className])\n      this.classMap[className] = {}\n    this.classMap[className][methodName] = `\n    ${methodName}(${genParams(params)}){\nconst ret={name:\"${className}-${methodName}\",body:{},query:{},params:{},realParam:'',method:\"${requestType}\",url:\"${url}\"}\n${params.reduce((p, c, i) => `${p}ret.${c.type}.${c.key}=arg${i}\\n${c.type === 'params' ? `ret.realParam+='/'+arg${i}\\n` : ''}`, '')}\nreturn ret\n    }\n    `\n  }\n}\n\n// function genExpression(type: string, key: string, index: number) {\n//   switch (type) {\n//     case 'params':\n//       return `ret.params+='/'+arg${index}`\n//     case 'query':\n//       return `ret.query+=ret.query?\"&${key}=\"+arg${index}:\"?${key}=\"+arg${index}`\n//     case 'body':\n//       return `ret.body[${key}]=arg${index}`\n//   }\n// }\n\nfunction genParams(decorators: any[]) {\n  let index = 0\n  return decorators.reduce((p) => {\n    return `${`${p}arg${index++}`},`\n  }, '')\n}\n","export const isUndefined = (obj: any): obj is undefined =>\n  typeof obj === 'undefined'\nexport const isNil = (obj: any): obj is null | undefined =>\n  isUndefined(obj) || obj === null\n\nexport const isObject = (fn: any): fn is object =>\n  !isNil(fn) && typeof fn === 'object'\n\n/**\n * @experiment\n */\nexport class Wrap<F, T> {\n  constructor(public v1: F,\n    public V2: T) {\n\n  }\n\n  get value() {\n    return this.V2\n  }\n}\n","import type { Express } from 'express'\nimport { Pserver } from './server'\nimport { HttpException } from './exception/base'\nimport { isObject } from './utils'\nimport type { Pmeta } from './meta'\nexport function bindApp(app: Express, { meta, moduleMap }: { meta: Pmeta[]; moduleMap: any }, key = '/__PHECDA_SERVER__') {\n  const methodMap = {} as Record<string, (...args: any[]) => any>\n  for (const i of meta) {\n    const { name, method, route, header } = i.data\n    const server = new Pserver(`${name}`, i)\n    const instance = moduleMap.get(name)!\n    const handler = server.methodToHandler(instance[method].bind(instance))\n    methodMap[`${name}-${method}`] = handler\n    if (route) {\n      app[route.type](route.route, async (req, res) => {\n        instance.request = req\n        instance.meta = req.body\n\n        const ret = await handler(req)\n        for (const name in header)\n          res.set(name, header[name])\n\n        if (ret instanceof HttpException) {\n          res.status(ret.status).json(ret.data)\n\n          return\n        }\n        if (isObject(ret))\n          res.json(ret)\n        else\n          res.send(String(ret))\n      })\n    }\n  }\n  app.post(key, async (req, res) => {\n    const { body } = req\n    const ret = [] as any[]\n    for (const i in body) {\n      const res = await methodMap[i](body[i])\n      ret.push(ret instanceof HttpException ? res.data : res)\n    }\n\n    res.json(ret)\n  })\n}\n","import 'reflect-metadata'\nimport type { Phecda } from 'phecda-core'\nimport { getModelState, getState } from 'phecda-core'\n\nimport type { Construct, ServerMeta } from './types'\nimport { Pmeta } from './meta'\n\nexport function Factory<T>(Modules: Construct<T>[]) {\n  const moduleMap = new Map<string, InstanceType<Construct>>()\n  const meta: Pmeta[] = []\n  Modules.forEach(Module => buildNestModule(Module, moduleMap, meta) as InstanceType<Construct<T>>)\n  return { moduleMap, meta }\n}\n\nfunction buildNestModule(Module: Construct, map: Map<string, InstanceType<Construct>>, meta: Pmeta[]) {\n  const paramtypes = getParamtypes(Module) as Construct[]\n  let instance: InstanceType<Construct>\n  const name = Module.name\n  if (map.has(name)) {\n    instance = map.get(name)\n    if (!instance)\n      throw new Error(`exist Circular Module dep--${Module}`)\n    return instance\n  }\n  map.set(name, undefined)\n  if (paramtypes) {\n    instance = new Module(...paramtypes.map(item =>\n      buildNestModule(item, map, meta),\n    ))\n  }\n  else {\n    instance = new Module()\n  }\n  meta.push(...getMetaFromInstance(instance, name))\n  map.set(name, instance)\n\n  return instance\n}\n\nfunction getMetaFromInstance(instance: Phecda, name: string) {\n  const vars = getModelState(instance).filter(item => item !== '__CLASS')\n  const baseState = (getState(instance, '__CLASS') || {}) as ServerMeta\n  initState(baseState)\n  return vars.map((i) => {\n    const state = getState(instance, i) as ServerMeta\n    if (baseState.route && state.route)\n      state.route.route = baseState.route.route + state.route.route\n    state.name = name\n    state.method = i\n    const params = [] as any[]\n    for (const i of state.params || []) {\n      params.unshift(i)\n      if (i.index === 0)\n        break\n    }\n    state.params = params\n    initState(state)\n    state.header = Object.assign({}, baseState.header, state.header)\n    state.middlewares = [...new Set([...baseState.middlewares, ...state.middlewares])]\n    state.guards = [...new Set([...baseState.guards, ...state.guards])]\n    state.interceptors = [...new Set([...baseState.interceptors, ...state.interceptors])]\n\n    return new Pmeta(state as unknown as ServerMeta, getParamtypes(instance, i) || [])\n  })\n}\n\nfunction getParamtypes(Module: any, key?: string | symbol) {\n  return Reflect.getMetadata('design:paramtypes', Module, key!)\n}\n\nfunction initState(state: any) {\n  if (!state.header)\n    state.header = {}\n  if (!state.middlewares)\n    state.middlewares = []\n  if (!state.guards)\n    state.guards = []\n  if (!state.interceptors)\n    state.interceptors = []\n}\n","import type { ServerMeta } from './types'\n\nexport class Pmeta {\n  constructor(public data: ServerMeta, public reflect: any[]) {\n\n  }\n}\n","import { mergeState, setModalVar } from 'phecda-core'\n\nexport function Inject() { }\n\nexport function Header(name: string, value: string) {\n  return (target: any, k: PropertyKey) => {\n    setModalVar(target, k)\n    mergeState(target, k, {\n      header: { name, value },\n    })\n  }\n}\n\nexport * from './param'\nexport * from './route'\n","import { mergeState, setModalVar } from 'phecda-core'\n\nexport function BaseParam(type: string, key: string, validate?: boolean): any {\n  return (target: any, k: PropertyKey, index: number) => {\n    setModalVar(target, k)\n    mergeState(target, k, {\n      params: [{ type, key, index, validate }],\n    })\n  }\n}\n\nexport function Body(key: string, validate?: boolean) {\n  return BaseParam('body', key, validate)\n}\nexport function Query(key: string, validate?: boolean) {\n  return BaseParam('query', key, validate)\n}\nexport function Param(key: string, validate?: boolean) {\n  return BaseParam('params', key, validate)\n}\n","import { mergeState, setModalVar } from 'phecda-core'\n\nexport function Route(route: string, type?: string): any {\n  return (target: any, key?: PropertyKey) => {\n    if (key) {\n      setModalVar(target, key)\n      mergeState(target, key, {\n        route: {\n          route,\n          type,\n        },\n      })\n    }\n    else {\n      setModalVar(target.prototype, '__CLASS')\n      mergeState(target.prototype, '__CLASS', {\n        route: {\n          route,\n          type,\n        },\n      })\n    }\n  }\n}\n\nexport function Get(route: string) {\n  return Route(route, 'get')\n}\n\nexport function Post(route: string) {\n  return Route(route, 'post')\n}\nexport function Put(route: string) {\n  return Route(route, 'put')\n}\n\nexport function Delete(route: string) {\n  return Route(route, 'delete')\n}\n\nexport function Controller(route: string) {\n  return Route(route)\n}\n","import { resolve } from 'path'\nimport type { PluginOption } from 'vite'\nimport { normalizePath } from 'vite'\nimport { Pcompiler } from '../compiler'\nimport type { ServerMeta } from '../types'\nexport function Server(localPath: string): PluginOption {\n  let root: string\n  let metaPath: string\n  return {\n    name: 'phecda-server-vite:client',\n    enforce: 'pre',\n    configResolved(config) {\n      root = config.root || process.cwd()\n      metaPath = normalizePath(resolve(root, localPath))\n    },\n    resolveId(id) {\n      if (id.endsWith('.controller'))\n        return metaPath\n    },\n    transform(code, id) {\n      if (id === metaPath) {\n        const meta = JSON.parse(code) as ServerMeta[]\n        const compiler = new Pcompiler()\n\n        for (const i of meta)\n          compiler.addMethod(i.name, i.method, i.route?.route, i.route?.type, i.params)\n        return {\n          code: compiler.getContent(),\n        }\n      }\n    },\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACAO,IAAMA,gBAAN,cAA4BC,MAAAA;EACdC;EAAwBC;EAAuBC;EAAlEC,YAAmBH,SAAwBC,QAAuBC,cAAc,kBAAkB;AAChG,UAAMF,OAAAA;mBADWA;kBAAwBC;uBAAuBC;EAElE;EAEA,IAAIE,OAAO;AACT,WAAO;MAAEJ,SAAS,KAAKA;MAASE,aAAa,KAAKA;MAAaD,QAAQ,KAAKA;MAAQI,OAAO;IAAK;EAClG;AACF;AARaP;;;ACEN,IAAMQ,qBAAN,cAAiCC,cAAAA;EACtCC,YAAYC,SAAiB;AAC3B,UAAMA,SAAS,KAAK,iBAAA;EACtB;AACF;AAJaH;;;ACAN,IAAMI,oBAAN,cAAgCC,cAAAA;EACrCC,YAAYC,SAAiB;AAC3B,UAAMA,SAAS,KAAK,oBAAA;EACtB;AACF;AAJaH;;;ACAN,IAAMI,qBAAN,cAAiCC,cAAAA;EACtCC,YAAYC,SAAiB;AAC3B,UAAMA,SAAS,KAAK,oBAAA;EACtB;AACF;AAJaH;;;ACAN,IAAMI,sBAAN,cAAkCC,cAAAA;EACvCC,YAAYC,SAAiB;AAC3B,UAAMA,SAAS,KAAK,aAAA;EACtB;AACF;AAJaH;;;ACFb,yBAAuC;AAOhC,IAAMI,cAAc;EACzB,MAAMC,UAAUC,MAAyCC,SAAgB;AACvE,eAAWC,KAAKF,MAAM;AACpB,YAAM,EAAEG,UAAUC,IAAG,IAAKJ,KAAKE;AAC/B,UAAIC,aAAa;AACf;AACF,UAAIA,YAAY,EAAEC,KAAKC,gBAAgBJ,QAAQC,KAAK;AAClD,cAAM,IAAII,kBAAkB,GAAGF,cAAcH,QAAQC,GAAGK,MAAM;MAChE,OACK;AACH,gBAAIC,6BAASP,QAAQC,EAAE,GAAG;AACxB,gBAAMO,MAAM,UAAMC,iCAAaT,QAAQC,IAAIE,KAAK;YAAEL,WAAW;UAAM,CAAA;AACnE,cAAIU,IAAIE,IAAIC,SAAS;AACnB,kBAAM,IAAIN,kBAAkBG,IAAIE,IAAI,EAAE;QAC1C;MACF;IACF;AACA,WAAOX,KAAKa,IAAIC,CAAAA,SAAQA,KAAKV,GAAG;EAClC;AACF;;;ACnBO,IAAMW,WAAN,MAAMA;EASQC;EAAoBC;EARvCC;EACAC;EAOAC,YAAmBJ,KAAoBC,MAAa;eAAjCD;gBAAoBC;AACrCF,aAAQM,aAAaL,OAAO;EAC9B;EAEA,OAAOM,cAAcN,KAAaO,SAAc;AAC9CR,aAAQS,aAAaR,OAAOO;EAC9B;EAEA,OAAOE,oBAAoBT,KAAaO,SAAc;AACpDR,aAAQW,mBAAmBV,OAAOO;EACpC;EAEA,MAAMI,SAASC,KAAUC,QAAkB;AACzC,eAAWC,SAASD,QAAQ;AAC1B,UAAI,CAAC,MAAMd,SAAQS,aAAaM,SAASF,GAAAA;AACvC,cAAM,IAAIG,mBAAmB,oBAAoBD,OAAO;IAC5D;EACF;EAEA,MAAME,eAAeJ,KAAUK,cAAwB;AACrD,UAAMC,MAAM,CAAA;AACZ,eAAWC,eAAeF,cAAc;AACtC,YAAMG,OAAO,MAAMrB,SAAQW,mBAAmBS,eAAeP,GAAAA;AAC7D,UAAIQ;AACFF,YAAIG,KAAKD,IAAAA;IACb;AACA,WAAOF;EACT;EAEA,MAAMI,QAAQJ,KAAUK,KAAoC;AAC1D,eAAWC,MAAMD;AACfL,YAAO,MAAMM,GAAGN,GAAAA,IAAQA;AAE1B,WAAOA;EACT;EAEA,MAAMO,QAAQC,MAA0CC,SAAgB;AACtE,WAAO5B,SAAQ6B,KAAKC,UAAUH,MAAMC,OAAAA;EACtC;EAEAG,gBAAgB5B,QAAmC;AACjD,UAAM,EAAE6B,MAAM,EAAE5B,QAAQU,QAAQI,aAAY,GAAIU,QAAO,IAAK,KAAK1B;AAEjE,WAAO,OAAOW,QAAa;AACzB,UAAI;AACF,cAAM,KAAKD,SAASC,KAAKC,MAAAA;AACzB,cAAMmB,QAAQ,MAAM,KAAKhB,eAAeJ,KAAKK,YAAAA;AAC7C,cAAMS,OAAOvB,OAAO8B,IAAI,CAACC,UAAU;AACjC,gBAAM,EAAEC,MAAMnC,KAAKoC,SAAQ,IAAKF;AAChC,iBAAO;YAAEG,KAAKzB,IAAIuB,QAAQnC;YAAMoC;UAAS;QAC3C,CAAA;AAEA,cAAMlB,MAAM,MAAMhB,OAAAA,GAAU,MAAM,KAAKuB,QAAQC,MAAMC,OAAAA,CAAAA;AACrD,eAAO,KAAKL,QAAQJ,KAAKc,KAAAA;MAC3B,SACOM,GAAP;AACEC,gBAAQC,IAAIF,CAAAA;AACZ,YAAI,EAAEA,aAAaG;AACjB,iBAAO,IAAIC,mBAAmBJ,EAAEK,WAAWL,CAAAA;AAC7C,eAAOA;MACT;IACF;EACF;AACF;AAxEO,IAAMvC,UAAN;AAAMA;AAGX,cAHWA,SAGJ6B,QAAcgB;AACrB,cAJW7C,SAIJS,gBAA4D,CAAC;AACpE,cALWT,SAKJ8C,oBAAgE,CAAC;AACxE,cANW9C,SAMJW,sBAA0F,CAAC;AAClG,cAPWX,SAOJM,gBAAwC,CAAC;AAmE3C,SAASyC,SAAS9C,KAAaO,SAAsC;AAC1ER,UAAQO,cAAcN,KAAKO,OAAAA;AAC7B;AAFgBuC;AAIT,SAASC,eAAe/C,KAAaO,SAA8D;AACxGR,UAAQU,oBAAoBT,KAAKO,OAAAA;AACnC;AAFgBwC;AAIT,SAAStB,QAAQG,MAAa;AACnC7B,UAAQ6B,OAAOA;AACjB;AAFgBH;;;ACvFT,IAAMuB,YAAN,MAAMA;EACXC,UAAU;EACVC,WAAsD,CAAC;EACvDC,cAAc;EAAE;EAEhBC,aAAa;AACX,QAAIH,UAAU;AAEd,eAAWI,QAAQ,KAAKH,UAAU;AAChCD,iBAAW;uBACMI;cACTC,OAAOC,OAAO,KAAKL,SAASG,KAAK,EAAEG,OAAO,CAACC,GAAGC,MAAMD,IAAIC,CAAAA;;IAElE;AACA,WAAOT;EACT;EAEAU,UAAUC,WAAmBC,YAAoBC,QAAQ,IAAIC,cAAgC,IAAIC,SAAyD,CAAA,GAAI;AAC5J,UAAMC,MAAMH,MAAMI,QAAQ,iBAAiB,EAAA;AAC3C,QAAI,CAAC,KAAKhB,SAASU;AACjB,WAAKV,SAASU,aAAa,CAAC;AAC9B,SAAKV,SAASU,WAAWC,cAAc;MACrCA,cAAcM,UAAUH,MAAAA;mBACXJ,aAAaC,+DAA+DE,qBAAqBE;EAClHD,OAAOR,OAAO,CAACC,GAAGC,GAAGU,MAAM,GAAGX,QAAQC,EAAEW,QAAQX,EAAEY,UAAUF;EAAMV,EAAEW,SAAS,WAAW,yBAAyBD;IAAQ,MAAM,EAAA;;;;EAI/H;AACF;AA7BapB;AA0Cb,SAASmB,UAAUI,YAAmB;AACpC,MAAIC,QAAQ;AACZ,SAAOD,WAAWf,OAAO,CAACC,MAAM;AAC9B,WAAO,GAAG,GAAGA,OAAOe;EACtB,GAAG,EAAA;AACL;AALSL;;;AC5CF,IAAMM,cAAc,wBAACC,QAC1B,OAAOA,QAAQ,aADU;AAEpB,IAAMC,QAAQ,wBAACD,QACpBD,YAAYC,GAAAA,KAAQA,QAAQ,MADT;AAGd,IAAME,WAAW,wBAACC,OACvB,CAACF,MAAME,EAAAA,KAAO,OAAOA,OAAO,UADN;;;ACAjB,SAASC,QAAQC,KAAc,EAAEC,MAAMC,UAAS,GAAuCC,MAAM,sBAAsB;AACxH,QAAMC,YAAY,CAAC;AACnB,aAAWC,KAAKJ,MAAM;AACpB,UAAM,EAAEK,MAAMC,QAAQC,OAAOC,OAAM,IAAKJ,EAAEK;AAC1C,UAAMC,SAAS,IAAIC,QAAQ,GAAGN,QAAQD,CAAAA;AACtC,UAAMQ,WAAWX,UAAUY,IAAIR,IAAAA;AAC/B,UAAMS,UAAUJ,OAAOK,gBAAgBH,SAASN,QAAQU,KAAKJ,QAAAA,CAAAA;AAC7DT,cAAU,GAAGE,QAAQC,YAAYQ;AACjC,QAAIP,OAAO;AACTR,UAAIQ,MAAMU,MAAMV,MAAMA,OAAO,OAAOW,KAAKC,QAAQ;AAC/CP,iBAASQ,UAAUF;AACnBN,iBAASZ,OAAOkB,IAAIG;AAEpB,cAAMC,MAAM,MAAMR,QAAQI,GAAAA;AAC1B,mBAAWb,SAAQG;AACjBW,cAAII,IAAIlB,OAAMG,OAAOH,MAAK;AAE5B,YAAIiB,eAAeE,eAAe;AAChCL,cAAIM,OAAOH,IAAIG,MAAM,EAAEC,KAAKJ,IAAIb,IAAI;AAEpC;QACF;AACA,YAAIkB,SAASL,GAAAA;AACXH,cAAIO,KAAKJ,GAAAA;;AAETH,cAAIS,KAAKC,OAAOP,GAAAA,CAAAA;MACpB,CAAA;IACF;EACF;AACAvB,MAAI+B,KAAK5B,KAAK,OAAOgB,KAAKC,QAAQ;AAChC,UAAM,EAAEE,KAAI,IAAKH;AACjB,UAAMI,MAAM,CAAA;AACZ,eAAWlB,KAAKiB,MAAM;AACpB,YAAMF,OAAM,MAAMhB,UAAUC,GAAGiB,KAAKjB,EAAE;AACtCkB,UAAIS,KAAKT,eAAeE,gBAAgBL,KAAIV,OAAOU,IAAG;IACxD;AAEAA,QAAIO,KAAKJ,GAAAA;EACX,CAAA;AACF;AAvCgBxB;;;ACLhB,8BAAO;AAEP,IAAAkC,sBAAwC;;;ACAjC,IAAMC,QAAN,MAAMA;EACQC;EAAyBC;EAA5CC,YAAmBF,MAAyBC,SAAgB;gBAAzCD;mBAAyBC;EAE5C;AACF;AAJaF;;;ADKN,SAASI,QAAWC,SAAyB;AAClD,QAAMC,YAAY,oBAAIC,IAAAA;AACtB,QAAMC,OAAgB,CAAA;AACtBH,UAAQI,QAAQC,CAAAA,WAAUC,gBAAgBD,QAAQJ,WAAWE,IAAAA,CAAAA;AAC7D,SAAO;IAAEF;IAAWE;EAAK;AAC3B;AALgBJ;AAOhB,SAASO,gBAAgBD,QAAmBE,KAA2CJ,MAAe;AACpG,QAAMK,aAAaC,cAAcJ,MAAAA;AACjC,MAAIK;AACJ,QAAMC,OAAON,OAAOM;AACpB,MAAIJ,IAAIK,IAAID,IAAAA,GAAO;AACjBD,eAAWH,IAAIM,IAAIF,IAAAA;AACnB,QAAI,CAACD;AACH,YAAM,IAAII,MAAM,8BAA8BT,QAAQ;AACxD,WAAOK;EACT;AACAH,MAAIQ,IAAIJ,MAAMK,MAAAA;AACd,MAAIR,YAAY;AACdE,eAAW,IAAIL,OAAAA,GAAUG,WAAWD,IAAIU,CAAAA,SACtCX,gBAAgBW,MAAMV,KAAKJ,IAAAA,CAAAA,CAAAA;EAE/B,OACK;AACHO,eAAW,IAAIL,OAAAA;EACjB;AACAF,OAAKe,KAAI,GAAIC,oBAAoBT,UAAUC,IAAAA,CAAAA;AAC3CJ,MAAIQ,IAAIJ,MAAMD,QAAAA;AAEd,SAAOA;AACT;AAvBSJ;AAyBT,SAASa,oBAAoBT,UAAkBC,MAAc;AAC3D,QAAMS,WAAOC,mCAAcX,QAAAA,EAAUY,OAAOL,CAAAA,SAAQA,SAAS,SAAA;AAC7D,QAAMM,gBAAaC,8BAASd,UAAU,SAAA,KAAc,CAAC;AACrDe,YAAUF,SAAAA;AACV,SAAOH,KAAKb,IAAI,CAACmB,MAAM;AACrB,UAAMC,YAAQH,8BAASd,UAAUgB,CAAAA;AACjC,QAAIH,UAAUK,SAASD,MAAMC;AAC3BD,YAAMC,MAAMA,QAAQL,UAAUK,MAAMA,QAAQD,MAAMC,MAAMA;AAC1DD,UAAMhB,OAAOA;AACbgB,UAAME,SAASH;AACf,UAAMI,SAAS,CAAA;AACf,eAAWJ,MAAKC,MAAMG,UAAU,CAAA,GAAI;AAClCA,aAAOC,QAAQL,EAAAA;AACf,UAAIA,GAAEM,UAAU;AACd;IACJ;AACAL,UAAMG,SAASA;AACfL,cAAUE,KAAAA;AACVA,UAAMM,SAASC,OAAOC,OAAO,CAAC,GAAGZ,UAAUU,QAAQN,MAAMM,MAAM;AAC/DN,UAAMS,cAAc;SAAI,oBAAIC,IAAI;WAAId,UAAUa;WAAgBT,MAAMS;OAAY;;AAChFT,UAAMW,SAAS;SAAI,oBAAID,IAAI;WAAId,UAAUe;WAAWX,MAAMW;OAAO;;AACjEX,UAAMY,eAAe;SAAI,oBAAIF,IAAI;WAAId,UAAUgB;WAAiBZ,MAAMY;OAAa;;AAEnF,WAAO,IAAIC,MAAMb,OAAgClB,cAAcC,UAAUgB,CAAAA,KAAM,CAAA,CAAE;EACnF,CAAA;AACF;AAzBSP;AA2BT,SAASV,cAAcJ,QAAaoC,KAAuB;AACzD,SAAOC,QAAQC,YAAY,qBAAqBtC,QAAQoC,GAAAA;AAC1D;AAFShC;AAIT,SAASgB,UAAUE,OAAY;AAC7B,MAAI,CAACA,MAAMM;AACTN,UAAMM,SAAS,CAAC;AAClB,MAAI,CAACN,MAAMS;AACTT,UAAMS,cAAc,CAAA;AACtB,MAAI,CAACT,MAAMW;AACTX,UAAMW,SAAS,CAAA;AACjB,MAAI,CAACX,MAAMY;AACTZ,UAAMY,eAAe,CAAA;AACzB;AATSd;;;AEtET,IAAAmB,sBAAwC;;;ACAxC,IAAAC,sBAAwC;AAEjC,SAASC,UAAUC,MAAcC,KAAaC,UAAyB;AAC5E,SAAO,CAACC,QAAaC,GAAgBC,UAAkB;AACrDC,yCAAYH,QAAQC,CAAAA;AACpBG,wCAAWJ,QAAQC,GAAG;MACpBI,QAAQ;QAAC;UAAER;UAAMC;UAAKI;UAAOH;QAAS;;IACxC,CAAA;EACF;AACF;AAPgBH;AAST,SAASU,KAAKR,KAAaC,UAAoB;AACpD,SAAOH,UAAU,QAAQE,KAAKC,QAAAA;AAChC;AAFgBO;AAGT,SAASC,MAAMT,KAAaC,UAAoB;AACrD,SAAOH,UAAU,SAASE,KAAKC,QAAAA;AACjC;AAFgBQ;AAGT,SAASC,MAAMV,KAAaC,UAAoB;AACrD,SAAOH,UAAU,UAAUE,KAAKC,QAAAA;AAClC;AAFgBS;;;ACjBhB,IAAAC,sBAAwC;AAEjC,SAASC,MAAMC,OAAeC,MAAoB;AACvD,SAAO,CAACC,QAAaC,QAAsB;AACzC,QAAIA,KAAK;AACPC,2CAAYF,QAAQC,GAAAA;AACpBE,0CAAWH,QAAQC,KAAK;QACtBH,OAAO;UACLA;UACAC;QACF;MACF,CAAA;IACF,OACK;AACHG,2CAAYF,OAAOI,WAAW,SAAA;AAC9BD,0CAAWH,OAAOI,WAAW,WAAW;QACtCN,OAAO;UACLA;UACAC;QACF;MACF,CAAA;IACF;EACF;AACF;AArBgBF;AAuBT,SAASQ,IAAIP,OAAe;AACjC,SAAOD,MAAMC,OAAO,KAAA;AACtB;AAFgBO;AAIT,SAASC,KAAKR,OAAe;AAClC,SAAOD,MAAMC,OAAO,MAAA;AACtB;AAFgBQ;AAGT,SAASC,IAAIT,OAAe;AACjC,SAAOD,MAAMC,OAAO,KAAA;AACtB;AAFgBS;AAIT,SAASC,OAAOV,OAAe;AACpC,SAAOD,MAAMC,OAAO,QAAA;AACtB;AAFgBU;AAIT,SAASC,WAAWX,OAAe;AACxC,SAAOD,MAAMC,KAAAA;AACf;AAFgBW;;;AFtCT,SAASC,SAAS;AAAE;AAAXA;AAET,SAASC,OAAOC,MAAcC,OAAe;AAClD,SAAO,CAACC,QAAaC,MAAmB;AACtCC,yCAAYF,QAAQC,CAAAA;AACpBE,wCAAWH,QAAQC,GAAG;MACpBG,QAAQ;QAAEN;QAAMC;MAAM;IACxB,CAAA;EACF;AACF;AAPgBF;;;AGJhB,kBAAwB;AAExB,kBAA8B;AAGvB,SAASQ,OAAOC,WAAiC;AACtD,MAAIC;AACJ,MAAIC;AACJ,SAAO;IACLC,MAAM;IACNC,SAAS;IACTC,eAAeC,QAAQ;AACrBL,aAAOK,OAAOL,QAAQM,QAAQC,IAAG;AACjCN,qBAAWO,+BAAcC,qBAAQT,MAAMD,SAAAA,CAAAA;IACzC;IACAW,UAAUC,IAAI;AACZ,UAAIA,GAAGC,SAAS,aAAA;AACd,eAAOX;IACX;IACAY,UAAUC,MAAMH,IAAI;AAClB,UAAIA,OAAOV,UAAU;AACnB,cAAMc,OAAOC,KAAKC,MAAMH,IAAAA;AACxB,cAAMI,WAAW,IAAIC,UAAAA;AAErB,mBAAWC,KAAKL;AACdG,mBAASG,UAAUD,EAAElB,MAAMkB,EAAEE,QAAQF,EAAEG,OAAOA,OAAOH,EAAEG,OAAOC,MAAMJ,EAAEK,MAAM;AAC9E,eAAO;UACLX,MAAMI,SAASQ,WAAU;QAC3B;MACF;IACF;EACF;AACF;AA3BgB5B;","names":["HttpException","Error","message","status","description","constructor","data","error","UndefinedException","HttpException","constructor","message","ValidateException","HttpException","constructor","message","ForbiddenException","HttpException","constructor","message","BadRequestException","HttpException","constructor","message","defaultPipe","transform","args","reflect","i","validate","arg","constructor","ValidateException","name","isPhecda","ret","plainToClass","err","length","map","item","Pserver","key","meta","method","params","constructor","serverRecord","registerGuard","handler","guardsRecord","registerInterceptor","interceptorsRecord","useGuard","req","guards","guard","ForbiddenException","useInterceptor","interceptors","ret","interceptor","post","push","usePost","cbs","cb","usePipe","args","reflect","pipe","transform","methodToHandler","data","posts","map","param","type","validate","arg","e","console","log","HttpException","UndefinedException","message","defaultPipe","middlewareRecord","addGuard","addInterceptor","Pcompiler","content","classMap","constructor","getContent","name","Object","values","reduce","p","c","addMethod","className","methodName","route","requestType","params","url","replace","genParams","i","type","key","decorators","index","isUndefined","obj","isNil","isObject","fn","bindApp","app","meta","moduleMap","key","methodMap","i","name","method","route","header","data","server","Pserver","instance","get","handler","methodToHandler","bind","type","req","res","request","body","ret","set","HttpException","status","json","isObject","send","String","post","push","import_phecda_core","Pmeta","data","reflect","constructor","Factory","Modules","moduleMap","Map","meta","forEach","Module","buildNestModule","map","paramtypes","getParamtypes","instance","name","has","get","Error","set","undefined","item","push","getMetaFromInstance","vars","getModelState","filter","baseState","getState","initState","i","state","route","method","params","unshift","index","header","Object","assign","middlewares","Set","guards","interceptors","Pmeta","key","Reflect","getMetadata","import_phecda_core","import_phecda_core","BaseParam","type","key","validate","target","k","index","setModalVar","mergeState","params","Body","Query","Param","import_phecda_core","Route","route","type","target","key","setModalVar","mergeState","prototype","Get","Post","Put","Delete","Controller","Inject","Header","name","value","target","k","setModalVar","mergeState","header","Server","localPath","root","metaPath","name","enforce","configResolved","config","process","cwd","normalizePath","resolve","resolveId","id","endsWith","transform","code","meta","JSON","parse","compiler","Pcompiler","i","addMethod","method","route","type","params","getContent"]}