@galaxy-stack/orbit-common 0.1.0

package/README.md

@@ -0,0 +1,98 @@
+# @galaxy-stack/orbit-common
+
+## Mô tả
+Package chứa các decorators, pipes, guards, interceptors và exceptions dùng chung trong Orbit framework.
+
+## Tính năng chính
+
+### 1. HTTP Decorators
+```typescript
+import { 
+  Controller, 
+  Get, Post, Put, Patch, Delete,
+  Body, Query, Param, Headers, Req, Res
+} from '@galaxy-stack/orbit-common';
+
+@Controller('api')
+class ApiController {
+  @Get('items')
+  getItems(@Query('page') page: string) {}
+
+  @Post('items')
+  createItem(@Body() data: any) {}
+}
+```
+
+### 2. Built-in Pipes
+- `ParseIntPipe`: Chuyển string thành number
+- `ParseFloatPipe`: Chuyển string thành float
+- `ParseBoolPipe`: Chuyển string thành boolean
+- `ParseArrayPipe`: Chuyển string thành array
+- `DefaultValuePipe`: Giá trị mặc định
+- `TrimPipe`: Xóa khoảng trắng
+
+```typescript
+@Get(':id')
+getUser(@Param('id', ParseIntPipe) id: number) {
+  // id đã được convert sang number
+}
+```
+
+### 3. HTTP Exceptions
+```typescript
+import {
+  BadRequestException,
+  UnauthorizedException,
+  ForbiddenException,
+  NotFoundException,
+  ConflictException,
+  InternalServerErrorException,
+} from '@galaxy-stack/orbit-common';
+
+throw new NotFoundException('User not found');
+```
+
+### 4. Guards
+```typescript
+import { CanActivate, ExecutionContext } from '@galaxy-stack/orbit-common';
+
+class AuthGuard implements CanActivate {
+  canActivate(context: ExecutionContext): boolean {
+    const request = context.switchToHttp().getRequest();
+    return !!request.headers.authorization;
+  }
+}
+```
+
+### 5. Interceptors
+```typescript
+import { Interceptor, ExecutionContext } from '@galaxy-stack/orbit-common';
+
+class LoggingInterceptor implements Interceptor {
+  async intercept(context: ExecutionContext, next: () => Promise<any>) {
+    console.log('Before...');
+    const result = await next();
+    console.log('After...');
+    return result;
+  }
+}
+```
+
+## Cách sử dụng
+
+```typescript
+import { 
+  Controller, Get, UseGuards, UsePipes,
+  ParseIntPipe, AuthGuard 
+} from '@galaxy-stack/orbit-common';
+
+@Controller('users')
+@UseGuards(AuthGuard)
+class UserController {
+  @Get(':id')
+  @UsePipes(ParseIntPipe)
+  getUser(@Param('id') id: number) {
+    return { id };
+  }
+}
+```

package/dist/decorators/catch.decorator.d.ts

@@ -0,0 +1,19 @@
+import 'reflect-metadata';
+import type { Type } from '../interfaces/type.interface';
+export interface ArgumentsHost {
+    getArgs<T extends any[] = any[]>(): T;
+    getArgByIndex<T = any>(index: number): T;
+    getType<T extends string = string>(): T;
+}
+export interface HttpArgumentsHost {
+    getRequest<T = any>(): T;
+    getResponse<T = any>(): T;
+    getNext<T = any>(): T;
+}
+export interface ExceptionFilter<T = any> {
+    catch(exception: T, host: ArgumentsHost): any;
+}
+export declare function Catch(...exceptions: Type<any>[]): ClassDecorator;
+export declare function UseFilters(...filters: (Type<ExceptionFilter> | ExceptionFilter)[]): MethodDecorator & ClassDecorator;
+export declare function getCatchExceptions(target: Type): Type<any>[];
+export declare function getFilters(target: Object, propertyKey?: string | symbol): (Type<ExceptionFilter> | ExceptionFilter)[];

