phecda-server 6.0.2 → 6.1.0

package/dist/chunk-NL6QBQAR.js

@@ -0,0 +1,266 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
+
+
+
+
+var _chunkTVT62GIXjs = require('./chunk-TVT62GIX.js');
+
+// src/meta.ts
+var Meta = class {
+  static {
+    _chunkTVT62GIXjs.__name.call(void 0, this, "Meta");
+  }
+  
+  
+  constructor(data, paramsType) {
+    this.data = data;
+    this.paramsType = paramsType;
+  }
+};
+
+// src/core.ts
+require('reflect-metadata');
+var _events = require('events'); var _events2 = _interopRequireDefault(_events);
+var _phecdacore = require('phecda-core');
+var _debug = require('debug'); var _debug2 = _interopRequireDefault(_debug);
+var debug = _debug2.default.call(void 0, "phecda-server(createPhecda)");
+var emitter = new (0, _events2.default)();
+function defaultServerInject() {
+  if (!_phecdacore.getInject.call(void 0, "watcher")) {
+    _phecdacore.setInject.call(void 0, "watcher", ({ eventName, instance, property, options }) => {
+      const fn = typeof instance[property] === "function" ? instance[property].bind(instance) : (v) => instance[property] = v;
+      if (_optionalChain([options, 'optionalAccess', _ => _.once])) emitter.once(eventName, fn);
+      else emitter.on(eventName, fn);
+      return () => {
+        emitter.off(eventName, fn);
+      };
+    });
+  }
+}
+_chunkTVT62GIXjs.__name.call(void 0, defaultServerInject, "defaultServerInject");
+var phecdaNamespace = /* @__PURE__ */ new Map();
+var ServerPhecda = (_class = class {
+  static {
+    _chunkTVT62GIXjs.__name.call(void 0, this, "ServerPhecda");
+  }
+  __init() {this.moduleMap = /* @__PURE__ */ new Map()}
+  __init2() {this.meta = []}
+  __init3() {this.modelMap = /* @__PURE__ */ new WeakMap()}
+  __init4() {this.modelSet = /* @__PURE__ */ new WeakSet()}
+  __init5() {this.dependenceGraph = /* @__PURE__ */ new Map()}
+  
+  
+  
+  constructor(options) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);
+    defaultServerInject();
+    const { namespace = "default", parseModule = /* @__PURE__ */ _chunkTVT62GIXjs.__name.call(void 0, (module) => module, "parseModule"), parseMeta = /* @__PURE__ */ _chunkTVT62GIXjs.__name.call(void 0, (meta) => meta, "parseMeta"), generators = [] } = options;
+    phecdaNamespace.set(namespace, this);
+    this.parseMeta = parseMeta;
+    this.parseModule = parseModule;
+    this.generators = generators;
+  }
+  async start(models) {
+    for (const model of models) await this.buildDepModule(model);
+    const generateCode = /* @__PURE__ */ _chunkTVT62GIXjs.__name.call(void 0, async () => {
+      if (_chunkTVT62GIXjs.IS_HMR) {
+        return Promise.all(this.generators.map((generator) => {
+          debug(`generate "${generator.name}" code to ${generator.path}`);
+          return generator.output(this.meta);
+        }));
+      }
+    }, "generateCode");
+    generateCode().then(() => {
+      if (_chunkTVT62GIXjs.IS_ONLY_GENERATE) process.exit(4);
+    });
+    if (_chunkTVT62GIXjs.IS_HMR) {
+      if (!globalThis.__PS_HMR__) globalThis.__PS_HMR__ = [];
+      _optionalChain([globalThis, 'access', _2 => _2.__PS_HMR__, 'optionalAccess', _3 => _3.push, 'call', _4 => _4(async (files) => {
+        debug("reload files ");
+        for (const file of files) {
+          const models2 = await Promise.resolve().then(() => _interopRequireWildcard(require(file)));
+          for (const i in models2) {
+            if (_phecdacore.isPhecda.call(void 0, models2[i])) await this.add(models2[i]);
+          }
+        }
+        generateCode();
+      })]);
+    }
+  }
+  async add(Model) {
+    const tag = _phecdacore.getTag.call(void 0, 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 _phecdacore.invokeUnmount.call(void 0, 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);
+  }
+  async buildDepModule(Model) {
+    const paramtypes = getParamTypes(Model);
+    let module;
+    const tag = _phecdacore.getTag.call(void 0, 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 (this.modelMap.get(module) !== Model && !this.modelSet.has(Model)) {
+        this.modelSet.add(Model);
+        if (module instanceof Model) _chunkTVT62GIXjs.log.call(void 0, `Module taged ${String(tag)} has been overridden`);
+        else _chunkTVT62GIXjs.log.call(void 0, `Synonym module: Module taged "${String(tag)}" has been loaded before, so phecda-server won't load Module "${Model.name}"`, "warn");
+      }
+      return {
+        module,
+        tag
+      };
+    }
+    this.moduleMap.set(tag, void 0);
+    debug(`instantiate module "${String(tag)}"`);
+    if (paramtypes) {
+      const paramtypesInstances = [];
+      for (const i in paramtypes) {
+        const { module: sub, tag: subTag } = await this.buildDepModule(paramtypes[i]);
+        paramtypesInstances[i] = sub;
+        if (!this.dependenceGraph.has(subTag)) this.dependenceGraph.set(subTag, /* @__PURE__ */ new Set());
+        this.dependenceGraph.get(subTag).add(tag);
+      }
+      module = this.parseModule(new Model(...paramtypesInstances));
+    } else {
+      module = this.parseModule(new Model());
+    }
+    this.meta.push(...getMetaFromInstance(module, tag, Model.name).map(this.parseMeta).filter((item) => !!item));
+    debug(`init module "${String(tag)}"`);
+    if (!_chunkTVT62GIXjs.IS_ONLY_GENERATE) await _phecdacore.invokeInit.call(void 0, module);
+    debug(`add module "${String(tag)}"`);
+    this.moduleMap.set(tag, module);
+    this.modelMap.set(module, Model);
+    return {
+      module,
+      tag
+    };
+  }
+  has(modelOrTag) {
+    return this.moduleMap.has(typeof modelOrTag === "function" ? _phecdacore.getTag.call(void 0, modelOrTag) : modelOrTag);
+  }
+  get(modelOrTag) {
+    const tag = typeof modelOrTag === "function" ? _phecdacore.getTag.call(void 0, modelOrTag) : modelOrTag;
+    if (!this.has(tag)) throw new Error(`module "${tag.toString()}" doesn't exist`);
+    return this.moduleMap.get(tag);
+  }
+}, _class);
+async function Factory(models, opts = {}) {
+  const phecda = new ServerPhecda(opts);
+  await phecda.start(models);
+  return phecda;
+}
+_chunkTVT62GIXjs.__name.call(void 0, Factory, "Factory");
+function useS(nsOrModel, namespace) {
+  if (!nsOrModel) {
+    namespace = "default";
+  } else {
+    if (typeof nsOrModel === "string") namespace = nsOrModel;
+    else if (!namespace) namespace = "default";
+  }
+  if (!phecdaNamespace.has(namespace)) throw new Error(`namespace "${namespace}" doesn't exist`);
+  const serverPhecda = phecdaNamespace.get(namespace);
+  if (nsOrModel && typeof nsOrModel !== "string") return serverPhecda.get(nsOrModel);
+  else return serverPhecda;
+}
+_chunkTVT62GIXjs.__name.call(void 0, useS, "useS");
+function getMetaFromInstance(instance, tag, name) {
+  const propertyKeys = _phecdacore.getMetaKey.call(void 0, instance).filter((item) => typeof item === "string");
+  const baseMeta = _phecdacore.getMergedMeta.call(void 0, instance, void 0);
+  const ctxs = baseMeta.ctxs;
+  return propertyKeys.filter((i) => typeof instance[i] === "function").map((i) => {
+    const meta = _phecdacore.getMergedMeta.call(void 0, instance, i);
+    const metaData = {
+      ...meta,
+      name,
+      tag,
+      func: i
+    };
+    if (baseMeta.controller) {
+      if (typeof tag !== "string") _chunkTVT62GIXjs.log.call(void 0, `can't use Tag with ${typeof tag} on controller "${instance.constructor.name}",instead with "${tag = String(tag)}"`, "error");
+      metaData.controller = baseMeta.controller;
+      metaData[baseMeta.controller] = {
+        ...baseMeta[baseMeta.controller],
+        ...meta[baseMeta.controller]
+      };
+      const params = _phecdacore.getMetaParams.call(void 0, instance, i).map((item) => _phecdacore.getMergedMeta.call(void 0, instance, i, item));
+      params.forEach((item, index) => {
+        if (!item.pipe) item.pipe = meta.pipe || baseMeta.pipe;
+        if (!item.define) item.define = {};
+        item.index = index;
+      });
+      metaData.ctxs = ctxs;
+      metaData.params = params;
+      metaData.filter = meta.filter || baseMeta.filter;
+      metaData.define = {
+        ...baseMeta.define,
+        ...meta.define
+      };
+      for (const item of [
+        "plugins",
+        "guards",
+        "interceptors"
+      ]) {
+        const set = new Set(baseMeta[item]);
+        if (meta[item]) {
+          meta[item].forEach((part) => {
+            set.delete(part);
+            set.add(part);
+          });
+        }
+        metaData[item] = [
+          ...set
+        ];
+      }
+    }
+    return new Meta(deepFreeze(metaData), getParamTypes(instance, i) || []);
+  });
+}
+_chunkTVT62GIXjs.__name.call(void 0, getMetaFromInstance, "getMetaFromInstance");
+function deepFreeze(object) {
+  Object.freeze(object);
+  Object.getOwnPropertyNames(object).forEach((prop) => {
+    if (object[prop] !== null && (typeof object[prop] === "object" || typeof object[prop] === "function") && !Object.isFrozen(object[prop])) deepFreeze(object[prop]);
+  });
+  return object;
+}
+_chunkTVT62GIXjs.__name.call(void 0, deepFreeze, "deepFreeze");
+function getParamTypes(Model, key) {
+  return Reflect.getMetadata("design:paramtypes", Model, key);
+}
+_chunkTVT62GIXjs.__name.call(void 0, getParamTypes, "getParamTypes");
+
+
+
+
+
+
+
+
+
+exports.Meta = Meta; exports.emitter = emitter; exports.defaultServerInject = defaultServerInject; exports.phecdaNamespace = phecdaNamespace; exports.ServerPhecda = ServerPhecda; exports.Factory = Factory; exports.useS = useS;

