phecda-server 1.5.0 → 2.0.0

package/dist/index.d.ts

@@ -1,9 +1,26 @@
-import { RequestHandler, Express } from 'express';
-import { H as HttpException, M as Meta, P, S as ServerCtx, a as ServerMergeCtx, b as ServerFilter, c as MQFilter, E as Emitter } from './axios-646333e3.js';
-export { $ as $S, f as Base, B as BaseError, C as Construct, d as MergeType, e as MqCtx, g as RequestMethod, R as RequestType, j as createParallelReq, h as createReq, i as createSeriesReq, k as isError, m as merge, t as toReq } from './axios-646333e3.js';
+import { Request, Response, RequestHandler, Express } from 'express';
+import { Events } from 'phecda-core';
 export * from 'phecda-core';
-import amqplib from 'amqplib';
-import 'axios';
+
+declare class Meta {
+    data: P.Meta;
+    handlers: P.Handler[];
+    reflect: any[];
+    constructor(data: P.Meta, handlers: P.Handler[], reflect: any[]);
+}
+
+declare class HttpException extends Error {
+    message: string;
+    status: number;
+    description: string;
+    constructor(message: string, status: number, description?: string);
+    get data(): {
+        message: string;
+        description: string;
+        status: number;
+        error: boolean;
+    };
+}
 
 declare class UndefinedException extends HttpException {
     constructor(message: string);
@@ -61,6 +78,80 @@ declare class FrameworkException extends HttpException {
     constructor(message: string);
 }
 
+type Construct<T = any> = new (...args: any[]) => T;
+interface Emitter {
+    on<N extends keyof Events>(eventName: N, cb: (args: Events[N]) => void): void;
+    once<N extends keyof Events>(eventName: N, cb: (args: Events[N]) => void): void;
+    off<N extends keyof Events>(eventName: N, cb: (args: Events[N]) => void): void;
+    removeAllListeners<N extends keyof Events>(eventName: N): void;
+    emit<N extends keyof Events>(eventName: N, param: Events[N]): void;
+}
+type RequestType = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'options' | 'head';
+type MergeType = <R extends Promise<any>[]>(...args: R) => {
+    [K in keyof R]: Awaited<R[K]>;
+};
+interface ServerMergeCtx {
+    request: Request;
+    response: Response;
+    meta: Record<string, Meta>;
+    isMerge: true;
+    tags?: string[];
+}
+interface ServerCtx {
+    request: Request;
+    response: Response;
+    meta: Meta;
+}
+interface BaseError {
+    error: true;
+    status: number;
+}
+type ServerFilter<E extends HttpException = any> = (err: E | Error, contextData: ServerMergeCtx | ServerCtx) => any;
+declare class Base {
+    context: ServerMergeCtx | ServerCtx;
+}
+declare namespace P {
+    interface Error extends BaseError {
+        message: string;
+        description: string;
+    }
+    type ResOrErr<R> = {
+        [K in keyof R]: Awaited<R[K]> | Error;
+    };
+    type Res<T> = T;
+    type Guard = ((contextData: ServerCtx, isMerge?: false) => Promise<boolean> | boolean) | ((contextData: ServerMergeCtx, isMerge?: true) => Promise<boolean> | boolean);
+    type Interceptor = ((contextData: ServerCtx, isMerge?: false) => any) | ((contextData: ServerMergeCtx, isMerge?: true) => any);
+    interface Handler {
+        error?: (arg: any) => void;
+    }
+    interface Meta {
+        route?: {
+            type: RequestType;
+            route: string;
+        };
+        define?: any;
+        header: Record<string, string>;
+        params: {
+            type: string;
+            index: number;
+            key: string;
+            validate?: boolean;
+        }[];
+        guards: string[];
+        interceptors: string[];
+        middlewares: string[];
+        method: string;
+        name: string;
+        tag: string;
+    }
+    interface Pipe {
+        transform(args: {
+            arg: any;
+            validate?: boolean;
+        }[], reflect: any[]): Promise<any[]>;
+    }
+}
+
 declare class Phistroy {
     guard: string[];
     interceptor: string[];
@@ -117,32 +208,6 @@ declare function addMiddleware(key: string, handler: RequestHandler): void;
 declare function useServerPipe(pipe: P.Pipe): void;
 declare function useServerFilter(filter: ServerFilter): void;
 
-declare class RabbitMqContext extends Context {
-    static pipe: P.Pipe;
-    static filter: MQFilter<any>;
-    static middlewareRecord: Record<string, (...params: any) => boolean>;
-    static useMiddleware(middlewares: string[]): ((...params: any) => boolean)[];
-    usePipe(args: {
-        arg: any;
-        validate?: boolean;
-    }[], reflect: any[]): Promise<any[]>;
-    static useFilter(arg: any, data: MQFilter): any;
-    useFilter(arg: any): any;
-}
-declare function useMqPipe(pipe: P.Pipe): void;
-declare function useMqFilter(filter: MQFilter): void;
-
-declare class Compiler {
-    classMap: Record<string, {
-        [key: string]: string;
-    }>;
-    name: string;
-    constructor();
-    getContent(): string;
-    createRequest(): string;
-    addMethod(args: P.Meta): void;
-}
-
 declare const emitter: Emitter;
 declare function Factory(Modules: (new (...args: any) => any)[]): Promise<{
     moduleMap: Map<string, any>;
@@ -173,18 +238,19 @@ declare function Guard(...guards: string[]): any;
 declare function Middle(...middlewares: string[]): any;
 declare function Interceptor(...interceptors: string[]): any;
 
-declare function MQ(queue: string, routeKey: string, options?: amqplib.Options.Consume): (target: any, k: PropertyKey) => void;
-
 declare function Inject(_target: any): void;
 declare function Header(name: string, value: string): (target: any, k: PropertyKey) => void;
-declare function Define(key: string, value: any): (target: any, k: PropertyKey) => void;
+declare function Define(key: string, value: any): (target: any, k?: PropertyKey) => void;
 
 declare const defaultPipe: P.Pipe;
 
-declare function bindMQ(ch: amqplib.Channel, { meta, moduleMap }: Awaited<ReturnType<typeof Factory>>): Promise<void>;
-type MqMethod<T> = (arg: T) => void;
-declare function createPub<T extends (...args: any[]) => any>(ch: amqplib.Channel, method: T, type?: string): Promise<MqMethod<Parameters<T>>>;
+declare const isUndefined: (obj: any) => obj is undefined;
+declare const isNil: (obj: any) => obj is null | undefined;
+declare const isObject: (fn: any) => fn is object;
+declare function resolveDep(ret: any, key: string): any;
+declare function isMerge(data: ServerCtx | ServerMergeCtx): data is ServerMergeCtx;
 
-declare function createMqReq(channel: amqplib.Channel): <R>(arg: R) => Promise<void>;
+declare const SERIES_SYMBOL = "__symbol_series__";
+declare const MERGE_SYMBOL = "__symbol_req__";
 
-export { BadGatewayException, BadRequestException, BaseParam, Body, Compiler, ConflictException, Context, Controller, Define, Delete, Emitter, Factory, ForbiddenException, FrameworkException, Get, Guard, Header, HttpException, Inject, Interceptor, InvalidInputException, MQ, MQFilter, Meta, Middle, NotFoundException, Options, P, Param, PayloadLargeException, Post, Put, Query, RabbitMqContext, Route, ServerContext, ServerCtx, ServerFilter, ServerMergeCtx, ServiceUnavailableException, TimeoutException, UnauthorizedException, UndefinedException, UnsupportedMediaTypeException, ValidateException, addGuard, addInterceptor, addMiddleware, bindApp, bindMQ, createMqReq, createPub, defaultPipe, emitter, getInstance, parseMeta, useMqFilter, useMqPipe, useServerFilter, useServerPipe };
+export { BadGatewayException, BadRequestException, Base, BaseError, BaseParam, Body, ConflictException, Construct, Context, Controller, Define, Delete, Emitter, Factory, ForbiddenException, FrameworkException, Get, Guard, Header, HttpException, Inject, Interceptor, InvalidInputException, MERGE_SYMBOL, MergeType, Meta, Middle, NotFoundException, Options, P, Param, PayloadLargeException, Post, Put, Query, RequestType, Route, SERIES_SYMBOL, ServerContext, ServerCtx, ServerFilter, ServerMergeCtx, ServiceUnavailableException, TimeoutException, UnauthorizedException, UndefinedException, UnsupportedMediaTypeException, ValidateException, addGuard, addInterceptor, addMiddleware, bindApp, defaultPipe, emitter, getInstance, isMerge, isNil, isObject, isUndefined, parseMeta, resolveDep, useServerFilter, useServerPipe };

package/dist/index.js

@@ -33,13 +33,11 @@ var __publicField = (obj, key, value) => {
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  $S: () => $S,
   BadGatewayException: () => BadGatewayException,
   BadRequestException: () => BadRequestException,
   Base: () => Base,
   BaseParam: () => BaseParam,
   Body: () => Body,
-  Compiler: () => Compiler,
   ConflictException: () => ConflictException,
   Context: () => Context,
   Controller: () => Controller,
@@ -55,7 +53,7 @@ __export(src_exports, {
   Inject: () => Inject,
   Interceptor: () => Interceptor,
   InvalidInputException: () => InvalidInputException,
-  MQ: () => MQ,
+  MERGE_SYMBOL: () => MERGE_SYMBOL,
   Meta: () => Meta,
   Middle: () => Middle,
   NotFoundException: () => NotFoundException,
@@ -64,8 +62,8 @@ __export(src_exports, {
   Post: () => Post,
   Put: () => Put,
   Query: () => Query,
-  RabbitMqContext: () => RabbitMqContext,
   Route: () => Route,
+  SERIES_SYMBOL: () => SERIES_SYMBOL,
   ServerContext: () => ServerContext,
   ServiceUnavailableException: () => ServiceUnavailableException,
   TimeoutException: () => TimeoutException,
@@ -77,21 +75,15 @@ __export(src_exports, {
   addInterceptor: () => addInterceptor,
   addMiddleware: () => addMiddleware,
   bindApp: () => bindApp,
-  bindMQ: () => bindMQ,
-  createMqReq: () => createMqReq,
-  createParallelReq: () => createParallelReq,
-  createPub: () => createPub,
-  createReq: () => createReq,
-  createSeriesReq: () => createSeriesReq,
   defaultPipe: () => defaultPipe,
   emitter: () => emitter,
   getInstance: () => getInstance,
-  isError: () => isError,
-  merge: () => merge,
+  isMerge: () => isMerge,
+  isNil: () => isNil,
+  isObject: () => isObject,
+  isUndefined: () => isUndefined,
   parseMeta: () => parseMeta,
-  toReq: () => toReq,
-  useMqFilter: () => useMqFilter,
-  useMqPipe: () => useMqPipe,
+  resolveDep: () => resolveDep,
   useServerFilter: () => useServerFilter,
   useServerPipe: () => useServerPipe
 });
@@ -264,10 +256,6 @@ var serverFilter = /* @__PURE__ */ __name((e) => {
     e = new UndefinedException(e.message || e);
   return e.data;
 }, "serverFilter");
-var rabbitMqFilter = /* @__PURE__ */ __name((e, data) => {
-  const { channel, message } = data;
-  channel.reject(message, true);
-}, "rabbitMqFilter");
 
 // src/history.ts
 var Phistroy = class {
@@ -302,23 +290,23 @@ var _Context = class {
   static registerInterceptor(key, handler) {
     _Context.interceptorsRecord[key] = handler;
   }
-  async useGuard(guards, isMerge = false) {
+  async useGuard(guards, isMerge2 = false) {
     for (const guard of guards) {
       if (this.history.record(guard, "guard")) {
         if (!(guard in _Context.guardsRecord))
           throw new FrameworkException(`can't find guard named ${guard}`);
-        if (!await _Context.guardsRecord[guard](this.data, isMerge))
+        if (!await _Context.guardsRecord[guard](this.data, isMerge2))
           throw new ForbiddenException(`Guard exception--${guard}`);
       }
     }
   }
-  async useInterceptor(interceptors, isMerge = false) {
+  async useInterceptor(interceptors, isMerge2 = false) {
     const ret = [];
     for (const interceptor of interceptors) {
       if (this.history.record(interceptor, "interceptor")) {
         if (!(interceptor in _Context.interceptorsRecord))
           throw new FrameworkException(`can't find guard named ${interceptor}`);
-        const post = await _Context.interceptorsRecord[interceptor](this.data, isMerge);
+        const post = await _Context.interceptorsRecord[interceptor](this.data, isMerge2);
         if (post)
           ret.push(post);
       }
@@ -408,93 +396,12 @@ function useServerFilter(filter) {
 }
 __name(useServerFilter, "useServerFilter");
 
-// src/context/micro.ts
-var _RabbitMqContext = class extends Context {
-  static useMiddleware(middlewares) {
-    return middlewares.map((m) => {
-      if (!(m in _RabbitMqContext.middlewareRecord))
-        throw new FrameworkException(`can't find middleware named ${m}`);
-      return _RabbitMqContext.middlewareRecord[m];
-    });
-  }
-  async usePipe(args, reflect) {
-    return _RabbitMqContext.pipe.transform?.(args, reflect);
-  }
-  static useFilter(arg, data) {
-    return _RabbitMqContext.filter(arg, data);
-  }
-  useFilter(arg) {
-    return _RabbitMqContext.filter(arg, this.data);
-  }
-};
-var RabbitMqContext = _RabbitMqContext;
-__name(RabbitMqContext, "RabbitMqContext");
-__publicField(RabbitMqContext, "pipe", defaultPipe);
-__publicField(RabbitMqContext, "filter", rabbitMqFilter);
-__publicField(RabbitMqContext, "middlewareRecord", {});
-function useMqPipe(pipe) {
-  RabbitMqContext.pipe = pipe;
-}
-__name(useMqPipe, "useMqPipe");
-function useMqFilter(filter) {
-  RabbitMqContext.filter = filter;
-}
-__name(useMqFilter, "useMqFilter");
-
 // src/types.ts
 var Base = class {
   context;
 };
 __name(Base, "Base");
 
-// src/compiler.ts
-var Compiler = class {
-  classMap = {};
-  name;
-  constructor() {
-  }
-  getContent() {
-    let content = "";
-    for (const name in this.classMap) {
-      content += `
-        export class ${name}{
-            ${Object.values(this.classMap[name]).reduce((p, c) => p + c)}
-            }`;
-    }
-    return content;
-  }
-  createRequest() {
-    let content = "import {useC} from 'phecda-server'\n";
-    for (const name in this.classMap)
-      content += `export const {${Object.keys(this.classMap[name]).join(",")}}=useC(${name})
-`;
-    return content;
-  }
-  addMethod(args) {
-    const { route: { route = "/", type = "get" } = {}, name, method, params, tag } = args;
-    const url = route.replace(/\/\:([^\/]*)/g, "");
-    this.name = name;
-    if (!this.classMap[name])
-      this.classMap[name] = {};
-    this.classMap[name][method] = `
-    ${method}(${genParams(params)}){
-const ret={tag:"${tag}-${method}",body:{},query:{},params:{},realParam:'',method:"${type}",url:"${url}"}
-${params.filter((item) => item.key).reduce((p, c, i) => `${p}ret.${c.type}.${c.key}=arg${i}
-${c.type === "params" ? `ret.realParam+='/'+arg${i}
-` : ""}`, "")}
-return ret
-    }
-    `;
-  }
-};
-__name(Compiler, "Compiler");
-function genParams(decorators) {
-  return decorators.map((_, i) => {
-    return `${`arg${i}`}`;
-  }).join(",");
-}
-__name(genParams, "genParams");
-
 // src/utils.ts
 var isUndefined = /* @__PURE__ */ __name((obj) => typeof obj === "undefined", "isUndefined");
 var isNil = /* @__PURE__ */ __name((obj) => isUndefined(obj) || obj === null, "isNil");
@@ -505,6 +412,10 @@ function resolveDep(ret, key) {
   return ret;
 }
 __name(resolveDep, "resolveDep");
+function isMerge(data) {
+  return !!data.isMerge;
+}
+__name(isMerge, "isMerge");
 
 // src/common.ts
 var SERIES_SYMBOL = "__symbol_series__";
@@ -661,8 +572,8 @@ __name(bindApp, "bindApp");
 
 // src/core.ts
 var import_reflect_metadata = require("reflect-metadata");
-var import_events = __toESM(require("events"));
 var import_fs = __toESM(require("fs"));
+var import_node_events = __toESM(require("events"));
 var import_phecda_core2 = require("phecda-core");
 
 // src/meta.ts
@@ -679,7 +590,7 @@ var Meta = class {
 __name(Meta, "Meta");
 
 // src/core.ts
-var emitter = new import_events.default();
+var emitter = new import_node_events.default();
 async function Factory(Modules) {
   const moduleMap = /* @__PURE__ */ new Map();
   const meta = [];
@@ -743,7 +654,14 @@ function getMetaFromInstance(instance, name, tag) {
     }
     state.params = params;
     initState(state);
-    state.header = Object.assign({}, baseState.header, state.header);
+    state.define = {
+      ...baseState.define,
+      ...state.define
+    };
+    state.header = {
+      ...baseState.header,
+      ...state.header
+    };
     state.middlewares = [
       .../* @__PURE__ */ new Set([
         ...baseState.middlewares,
@@ -771,6 +689,8 @@ function getParamtypes(Module, key) {
 }
 __name(getParamtypes, "getParamtypes");
 function initState(state) {
+  if (!state.define)
+    state.define = {};
   if (!state.header)
     state.header = {};
   if (!state.middlewares)
@@ -783,7 +703,7 @@ function initState(state) {
 __name(initState, "initState");
 
 // src/decorators/index.ts
-var import_phecda_core6 = require("phecda-core");
+var import_phecda_core5 = require("phecda-core");
 
 // src/decorators/param.ts
 var import_phecda_core3 = require("phecda-core");
@@ -921,30 +841,14 @@ function Interceptor(...interceptors) {
 }
 __name(Interceptor, "Interceptor");
 
-// src/decorators/micro.ts
-var import_phecda_core5 = require("phecda-core");
-function MQ(queue, routeKey, options) {
-  return (target, k) => {
-    (0, import_phecda_core5.setModalVar)(target, k);
-    (0, import_phecda_core5.mergeState)(target, k, {
-      mq: {
-        queue,
-        routeKey,
-        options
-      }
-    });
-  };
-}
-__name(MQ, "MQ");
-
 // src/decorators/index.ts
 function Inject(_target) {
 }
 __name(Inject, "Inject");
 function Header(name, value) {
   return (target, k) => {
-    (0, import_phecda_core6.setModalVar)(target, k);
-    (0, import_phecda_core6.mergeState)(target, k, {
+    (0, import_phecda_core5.setModalVar)(target, k);
+    (0, import_phecda_core5.mergeState)(target, k, {
       header: {
         name,
         value
@@ -955,179 +859,34 @@ function Header(name, value) {
 __name(Header, "Header");
 function Define(key, value) {
   return (target, k) => {
-    (0, import_phecda_core6.setModalVar)(target, k);
-    (0, import_phecda_core6.mergeState)(target, k, {
-      define: {
-        [key]: value
-      }
-    });
+    if (k) {
+      (0, import_phecda_core5.setModalVar)(target, k);
+      (0, import_phecda_core5.mergeState)(target, k, {
+        define: {
+          [key]: value
+        }
+      });
+    } else {
+      (0, import_phecda_core5.setModalVar)(target.prototype, "__CLASS");
+      (0, import_phecda_core5.mergeState)(target.prototype, "__CLASS", {
+        define: {
+          [key]: value
+        }
+      });
+    }
   };
 }
 __name(Define, "Define");
 
 // src/index.ts
 __reExport(src_exports, require("phecda-core"), module.exports);
-
-// src/config.ts
-var Pconfig = {
-  rabbitmq: {
-    guard: false,
-    interceptor: false
-  }
-};
-
-// src/micro-services/rabbitmq.ts
-async function bindMQ(ch, { meta, moduleMap }) {
-  for (const item of meta) {
-    const { route, name, method, mq: { routeKey, queue: queueName, options } = {} } = item.data;
-    const tag = `${name}-${method}`;
-    Context.metaRecord[tag] = item;
-    const { guards, reflect, interceptors, params } = Context.metaDataRecord[tag] ? Context.metaDataRecord[tag] : Context.metaDataRecord[tag] = parseMeta(item);
-    const instance = moduleMap.get(name);
-    const handler = instance[method].bind(instance);
-    Context.instanceRecord[name] = instance;
-    if (route) {
-      const { queue } = await ch.assertQueue(route.route);
-      if (queueName && routeKey)
-        await ch.bindQueue(queue, queueName, routeKey);
-      ch.consume(route.route, async (msg) => {
-        if (msg !== null) {
-          const content = msg.content.toString();
-          const data = params.length > 0 ? JSON.parse(content) : content;
-          const contextMeta = {
-            message: msg,
-            content,
-            channel: ch
-          };
-          const context = new RabbitMqContext(tag, contextMeta);
-          try {
-            if (Pconfig.rabbitmq.guard)
-              await context.useGuard(guards);
-            if (Pconfig.rabbitmq.interceptor)
-              await context.useInterceptor(interceptors);
-            const args = await context.usePipe(params.map(({ key, validate }) => {
-              return {
-                arg: resolveDep(data, key),
-                validate
-              };
-            }), reflect);
-            instance.meta = contextMeta;
-            await context.usePost(await handler(...args));
-            ch.ack(msg);
-          } catch (e) {
-            item.handlers.forEach((handler2) => handler2.error?.(e));
-            context.useFilter(e);
-          }
-        } else {
-        }
-      }, options);
-    }
-  }
-}
-__name(bindMQ, "bindMQ");
-async function createPub(ch, method, type) {
-  const { exchange, routeKey, queue } = method();
-  if (exchange)
-    await ch.assertExchange(exchange, type);
-  else
-    await ch.assertQueue(queue);
-  return async (arg) => {
-    const { args } = method(arg);
-    const msg = Buffer.from(JSON.stringify(args));
-    if (exchange)
-      await ch.publish(exchange, routeKey, msg);
-    else
-      await ch.sendToQueue(queue, msg);
-  };
-}
-__name(createPub, "createPub");
-
-// src/client/axios.ts
-function toReq(arg) {
-  const { body, query, realParam, method, url } = arg;
-  return {
-    method,
-    url,
-    body,
-    query: Object.keys(query).length > 0 ? `?${Object.entries(query).map(([k, v]) => `${k}=${v}`).join("&")}` : "",
-    params: realParam
-  };
-}
-__name(toReq, "toReq");
-var merge = /* @__PURE__ */ __name((...args) => {
-  const ret = [];
-  for (const i of args) {
-    const { body, query, params, tag } = i;
-    ret.push({
-      tag,
-      body,
-      query,
-      params
-    });
-  }
-  return ret;
-}, "merge");
-function createReq(instance) {
-  return (arg, config) => {
-    const { url, params, query, body, method } = toReq(arg);
-    if (!method) {
-      console.warn("methods without route decorator won't send request");
-      return;
-    }
-    const ret = [
-      `${url}${params}${query}`
-    ];
-    body && ret.push(body);
-    config && ret.push(config);
-    return instance[method](...ret);
-  };
-}
-__name(createReq, "createReq");
-function createSeriesReq(instance, key = "/__PHECDA_SERVER__") {
-  return (args, config) => {
-    return instance.post(key, {
-      category: "series",
-      data: merge(...args)
-    }, config);
-  };
-}
-__name(createSeriesReq, "createSeriesReq");
-function createParallelReq(instance, key = "/__PHECDA_SERVER__") {
-  return (args, config) => {
-    return instance.post(key, {
-      category: "parallel",
-      data: merge(...args)
-    }, config);
-  };
-}
-__name(createParallelReq, "createParallelReq");
-function isError(data) {
-  return typeof data === "object" && data.error;
-}
-__name(isError, "isError");
-function $S(index, key = "") {
-  return `${SERIES_SYMBOL}@${index}@${key}`;
-}
-__name($S, "$S");
-
-// src/client/server.ts
-function createMqReq(channel) {
-  return async (arg) => {
-    const { url, body } = arg;
-    await channel.assertQueue(url);
-    await channel.sendToQueue(url, Buffer.from(JSON.stringify(body)));
-  };
-}
-__name(createMqReq, "createMqReq");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  $S,
   BadGatewayException,
   BadRequestException,
   Base,
   BaseParam,
   Body,
-  Compiler,
   ConflictException,
   Context,
   Controller,
@@ -1143,7 +902,7 @@ __name(createMqReq, "createMqReq");
   Inject,
   Interceptor,
   InvalidInputException,
-  MQ,
+  MERGE_SYMBOL,
   Meta,
   Middle,
   NotFoundException,
@@ -1152,8 +911,8 @@ __name(createMqReq, "createMqReq");
   Post,
   Put,
   Query,
-  RabbitMqContext,
   Route,
+  SERIES_SYMBOL,
   ServerContext,
   ServiceUnavailableException,
   TimeoutException,
@@ -1165,21 +924,15 @@ __name(createMqReq, "createMqReq");
   addInterceptor,
   addMiddleware,
   bindApp,
-  bindMQ,
-  createMqReq,
-  createParallelReq,
-  createPub,
-  createReq,
-  createSeriesReq,
   defaultPipe,
   emitter,
   getInstance,
-  isError,
-  merge,
+  isMerge,
+  isNil,
+  isObject,
+  isUndefined,
   parseMeta,
-  toReq,
-  useMqFilter,
-  useMqPipe,
+  resolveDep,
   useServerFilter,
   useServerPipe
 });