phecda-server 3.0.3 → 3.2.0-alpha.0

package/dist/index.mjs

@@ -41,18 +41,18 @@ __name(ValidateException, "ValidateException");
 
 // src/pipe.ts
 var defaultPipe = {
-  async transform(args, reflect) {
+  async transform(args) {
     for (const i in args) {
-      const { validate, arg } = args[i];
-      if (validate === false)
+      const { option, arg, reflect } = args[i];
+      if (option === false)
         continue;
-      if (!reflect[i]) {
-        if (validate && arg)
-          args[i].arg = validate(arg);
+      if (!reflect) {
+        if (option && arg)
+          args[i].arg = option(arg);
         continue;
       }
-      if (isPhecda(reflect[i])) {
-        const ret = await plainToClass(reflect[i], arg, {
+      if (isPhecda(reflect)) {
+        const ret = await plainToClass(reflect, arg, {
           transform: true
         });
         if (ret.err.length > 0)
@@ -62,9 +62,9 @@ var defaultPipe = {
         if ([
           Number,
           Boolean
-        ].includes(reflect[i])) {
-          args[i].arg = reflect[i](arg);
-          if (reflect[i] === Number && Object.is(args[i].arg, NaN))
+        ].includes(reflect)) {
+          args[i].arg = reflect(arg);
+          if (reflect === Number && Object.is(args[i].arg, NaN))
             throw new ValidateException(`parameter ${Number(i) + 1} should be a number`);
         }
       }
@@ -189,7 +189,7 @@ var serverFilter = /* @__PURE__ */ __name((e) => {
 }, "serverFilter");
 
 // src/history.ts
-var Phistroy = class {
+var Histroy = class {
   guard = [];
   interceptor = [];
   record(name, type) {
@@ -200,7 +200,17 @@ var Phistroy = class {
     return false;
   }
 };
-__name(Phistroy, "Phistroy");
+__name(Histroy, "Histroy");
+
+// src/utils.ts
+import pc from "picocolors";
+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");
+function warn(msg, color = "yellow") {
+  console.warn(`${pc.magenta("[phecda-server]")} ${pc[color](msg)}`);
+}
+__name(warn, "warn");
 
 // src/context/base.ts
 var _Context = class {
@@ -213,7 +223,7 @@ var _Context = class {
   constructor(key, data) {
     this.key = key;
     this.data = data;
-    this.history = new Phistroy();
+    this.history = new Histroy();
   }
   static registerGuard(key, handler) {
     _Context.guardsRecord[key] = handler;
@@ -256,7 +266,6 @@ var Context = _Context;
 __name(Context, "Context");
 __publicField(Context, "metaRecord", {});
 __publicField(Context, "metaDataRecord", {});
-__publicField(Context, "instanceRecord", {});
 __publicField(Context, "guardsRecord", {});
 __publicField(Context, "interceptorsRecord", {});
 function addGuard(key, handler) {
@@ -267,26 +276,19 @@ function addInterceptor(key, handler) {
   Context.registerInterceptor(key, handler);
 }
 __name(addInterceptor, "addInterceptor");
-function getInstance(tag) {
-  return Context.instanceRecord[tag];
-}
-__name(getInstance, "getInstance");
 function parseMeta(meta) {
   const { data: { params, guards, interceptors, middlewares }, reflect, handlers } = meta;
+  params.forEach(({ index, key }, i) => {
+    if (index !== i)
+      warn(`the ${i + 1}th argument on the method '${key}' require decorator`);
+  });
   return {
     guards,
     reflect,
     interceptors,
     middlewares,
     handlers,
-    params: params.map((param) => {
-      const { type, key, validate } = param;
-      return {
-        type,
-        key,
-        validate
-      };
-    })
+    params
   };
 }
 __name(parseMeta, "parseMeta");
@@ -300,8 +302,8 @@ var _ServerContext = class extends Context {
       return _ServerContext.middlewareRecord[m];
     });
   }
-  async usePipe(args, reflect) {
-    return _ServerContext.pipe.transform?.(args, reflect, this.data);
+  async usePipe(args, tag) {
+    return _ServerContext.pipe.transform?.(args, tag, this.data);
   }
   static useFilter(arg, data) {
     return _ServerContext.filter(arg, data);
@@ -334,16 +336,6 @@ var Base = class {
 };
 __name(Base, "Base");
 
-// src/utils.ts
-import pc from "picocolors";
-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");
-function warn(msg) {
-  console.warn(`${pc.magenta("[phecda-server]")} ${pc.yellow(msg)}`);
-}
-__name(warn, "warn");
-
 // src/helper.ts
 function isMerge(data) {
   return !!data.isMerge;
@@ -359,17 +351,17 @@ __name(resolveDep, "resolveDep");
 // src/common.ts
 var SERIES_SYMBOL = "__symbol_series__";
 var MERGE_SYMBOL = "__symbol_req__";
+var UNMOUNT_SYMBOL = "__symbol_unmount__";
 
 // src/server/express.ts
-function bindApp(app, { meta, moduleMap }, options = {}) {
-  const { globalGuards, globalInterceptors, route, middlewares: proMiddle } = {
+function bindApp(app, { moduleMap, meta }, options = {}) {
+  const { dev = process.env.NODE_ENV !== "production", globalGuards, globalInterceptors, route, middlewares: proMiddle } = {
     route: "/__PHECDA_SERVER__",
     globalGuards: [],
     globalInterceptors: [],
     middlewares: [],
     ...options
   };
-  const methodMap = {};
   const contextMeta = {};
   app.post(route, (req, _res, next) => {
     req[MERGE_SYMBOL] = true;
@@ -411,28 +403,36 @@ function bindApp(app, { meta, moduleMap }, options = {}) {
       if (category === "series") {
         for (const item of data) {
           const { tag } = item;
-          const [name] = tag.split("-");
+          const [name, method] = tag.split("-");
           const { reflect, params } = Context.metaDataRecord[tag];
           const instance = moduleMap.get(name);
           try {
             if (!params)
               throw new BadRequestException(`"${tag}" doesn't exist`);
-            const args = await context.usePipe(params.map(({ type, key, validate }) => {
+            const args = await context.usePipe(params.map(({ type, key, option, index }) => {
               const arg = resolveDep(item[type], key);
               if (typeof arg === "string" && arg.startsWith(SERIES_SYMBOL)) {
-                const [, index, argKey] = arg.split("@");
+                const [, argIndex, argKey] = arg.split("@");
                 return {
-                  arg: resolveDep(ret[Number(index)], argKey || key),
-                  validate
+                  arg: resolveDep(ret[Number(argIndex)], argKey || key),
+                  option,
+                  index,
+                  type,
+                  key,
+                  reflect: reflect[index]
                 };
               }
               return {
                 arg,
-                validate
+                option,
+                index,
+                type,
+                key,
+                reflect: reflect[index]
               };
-            }), reflect);
+            }), tag);
             instance.context = contextData;
-            ret.push(await methodMap[tag](...args));
+            ret.push(await moduleMap.get(name)[method](...args));
           } catch (e) {
             const m = Context.metaRecord[tag];
             m.handlers.forEach((handler) => handler.error?.(e));
@@ -445,21 +445,25 @@ function bindApp(app, { meta, moduleMap }, options = {}) {
         return Promise.all(data.map((item) => {
           return new Promise(async (resolve) => {
             const { tag } = item;
-            const [name] = tag.split("-");
+            const [name, method] = tag.split("-");
             const { reflect, params, handlers } = Context.metaDataRecord[tag];
             const instance = moduleMap.get(name);
             try {
               if (!params)
                 throw new BadRequestException(`"${tag}" doesn't exist`);
-              const args = await context.usePipe(params.map(({ type, key, validate }) => {
+              const args = await context.usePipe(params.map(({ type, key, option, index }) => {
                 const arg = resolveDep(item[type], key);
                 return {
                   arg,
-                  validate
+                  type,
+                  key,
+                  option,
+                  index,
+                  reflect: reflect[index]
                 };
-              }), reflect);
+              }), tag);
               instance.context = contextData;
-              resolve(await methodMap[tag](...args));
+              resolve(await moduleMap.get(name)[method](...args));
             } catch (e) {
               handlers.forEach((handler) => handler.error?.(e));
               resolve(await context.useFilter(e));
@@ -474,58 +478,72 @@ function bindApp(app, { meta, moduleMap }, options = {}) {
       res.status(err.status).json(err);
     }
   });
-  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;
-    Context.metaRecord[methodTag] = i;
-    let { guards, reflect, interceptors, params, handlers, middlewares } = Context.metaDataRecord[methodTag] ? Context.metaDataRecord[methodTag] : Context.metaDataRecord[methodTag] = parseMeta(i);
-    guards = [
-      ...globalGuards,
-      ...guards
-    ];
-    interceptors = [
-      ...globalInterceptors,
-      ...interceptors
-    ];
-    const handler = instance[method].bind(instance);
-    methodMap[methodTag] = handler;
-    Context.instanceRecord[name] = instance;
-    if (route2) {
-      app[route2.type](route2.route, ...ServerContext.useMiddleware(middlewares), async (req, res) => {
-        const contextData = {
-          request: req,
-          meta: i,
-          response: res,
-          moduleMap
-        };
-        const context = new ServerContext(methodTag, contextData);
-        try {
-          for (const name2 in header)
-            res.set(name2, header[name2]);
-          await context.useGuard(guards);
-          await context.useInterceptor(interceptors);
-          const args = await context.usePipe(params.map(({ type, key, validate }) => {
-            return {
-              arg: resolveDep(req[type], key),
-              validate
-            };
-          }), reflect);
-          instance.context = contextData;
-          const ret = await context.usePost(await handler(...args));
-          if (isObject(ret))
-            res.json(ret);
-          else
-            res.send(String(ret));
-        } catch (e) {
-          handlers.forEach((handler2) => handler2.error?.(e));
-          const err = await context.useFilter(e);
-          res.status(err.status).json(err);
-        }
-      });
+  async function createRoute() {
+    for (const i of meta) {
+      const { method, route: route2, header, tag } = i.data;
+      const methodTag = `${tag}-${method}`;
+      contextMeta[methodTag] = i;
+      Context.metaRecord[methodTag] = i;
+      let { guards, reflect, interceptors, params, handlers, middlewares } = Context.metaDataRecord[methodTag] ? Context.metaDataRecord[methodTag] : Context.metaDataRecord[methodTag] = parseMeta(i);
+      guards = [
+        ...globalGuards,
+        ...guards
+      ];
+      interceptors = [
+        ...globalInterceptors,
+        ...interceptors
+      ];
+      if (route2) {
+        app[route2.type](route2.route, ...ServerContext.useMiddleware(middlewares), async (req, res) => {
+          const instance = moduleMap.get(tag);
+          const contextData = {
+            request: req,
+            meta: i,
+            response: res,
+            moduleMap
+          };
+          const context = new ServerContext(methodTag, contextData);
+          try {
+            for (const name in header)
+              res.set(name, header[name]);
+            await context.useGuard(guards);
+            await context.useInterceptor(interceptors);
+            const args = await context.usePipe(params.map(({ type, key, option, index }) => {
+              return {
+                arg: resolveDep(req[type], key),
+                option,
+                key,
+                type,
+                index,
+                reflect: reflect[index]
+              };
+            }), methodTag);
+            instance.context = contextData;
+            const ret = await context.usePost(await instance[method](...args));
+            if (isObject(ret))
+              res.json(ret);
+            else
+              res.send(String(ret));
+          } catch (e) {
+            handlers.forEach((handler) => handler.error?.(e));
+            const err = await context.useFilter(e);
+            res.status(err.status).json(err);
+          }
+        });
+      }
     }
   }
+  __name(createRoute, "createRoute");
+  createRoute();
+  if (dev) {
+    const rawMetaHmr = globalThis.__PHECDA_SERVER_META__;
+    globalThis.__PHECDA_SERVER_META__ = () => {
+      app.stack = app.stack.slice(0, 1);
+      Context.metaDataRecord = {};
+      createRoute();
+      rawMetaHmr?.();
+    };
+  }
 }
 __name(bindApp, "bindApp");
 
@@ -533,7 +551,8 @@ __name(bindApp, "bindApp");
 import "reflect-metadata";
 import fs from "fs";
 import EventEmitter from "node:events";
-import { getExposeKey, getHandler, getState, injectProperty, registerAsync } from "phecda-core";
+import { getExposeKey, getHandler, getState, injectProperty, isPhecda as isPhecda2, registerAsync } from "phecda-core";
+import Debug from "debug";
 
 // src/meta.ts
 var Meta = class {
@@ -549,11 +568,14 @@ var Meta = class {
 __name(Meta, "Meta");
 
 // src/core.ts
+var debug = Debug("phecda-server");
 var emitter = new EventEmitter();
-var constructorMap = /* @__PURE__ */ new Map();
-async function Factory(Modules) {
+async function Factory(Modules, opts = {}) {
   const moduleMap = /* @__PURE__ */ new Map();
   const meta = [];
+  const constructorMap = /* @__PURE__ */ new Map();
+  const moduleGraph = /* @__PURE__ */ new WeakMap();
+  const { dev = process.env.NODE_ENV === "development", file = "pmeta.js" } = opts;
   injectProperty("watcher", ({ eventName, instance, key, options }) => {
     const fn = typeof instance[key] === "function" ? instance[key].bind(instance) : (v) => instance[key] = v;
     if (options?.once)
@@ -561,45 +583,94 @@ async function Factory(Modules) {
     else
       emitter.on(eventName, fn);
   });
+  async function update(Module) {
+    const tag = Module.prototype?.__TAG__ || Module.name;
+    if (!moduleMap.has(tag))
+      return;
+    debug(`update module "${tag}"`);
+    const instance = moduleMap.get(tag);
+    if (instance?.[UNMOUNT_SYMBOL]) {
+      for (const cb of instance[UNMOUNT_SYMBOL])
+        await cb();
+    }
+    moduleMap.delete(tag);
+    constructorMap.delete(tag);
+    for (let i = meta.length - 1; i >= 0; i--) {
+      if (meta[i].data.tag === tag)
+        meta.splice(i, 1);
+    }
+    const newModule = await buildNestModule(Module, moduleMap);
+    moduleGraph.get(instance)?.forEach((module) => {
+      for (const key in module) {
+        if (module[key] === instance)
+          module[key] = newModule;
+      }
+    });
+    moduleGraph.get(instance);
+    moduleMap.set(tag, newModule);
+  }
+  __name(update, "update");
+  async function buildNestModule(Module, map) {
+    const paramtypes = getParamtypes(Module);
+    let instance;
+    const tag = Module.prototype?.__TAG__ || Module.name;
+    if (map.has(tag)) {
+      instance = map.get(tag);
+      if (!instance)
+        throw new Error(`exist Circular-Dependency or Multiple modules with the same name/tag [tag] ${tag}--[module] ${Module}`);
+      if (constructorMap.get(tag) !== Module)
+        warn(`Synonym module: Module taged "${tag}" has been loaded before, so phecda-server won't load Module "${Module.name}"`);
+      return instance;
+    }
+    map.set(tag, void 0);
+    if (paramtypes) {
+      const paramtypesInstances = [];
+      for (const i in paramtypes)
+        paramtypesInstances[i] = await buildNestModule(paramtypes[i], map);
+      instance = new Module(...paramtypesInstances);
+      for (const i of paramtypesInstances) {
+        if (!moduleGraph.has(i))
+          moduleGraph.set(i, []);
+        moduleGraph.get(i).push(instance);
+      }
+    } else {
+      instance = new Module();
+    }
+    meta.push(...getMetaFromInstance(instance, tag, Module.name));
+    await registerAsync(instance);
+    map.set(tag, instance);
+    constructorMap.set(tag, Module);
+    return instance;
+  }
+  __name(buildNestModule, "buildNestModule");
   for (const Module of Modules)
-    await buildNestModule(Module, moduleMap, meta);
-  constructorMap.clear();
+    await buildNestModule(Module, moduleMap);
+  function writeMeta() {
+    debug("write metadata");
+    fs.promises.writeFile(file, JSON.stringify(meta.map((item) => item.data)));
+  }
+  __name(writeMeta, "writeMeta");
+  writeMeta();
+  if (dev) {
+    globalThis.__PHECDA_SERVER_HMR__ = async (file2) => {
+      debug(`reload file ${file2}`);
+      const module = await import(file2);
+      for (const i in module) {
+        if (isPhecda2(module[i]))
+          await update(module[i]);
+      }
+    };
+    globalThis.__PHECDA_SERVER_META__ = writeMeta;
+  }
   return {
     moduleMap,
     meta,
-    output: (p = "pmeta.js") => fs.writeFileSync(p, JSON.stringify(meta.map((item) => item.data)))
+    constructorMap,
+    update
   };
 }
 __name(Factory, "Factory");
-async function buildNestModule(Module, map, meta) {
-  const paramtypes = getParamtypes(Module);
-  let instance;
-  const tag = Module.prototype?.__TAG__ || Module.name;
-  if (map.has(tag)) {
-    instance = map.get(tag);
-    if (!instance)
-      throw new Error(`exist Circular-Dependency or Multiple modules with the same name/tag [tag] ${tag}--[module] ${Module}`);
-    if (constructorMap.get(tag) !== Module)
-      warn(`Synonym module: Module taged "${tag}" has been loaded before, so phecda-server won't load Module "${Module.name}"`);
-    return instance;
-  }
-  map.set(tag, void 0);
-  if (paramtypes) {
-    const paramtypesInstances = [];
-    for (const i in paramtypes)
-      paramtypesInstances[i] = await buildNestModule(paramtypes[i], map, meta);
-    instance = new Module(...paramtypesInstances);
-  } else {
-    instance = new Module();
-  }
-  meta.push(...getMetaFromInstance(instance, Module.name, tag));
-  await registerAsync(instance);
-  map.set(tag, instance);
-  constructorMap.set(tag, Module);
-  return instance;
-}
-__name(buildNestModule, "buildNestModule");
-function getMetaFromInstance(instance, name, tag) {
+function getMetaFromInstance(instance, tag, name) {
   const vars = getExposeKey(instance).filter((item) => item !== "__CLASS");
   const baseState = getState(instance, "__CLASS") || {};
   initState(baseState);
@@ -670,13 +741,20 @@ function initState(state) {
     state.interceptors = [];
 }
 __name(initState, "initState");
+var Dev = class {
+  [UNMOUNT_SYMBOL] = [];
+  onUnmount(cb) {
+    this[UNMOUNT_SYMBOL].push(cb);
+  }
+};
+__name(Dev, "Dev");
 
 // src/decorators/index.ts
 import { setModelVar as setModelVar3, setState as setState3 } from "phecda-core";
 
 // src/decorators/param.ts
 import { setModelVar, setState } from "phecda-core";
-function BaseParam(type, key, validate) {
+function BaseParam(type, key, option) {
   return (target, k, index) => {
     setModelVar(target, k);
     const state = target._namespace.__STATE_NAMESPACE__.get(k) || {};
@@ -686,7 +764,7 @@ function BaseParam(type, key, validate) {
       type,
       key,
       index,
-      validate
+      option
     });
     setState(target, k, state);
   };
@@ -830,6 +908,7 @@ export {
   Controller,
   Define,
   Delete,
+  Dev,
   Factory,
   ForbiddenException,
   FrameworkException,
@@ -854,6 +933,7 @@ export {
   ServerContext,
   ServiceUnavailableException,
   TimeoutException,
+  UNMOUNT_SYMBOL,
   UnauthorizedException,
   UndefinedException,
   UnsupportedMediaTypeException,
@@ -862,10 +942,8 @@ export {
   addInterceptor,
   addMiddleware,
   bindApp,
-  constructorMap,
   defaultPipe,
   emitter,
-  getInstance,
   isMerge,
   parseMeta,
   resolveDep,