package/dist/{chunk-GHFSIZUO.js → chunk-TVT62GIX.js}

@@ -17,13 +17,19 @@ var PS_EXIT_CODE;
 var _picocolors = require('picocolors'); var _picocolors2 = _interopRequireDefault(_picocolors);
 var _tsmixer = require('ts-mixer');
 var time;
-var internalLogger = console;
+var internalLogger;
 function setLogger(logger) {
   internalLogger = logger;
 }
 __name(setLogger, "setLogger");
+function getLogger() {
+  return internalLogger;
+}
+__name(getLogger, "getLogger");
 function log(msg, level = "log") {
+  if (internalLogger) internalLogger[level](msg);
   const logLevel = {
+    debug: -1,
     info: 0,
     log: 1,
     warn: 2,
@@ -31,6 +37,7 @@ function log(msg, level = "log") {
   }[level];
   if (logLevel < LOG_LEVEL) return;
   const color = {
+    debug: "bgMagenta",
     error: "red",
     info: "gray",
     warn: "yellow",
@@ -40,7 +47,7 @@ function log(msg, level = "log") {
   const current = Date.now();
   const interval = time && current - time ? `+${current - time}` : "";
   time = current;
-  internalLogger[level](`${_picocolors2.default.magenta("[phecda-server]")} ${_picocolors2.default.gray(`${date.getHours()}:${date.getMinutes()}:${date.getSeconds()}`)} ${_picocolors2.default[color](msg)} ${_picocolors2.default.gray(interval)}`);
+  console[level](`${_picocolors2.default.magenta("[phecda-server]")} ${_picocolors2.default.gray(`${date.getHours()}:${date.getMinutes()}:${date.getSeconds()}`)} ${_picocolors2.default[color](msg)} ${_picocolors2.default.gray(interval)}`);
 }
 __name(log, "log");
 
@@ -55,4 +62,5 @@ __name(log, "log");
 
 
 
-exports.__name = __name; exports.ERROR_SYMBOL = ERROR_SYMBOL; exports.IS_HMR = IS_HMR; exports.IS_ONLY_GENERATE = IS_ONLY_GENERATE; exports.IS_STRICT = IS_STRICT; exports.LOG_LEVEL = LOG_LEVEL; exports.PS_EXIT_CODE = PS_EXIT_CODE; exports.setLogger = setLogger; exports.log = log; exports.Mixin = _tsmixer.Mixin;
+
+exports.__name = __name; exports.ERROR_SYMBOL = ERROR_SYMBOL; exports.IS_HMR = IS_HMR; exports.IS_ONLY_GENERATE = IS_ONLY_GENERATE; exports.IS_STRICT = IS_STRICT; exports.LOG_LEVEL = LOG_LEVEL; exports.PS_EXIT_CODE = PS_EXIT_CODE; exports.setLogger = setLogger; exports.getLogger = getLogger; exports.log = log; exports.Mixin = _tsmixer.Mixin;

package/dist/core-BlN0Spy9.d.ts

@@ -0,0 +1,47 @@
+import { Construct } from 'phecda-core';
+import { b as MetaData, M as Meta, E as Emitter } from './meta-KtfiBIde.js';
+
+declare abstract class Generator {
+    private _path;
+    constructor(path?: string);
+    abstract name: string;
+    get path(): string;
+    abstract generateCode(meta: MetaData[]): string;
+    output(meta: Meta[]): Promise<void>;
+}
+
+declare const emitter: Emitter;
+interface Options {
+    parseModule?: (module: any) => any;
+    parseMeta?: (meta: Meta) => Meta | null | undefined;
+    generators?: Generator[];
+    namespace?: string;
+}
+declare function defaultServerInject(): void;
+declare const phecdaNamespace: Map<string, ServerPhecda>;
+declare class ServerPhecda {
+    moduleMap: Map<PropertyKey, any>;
+    meta: Meta[];
+    modelMap: WeakMap<any, Construct>;
+    modelSet: WeakSet<Construct>;
+    dependenceGraph: Map<PropertyKey, Set<PropertyKey>>;
+    parseModule: (module: any) => any;
+    parseMeta: (meta: Meta) => Meta | null | undefined;
+    generators: Generator[];
+    constructor(options: Options);
+    start(models: Construct[]): Promise<void>;
+    add(Model: Construct): Promise<void>;
+    del(tag: PropertyKey): Promise<any>;
+    destroy(): Promise<void>;
+    protected buildDepModule(Model: Construct): Promise<{
+        module: any;
+        tag: PropertyKey;
+    }>;
+    has(modelOrTag: Construct | PropertyKey): boolean;
+    get<Model extends Construct>(modelOrTag: Model | PropertyKey): InstanceType<Model>;
+}
+declare function Factory(models: Construct[], opts?: Options): Promise<ServerPhecda>;
+declare function useS<Model extends Construct>(model: Model, namespace?: string): InstanceType<Model>;
+declare function useS(namespace?: string): ServerPhecda;
+
+export { Factory as F, Generator as G, type Options as O, ServerPhecda as S, defaultServerInject as d, emitter as e, phecdaNamespace as p, useS as u };

package/dist/core-P1CsH6jz.d.mts

@@ -0,0 +1,47 @@
+import { Construct } from 'phecda-core';
+import { b as MetaData, M as Meta, E as Emitter } from './meta-KtfiBIde.mjs';
+
+declare abstract class Generator {
+    private _path;
+    constructor(path?: string);
+    abstract name: string;
+    get path(): string;
+    abstract generateCode(meta: MetaData[]): string;
+    output(meta: Meta[]): Promise<void>;
+}
+
+declare const emitter: Emitter;
+interface Options {
+    parseModule?: (module: any) => any;
+    parseMeta?: (meta: Meta) => Meta | null | undefined;
+    generators?: Generator[];
+    namespace?: string;
+}
+declare function defaultServerInject(): void;
+declare const phecdaNamespace: Map<string, ServerPhecda>;
+declare class ServerPhecda {
+    moduleMap: Map<PropertyKey, any>;
+    meta: Meta[];
+    modelMap: WeakMap<any, Construct>;
+    modelSet: WeakSet<Construct>;
+    dependenceGraph: Map<PropertyKey, Set<PropertyKey>>;
+    parseModule: (module: any) => any;
+    parseMeta: (meta: Meta) => Meta | null | undefined;
+    generators: Generator[];
+    constructor(options: Options);
+    start(models: Construct[]): Promise<void>;
+    add(Model: Construct): Promise<void>;
+    del(tag: PropertyKey): Promise<any>;
+    destroy(): Promise<void>;
+    protected buildDepModule(Model: Construct): Promise<{
+        module: any;
+        tag: PropertyKey;
+    }>;
+    has(modelOrTag: Construct | PropertyKey): boolean;
+    get<Model extends Construct>(modelOrTag: Model | PropertyKey): InstanceType<Model>;
+}
+declare function Factory(models: Construct[], opts?: Options): Promise<ServerPhecda>;
+declare function useS<Model extends Construct>(model: Model, namespace?: string): InstanceType<Model>;
+declare function useS(namespace?: string): ServerPhecda;
+
+export { Factory as F, Generator as G, type Options as O, ServerPhecda as S, defaultServerInject as d, emitter as e, phecdaNamespace as p, useS as u };

package/dist/helper.js

@@ -7,8 +7,8 @@
 
 
 
-var _chunk7SYPUIBYjs = require('./chunk-7SYPUIBY.js');
-require('./chunk-GHFSIZUO.js');
+var _chunkDVTBLV6Ijs = require('./chunk-DVTBLV6I.js');
+require('./chunk-TVT62GIX.js');
 
 
 
@@ -18,4 +18,4 @@ require('./chunk-GHFSIZUO.js');
 
 
 
-exports.HMR = _chunk7SYPUIBYjs.HMR; exports.argToReq = _chunk7SYPUIBYjs.argToReq; exports.createControllerMetaMap = _chunk7SYPUIBYjs.createControllerMetaMap; exports.detectAopDep = _chunk7SYPUIBYjs.detectAopDep; exports.genClientQueue = _chunk7SYPUIBYjs.genClientQueue; exports.mergeObject = _chunk7SYPUIBYjs.mergeObject; exports.resolveDep = _chunk7SYPUIBYjs.resolveDep; exports.shallowClone = _chunk7SYPUIBYjs.shallowClone;
+exports.HMR = _chunkDVTBLV6Ijs.HMR; exports.argToReq = _chunkDVTBLV6Ijs.argToReq; exports.createControllerMetaMap = _chunkDVTBLV6Ijs.createControllerMetaMap; exports.detectAopDep = _chunkDVTBLV6Ijs.detectAopDep; exports.genClientQueue = _chunkDVTBLV6Ijs.genClientQueue; exports.mergeObject = _chunkDVTBLV6Ijs.mergeObject; exports.resolveDep = _chunkDVTBLV6Ijs.resolveDep; exports.shallowClone = _chunkDVTBLV6Ijs.shallowClone;

package/dist/helper.mjs

@@ -7,8 +7,8 @@ import {
   mergeObject,
   resolveDep,
   shallowClone
-} from "./chunk-WXFZZZRY.mjs";
-import "./chunk-UXD62LGG.mjs";
+} from "./chunk-2CFYUXPM.mjs";
+import "./chunk-G7TD2VB7.mjs";
 export {
   HMR,
   argToReq,

package/dist/index.d.mts

@@ -1,7 +1,7 @@
 import { B as BaseContext, D as DefaultOptions, C as ControllerMetaData, b as MetaData, E as Emitter, c as BaseError } from './meta-KtfiBIde.mjs';
 export { g as BaseRequestType, f as BaseReturn, a as ControllerMeta, h as CustomResponse, j as ERROR_SYMBOL, i as ExtractResponse, I as IS_HMR, k as IS_ONLY_GENERATE, l as IS_STRICT, L as LOG_LEVEL, M as Meta, O as OmitFunction, m as PS_EXIT_CODE, P as PickFunc, S as ServiceMetaData, e as ToClientFn, d as ToClientInstance, T as ToClientMap } from './meta-KtfiBIde.mjs';
-import { G as Generator } from './core-2SNw8m2B.mjs';
-export { F as Factory, O as Options, c as createPhecda, e as emitter, i as isObject } from './core-2SNw8m2B.mjs';
+import { G as Generator } from './core-P1CsH6jz.mjs';
+export { F as Factory, O as Options, S as ServerPhecda, d as defaultServerInject, e as emitter, p as phecdaNamespace, u as useS } from './core-P1CsH6jz.mjs';
 import { Base } from 'phecda-core';
 export * from 'phecda-core';
 import { H as HttpContext } from './types-BvD3B5Ny.mjs';
@@ -221,7 +221,7 @@ declare abstract class PPipe<C extends BaseContext = any> extends ServerBase {
 declare abstract class PPlugin extends ServerBase {
     readonly key: PropertyKey;
     constructor(tag?: string);
-    abstract use<Plugin = any>(framework: string): Plugin;
+    abstract use<Plugin = any>(framework: string): Plugin | undefined;
 }
 
 interface PExtension<C extends BaseContext = any, E extends Exception = Exception> {
@@ -243,8 +243,9 @@ declare class PExtension extends ServerBase {
     constructor(tag?: string);
 }
 
-type LogLevel = 'error' | 'info' | 'warn' | 'log';
+type LogLevel = 'error' | 'info' | 'warn' | 'log' | 'debug';
 declare function setLogger(logger: Record<LogLevel, (msg: string) => void>): void;
+declare function getLogger(): Record<LogLevel, (msg: string) => void>;
 declare function log(msg: string, level?: LogLevel): void;
 
-export { Arg, BadGatewayException, BadRequestException, BaseContext, BaseError, BaseParam, Body, ConflictException, Context, Controller, ControllerMetaData, Ctx, DefaultOptions, Define, Delete, Emitter, Exception, Filter, type FilterType, ForbiddenException, FrameworkException, Generator, Get, Guard, type GuardType, HTTPGenerator, Head, Header, HttpBase, HttpContext, Interceptor, type InterceptorType, InvalidInputException, MetaData, NotFoundException, PExtension, PFilter, PGuard, PInterceptor, PPipe, PPlugin, Param, Patch, PayloadLargeException, Pipe, type PipeArg, type PipeType, Plugin, Post, Put, Query, Queue, RPCGenerator, Route, Rpc, RpcBase, RpcContext, Search, ServerBase, ServiceUnavailableException, TimeoutException, TimerException, UnauthorizedException, UndefinedException, UnsupportedMediaTypeException, ValidateException, WorkerException, addFilter, addGuard, addInterceptor, addPipe, addPlugin, defaultPipe, log, setLogger };
+export { Arg, BadGatewayException, BadRequestException, BaseContext, BaseError, BaseParam, Body, ConflictException, Context, Controller, ControllerMetaData, Ctx, DefaultOptions, Define, Delete, Emitter, Exception, Filter, type FilterType, ForbiddenException, FrameworkException, Generator, Get, Guard, type GuardType, HTTPGenerator, Head, Header, HttpBase, HttpContext, Interceptor, type InterceptorType, InvalidInputException, MetaData, NotFoundException, PExtension, PFilter, PGuard, PInterceptor, PPipe, PPlugin, Param, Patch, PayloadLargeException, Pipe, type PipeArg, type PipeType, Plugin, Post, Put, Query, Queue, RPCGenerator, Route, Rpc, RpcBase, RpcContext, Search, ServerBase, ServiceUnavailableException, TimeoutException, TimerException, UnauthorizedException, UndefinedException, UnsupportedMediaTypeException, ValidateException, WorkerException, addFilter, addGuard, addInterceptor, addPipe, addPlugin, defaultPipe, getLogger, log, setLogger };

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { B as BaseContext, D as DefaultOptions, C as ControllerMetaData, b as MetaData, E as Emitter, c as BaseError } from './meta-KtfiBIde.js';
 export { g as BaseRequestType, f as BaseReturn, a as ControllerMeta, h as CustomResponse, j as ERROR_SYMBOL, i as ExtractResponse, I as IS_HMR, k as IS_ONLY_GENERATE, l as IS_STRICT, L as LOG_LEVEL, M as Meta, O as OmitFunction, m as PS_EXIT_CODE, P as PickFunc, S as ServiceMetaData, e as ToClientFn, d as ToClientInstance, T as ToClientMap } from './meta-KtfiBIde.js';
-import { G as Generator } from './core-BmJJLUqj.js';
-export { F as Factory, O as Options, c as createPhecda, e as emitter, i as isObject } from './core-BmJJLUqj.js';
+import { G as Generator } from './core-BlN0Spy9.js';
+export { F as Factory, O as Options, S as ServerPhecda, d as defaultServerInject, e as emitter, p as phecdaNamespace, u as useS } from './core-BlN0Spy9.js';
 import { Base } from 'phecda-core';
 export * from 'phecda-core';
 import { H as HttpContext } from './types-DIw7B6Up.js';
@@ -221,7 +221,7 @@ declare abstract class PPipe<C extends BaseContext = any> extends ServerBase {
 declare abstract class PPlugin extends ServerBase {
     readonly key: PropertyKey;
     constructor(tag?: string);
-    abstract use<Plugin = any>(framework: string): Plugin;
+    abstract use<Plugin = any>(framework: string): Plugin | undefined;
 }
 
 interface PExtension<C extends BaseContext = any, E extends Exception = Exception> {
@@ -243,8 +243,9 @@ declare class PExtension extends ServerBase {
     constructor(tag?: string);
 }
 
-type LogLevel = 'error' | 'info' | 'warn' | 'log';
+type LogLevel = 'error' | 'info' | 'warn' | 'log' | 'debug';
 declare function setLogger(logger: Record<LogLevel, (msg: string) => void>): void;
+declare function getLogger(): Record<LogLevel, (msg: string) => void>;
 declare function log(msg: string, level?: LogLevel): void;
 
-export { Arg, BadGatewayException, BadRequestException, BaseContext, BaseError, BaseParam, Body, ConflictException, Context, Controller, ControllerMetaData, Ctx, DefaultOptions, Define, Delete, Emitter, Exception, Filter, type FilterType, ForbiddenException, FrameworkException, Generator, Get, Guard, type GuardType, HTTPGenerator, Head, Header, HttpBase, HttpContext, Interceptor, type InterceptorType, InvalidInputException, MetaData, NotFoundException, PExtension, PFilter, PGuard, PInterceptor, PPipe, PPlugin, Param, Patch, PayloadLargeException, Pipe, type PipeArg, type PipeType, Plugin, Post, Put, Query, Queue, RPCGenerator, Route, Rpc, RpcBase, RpcContext, Search, ServerBase, ServiceUnavailableException, TimeoutException, TimerException, UnauthorizedException, UndefinedException, UnsupportedMediaTypeException, ValidateException, WorkerException, addFilter, addGuard, addInterceptor, addPipe, addPlugin, defaultPipe, log, setLogger };
+export { Arg, BadGatewayException, BadRequestException, BaseContext, BaseError, BaseParam, Body, ConflictException, Context, Controller, ControllerMetaData, Ctx, DefaultOptions, Define, Delete, Emitter, Exception, Filter, type FilterType, ForbiddenException, FrameworkException, Generator, Get, Guard, type GuardType, HTTPGenerator, Head, Header, HttpBase, HttpContext, Interceptor, type InterceptorType, InvalidInputException, MetaData, NotFoundException, PExtension, PFilter, PGuard, PInterceptor, PPipe, PPlugin, Param, Patch, PayloadLargeException, Pipe, type PipeArg, type PipeType, Plugin, Post, Put, Query, Queue, RPCGenerator, Route, Rpc, RpcBase, RpcContext, Search, ServerBase, ServiceUnavailableException, TimeoutException, TimerException, UnauthorizedException, UndefinedException, UnsupportedMediaTypeException, ValidateException, WorkerException, addFilter, addGuard, addInterceptor, addPipe, addPlugin, defaultPipe, getLogger, log, setLogger };