@ajke/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,255 @@
+import { Hono, Context } from 'hono';
+export { errorHandler, requestLogger } from './middleware/index.js';
+import { z } from 'zod';
+
+declare const INJECT_CUSTOM_TOKENS_KEY = "wilt:inject:custom:tokens";
+declare function Injectable(): (target: any) => void;
+declare function Inject(token?: any): (target: any, propertyKey: string | symbol | undefined, parameterIndex: number) => any;
+
+interface CustomDecorator<TKey = string> {
+    (target: any, key?: any, descriptor?: any): any;
+    KEY: TKey;
+}
+declare function SetMetadata<K = string, V = any>(metadataKey: K, metadataValue: V): CustomDecorator<K>;
+
+declare const GUARDS_METADATA = "wilt:guards";
+declare function UseGuards(...guards: (new (...args: any[]) => any)[]): MethodDecorator & ClassDecorator;
+
+declare const INTERCEPTORS_METADATA = "wilt:interceptors";
+declare function UseInterceptors(...interceptors: (new (...args: any[]) => any)[]): MethodDecorator & ClassDecorator;
+
+declare const FILTERS_METADATA = "wilt:filters";
+declare const CATCH_METADATA = "wilt:catch";
+declare function Catch(...exceptions: (new (...args: any[]) => any)[]): ClassDecorator;
+declare function UseFilters(...filters: (new (...args: any[]) => any)[]): MethodDecorator & ClassDecorator;
+
+declare const OPTIONAL_METADATA = "wilt:optional";
+declare function Optional(): ParameterDecorator;
+
+declare function Controller(prefix?: string): (target: any) => void;
+declare function registerControllerRoutes(router: Hono<{
+    Bindings: any;
+}>, controller: any, prefix?: string, instanceRegistry?: Map<any, any>): void;
+
+declare const Get: (path?: string) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+declare const Post: (path?: string) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+declare const Put: (path?: string) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+declare const Delete: (path?: string) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+declare const Patch: (path?: string) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+
+declare const ROUTE_PARAMS_METADATA = "wilt:route-params";
+declare const TOTAL_PARAMS_METADATA = "wilt:total-params";
+type RouteParamType = "body" | "param" | "query" | "headers" | "ip" | "req";
+interface RouteParamMetadata {
+    index: number;
+    type: RouteParamType;
+    data?: string;
+}
+declare const Body: (data?: string) => ParameterDecorator;
+declare const Param: (data?: string) => ParameterDecorator;
+declare const Query: (data?: string) => ParameterDecorator;
+declare const Headers: (data?: string) => ParameterDecorator;
+declare function Ip(): ParameterDecorator;
+declare function Req(): ParameterDecorator;
+
+declare const HTTP_CODE_METADATA = "wilt:http-code";
+declare function HttpCode(statusCode: number): MethodDecorator;
+
+declare const HEADER_METADATA = "wilt:response-headers";
+declare function Header(name: string, value: string): MethodDecorator;
+
+declare const REDIRECT_METADATA = "wilt:redirect";
+interface RedirectMetadata {
+    url: string;
+    statusCode: number;
+}
+declare function Redirect(url: string, statusCode?: number): MethodDecorator;
+
+interface ForwardReference<T = any> {
+    forwardRef: () => T;
+}
+interface ModuleMetadata {
+    imports?: any[];
+    controllers?: any[];
+    providers?: any[];
+    exports?: any[];
+    entities?: any[];
+}
+interface RouteMetadata {
+    method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+    path: string;
+    handler: string;
+}
+
+declare function Module(config: ModuleMetadata): (target: any) => void;
+
+declare const GLOBAL_MODULE_METADATA = "wilt:global";
+declare function Global(): ClassDecorator;
+
+declare function createModule<B extends object = Record<string, unknown>>(moduleClass: any, { middlewares }?: {
+    middlewares?: any[];
+}): Hono<{
+    Bindings: B;
+}>;
+
+type HttpStatusCode = 200 | 201 | 202 | 400 | 401 | 403 | 404 | 409 | 500;
+interface BaseResponse<T = any> {
+    success: boolean;
+    data?: T;
+    message?: string;
+    timestamp: string;
+}
+interface PaginatedResponse<T = any> extends BaseResponse<T[]> {
+    pagination: {
+        page: number;
+        limit: number;
+        total: number;
+        totalPages: number;
+    };
+}
+interface ErrorResponse {
+    success: false;
+    error: {
+        code: string;
+        message: string;
+        stack?: string;
+    };
+    timestamp: string;
+}
+
+interface HttpArgumentsHost {
+    getRequest<T = Context>(): T;
+}
+interface ArgumentsHost {
+    switchToHttp(): HttpArgumentsHost;
+}
+interface ExecutionContext extends ArgumentsHost {
+    getClass<T = any>(): new (...args: any[]) => T;
+    getHandler(): Function;
+}
+declare function createExecutionContext(c: Context, controllerClass: any, handler: Function): ExecutionContext;
+declare function createArgumentsHost(c: Context): ArgumentsHost;
+
+interface CanActivate {
+    canActivate(context: ExecutionContext): boolean | Promise<boolean>;
+}
+
+interface CallHandler<T = any> {
+    handle(): Promise<T>;
+}
+interface NestInterceptor<T = any, R = any> {
+    intercept(context: ExecutionContext, next: CallHandler<T>): Promise<R>;
+}
+
+interface ExceptionFilter<T = any> {
+    catch(exception: T, host: ArgumentsHost): Response | Promise<Response> | void;
+}
+
+interface ArgumentMetadata {
+    type: "body" | "query" | "param" | "custom";
+    metatype?: new (...args: any[]) => any;
+    data?: string;
+}
+interface PipeTransform<T = any, R = any> {
+    transform(value: T, metadata: ArgumentMetadata): R | Promise<R>;
+}
+
+interface OnModuleInit {
+    onModuleInit(): void | Promise<void>;
+}
+interface OnModuleDestroy {
+    onModuleDestroy(): void | Promise<void>;
+}
+interface OnApplicationBootstrap {
+    onApplicationBootstrap(): void | Promise<void>;
+}
+interface BeforeApplicationShutdown {
+    beforeApplicationShutdown(signal?: string): void | Promise<void>;
+}
+interface OnApplicationShutdown {
+    onApplicationShutdown(signal?: string): void | Promise<void>;
+}
+
+interface ValidationRule {
+    field: string;
+    required?: boolean;
+    type?: "string" | "number" | "boolean" | "object" | "array";
+    minLength?: number;
+    maxLength?: number;
+    pattern?: RegExp;
+    custom?: (value: any) => boolean;
+}
+declare function Validate(rules: ValidationRule[]): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+
+declare function ZodValidate(schema: z.ZodSchema): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+
+declare function QueryValidate(schema: z.ZodSchema): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+
+declare class HttpException extends Error {
+    private readonly response;
+    private readonly statusCode;
+    constructor(response: string | Record<string, any>, statusCode: number);
+    getStatus(): number;
+    getResponse(): string | Record<string, any>;
+}
+
+declare class BadRequestException extends HttpException {
+    constructor(message?: string | Record<string, any>);
+}
+declare class UnauthorizedException extends HttpException {
+    constructor(message?: string | Record<string, any>);
+}
+declare class ForbiddenException extends HttpException {
+    constructor(message?: string | Record<string, any>);
+}
+declare class NotFoundException extends HttpException {
+    constructor(message?: string | Record<string, any>);
+}
+declare class MethodNotAllowedException extends HttpException {
+    constructor(message?: string | Record<string, any>);
+}
+declare class ConflictException extends HttpException {
+    constructor(message?: string | Record<string, any>);
+}
+declare class GoneException extends HttpException {
+    constructor(message?: string | Record<string, any>);
+}
+declare class UnprocessableEntityException extends HttpException {
+    constructor(message?: string | Record<string, any>);
+}
+declare class TooManyRequestsException extends HttpException {
+    constructor(message?: string | Record<string, any>);
+}
+declare class InternalServerErrorException extends HttpException {
+    constructor(message?: string | Record<string, any>);
+}
+declare class NotImplementedException extends HttpException {
+    constructor(message?: string | Record<string, any>);
+}
+declare class ServiceUnavailableException extends HttpException {
+    constructor(message?: string | Record<string, any>);
+}
+
+declare class Reflector {
+    get<T = any>(metadataKey: string, target: Function): T;
+    getAllAndOverride<T = any>(metadataKey: string, targets: Function[]): T;
+    getAllAndMerge<T extends any[] = any[]>(metadataKey: string, targets: Function[]): T;
+}
+
+declare function forwardRef<T = any>(fn: () => T): ForwardReference<T>;
+declare function isForwardRef(val: any): val is ForwardReference;
+
+declare class _ResponseUtil {
+    private static instance;
+    private logger;
+    private constructor();
+    static getInstance(): _ResponseUtil;
+    success<T>(c: Context, data: T, message?: string, status?: HttpStatusCode): Response;
+    error(c: Context, message: string, status?: HttpStatusCode): Response;
+    paginated<T>(c: Context, data: T[], page: number, limit: number, total: number, message?: string): Response;
+}
+declare const ResponseUtil: _ResponseUtil;
+
+declare function applyDecorators(...decorators: (ClassDecorator | MethodDecorator | PropertyDecorator)[]): (...args: any[]) => any;
+
+export { type ArgumentMetadata, type ArgumentsHost, BadRequestException, type BaseResponse, type BeforeApplicationShutdown, Body, CATCH_METADATA, type CallHandler, type CanActivate, Catch, ConflictException, Controller, type CustomDecorator, Delete, type ErrorResponse, type ExceptionFilter, type ExecutionContext, FILTERS_METADATA, ForbiddenException, type ForwardReference, GLOBAL_MODULE_METADATA, GUARDS_METADATA, Get, Global, GoneException, HEADER_METADATA, HTTP_CODE_METADATA, Header, Headers, type HttpArgumentsHost, HttpCode, HttpException, type HttpStatusCode, INJECT_CUSTOM_TOKENS_KEY, INTERCEPTORS_METADATA, Inject, Injectable, InternalServerErrorException, Ip, MethodNotAllowedException, Module, type ModuleMetadata, type NestInterceptor, NotFoundException, NotImplementedException, OPTIONAL_METADATA, type OnApplicationBootstrap, type OnApplicationShutdown, type OnModuleDestroy, type OnModuleInit, Optional, type PaginatedResponse, Param, Patch, type PipeTransform, Post, Put, Query, QueryValidate, REDIRECT_METADATA, ROUTE_PARAMS_METADATA, Redirect, type RedirectMetadata, Reflector, Req, Req as Request, ResponseUtil, type RouteMetadata, type RouteParamMetadata, type RouteParamType, ServiceUnavailableException, SetMetadata, TOTAL_PARAMS_METADATA, TooManyRequestsException, UnauthorizedException, UnprocessableEntityException, UseFilters, UseGuards, UseInterceptors, Validate, type ValidationRule, ZodValidate, _ResponseUtil, applyDecorators, createArgumentsHost, createExecutionContext, createModule, forwardRef, isForwardRef, registerControllerRoutes };