phecda-server 7.0.0-alpha.1 → 7.0.0-alpha.10

package/dist/chunk-NQ55PA2X.mjs

@@ -0,0 +1,152 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/common.ts
+var ERROR_SYMBOL = "__PS_ERROR__";
+var IS_DEV = process.env.NODE_ENV === "development";
+var IS_ONLY_GENERATE = !!process.env.PS_GENERATE;
+var IS_STRICT = !!process.env.PS_STRICT;
+var IS_PURE = !!process.env.PS_PURE;
+var LOG_LEVEL = Number(process.env.PS_LOG_LEVEL || 0);
+var PS_EXIT_CODE = /* @__PURE__ */ function(PS_EXIT_CODE2) {
+  PS_EXIT_CODE2[PS_EXIT_CODE2["RELAUNCH"] = 4171] = "RELAUNCH";
+  PS_EXIT_CODE2[PS_EXIT_CODE2["EXIT"] = 4172] = "EXIT";
+  return PS_EXIT_CODE2;
+}({});
+
+// src/utils.ts
+import pc from "picocolors";
+import { Mixin } from "ts-mixer";
+var isObject = /* @__PURE__ */ __name((fn) => fn !== null && typeof fn === "object", "isObject");
+var isPlainObject = /* @__PURE__ */ __name((fn) => {
+  if (!isObject(fn)) return false;
+  const proto = Object.getPrototypeOf(fn);
+  if (proto === null) return true;
+  const ctor = Object.prototype.hasOwnProperty.call(proto, "constructor") && proto.constructor;
+  return typeof ctor === "function" && ctor instanceof ctor && Function.prototype.toString.call(ctor) === Function.prototype.toString.call(Object);
+}, "isPlainObject");
+var InternalLogger = class InternalLogger2 {
+  static {
+    __name(this, "InternalLogger");
+  }
+  time;
+  color = {
+    debug: "bgMagenta",
+    error: "red",
+    info: "gray",
+    warn: "yellow",
+    log: "green"
+  };
+  dateFormatter = new Intl.DateTimeFormat(void 0, {
+    year: "numeric",
+    hour: "numeric",
+    minute: "numeric",
+    second: "numeric",
+    day: "2-digit",
+    month: "2-digit"
+  });
+  diffTimestamp() {
+    const now = Date.now();
+    if (!this.time) return "";
+    const diff = now - this.time;
+    this.time = now;
+    return diff ? pc.yellow(` +${diff}`) : "";
+  }
+  colorize(message, logLevel) {
+    return pc[this.color[logLevel]](message);
+  }
+  isAllowLog(level) {
+    const logLevel = {
+      debug: -1,
+      info: 0,
+      log: 1,
+      warn: 2,
+      error: 3
+    }[level];
+    if (logLevel < LOG_LEVEL) return false;
+    return true;
+  }
+  stringifyMessage(message, logLevel) {
+    if (typeof message === "function") {
+      const messageAsStr = Function.prototype.toString.call(message);
+      const isClass = messageAsStr.startsWith("class ");
+      if (isClass) {
+        return this.stringifyMessage(message.name, logLevel);
+      }
+      return this.stringifyMessage(message(), logLevel);
+    }
+    return isPlainObject(message) || Array.isArray(message) ? `${this.colorize("Object:", logLevel)}
+${JSON.stringify(message, (key, value) => typeof value === "bigint" ? value.toString() : value, 2)}
+` : this.colorize(message, logLevel);
+  }
+  log(msg, level, ctx) {
+    if (!this.isAllowLog(level)) return;
+    msg = this.stringifyMessage(msg, level);
+    const pidMsg = this.colorize(`[${process.env.PS_APP_NAME || "phecda-server"}] ${process.pid}`, level);
+    const ctxMsg = ctx ? this.colorize(pc.bold(`[${ctx}] `), level) : "";
+    const timeDiff = this.diffTimestamp();
+    const levelMsg = this.colorize(level.toUpperCase().padStart(7, " "), level);
+    process.stdout.write(`${pidMsg} ${this.dateFormatter.format(Date.now())} ${levelMsg} ${ctxMsg}${msg}${timeDiff}
+`);
+  }
+};
+var _logger = new InternalLogger();
+function setLogger(logger) {
+  _logger = logger;
+}
+__name(setLogger, "setLogger");
+function getLogger() {
+  return _logger;
+}
+__name(getLogger, "getLogger");
+function log(msg, level = "log", ctx) {
+  _logger.log(msg, level, ctx);
+}
+__name(log, "log");
+function runMiddleware(ctx, middleware) {
+  return new Promise((resolve) => {
+    middleware(ctx.getRequest(), ctx.getResponse(), resolve);
+  });
+}
+__name(runMiddleware, "runMiddleware");
+
+// src/hmr.ts
+function HMR(cb) {
+  if (IS_DEV) {
+    if (!globalThis.__PS_HMR__) globalThis.__PS_HMR__ = [];
+    globalThis.__PS_HMR__.push(cb);
+  }
+}
+__name(HMR, "HMR");
+async function RELOAD(oldModels, newModels) {
+  log("reload module...");
+  for (const cb of globalThis.__PS_HMR__) await cb(oldModels, newModels);
+  log("reload done");
+}
+__name(RELOAD, "RELOAD");
+function RELAUNCH() {
+  if (IS_DEV) {
+    log("relaunch...");
+    process.exit(PS_EXIT_CODE.RELAUNCH);
+  }
+}
+__name(RELAUNCH, "RELAUNCH");
+
+export {
+  __name,
+  ERROR_SYMBOL,
+  IS_DEV,
+  IS_ONLY_GENERATE,
+  IS_STRICT,
+  IS_PURE,
+  LOG_LEVEL,
+  PS_EXIT_CODE,
+  setLogger,
+  getLogger,
+  log,
+  runMiddleware,
+  Mixin,
+  HMR,
+  RELOAD,
+  RELAUNCH
+};