package/dist/decorators/http-code.decorator.d.ts

@@ -0,0 +1,11 @@
+import 'reflect-metadata';
+export declare function HttpCode(statusCode: number): MethodDecorator;
+export declare function Header(name: string, value: string): MethodDecorator;
+export declare function Redirect(url: string, statusCode?: number): MethodDecorator;
+export declare function Render(template: string): MethodDecorator;
+export declare function getHttpCode(target: Object, propertyKey: string | symbol): number | undefined;
+export declare function getHeaders(target: Object, propertyKey: string | symbol): Record<string, string>;
+export declare function getRedirect(target: Object, propertyKey: string | symbol): {
+    url: string;
+    statusCode: number;
+} | undefined;

package/dist/decorators/index.d.ts

@@ -0,0 +1,7 @@
+export * from './params.decorator';
+export * from './http-code.decorator';
+export * from './use-guards.decorator';
+export * from './use-pipes.decorator';
+export * from './use-interceptors.decorator';
+export * from './catch.decorator';
+export * from './transform.decorator';

package/dist/decorators/params.decorator.d.ts

@@ -0,0 +1,31 @@
+import 'reflect-metadata';
+export declare enum ParamType {
+    BODY = "body",
+    QUERY = "query",
+    PARAM = "param",
+    HEADERS = "headers",
+    REQUEST = "request",
+    RESPONSE = "response",
+    IP = "ip",
+    SESSION = "session",
+    FILE = "file",
+    FILES = "files"
+}
+export interface ParamMetadata {
+    type: ParamType;
+    data?: string;
+    index: number;
+}
+export declare const Body: (data?: string) => ParameterDecorator;
+export declare const Query: (data?: string) => ParameterDecorator;
+export declare const Param: (data?: string) => ParameterDecorator;
+export declare const Headers: (data?: string) => ParameterDecorator;
+export declare const Req: (data?: string) => ParameterDecorator;
+export declare const Request: (data?: string) => ParameterDecorator;
+export declare const Res: (data?: string) => ParameterDecorator;
+export declare const Response: (data?: string) => ParameterDecorator;
+export declare const Ip: (data?: string) => ParameterDecorator;
+export declare const Session: (data?: string) => ParameterDecorator;
+export declare const UploadedFile: (data?: string) => ParameterDecorator;
+export declare const UploadedFiles: (data?: string) => ParameterDecorator;
+export declare function getParamMetadata(target: Object, propertyKey: string | symbol): ParamMetadata[];

package/dist/decorators/transform.decorator.d.ts

@@ -0,0 +1,20 @@
+export declare const TRANSFORM_METADATA: unique symbol;
+export interface TransformOptions {
+    toClassOnly?: boolean;
+    toPlainOnly?: boolean;
+    groups?: string[];
+}
+export interface TransformFn {
+    (value: any, obj: any): any;
+}
+export declare function Transform(transformFn: TransformFn, options?: TransformOptions): PropertyDecorator;
+export declare function ToInt(): PropertyDecorator;
+export declare function ToFloat(): PropertyDecorator;
+export declare function ToBoolean(): PropertyDecorator;
+export declare function ToDate(): PropertyDecorator;
+export declare function ToLowerCase(): PropertyDecorator;
+export declare function ToUpperCase(): PropertyDecorator;
+export declare function Trim(): PropertyDecorator;
+export declare function ToArray(): PropertyDecorator;
+export declare function DefaultValue(defaultVal: any): PropertyDecorator;
+export declare function applyTransforms<T extends object>(instance: T): T;

package/dist/decorators/use-guards.decorator.d.ts

@@ -0,0 +1,5 @@
+import 'reflect-metadata';
+import type { CanActivate, GuardClass } from '../interfaces/guard.interface';
+export declare const GUARDS_METADATA = "orbit:guards";
+export declare function UseGuards(...guards: (GuardClass | CanActivate)[]): MethodDecorator & ClassDecorator;
+export declare function getGuards(target: Object, propertyKey?: string | symbol): (GuardClass | CanActivate)[];

