phecda-server 3.1.0 → 3.2.0-alpha.1

package/bin/cli.js

@@ -1,12 +1,33 @@
-const fs = require('fs')
-const path = require('path')
-const [module, dir = ''] = process.argv.slice(2)
+const { exec } = require('child_process')
+const pc = require('picocolors')
+const cmd = process.argv.slice(2)[0]
+let child
+function startChild() {
+  child = exec(`node --import phecda-server/register ${cmd}`, {
+    env: process.env,
+    // cwd: process.cwd(),
+  })
+  child.stderr.pipe(process.stderr)
+  child.stdin.pipe(process.stdin)
+  child.stdout.pipe(process.stdout)
 
-const dirPath = path.resolve(process.cwd(), dir, module)
-fs.mkdirSync(dirPath)
+  child.on('exit', (code) => {
+    if (code === 3) {
+      log('relunch...')
+      return startChild()
+    }
 
-fs.writeFileSync(path.resolve(dirPath, `${module}.controller.ts`), `
-export class ${module.slice(0).toUpperCase()}${module.slice(1)}Controller{
+    process.exit(0)
+  })
+}
+
+process.on('SIGINT', () => {
+  child.kill('SIGINT')
+})
 
+function log(msg, color = 'green') {
+  const date = new Date()
+  console.log(`${pc.gray(`${date.getHours()} ${date.getMinutes()} ${date.getSeconds()}`)} ${pc.magenta('[phecda-server]')} ${pc[color](msg)}`)
 }
-`)
+
+startChild()

package/dist/index.d.ts

@@ -149,7 +149,7 @@ declare namespace P {
     interface Pipe {
         transform(args: {
             arg: any;
-            option?: boolean;
+            option?: any;
             key: string;
             type: string;
             index: number;
@@ -158,7 +158,7 @@ declare namespace P {
     }
 }
 
-declare class Phistroy {
+declare class Histroy {
     guard: string[];
     interceptor: string[];
     record(name: string, type: 'guard' | 'interceptor'): boolean;
@@ -171,11 +171,10 @@ declare abstract class Context<Data = any> {
     params: string[];
     static metaRecord: Record<string, Meta>;
     static metaDataRecord: Record<string, ReturnType<typeof parseMeta>>;
-    static instanceRecord: Record<string, any>;
     static guardsRecord: Record<string, any>;
     static interceptorsRecord: Record<string, any>;
     post: ((...params: any) => any)[];
-    history: Phistroy;
+    history: Histroy;
     constructor(key: string, data: Data);
     static registerGuard(key: string, handler: any): void;
     static registerInterceptor(key: string, handler: any): void;
@@ -185,7 +184,6 @@ declare abstract class Context<Data = any> {
 }
 declare function addGuard(key: string, handler: P.Guard): void;
 declare function addInterceptor(key: string, handler: P.Interceptor): void;
-declare function getInstance(tag: string): any;
 declare function parseMeta(meta: Meta): {
     guards: string[];
     reflect: any[];
@@ -202,7 +200,7 @@ declare function parseMeta(meta: Meta): {
 
 declare class ServerContext extends Context<ServerCtx | ServerMergeCtx> {
     static pipe: P.Pipe;
-    static filter: ServerFilter<any>;
+    static filter: ServerFilter;
     static middlewareRecord: Record<string, (...params: any) => any>;
     static useMiddleware(middlewares: string[]): ((...params: any) => any)[];
     usePipe(args: {
@@ -220,21 +218,33 @@ declare function addMiddleware(key: string, handler: RequestHandler): void;
 declare function useServerPipe(pipe: P.Pipe): void;
 declare function useServerFilter(filter: ServerFilter): void;
 
+declare const SERIES_SYMBOL = "__symbol_series__";
+declare const MERGE_SYMBOL = "__symbol_req__";
+declare const UNMOUNT_SYMBOL = "__symbol_unmount__";
+
 declare const emitter: Emitter;
-declare const constructorMap: Map<any, any>;
-declare function Factory(Modules: (new (...args: any) => any)[]): Promise<{
+declare function Factory(Modules: (new (...args: any) => any)[], opts?: {
+    dev?: boolean;
+    file?: string;
+}): Promise<{
     moduleMap: Map<string, any>;
     meta: Meta[];
-    output: (p?: string) => void;
+    constructorMap: Map<any, any>;
+    update: (Module: Construct) => Promise<void>;
 }>;
+declare class Dev {
+    [UNMOUNT_SYMBOL]: (() => void)[];
+    onUnmount(cb: () => void): void;
+}
 
 interface Options {
+    dev?: boolean;
     route?: string;
     globalGuards?: string[];
     globalInterceptors?: string[];
     middlewares?: string[];
 }
-declare function bindApp(app: Express | Router, { meta, moduleMap }: Awaited<ReturnType<typeof Factory>>, options?: Options): void;
+declare function bindApp(app: Express | Router, { moduleMap, meta }: Awaited<ReturnType<typeof Factory>>, options?: Options): void;
 
 declare function BaseParam(type: string, key: string, option?: any): any;
 declare function Body(key?: string, pipeOpts?: any): any;
@@ -260,7 +270,4 @@ declare const defaultPipe: P.Pipe;
 declare function isMerge(data: ServerCtx | ServerMergeCtx): data is ServerMergeCtx;
 declare function resolveDep(ret: any, key: string): any;
 
-declare const SERIES_SYMBOL = "__symbol_series__";
-declare const MERGE_SYMBOL = "__symbol_req__";
-
-export { BadGatewayException, BadRequestException, Base, BaseError, BaseParam, Body, ConflictException, Construct, Context, Controller, Define, Delete, Emitter, Factory, ForbiddenException, FrameworkException, Get, Guard, Header, HttpException, Interceptor, InvalidInputException, MERGE_SYMBOL, MergeType, Meta, Middle, NotFoundException, Options, P, Param, Patch, PayloadLargeException, Post, Put, Query, RequestType, Route, SERIES_SYMBOL, ServerContext, ServerCtx, ServerFilter, ServerMergeCtx, ServiceUnavailableException, TimeoutException, UnauthorizedException, UndefinedException, UnsupportedMediaTypeException, ValidateException, addGuard, addInterceptor, addMiddleware, bindApp, constructorMap, defaultPipe, emitter, getInstance, isMerge, parseMeta, resolveDep, useServerFilter, useServerPipe };
+export { BadGatewayException, BadRequestException, Base, BaseError, BaseParam, Body, ConflictException, Construct, Context, Controller, Define, Delete, Dev, Emitter, Factory, ForbiddenException, FrameworkException, Get, Guard, Header, HttpException, Interceptor, InvalidInputException, MERGE_SYMBOL, MergeType, Meta, Middle, NotFoundException, Options, P, Param, Patch, PayloadLargeException, Post, Put, Query, RequestType, Route, SERIES_SYMBOL, ServerContext, ServerCtx, ServerFilter, ServerMergeCtx, ServiceUnavailableException, TimeoutException, UNMOUNT_SYMBOL, UnauthorizedException, UndefinedException, UnsupportedMediaTypeException, ValidateException, addGuard, addInterceptor, addMiddleware, bindApp, defaultPipe, emitter, isMerge, parseMeta, resolveDep, useServerFilter, useServerPipe };

package/dist/index.js

@@ -43,6 +43,7 @@ __export(src_exports, {
   Controller: () => Controller,
   Define: () => Define,
   Delete: () => Delete,
+  Dev: () => Dev,
   Factory: () => Factory,
   ForbiddenException: () => ForbiddenException,
   FrameworkException: () => FrameworkException,
@@ -67,6 +68,7 @@ __export(src_exports, {
   ServerContext: () => ServerContext,
   ServiceUnavailableException: () => ServiceUnavailableException,
   TimeoutException: () => TimeoutException,
+  UNMOUNT_SYMBOL: () => UNMOUNT_SYMBOL,
   UnauthorizedException: () => UnauthorizedException,
   UndefinedException: () => UndefinedException,
   UnsupportedMediaTypeException: () => UnsupportedMediaTypeException,
@@ -75,10 +77,8 @@ __export(src_exports, {
   addInterceptor: () => addInterceptor,
   addMiddleware: () => addMiddleware,
   bindApp: () => bindApp,
-  constructorMap: () => constructorMap,
   defaultPipe: () => defaultPipe,
   emitter: () => emitter,
-  getInstance: () => getInstance,
   isMerge: () => isMerge,
   parseMeta: () => parseMeta,
   resolveDep: () => resolveDep,
@@ -270,7 +270,7 @@ var serverFilter = /* @__PURE__ */ __name((e) => {
 }, "serverFilter");
 
 // src/history.ts
-var Phistroy = class {
+var Histroy = class {
   guard = [];
   interceptor = [];
   record(name, type) {
@@ -281,7 +281,7 @@ var Phistroy = class {
     return false;
   }
 };
-__name(Phistroy, "Phistroy");
+__name(Histroy, "Histroy");
 
 // src/utils.ts
 var import_picocolors = __toESM(require("picocolors"));
@@ -304,7 +304,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;
@@ -347,7 +347,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) {
@@ -358,10 +357,6 @@ 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) => {
@@ -437,17 +432,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;
@@ -489,7 +484,7 @@ 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 {
@@ -518,7 +513,7 @@ function bindApp(app, { meta, moduleMap }, options = {}) {
               };
             }), 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));
@@ -531,7 +526,7 @@ 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 {
@@ -549,7 +544,7 @@ function bindApp(app, { meta, moduleMap }, options = {}) {
                 };
               }), 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));
@@ -564,62 +559,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, 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 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");
 
@@ -628,6 +633,7 @@ var import_reflect_metadata = require("reflect-metadata");
 var import_fs = __toESM(require("fs"));
 var import_node_events = __toESM(require("events"));
 var import_phecda_core2 = require("phecda-core");
+var import_debug = __toESM(require("debug"));
 
 // src/meta.ts
 var Meta = class {
@@ -643,11 +649,14 @@ var Meta = class {
 __name(Meta, "Meta");
 
 // src/core.ts
+var debug = (0, import_debug.default)("phecda-server");
 var emitter = new import_node_events.default();
-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 Map();
+  const { dev = process.env.NODE_ENV !== "production", file = "pmeta.js" } = opts;
   (0, import_phecda_core2.injectProperty)("watcher", ({ eventName, instance, key, options }) => {
     const fn = typeof instance[key] === "function" ? instance[key].bind(instance) : (v) => instance[key] = v;
     if (options?.once)
@@ -655,45 +664,104 @@ 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 { instance: newModule } = await buildNestModule(Module);
+    if (moduleGraph.has(tag)) {
+      [
+        ...moduleGraph.get(tag)
+      ].forEach((tag2) => {
+        const module2 = moduleMap.get(tag2);
+        for (const key in module2) {
+          if (module2[key] === instance)
+            module2[key] = newModule;
+        }
+      });
+    }
+    moduleMap.set(tag, newModule);
+  }
+  __name(update, "update");
+  async function buildNestModule(Module) {
+    const paramtypes = getParamtypes(Module);
+    let instance;
+    const tag = Module.prototype?.__TAG__ || Module.name;
+    if (moduleMap.has(tag)) {
+      instance = moduleMap.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,
+        tag
+      };
+    }
+    moduleMap.set(tag, void 0);
+    if (paramtypes) {
+      const paramtypesInstances = [];
+      for (const i in paramtypes) {
+        const { instance: sub, tag: subTag } = await buildNestModule(paramtypes[i]);
+        paramtypesInstances[i] = sub;
+        if (!moduleGraph.has(subTag))
+          moduleGraph.set(subTag, /* @__PURE__ */ new Set());
+        moduleGraph.get(subTag).add(tag);
+      }
+      instance = new Module(...paramtypesInstances);
+    } else {
+      instance = new Module();
+    }
+    meta.push(...getMetaFromInstance(instance, tag, Module.name));
+    await (0, import_phecda_core2.registerAsync)(instance);
+    moduleMap.set(tag, instance);
+    constructorMap.set(tag, Module);
+    return {
+      instance,
+      tag
+    };
+  }
+  __name(buildNestModule, "buildNestModule");
   for (const Module of Modules)
-    await buildNestModule(Module, moduleMap, meta);
-  constructorMap.clear();
+    await buildNestModule(Module);
+  function writeMeta() {
+    debug("write metadata");
+    import_fs.default.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 module2 = await import(file2);
+      for (const i in module2) {
+        if ((0, import_phecda_core2.isPhecda)(module2[i]))
+          await update(module2[i]);
+      }
+    };
+    globalThis.__PHECDA_SERVER_META__ = writeMeta;
+  }
   return {
     moduleMap,
     meta,
-    output: (p = "pmeta.js") => import_fs.default.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 (0, import_phecda_core2.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 = (0, import_phecda_core2.getExposeKey)(instance).filter((item) => item !== "__CLASS");
   const baseState = (0, import_phecda_core2.getState)(instance, "__CLASS") || {};
   initState(baseState);
@@ -764,6 +832,13 @@ 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
 var import_phecda_core5 = require("phecda-core");
@@ -925,6 +1000,7 @@ __reExport(src_exports, require("phecda-core"), module.exports);
   Controller,
   Define,
   Delete,
+  Dev,
   Factory,
   ForbiddenException,
   FrameworkException,
@@ -949,6 +1025,7 @@ __reExport(src_exports, require("phecda-core"), module.exports);
   ServerContext,
   ServiceUnavailableException,
   TimeoutException,
+  UNMOUNT_SYMBOL,
   UnauthorizedException,
   UndefinedException,
   UnsupportedMediaTypeException,
@@ -957,10 +1034,8 @@ __reExport(src_exports, require("phecda-core"), module.exports);
   addInterceptor,
   addMiddleware,
   bindApp,
-  constructorMap,
   defaultPipe,
   emitter,
-  getInstance,
   isMerge,
   parseMeta,
   resolveDep,