@hemia/common 0.0.1 → 0.0.3

package/dist/hemia-common.esm.js

@@ -5,7 +5,10 @@ const METADATA_KEYS = {
     ROUTES: 'routes',
     PARAMS: 'params',
     HEADERS: 'headers',
-    REDIRECT: 'redirect'
+    REDIRECT: 'redirect',
+    GUARDS: 'hemia:guards',
+    INTERCEPTORS: 'hemia:interceptors',
+    CUSTOM: 'hemia:custom'
 };
 
 const Controller = (basePath = '/') => {
@@ -94,8 +97,130 @@ const Redirect = (url, statusCode = 302) => {
     };
 };
 
+function extendArrayMetadata(key, metadata, target) {
+    const previousValue = Reflect.getMetadata(key, target) || [];
+    const value = [...previousValue, ...metadata];
+    Reflect.defineMetadata(key, value, target);
+}
+
+/**
+ * Decorador que vincula Guards al controlador o método.
+ * @param guards Una lista de clases Guard o instancias de Guard.
+ */
+function UseGuards(...guards) {
+    return (target, key, descriptor) => {
+        guards.filter(guard => guard && (typeof guard === 'function' || typeof guard === 'object'));
+        if (descriptor) {
+            extendArrayMetadata(METADATA_KEYS.GUARDS, guards, descriptor.value);
+            return descriptor;
+        }
+        extendArrayMetadata(METADATA_KEYS.GUARDS, guards, target);
+        return target;
+    };
+}
+
+/**
+ * Decorador que vincula Interceptores al controlador o método.
+ * @param interceptors Una lista de clases Interceptor o instancias.
+ */
+function UseInterceptors(...interceptors) {
+    return (target, key, descriptor) => {
+        const validInterceptors = interceptors.filter(i => i && (typeof i === 'function' || typeof i === 'object'));
+        if (descriptor) {
+            extendArrayMetadata(METADATA_KEYS.INTERCEPTORS, validInterceptors, descriptor.value);
+            return descriptor;
+        }
+        extendArrayMetadata(METADATA_KEYS.INTERCEPTORS, validInterceptors, target);
+        return target;
+    };
+}
+
+class ApiResponse {
+    static success(data, message = 'OK', status = 200) {
+        return {
+            success: true,
+            message,
+            data,
+            status,
+        };
+    }
+    static error(message, error = null, status = 500) {
+        return {
+            success: false,
+            message,
+            error,
+            status,
+        };
+    }
+}
+
 function isRedirectResponse(value) {
     return value && typeof value === 'object' && typeof value.url === 'string';
 }
 
-export { Body, Controller, Delete, Get, Head, Header, Headers, Host, HttpMethod, Ip, METADATA_KEYS, Next, Options, Param, ParamType, Patch, Post, Put, Query, Redirect, Req, Request, Res, Response, Session, isRedirectResponse };
+class HttpError extends Error {
+    constructor(message, statusCode, error) {
+        super(message);
+        this.message = message;
+        this.statusCode = statusCode;
+        this.error = error;
+    }
+}
+class NotFoundError extends HttpError {
+    constructor(message = 'Resource not found', error) {
+        super(message, 404, error);
+    }
+}
+class BadRequestError extends HttpError {
+    constructor(message = 'Invalid data', error) {
+        super(message, 400, error);
+    }
+}
+class UnauthorizedError extends HttpError {
+    constructor(message = 'Unauthorized', error) {
+        super(message, 401, error);
+    }
+}
+class ForbiddenError extends HttpError {
+    constructor(message = 'Forbidden', error) {
+        super(message, 403, error);
+    }
+}
+class InternalServerError extends HttpError {
+    constructor(message = 'Internal server error', error) {
+        super(message, 500, error);
+    }
+}
+class ConflictError extends HttpError {
+    constructor(message = 'Conflict', error) {
+        super(message, 409, error);
+    }
+}
+class UnprocessableEntityError extends HttpError {
+    constructor(message = 'Unprocessable Entity', error) {
+        super(message, 422, error);
+    }
+}
+class ServiceUnavailableError extends HttpError {
+    constructor(message = 'Service Unavailable', error) {
+        super(message, 503, error);
+    }
+}
+class GatewayTimeoutError extends HttpError {
+    constructor(message = 'Gateway Timeout', error) {
+        super(message, 504, error);
+    }
+}
+class CustomHttpError extends HttpError {
+    constructor(message, statusCode, error) {
+        super(message, statusCode, error);
+    }
+}
+class HttpErrorWithDetails extends HttpError {
+    constructor(message, statusCode, details, error) {
+        super(message, statusCode, error);
+        this.details = details;
+    }
+}
+
+export { ApiResponse, BadRequestError, Body, ConflictError, Controller, CustomHttpError, Delete, ForbiddenError, GatewayTimeoutError, Get, Head, Header, Headers, Host, HttpError, HttpErrorWithDetails, HttpMethod, InternalServerError, Ip, METADATA_KEYS, Next, NotFoundError, Options, Param, ParamType, Patch, Post, Put, Query, Redirect, Req, Request, Res, Response, ServiceUnavailableError, Session, UnauthorizedError, UnprocessableEntityError, UseGuards, UseInterceptors, isRedirectResponse };

