phecda-server 4.0.0-alpha.6 → 4.0.0-alpha.8

package/dist/core-edac98be.d.ts

@@ -0,0 +1,21 @@
+import { P, a as Emitter, C as Construct } from './types-0b94277f.js';
+
+declare class Meta {
+    data: P.Meta;
+    handlers: P.Handler[];
+    reflect: any[];
+    constructor(data: P.Meta, handlers: P.Handler[], reflect: any[]);
+}
+
+declare const emitter: Emitter;
+declare function Factory(Modules: (new (...args: any) => any)[], opts?: {
+    http?: string;
+    rpc?: string;
+}): Promise<{
+    moduleMap: Map<string, any>;
+    meta: Meta[];
+    constructorMap: Map<any, any>;
+    update: (Module: Construct) => Promise<void>;
+}>;
+
+export { Factory as F, Meta as M, emitter as e };

package/dist/index.d.ts

@@ -1,10 +1,14 @@
-import { RequestHandler, Router } from 'express';
-import { E as Exception, P, S as ServerCtx, a as ServerErr } from './types-2c710fc7.js';
-export { c as Base, B as BaseError, C as Construct, b as Emitter, M as MergeType, d as Meta, R as RequestType, T as ToInstance } from './types-2c710fc7.js';
-import { B as BaseContext, F as Factory } from './core-c289deb2.js';
-export { e as emitter } from './core-c289deb2.js';
+import { E as Exception, P } from './types-0b94277f.js';
+export { B as BaseError, C as Construct, a as Emitter, M as MergeType, R as RequestType, S as ServerErr, T as ToInstance } from './types-0b94277f.js';
+export { F as Factory, M as Meta, e as emitter } from './core-edac98be.js';
 export * from 'phecda-core';
 
+declare class Histroy {
+    guard: string[];
+    interceptor: string[];
+    record(name: string, type: 'guard' | 'interceptor'): boolean;
+}
+
 declare class UndefinedException extends Exception {
     constructor(message: string);
 }
@@ -61,40 +65,39 @@ declare class FrameworkException extends Exception {
     constructor(message: string);
 }
 