package/dist/{chunk-XYVMNY2X.mjs → chunk-YCES6ABN.mjs}

@@ -1,9 +1,10 @@
 import {
-  IS_HMR,
+  HMR,
   IS_ONLY_GENERATE,
+  PS_EXIT_CODE,
   __name,
   log
-} from "./chunk-WHJ5FALK.mjs";
+} from "./chunk-NQ55PA2X.mjs";
 
 // src/meta.ts
 var Meta = class {
@@ -21,7 +22,7 @@ var Meta = class {
 // src/core.ts
 import "reflect-metadata";
 import EventEmitter from "node:events";
-import { getInject, getMergedMeta, getMetaKey, getMetaParams, getTag, invokeInit, invokeUnmount, isPhecda, setInject } from "phecda-core";
+import { getInject, getMergedMeta, getMetaKey, getMetaParams, getTag, invokeInit, invokeUnmount, setInject } from "phecda-core";
 import Debug from "debug";
 var debug = Debug("phecda-server(Factory)");
 var emitter = new EventEmitter();
@@ -61,63 +62,86 @@ var ServerPhecda = class {
   }
   async start(models) {
     for (const model of models) await this.buildDepModule(model);
-    const generateCode = /* @__PURE__ */ __name(async () => {
-      if (IS_HMR) {
-        return Promise.all(this.generators.map((generator) => {
-          debug(`generate "${generator.name}" code to ${generator.path}`);
-          return generator.output(this.meta);
-        }));
+    this.hmr();
+    this.generateCode().then(() => {
+      if (IS_ONLY_GENERATE) {
+        log("Only generate code");
+        process.exit(PS_EXIT_CODE.EXIT);
       }
-    }, "generateCode");
-    generateCode().then(() => {
-      if (IS_ONLY_GENERATE) process.exit(4);
     });
-    if (IS_HMR) {
-      if (!globalThis.__PS_HMR__) globalThis.__PS_HMR__ = [];
-      globalThis.__PS_HMR__?.push(async (files) => {
-        debug("reload files ");
-        for (const file of files) {
-          const models2 = await import(file);
-          for (const i in models2) {
-            if (isPhecda(models2[i])) await this.add(models2[i]);
-          }
-        }
-        generateCode();
-      });
-    }
   }
-  async add(Model) {
-    const tag = getTag(Model);
-    const oldInstance = await this.del(tag);
-    const { module: newModule } = await this.buildDepModule(Model);
-    if (oldInstance && this.dependenceGraph.has(tag)) {
-      debug(`replace module "${String(tag)}"`);
-      [
-        ...this.dependenceGraph.get(tag)
-      ].forEach((tag2) => {
-        const module = this.moduleMap.get(tag2);
-        for (const key in module) {
-          if (module[key] === oldInstance) module[key] = newModule;
-        }
-      });
-    }
-  }
-  async del(tag) {
-    if (!this.moduleMap.has(tag)) return;
-    const module = this.moduleMap.get(tag);
-    debug(`unmount module "${String(tag)}"`);
-    await invokeUnmount(module);
-    debug(`del module "${String(tag)}"`);
-    this.moduleMap.delete(tag);
-    this.modelMap.delete(module);
-    for (let i = this.meta.length - 1; i >= 0; i--) {
-      if (this.meta[i].data.tag === tag) this.meta.splice(i, 1);
-    }
-    return module;
+  generateCode = /* @__PURE__ */ __name(async () => {
+    return Promise.all(this.generators.map((generator) => {
+      debug(`generate "${generator.name}" code to ${generator.path}`);
+      return generator.output(this.meta);
+    }));
+  }, "generateCode");
+  hmr() {
+    HMR(async (oldModels, newModels) => {
+      debug("reload models ");
+      await this.replace(oldModels, newModels);
+      this.generateCode();
+    });
   }
+  // async add(Model: Construct) {
+  //   const tag = getTag(Model)
+  //   const oldInstance = await this.del(tag)
+  //   const { module: newModule } = await this.buildDepModule(Model)
+  //   if (oldInstance && this.dependenceGraph.has(tag)) {
+  //     debug(`replace module "${String(tag)}"`);
+  //     [...this.dependenceGraph.get(tag)!].forEach((tag) => {
+  //       const module = this.moduleMap.get(tag)
+  //       for (const key in module) {
+  //         if (module[key] === oldInstance)
+  //           module[key] = newModule
+  //       }
+  //     })
+  //   }
+  // }
+  // async del(modelOrTag: Construct | PropertyKey) {
+  //   const tag = typeof modelOrTag === 'function' ? getTag(modelOrTag) : modelOrTag
+  //   if (!this.moduleMap.has(tag))
+  //     return
+  //   const module = this.moduleMap.get(tag)
+  //   debug(`unmount module "${String(tag)}"`)
+  //   await invokeUnmount(module)
+  //   debug(`del module "${String(tag)}"`)
+  //   this.moduleMap.delete(tag)
+  //   this.modelMap.delete(module)
+  //   for (let i = this.meta.length - 1; i >= 0; i--) {
+  //     if (this.meta[i].data.tag === tag)
+  //       this.meta.splice(i, 1)
+  //   }
+  //   return module
+  // }
   async destroy() {
     debug("destroy all");
-    for (const [tag] of this.moduleMap) await this.del(tag);
+    this.replace(Object.values(this.modelMap), []);
+  }
+  createProxyModule(tag) {
+    const that = this;
+    return new Proxy({}, {
+      get(_target, prop) {
+        const module = that.moduleMap.get(tag);
+        return Reflect.get(module, prop, module);
+      },
+      set(_target, prop, newValue) {
+        const module = that.moduleMap.get(tag);
+        return Reflect.set(module, prop, newValue, module);
+      },
+      has(_target, prop) {
+        return Reflect.has(that.moduleMap.get(tag), prop);
+      },
+      ownKeys() {
+        return Reflect.ownKeys(that.moduleMap.get(tag));
+      },
+      getPrototypeOf() {
+        return Reflect.getPrototypeOf(that.moduleMap.get(tag));
+      },
+      getOwnPropertyDescriptor(_target, prop) {
+        return Reflect.getOwnPropertyDescriptor(that.moduleMap.get(tag), prop);
+      }
+    });
   }
   async buildDepModule(Model) {
     const paramtypes = getParamTypes(Model);
@@ -125,7 +149,13 @@ var ServerPhecda = class {
     const tag = getTag(Model);
     if (this.moduleMap.has(tag)) {
       module = this.moduleMap.get(tag);
-      if (!module) throw new Error(`exist Circular-Dependency or Multiple modules with the same name/tag [tag] ${String(tag)}--[module] ${Model}`);
+      if (!module) {
+        log(`Exist Circular-Dependency or Multiple modules with the same tag [${String(tag)}]`, "warn");
+        return {
+          module: this.createProxyModule(tag),
+          tag
+        };
+      }
       if (this.modelMap.get(module) !== Model && !this.modelSet.has(Model)) {
         this.modelSet.add(Model);
         if (module instanceof Model) log(`Module taged ${String(tag)} has been overridden`);
@@ -161,6 +191,42 @@ var ServerPhecda = class {
       tag
     };
   }
+  async replace(oldModels, newModels) {
+    const oldModules = (await Promise.all(oldModels.map(async (model) => {
+      const tag = getTag(model);
+      if (!this.has(tag)) return;
+      const module = this.moduleMap.get(tag);
+      debug(`unmount module "${String(tag)}"`);
+      await invokeUnmount(module);
+      debug(`del module "${String(tag)}"`);
+      this.moduleMap.delete(tag);
+      this.modelMap.delete(module);
+      for (let i = this.meta.length - 1; i >= 0; i--) {
+        if (this.meta[i].data.tag === tag) this.meta.splice(i, 1);
+      }
+      return module;
+    }))).filter((item) => item);
+    for (const model of newModels) {
+      debug(`mount module: ${model.name}`);
+      await this.buildDepModule(model);
+    }
+    debug("replace old modules");
+    for (const module of oldModules) {
+      const tag = getTag(module);
+      if (this.dependenceGraph.has(tag)) {
+        [
+          ...this.dependenceGraph.get(tag)
+        ].forEach((depTag) => {
+          const depModule = this.moduleMap.get(depTag);
+          if (depModule) {
+            for (const key in depModule) {
+              if (depModule[key] === module) depModule[key] = this.moduleMap.get(tag);
+            }
+          }
+        });
+      }
+    }
+  }
   has(modelOrTag) {
     return this.moduleMap.has(typeof modelOrTag === "function" ? getTag(modelOrTag) : modelOrTag);
   }
@@ -250,7 +316,9 @@ function deepFreeze(object) {
 }
 __name(deepFreeze, "deepFreeze");
 function getParamTypes(Model, key) {
-  return Reflect.getMetadata("design:paramtypes", Model, key);
+  const paramTypes = Reflect.getMetadata("design:paramtypes", Model, key);
+  if (typeof paramTypes === "function") return paramTypes();
+  else return paramTypes;
 }
 __name(getParamTypes, "getParamTypes");
 

package/dist/{chunk-V7EI76QQ.mjs → chunk-Z7NAAE4M.mjs}

@@ -1,11 +1,13 @@
 import {
   ERROR_SYMBOL,
-  IS_HMR,
+  HMR,
+  IS_DEV,
+  IS_PURE,
   IS_STRICT,
   LOG_LEVEL,
   __name,
   log
-} from "./chunk-WHJ5FALK.mjs";
+} from "./chunk-NQ55PA2X.mjs";
 
 // src/helper.ts
 import pc2 from "picocolors";
@@ -230,10 +232,25 @@ var Context = class _Context {
   };
   static guardRecord = {};
   static addonRecord = {};
+  ctx;
+  canGetCtx;
   constructor(data) {
     this.data = data;
-    if (IS_HMR)
+    this.canGetCtx = true;
+    if (IS_DEV)
       data._context = this;
+    const that = this;
+    this.ctx = new Proxy(data, {
+      get(target, p) {
+        if (IS_DEV && !that.canGetCtx) throw new FrameworkException("ctx must be obtained within the same request cycle in controller");
+        if (!(p in target)) log(`attribute "${p}" does not exist on ctx, which might be due to a missing AOP role (such as a guard).`, "warn", data.tag);
+        return target[p];
+      },
+      set(target, p, newValue) {
+        target[p] = newValue;
+        return true;
+      }
+    });
   }
   static getAop(meta, opts) {
     const { globalGuards = [], globalFilter = "default", globalPipe = "default" } = opts;
@@ -269,14 +286,20 @@ ${pc.red(`Filter ${filter2}[${filter2 || "default"}]`)}`);
           if (index === guards.length) {
             const instance = moduleMap.get(tag);
             if (ctxs) {
-              ctxs.forEach((ctx) => instance[ctx] = this.data);
+              ctxs.forEach((ctx) => instance[ctx] = this.ctx);
             }
             const args = await Promise.all(params.map((item, i) => pipe[i]({
               arg: resolveDep(this.data[item.type], item.key),
               reflect: paramsType[item.index],
               ...item
-            }, this.data)));
+            }, this.ctx)));
+            if (IS_DEV) {
+              Promise.resolve().then(() => {
+                this.canGetCtx = false;
+              });
+            }
             res = await instance[func](...args);
+            this.canGetCtx = true;
           } else {
             let nextPromise;
             async function next() {
@@ -289,7 +312,7 @@ ${pc.red(`Filter ${filter2}[${filter2 || "default"}]`)}`);
               });
             }
             __name(next, "next");
-            const ret = await guards[index](this.data, next);
+            const ret = await guards[index](this.ctx, next);
             if (ret !== void 0) {
               res = ret;
             } else {
@@ -302,7 +325,7 @@ ${pc.red(`Filter ${filter2}[${filter2 || "default"}]`)}`);
       await nextHandler(0)();
       return successCb(res);
     } catch (e) {
-      const err = await filter(e, this.data);
+      const err = await filter(e, this.ctx);
       return failCb(err);
     }
   }
@@ -356,32 +379,12 @@ function addAddon(key, addon, priority = 0) {
 }
 __name(addAddon, "addAddon");
 
-// src/hmr.ts
-function HMR(cb) {
-  if (IS_HMR) globalThis.__PS_HMR__?.push(cb);
-}
-__name(HMR, "HMR");
-
 // src/http/helper.ts
 function resolveDep(ret, key) {
   if (key) return ret?.[key];
   return ret;
 }
 __name(resolveDep, "resolveDep");
-function argToReq(params, args, headers) {
-  const req = {
-    body: {},
-    query: {},
-    params: {},
-    headers
-  };
-  params.forEach((param) => {
-    if (param.key) req[param.type][param.key] = args[param.index];
-    else req[param.type] = args[param.index];
-  });
-  return req;
-}
-__name(argToReq, "argToReq");
 
 // src/rpc/helper.ts
 import { hostname } from "os";
@@ -423,6 +426,7 @@ function createControllerMetaMap(meta, filter) {
 }
 __name(createControllerMetaMap, "createControllerMetaMap");
 function detectAopDep(meta, { guards, addons } = {}, controller = "http") {
+  if (IS_PURE) return;
   const addonSet = /* @__PURE__ */ new Set();
   const guardSet = /* @__PURE__ */ new Set();
   const pipeSet = /* @__PURE__ */ new Set();
@@ -441,8 +445,10 @@ function detectAopDep(meta, { guards, addons } = {}, controller = "http") {
       guardSet.add(item);
     });
     meta.forEach(({ data }) => {
+      if (!data.controller) return;
+      if (typeof data.tag !== "string") warningSet.add(`Tag of controller "${data.name}" should be a string`);
       if (data.controller !== controller) {
-        if (data[controller]) warningSet.add(`Should use ${controller} controller to decorate class "${data.name}" or method "${data.func}"`);
+        if (data[controller]) warningSet.add(`Should use ${controller} controller to decorate class "${data.name}"`);
         return;
       }
       if (data.filter) filterSet.add(data.filter);
@@ -465,7 +471,10 @@ function detectAopDep(meta, { guards, addons } = {}, controller = "http") {
       ...filterSet
     ].filter((i) => !Context.filterRecord[i]);
     function exit() {
-      if (IS_STRICT) process.exit(5);
+      if (IS_STRICT) {
+        log("Does not meet strict mode requirements", "error");
+        process.exit(1);
+      }
     }
     __name(exit, "exit");
     if (missAddons.length) {
@@ -498,6 +507,14 @@ function detectAopDep(meta, { guards, addons } = {}, controller = "http") {
   };
 }
 __name(detectAopDep, "detectAopDep");
+function joinUrl(base, ...paths) {
+  const joinedPath = [
+    base,
+    ...paths
+  ].filter((p) => p).map((path) => path.replace(/(^\/)/g, "")).join("/");
+  return `/${joinedPath}`;
+}
+__name(joinUrl, "joinUrl");
 
 export {
   defaultPipe,
@@ -523,12 +540,11 @@ export {
   addFilter,
   addGuard,
   addAddon,
-  HMR,
   resolveDep,
-  argToReq,
   genClientQueue,
   shallowClone,
   mergeObject,
   createControllerMetaMap,
-  detectAopDep
+  detectAopDep,
+  joinUrl
 };

package/dist/{core-BIcUwV18.d.mts → core-CUTbX_IS.d.ts}

@@ -1,5 +1,5 @@
 import { Construct } from 'phecda-core';
-import { b as MetaData, M as Meta, E as Emitter } from './meta-BXKLFTgG.mjs';
+import { b as MetaData, M as Meta, E as Emitter } from './meta-CR-D39hQ.js';
 
 declare abstract class Generator {
     private _path;
@@ -30,13 +30,15 @@ declare class ServerPhecda {
     generators: Generator[];
     constructor(options: Options);
     start(models: Construct[]): Promise<void>;
-    add(Model: Construct): Promise<void>;
-    del(tag: PropertyKey): Promise<any>;
+    generateCode: () => Promise<void[]>;
+    hmr(): void;
     destroy(): Promise<void>;
+    createProxyModule(tag: PropertyKey): {};
     protected buildDepModule(Model: Construct): Promise<{
         module: any;
         tag: PropertyKey;
     }>;
+    replace(oldModels: Construct[], newModels: Construct[]): Promise<void>;
     has(modelOrTag: Construct | PropertyKey): boolean;
     get<Model extends Construct>(modelOrTag: Model | PropertyKey): InstanceType<Model>;
 }

package/dist/{core-CYwEPfN4.d.ts → core-DIfgUKIU.d.mts}

@@ -1,5 +1,5 @@
 import { Construct } from 'phecda-core';
-import { b as MetaData, M as Meta, E as Emitter } from './meta-BXKLFTgG.js';
+import { b as MetaData, M as Meta, E as Emitter } from './meta-CR-D39hQ.mjs';
 
 declare abstract class Generator {
     private _path;
@@ -30,13 +30,15 @@ declare class ServerPhecda {
     generators: Generator[];
     constructor(options: Options);
     start(models: Construct[]): Promise<void>;
-    add(Model: Construct): Promise<void>;
-    del(tag: PropertyKey): Promise<any>;
+    generateCode: () => Promise<void[]>;
+    hmr(): void;
     destroy(): Promise<void>;
+    createProxyModule(tag: PropertyKey): {};
     protected buildDepModule(Model: Construct): Promise<{
         module: any;
         tag: PropertyKey;
     }>;
+    replace(oldModels: Construct[], newModels: Construct[]): Promise<void>;
     has(modelOrTag: Construct | PropertyKey): boolean;
     get<Model extends Construct>(modelOrTag: Model | PropertyKey): InstanceType<Model>;
 }

package/dist/helper.d.mts

@@ -1,10 +1,11 @@
-import { C as ControllerMetaData, M as Meta, a as ControllerMeta } from './meta-BXKLFTgG.mjs';
-import 'phecda-core';
+import { M as Meta, C as ControllerMeta } from './meta-CR-D39hQ.mjs';
+import { Construct } from 'phecda-core';
 
-declare function HMR(cb: (...args: any) => any): void;
+declare function HMR(cb: (oldModels: Construct[], newModels: Construct[]) => any): void;
+declare function RELOAD(oldModels: Construct[], newModels: Construct[]): Promise<void>;
+declare function RELAUNCH(): void;
 
 declare function resolveDep(ret: any, key: string): any;
-declare function argToReq(params: ControllerMetaData['params'], args: any[], headers: Record<string, any>): any;
 
 declare function genClientQueue(key?: string): string;
 
@@ -20,6 +21,7 @@ declare function detectAopDep(meta: Meta[], { guards, addons }?: {
     guardSet: Set<string>;
     pipeSet: Set<string>;
     filterSet: Set<string>;
-};
+} | undefined;
+declare function joinUrl(base: string, ...paths: string[]): string;
 
-export { HMR, argToReq, createControllerMetaMap, detectAopDep, genClientQueue, mergeObject, resolveDep, shallowClone };
+export { HMR, RELAUNCH, RELOAD, createControllerMetaMap, detectAopDep, genClientQueue, joinUrl, mergeObject, resolveDep, shallowClone };

package/dist/helper.d.ts

@@ -1,10 +1,11 @@
-import { C as ControllerMetaData, M as Meta, a as ControllerMeta } from './meta-BXKLFTgG.js';
-import 'phecda-core';
+import { M as Meta, C as ControllerMeta } from './meta-CR-D39hQ.js';
+import { Construct } from 'phecda-core';
 
-declare function HMR(cb: (...args: any) => any): void;
+declare function HMR(cb: (oldModels: Construct[], newModels: Construct[]) => any): void;
+declare function RELOAD(oldModels: Construct[], newModels: Construct[]): Promise<void>;
+declare function RELAUNCH(): void;
 
 declare function resolveDep(ret: any, key: string): any;
-declare function argToReq(params: ControllerMetaData['params'], args: any[], headers: Record<string, any>): any;
 
 declare function genClientQueue(key?: string): string;
 
@@ -20,6 +21,7 @@ declare function detectAopDep(meta: Meta[], { guards, addons }?: {
     guardSet: Set<string>;
     pipeSet: Set<string>;
     filterSet: Set<string>;
-};
+} | undefined;
+declare function joinUrl(base: string, ...paths: string[]): string;
 
-export { HMR, argToReq, createControllerMetaMap, detectAopDep, genClientQueue, mergeObject, resolveDep, shallowClone };
+export { HMR, RELAUNCH, RELOAD, createControllerMetaMap, detectAopDep, genClientQueue, joinUrl, mergeObject, resolveDep, shallowClone };

package/dist/helper.js

@@ -6,16 +6,21 @@
 
 
 
+var _chunkG7JFKM2Mjs = require('./chunk-G7JFKM2M.js');
 
-var _chunkGSPBHZBHjs = require('./chunk-GSPBHZBH.js');
-require('./chunk-J5CFUN4V.js');
 
 
 
+var _chunk4LLLQOMFjs = require('./chunk-4LLLQOMF.js');
 
 
 
 
 
 
-exports.HMR = _chunkGSPBHZBHjs.HMR; exports.argToReq = _chunkGSPBHZBHjs.argToReq; exports.createControllerMetaMap = _chunkGSPBHZBHjs.createControllerMetaMap; exports.detectAopDep = _chunkGSPBHZBHjs.detectAopDep; exports.genClientQueue = _chunkGSPBHZBHjs.genClientQueue; exports.mergeObject = _chunkGSPBHZBHjs.mergeObject; exports.resolveDep = _chunkGSPBHZBHjs.resolveDep; exports.shallowClone = _chunkGSPBHZBHjs.shallowClone;
+
+
+
+
+
+exports.HMR = _chunk4LLLQOMFjs.HMR; exports.RELAUNCH = _chunk4LLLQOMFjs.RELAUNCH; exports.RELOAD = _chunk4LLLQOMFjs.RELOAD; exports.createControllerMetaMap = _chunkG7JFKM2Mjs.createControllerMetaMap; exports.detectAopDep = _chunkG7JFKM2Mjs.detectAopDep; exports.genClientQueue = _chunkG7JFKM2Mjs.genClientQueue; exports.joinUrl = _chunkG7JFKM2Mjs.joinUrl; exports.mergeObject = _chunkG7JFKM2Mjs.mergeObject; exports.resolveDep = _chunkG7JFKM2Mjs.resolveDep; exports.shallowClone = _chunkG7JFKM2Mjs.shallowClone;