phecda-server 3.2.0-alpha.5 → 4.0.0-alpha.11

package/dist/core-91ada79c.d.ts

@@ -0,0 +1,21 @@
+import { P, a as Emitter, C as Construct } from './types-70714e01.js';
+
+declare class Meta {
+    data: P.Meta;
+    handlers: P.Handler[];
+    paramsType: any[];
+    constructor(data: P.Meta, handlers: P.Handler[], paramsType: 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,160 +1,112 @@
-import { RequestHandler, Express, Router } from 'express';
-import { H as HttpException, M as Meta, P, S as ServerCtx, a as ServerMergeCtx, b as ServerFilter, E as Emitter, C as Construct } from './types-b69250fd.js';
-export { d as Base, B as BaseError, c as MergeType, R as RequestType } from './types-b69250fd.js';
+import { E as Exception, P } from './types-70714e01.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-70714e01.js';
+export { F as Factory, M as Meta, e as emitter } from './core-91ada79c.js';
 export * from 'phecda-core';
 
-declare class UndefinedException extends HttpException {
-    constructor(message: string);
+declare class Histroy {
+    guard: string[];
+    interceptor: string[];
+    record(name: string, type: 'guard' | 'interceptor'): boolean;
 }
 
-declare class ValidateException extends HttpException {
+declare class UndefinedException extends Exception {
     constructor(message: string);
 }
 
-declare class ForbiddenException extends HttpException {
+declare class ValidateException extends Exception {
     constructor(message: string);
 }
 
-declare class BadRequestException extends HttpException {
+declare class ForbiddenException extends Exception {
     constructor(message: string);
 }
 
-declare class NotFoundException extends HttpException {
+declare class BadRequestException extends Exception {
     constructor(message: string);
 }
 
-declare class ConflictException extends HttpException {
+declare class NotFoundException extends Exception {
     constructor(message: string);
 }
 
-declare class BadGatewayException extends HttpException {
+declare class ConflictException extends Exception {
     constructor(message: string);
 }
 
-declare class InvalidInputException extends HttpException {
+declare class BadGatewayException extends Exception {
     constructor(message: string);
 }
 
-declare class UnsupportedMediaTypeException extends HttpException {
+declare class InvalidInputException extends Exception {
     constructor(message: string);
 }
 
-declare class PayloadLargeException extends HttpException {
+declare class UnsupportedMediaTypeException extends Exception {
     constructor(message: string);
 }
 
-declare class TimeoutException extends HttpException {
+declare class PayloadLargeException extends Exception {
     constructor(message: string);
 }
 
-declare class UnauthorizedException extends HttpException {
+declare class TimeoutException extends Exception {
     constructor(message: string);
 }
 
-declare class ServiceUnavailableException extends HttpException {
+declare class UnauthorizedException extends Exception {
     constructor(message: string);
 }
 
-declare class FrameworkException extends HttpException {
+declare class ServiceUnavailableException extends Exception {
     constructor(message: string);
 }
 
-declare class Histroy {
-    guard: string[];
-    interceptor: string[];
-    record(name: string, type: 'guard' | 'interceptor'): boolean;
+declare class FrameworkException extends Exception {
+    constructor(message: string);
 }
 
-declare abstract class Context<Data = any> {
-    key: string;
+declare const guardsRecord: Record<string, P.Guard<any>>;
+declare class Context<Data = any> {
+    tag: string;
     data: Data;
     method: string;
     params: string[];
-    static metaRecord: Record<string, Meta>;
-    static metaDataRecord: Record<string, ReturnType<typeof parseMeta>>;
-    static guardsRecord: Record<string, any>;
-    static interceptorsRecord: Record<string, any>;
-    post: ((...params: any) => any)[];
     history: Histroy;
-    constructor(key: string, data: Data);
-    static registerGuard(key: string, handler: any): void;
-    static registerInterceptor(key: string, handler: any): void;
-    useGuard(guards: string[], isMerge?: boolean): Promise<void>;
-    useInterceptor(interceptors: string[], isMerge?: boolean): Promise<void>;
-    usePost(data: any): Promise<any>;
-}
-declare function addGuard(key: string, handler: P.Guard): void;
-declare function addInterceptor(key: string, handler: P.Interceptor): void;
-declare function parseMeta(meta: Meta): {
-    guards: string[];
-    reflect: any[];
-    interceptors: string[];
-    middlewares: string[];
-    handlers: P.Handler[];
-    params: {
-        type: string;
-        index: number;
-        key: string;
-        option?: any;
-    }[];
-};
-
-declare class ServerContext extends Context<ServerCtx | ServerMergeCtx> {
-    static pipe: P.Pipe;
-    static filter: ServerFilter;
+    static filter: P.Filter;
+    static pipeRecord: Record<string, P.Pipe>;
+    static guardsRecord: Record<string, P.Guard>;
+    static interceptorsRecord: Record<string, P.Interceptor>;
     static middlewareRecord: Record<string, (...params: any) => any>;
-    static useMiddleware(middlewares: string[]): ((...params: any) => any)[];
+    postInterceptors: Function[];
+    constructor(tag: string, data: Data);
     usePipe(args: {
         arg: any;
-        option?: any;
+        pipe?: string;
+        pipeOpts?: any;
         type: string;
         key: string;
         index: number;
         reflect: any;
-    }[], tag: string): Promise<any[]>;
-    static useFilter(arg: any, data: ServerCtx | ServerMergeCtx): any;
+    }[]): Promise<any[]>;
     useFilter(arg: any): any;
-}
-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 = "__PS_SERIES__";
-declare const MERGE_SYMBOL = "__PS_MERGE__";
-declare const UNMOUNT_SYMBOL = "__PS_UNMOUNT__";
-declare const MODULE_SYMBOL = "__PS_MODULE__";
-declare const META_SYMBOL = "__PS_META__";
-declare const APP_SYMBOL = "__PS__";
-
-declare const emitter: Emitter;
-declare function Factory(Modules: (new (...args: any) => any)[], opts?: {
-    dev?: boolean;
-    file?: string;
-}): Promise<{
-    moduleMap: Map<string, any>;
-    meta: Meta[];
-    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, { moduleMap, meta }: Awaited<ReturnType<typeof Factory>>, options?: Options): void;
+    useGuard(guards: string[]): Promise<void>;
+    usePostInterceptor(ret: any): Promise<any>;
+    useInterceptor(interceptors: string[]): Promise<true | undefined>;
+    static useMiddleware(middlewares: string[]): any[];
+}
+declare function addMiddleware(key: string, handler: (...params: any) => any): void;
+declare function addPipe(key: string, 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;
-declare function Head(key: string, pipeOpts?: any): any;
-declare function Query(key?: string, pipeOpts?: any): any;
-declare function Param(key: string, pipeOpts?: any): any;
+declare function BaseParam(type: string, key: string): any;
+declare function Pipe(key?: string, opts?: any): (target: any, k: PropertyKey, index: number) => void;
+declare function Body(key?: string): any;
+declare function Head(key: string): any;
+declare function Query(key?: string): any;
+declare function Param(key: string): any;
+declare function Arg(): any;
 
 declare function Route(route: string, type?: string): any;
 declare function Get(route: string): any;
@@ -163,6 +115,9 @@ 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(...types: ('mq' | 'redis' | string)[]): (target: any, key?: PropertyKey) => void;
+declare function Event(isEvent?: boolean): (target: any, key?: PropertyKey) => void;
+
 declare function Guard(...guards: string[]): any;
 declare function Middle(...middlewares: string[]): any;
 declare function Interceptor(...interceptors: string[]): any;
@@ -172,7 +127,48 @@ declare function Define(key: string, value: any): (target: any, k?: PropertyKey)
 
 declare const defaultPipe: P.Pipe;
 
-declare function isMerge(data: ServerCtx | ServerMergeCtx): data is ServerMergeCtx;
 declare function resolveDep(ret: any, key: string): any;
 
-export { APP_SYMBOL, BadGatewayException, BadRequestException, BaseParam, Body, ConflictException, Construct, Context, Controller, Define, Delete, Dev, Emitter, Factory, ForbiddenException, FrameworkException, Get, Guard, Head, Header, HttpException, Interceptor, InvalidInputException, MERGE_SYMBOL, META_SYMBOL, MODULE_SYMBOL, Meta, Middle, NotFoundException, Options, P, Param, Patch, PayloadLargeException, Post, Put, Query, 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 };
+declare const MERGE_SYMBOL = "__PS_MERGE__";
+declare const UNMOUNT_SYMBOL = "__PS_UNMOUNT__";
+declare const MODULE_SYMBOL = "__PS_MODULE__";
+declare const META_SYMBOL = "__PS_META__";
+declare const APP_SYMBOL = "__PS__";
+
+declare class Dev {
+    [UNMOUNT_SYMBOL]: (() => void)[];
+    onUnmount(cb: () => void): void;
+}
+
+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 PInterceptor {
+    abstract use<C>(tag: string, ctx: C): ((arg: any) => any) | void;
+    constructor(tag: string);
+}
+
+declare abstract class PPipe {
+    constructor(key: string);
+    abstract use<C>(args: {
+        arg: any;
+        option?: any;
+        key: string;
+        type: string;
+        index: number;
+        reflect: any;
+    }, 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, BaseParam, Body, ConflictException, Context, Controller, Define, Delete, Dev, Event, 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, Pipe, Post, Put, Query, Route, Rpc, ServiceUnavailableException, TimeoutException, UNMOUNT_SYMBOL, UnauthorizedException, UndefinedException, UnsupportedMediaTypeException, ValidateException, addGuard, addInterceptor, addMiddleware, addPipe, defaultPipe, generateHTTPCode, generateRPCCode, guardsRecord, resolveDep, setFilter };