-declare const guardsRecord: Record<string, P.Guard<ServerCtx>>;
-declare const interceptorsRecord: Record<string, P.Interceptor<ServerCtx>>;
-declare const middlewareRecord: Record<string, (...params: any) => any>;
-declare const singletonConf: {
-    pipe: P.Pipe<any>;
-    filter: P.Filter<any, any, any>;
-};
-declare class Context extends BaseContext<ServerCtx> {
-    singletonConf: {
-        pipe: P.Pipe<any>;
-        filter: P.Filter<any, any, any>;
-    };
+declare const guardsRecord: Record<string, P.Guard<any>>;
+declare class Context<Data = any> {
+    tag: string;
+    data: Data;
+    method: string;
+    params: string[];
+    history: Histroy;
+    static filter: P.Filter;
+    static pipe: P.Pipe;
+    static guardsRecord: Record<string, P.Guard>;
+    static interceptorsRecord: Record<string, P.Interceptor>;
     static middlewareRecord: Record<string, (...params: any) => any>;
-    guardsRecord: Record<string, P.Guard<ServerCtx>>;
-    interceptorsRecord: Record<string, P.Interceptor<ServerCtx>>;
     postInterceptors: Function[];
+    constructor(tag: string, data: Data);
+    usePipe(args: {
+        arg: any;
+        option?: any;
+        type: string;
+        key: string;
+        index: number;
+        reflect: any;
+    }[]): Promise<any[]>;
+    useFilter(arg: any): any;
+    useGuard(guards: string[]): Promise<void>;
+    usePostInterceptor(ret: any): Promise<any>;
+    useInterceptor(interceptors: string[]): Promise<true | undefined>;
     static useMiddleware(middlewares: string[]): ((...params: any) => any)[];
 }
-declare function addMiddleware(key: string, handler: RequestHandler): void;
-declare function setPipe(pipe: P.Pipe<ServerCtx>): void;
-declare function setFilter(filter: P.Filter<ServerCtx, ServerErr>): void;
-declare function addGuard(key: string, handler: P.Guard<ServerCtx>): void;
-declare function addInterceptor(key: string, handler: P.Interceptor<ServerCtx>): void;
-
-interface Options {
-    dev?: boolean;
-    route?: string;
-    globalGuards?: string[];
-    globalInterceptors?: string[];
-    middlewares?: string[];
-    parallel?: boolean;
-    series?: boolean;
-}
-declare function bindApp(app: Router, { moduleMap, meta }: Awaited<ReturnType<typeof Factory>>, options?: Options): void;
+declare function addMiddleware(key: string, handler: (...params: any) => any): void;
+declare function setPipe(pipe: P.Pipe): void;
+declare function setFilter(filter: P.Filter): void;
+declare function addGuard(key: string, handler: P.Guard): void;
+declare function addInterceptor(key: string, handler: P.Interceptor): void;
 
 declare function BaseParam(type: string, key: string, option?: any): any;
 declare function Body(key?: string, pipeOpts?: any): any;
@@ -110,7 +113,7 @@ declare function Put(route: string): any;
 declare function Patch(route: string): any;
 declare function Delete(route: string): any;
 declare function Controller(route: string): any;
-declare function Rpc(...rpc: string[]): (target: any, key: PropertyKey) => void;
+declare function Rpc(...rpc: ('mq' | 'redis' | string)[]): (target: any, key: PropertyKey) => void;
 
 declare function Guard(...guards: string[]): any;
 declare function Middle(...middlewares: string[]): any;
@@ -135,35 +138,35 @@ declare class Dev {
     onUnmount(cb: () => void): void;
 }
 
-declare abstract class ServerGuard {
-    abstract use(tag: string, ctx: ServerCtx): Promise<boolean> | boolean;
+declare abstract class PFilter {
+    constructor();
+    abstract use<C, S, E extends Exception>(error: Error | E, tag?: string, ctx?: C): S;
+}
+
+declare abstract class PGuard {
+    abstract use<C>(tag: string, ctx: C): Promise<boolean> | boolean;
     constructor(tag: string);
 }
 
-declare abstract class ServerInterceptor {
-    abstract use(tag: string, ctx: ServerCtx): ((arg: any) => any) | void;
+declare abstract class PInterceptor {
+    abstract use<C>(tag: string, ctx: C): ((arg: any) => any) | void;
     constructor(tag: string);
 }
 
-declare abstract class ServerPipe {
+declare abstract class PPipe {
     constructor();
-    abstract use(args: {
+    abstract use<C>(args: {
         arg: any;
         option?: any;
         key: string;
         type: string;
         index: number;
         reflect: any;
-    }[], tag: string, ctx: ServerCtx): Promise<any[]>;
-}
-
-declare abstract class ServerFilter {
-    constructor();
-    abstract use<E extends Exception>(error: Error | E, tag?: string, ctx?: ServerCtx): ServerErr | Promise<ServerErr>;
+    }[], tag: string, ctx: C): Promise<any[]>;
 }
 
 declare function generateRPCCode(meta: P.Meta[]): string;
 
 declare function generateHTTPCode(meta: P.Meta[]): string;
 
-export { APP_SYMBOL, Arg, BadGatewayException, BadRequestException, BaseContext, BaseParam, Body, ConflictException, Context, Controller, Define, Delete, Dev, Exception, Factory, ForbiddenException, FrameworkException, Get, Guard, Head, Header, Interceptor, InvalidInputException, MERGE_SYMBOL, META_SYMBOL, MODULE_SYMBOL, Middle, NotFoundException, Options, P, Param, Patch, PayloadLargeException, Post, Put, Query, Route, Rpc, SERIES_SYMBOL, ServerCtx, ServerErr, ServerFilter, ServerGuard, ServerInterceptor, ServerPipe, ServiceUnavailableException, TimeoutException, UNMOUNT_SYMBOL, UnauthorizedException, UndefinedException, UnsupportedMediaTypeException, ValidateException, addGuard, addInterceptor, addMiddleware, bindApp, defaultPipe, generateHTTPCode, generateRPCCode, guardsRecord, interceptorsRecord, middlewareRecord, resolveDep, setFilter, setPipe, singletonConf };
+export { APP_SYMBOL, Arg, BadGatewayException, BadRequestException, BaseParam, Body, ConflictException, Context, Controller, Define, Delete, Dev, Exception, ForbiddenException, FrameworkException, Get, Guard, Head, Header, Interceptor, InvalidInputException, MERGE_SYMBOL, META_SYMBOL, MODULE_SYMBOL, Middle, NotFoundException, P, PFilter, PGuard, PInterceptor, PPipe, Param, Patch, PayloadLargeException, Post, Put, Query, Route, Rpc, SERIES_SYMBOL, ServiceUnavailableException, TimeoutException, UNMOUNT_SYMBOL, UnauthorizedException, UndefinedException, UnsupportedMediaTypeException, ValidateException, addGuard, addInterceptor, addMiddleware, defaultPipe, generateHTTPCode, generateRPCCode, guardsRecord, resolveDep, setFilter, setPipe };