package/dist/hemia-common.js

@@ -7,7 +7,10 @@ const METADATA_KEYS = {
     ROUTES: 'routes',
     PARAMS: 'params',
     HEADERS: 'headers',
-    REDIRECT: 'redirect'
+    REDIRECT: 'redirect',
+    GUARDS: 'hemia:guards',
+    INTERCEPTORS: 'hemia:interceptors',
+    CUSTOM: 'hemia:custom'
 };
 
 const Controller = (basePath = '/') => {
@@ -96,21 +99,153 @@ const Redirect = (url, statusCode = 302) => {
     };
 };
 
+function extendArrayMetadata(key, metadata, target) {
+    const previousValue = Reflect.getMetadata(key, target) || [];
+    const value = [...previousValue, ...metadata];
+    Reflect.defineMetadata(key, value, target);
+}
+
+/**
+ * Decorador que vincula Guards al controlador o método.
+ * @param guards Una lista de clases Guard o instancias de Guard.
+ */
+function UseGuards(...guards) {
+    return (target, key, descriptor) => {
+        guards.filter(guard => guard && (typeof guard === 'function' || typeof guard === 'object'));
+        if (descriptor) {
+            extendArrayMetadata(METADATA_KEYS.GUARDS, guards, descriptor.value);
+            return descriptor;
+        }
+        extendArrayMetadata(METADATA_KEYS.GUARDS, guards, target);
+        return target;
+    };
+}
+
+/**
+ * Decorador que vincula Interceptores al controlador o método.
+ * @param interceptors Una lista de clases Interceptor o instancias.
+ */
+function UseInterceptors(...interceptors) {
+    return (target, key, descriptor) => {
+        const validInterceptors = interceptors.filter(i => i && (typeof i === 'function' || typeof i === 'object'));
+        if (descriptor) {
+            extendArrayMetadata(METADATA_KEYS.INTERCEPTORS, validInterceptors, descriptor.value);
+            return descriptor;
+        }
+        extendArrayMetadata(METADATA_KEYS.INTERCEPTORS, validInterceptors, target);
+        return target;
+    };
+}
+
+class ApiResponse {
+    static success(data, message = 'OK', status = 200) {
+        return {
+            success: true,
+            message,
+            data,
+            status,
+        };
+    }
+    static error(message, error = null, status = 500) {
+        return {
+            success: false,
+            message,
+            error,
+            status,
+        };
+    }
+}
+
 function isRedirectResponse(value) {
     return value && typeof value === 'object' && typeof value.url === 'string';
 }
 
+class HttpError extends Error {
+    constructor(message, statusCode, error) {
+        super(message);
+        this.message = message;
+        this.statusCode = statusCode;
+        this.error = error;
+    }
+}
+class NotFoundError extends HttpError {
+    constructor(message = 'Resource not found', error) {
+        super(message, 404, error);
+    }
+}
+class BadRequestError extends HttpError {
+    constructor(message = 'Invalid data', error) {
+        super(message, 400, error);
+    }
+}
+class UnauthorizedError extends HttpError {
+    constructor(message = 'Unauthorized', error) {
+        super(message, 401, error);
+    }
+}
+class ForbiddenError extends HttpError {
+    constructor(message = 'Forbidden', error) {
+        super(message, 403, error);
+    }
+}
+class InternalServerError extends HttpError {
+    constructor(message = 'Internal server error', error) {
+        super(message, 500, error);
+    }
+}
+class ConflictError extends HttpError {
+    constructor(message = 'Conflict', error) {
+        super(message, 409, error);
+    }
+}
+class UnprocessableEntityError extends HttpError {
+    constructor(message = 'Unprocessable Entity', error) {
+        super(message, 422, error);
+    }
+}
+class ServiceUnavailableError extends HttpError {
+    constructor(message = 'Service Unavailable', error) {
+        super(message, 503, error);
+    }
+}
+class GatewayTimeoutError extends HttpError {
+    constructor(message = 'Gateway Timeout', error) {
+        super(message, 504, error);
+    }
+}
+class CustomHttpError extends HttpError {
+    constructor(message, statusCode, error) {
+        super(message, statusCode, error);
+    }
+}
+class HttpErrorWithDetails extends HttpError {
+    constructor(message, statusCode, details, error) {
+        super(message, statusCode, error);
+        this.details = details;
+    }
+}
+
+exports.ApiResponse = ApiResponse;
+exports.BadRequestError = BadRequestError;
 exports.Body = Body;