package/dist/decorators/use-interceptors.decorator.d.ts

@@ -0,0 +1,11 @@
+import 'reflect-metadata';
+import type { Type } from '../interfaces/type.interface';
+import type { ExecutionContext } from '../interfaces/execution-context.interface';
+export interface CallHandler<T = any> {
+    handle(): Promise<T>;
+}
+export interface OrbitInterceptor<T = any, R = any> {
+    intercept(context: ExecutionContext, next: CallHandler<T>): Promise<R>;
+}
+export declare function UseInterceptors(...interceptors: (Type<OrbitInterceptor> | OrbitInterceptor)[]): MethodDecorator & ClassDecorator;
+export declare function getInterceptors(target: Object, propertyKey?: string | symbol): (Type<OrbitInterceptor> | OrbitInterceptor)[];

package/dist/decorators/use-pipes.decorator.d.ts

@@ -0,0 +1,12 @@
+import 'reflect-metadata';
+import type { Type } from '../interfaces/type.interface';
+export interface ArgumentMetadata {
+    type: 'body' | 'query' | 'param' | 'custom';
+    metatype?: Type;
+    data?: string;
+}
+export interface PipeTransform<T = any, R = any> {
+    transform(value: T, metadata: ArgumentMetadata): R | Promise<R>;
+}
+export declare function UsePipes(...pipes: (Type<PipeTransform> | PipeTransform)[]): MethodDecorator & ClassDecorator;
+export declare function getPipes(target: Object, propertyKey?: string | symbol): (Type<PipeTransform> | PipeTransform)[];

package/dist/exceptions/http.exception.d.ts

@@ -0,0 +1,58 @@
+export declare class HttpException extends Error {
+    private readonly response;
+    private readonly status;
+    constructor(response: string | Record<string, any>, status: number);
+    private initMessage;
+    private initName;
+    getResponse(): string | Record<string, any>;
+    getStatus(): number;
+    toJSON(): Record<string, any>;
+}
+export declare class BadRequestException extends HttpException {
+    constructor(message?: string | Record<string, any>);
+}
+export declare class UnauthorizedException extends HttpException {
+    constructor(message?: string | Record<string, any>);
+}
+export declare class ForbiddenException extends HttpException {
+    constructor(message?: string | Record<string, any>);
+}
+export declare class NotFoundException extends HttpException {
+    constructor(message?: string | Record<string, any>);
+}
+export declare class MethodNotAllowedException extends HttpException {
+    constructor(message?: string | Record<string, any>);
+}
+export declare class NotAcceptableException extends HttpException {
+    constructor(message?: string | Record<string, any>);
+}
+export declare class ConflictException extends HttpException {
+    constructor(message?: string | Record<string, any>);
+}
+export declare class GoneException extends HttpException {
+    constructor(message?: string | Record<string, any>);
+}
+export declare class PayloadTooLargeException extends HttpException {
+    constructor(message?: string | Record<string, any>);
+}
+export declare class UnsupportedMediaTypeException extends HttpException {
+    constructor(message?: string | Record<string, any>);
+}
+export declare class UnprocessableEntityException extends HttpException {
+    constructor(message?: string | Record<string, any>);
+}
+export declare class InternalServerErrorException extends HttpException {
+    constructor(message?: string | Record<string, any>);
+}
+export declare class NotImplementedException extends HttpException {
+    constructor(message?: string | Record<string, any>);
+}
+export declare class BadGatewayException extends HttpException {
+    constructor(message?: string | Record<string, any>);
+}
+export declare class ServiceUnavailableException extends HttpException {
+    constructor(message?: string | Record<string, any>);
+}
+export declare class GatewayTimeoutException extends HttpException {
+    constructor(message?: string | Record<string, any>);
+}

package/dist/exceptions/index.d.ts

@@ -0,0 +1 @@
+export * from './http.exception';

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './decorators';
+export * from './exceptions';