+exports.ConflictError = ConflictError;
 exports.Controller = Controller;
+exports.CustomHttpError = CustomHttpError;
 exports.Delete = Delete;
+exports.ForbiddenError = ForbiddenError;
+exports.GatewayTimeoutError = GatewayTimeoutError;
 exports.Get = Get;
 exports.Head = Head;
 exports.Header = Header;
 exports.Headers = Headers;
 exports.Host = Host;
+exports.HttpError = HttpError;
+exports.HttpErrorWithDetails = HttpErrorWithDetails;
+exports.InternalServerError = InternalServerError;
 exports.Ip = Ip;
 exports.METADATA_KEYS = METADATA_KEYS;
 exports.Next = Next;
+exports.NotFoundError = NotFoundError;
 exports.Options = Options;
 exports.Param = Param;
 exports.Patch = Patch;
@@ -122,5 +257,10 @@ exports.Req = Req;
 exports.Request = Request;
 exports.Res = Res;
 exports.Response = Response;
+exports.ServiceUnavailableError = ServiceUnavailableError;
 exports.Session = Session;
+exports.UnauthorizedError = UnauthorizedError;
+exports.UnprocessableEntityError = UnprocessableEntityError;
+exports.UseGuards = UseGuards;
+exports.UseInterceptors = UseInterceptors;
 exports.isRedirectResponse = isRedirectResponse;

package/dist/types/decorators/core/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./use-guards.decorator";
+export * from "./use-interceptors.decorator";

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

@@ -0,0 +1,7 @@
+import 'reflect-metadata';
+import { CanActivate, Type } from '../../interfaces';
+/**
+ * Decorador que vincula Guards al controlador o método.
+ * @param guards Una lista de clases Guard o instancias de Guard.
+ */
+export declare function UseGuards(...guards: (Type<CanActivate> | CanActivate | Function)[]): (target: object | Function, key?: string | symbol, descriptor?: PropertyDescriptor) => object;

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

@@ -0,0 +1,7 @@
+import 'reflect-metadata';
+import { HemiaInterceptor, Type } from '../../interfaces';
+/**
+ * Decorador que vincula Interceptores al controlador o método.
+ * @param interceptors Una lista de clases Interceptor o instancias.
+ */
+export declare function UseInterceptors(...interceptors: (Type<HemiaInterceptor> | HemiaInterceptor | Function)[]): (target: object | Function, key?: string | symbol, descriptor?: PropertyDescriptor) => object;

package/dist/types/decorators/index.d.ts

@@ -1,2 +1,3 @@
-export * from "./controllers";
+export * from "./http";
 export * from "./metadata";
+export * from "./core";

package/dist/types/decorators/metadata.d.ts

@@ -4,4 +4,7 @@ export declare const METADATA_KEYS: {
     readonly PARAMS: "params";
     readonly HEADERS: "headers";
     readonly REDIRECT: "redirect";
+    readonly GUARDS: "hemia:guards";
+    readonly INTERCEPTORS: "hemia:interceptors";
+    readonly CUSTOM: "hemia:custom";
 };

package/dist/types/decorators/utils/extend-metadata.util.d.ts

@@ -0,0 +1,2 @@
+import 'reflect-metadata';
+export declare function extendArrayMetadata<T>(key: string, metadata: T[], target: object | Function): void;

package/dist/types/errors/http.error.d.ts

@@ -0,0 +1,40 @@
+export declare class HttpError extends Error {
+    message: string;
+    statusCode: number;
+    error?: string | undefined;
+    constructor(message: string, statusCode: number, error?: string | undefined);
+}
+export declare class NotFoundError extends HttpError {
+    constructor(message?: string, error?: string);
+}
+export declare class BadRequestError extends HttpError {
+    constructor(message?: string, error?: string);
+}
+export declare class UnauthorizedError extends HttpError {
+    constructor(message?: string, error?: string);
+}
+export declare class ForbiddenError extends HttpError {
+    constructor(message?: string, error?: string);
+}
+export declare class InternalServerError extends HttpError {
+    constructor(message?: string, error?: string);
+}
+export declare class ConflictError extends HttpError {
+    constructor(message?: string, error?: string);
+}
+export declare class UnprocessableEntityError extends HttpError {
+    constructor(message?: string, error?: string);
+}
+export declare class ServiceUnavailableError extends HttpError {
+    constructor(message?: string, error?: string);
+}
+export declare class GatewayTimeoutError extends HttpError {
+    constructor(message?: string, error?: string);
+}
+export declare class CustomHttpError extends HttpError {
+    constructor(message: string, statusCode: number, error?: string);
+}
+export declare class HttpErrorWithDetails extends HttpError {
+    details: any;
+    constructor(message: string, statusCode: number, details: any, error?: string);
+}

package/dist/types/errors/index.d.ts

@@ -0,0 +1 @@
+export * from "./http.error";

package/dist/types/index.d.ts

@@ -4,3 +4,4 @@ export * from "./enums";
 export * from "./interfaces";
 export * from "./types";
 export * from "./utils";
+export * from "./errors";

package/dist/types/interfaces/activate.interface.d.ts

@@ -0,0 +1,4 @@
+import { ExecutionContext } from "./features/execution-context.interface";
+export interface CanActivate {
+    canActivate(context: ExecutionContext): boolean | Promise<boolean>;
+}

package/dist/types/interfaces/api-response.interface.d.ts

@@ -0,0 +1,13 @@
+export interface IResponseData<T> {
+    success: boolean;
+    data?: T;
+    message: string;
+    error?: any;
+}
+export interface IApiResponse<T> extends IResponseData<T> {
+    status: number;
+}
+export declare class ApiResponse {
+    static success<T>(data: T, message?: string, status?: number): IApiResponse<T>;
+    static error(message: string, error?: any, status?: number): IApiResponse<null>;
+}

package/dist/types/interfaces/features/arguments-host.interface.d.ts

@@ -0,0 +1,18 @@
+export interface HttpArgumentsHost {
+    /** Retorna el objeto Request nativo (Express) */
+    getRequest<T = any>(): T;
+    /** Retorna el objeto Response nativo (Express) */
+    getResponse<T = any>(): T;
+    /** Retorna la función Next nativa (Express) */
+    getNext<T = any>(): T;
+}
+export interface ArgumentsHost {
+    /** Retorna el array de argumentos original [req, res, next] */
+    getArgs<T extends Array<any> = any[]>(): T;
+    /** Retorna un argumento específico por índice */
+    getArgByIndex<T = any>(index: number): T;
+    /** Cambia el contexto a HTTP para obtener métodos tipados */
+    switchToHttp(): HttpArgumentsHost;
+    /** Retorna el tipo de contexto actual (ej: 'http') */
+    getType<TContext extends string = string>(): TContext;
+}

package/dist/types/interfaces/features/execution-context.interface.d.ts

@@ -0,0 +1,14 @@
+import { Type } from "../type.interface";
+import { ArgumentsHost } from "./arguments-host.interface";
+export interface ExecutionContext extends ArgumentsHost {
+    /**
+     * Retorna la CLASE (Constructor) del controlador que se está ejecutando.
+     * Útil para leer metadata a nivel de clase (ej. @Roles('admin') sobre la clase)
+     */
+    getClass<T = any>(): Type<T>;
+    /**
+     * Retorna la FUNCIÓN (Método) del handler que se está ejecutando.
+     * Útil para leer metadata a nivel de método (ej. @Public() sobre el método)
+     */
+    getHandler(): Function;
+}

package/dist/types/interfaces/handler.interface.d.ts

@@ -0,0 +1,3 @@
+export interface CallHandler<T = any> {
+    handle(): Promise<T>;
+}

package/dist/types/interfaces/index.d.ts

@@ -1,2 +1,9 @@
 export * from './param.interface';
 export * from './route.interface';
+export * from './api-response.interface';
+export * from './activate.interface';
+export * from './features/execution-context.interface';
+export * from "./features/arguments-host.interface";
+export * from './type.interface';
+export * from './handler.interface';
+export * from './interceptor.interface';

package/dist/types/interfaces/interceptor.interface.d.ts

@@ -0,0 +1,5 @@
+import { ExecutionContext } from "./features/execution-context.interface";
+import { CallHandler } from "./handler.interface";
+export interface HemiaInterceptor<T = any, R = any> {
+    intercept(context: ExecutionContext, next: CallHandler<T>): Promise<R>;
+}

package/dist/types/interfaces/type.interface.d.ts

@@ -0,0 +1 @@
+export type Type<T = any> = new (...args: any[]) => T;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hemia/common",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Paquete común para proyectos de Hemia",
   "main": "dist/hemia-common.js",
   "module": "dist/hemia-common.esm.js",