opticore-api-gateway 1.0.0

package/dist/index.d.cts

@@ -0,0 +1,329 @@
+import { TFeatureRoutes, ICustomContext, TRouteHandler, IMultipleRouterConfig, IMultipleRouteDefinition } from 'opticore-router';
+import * as express from 'express';
+import * as http from 'node:http';
+
+interface IServiceConfig {
+    name: string;
+    url: string;
+    healthCheck?: string;
+    weight?: number;
+    timeout?: number;
+    retries?: number;
+}
+
+interface ICircuitBreakerConfig {
+    failureThreshold: number;
+    resetTimeout: number;
+    halfOpenMaxAttempts: number;
+}
+
+/**
+ *
+ */
+interface IRouteConfig {
+    path: string;
+    method: 'get' | 'post' | 'put' | 'delete' | 'patch' | 'options' | 'head';
+    target: string | string[];
+    middlewares?: any[];
+    timeout?: number;
+    retries?: number;
+    circuitBreaker?: ICircuitBreakerConfig;
+    serviceName?: string;
+}
+
+interface IGatewayConfig {
+    port: number;
+    services: IServiceConfig[];
+    routes: IRouteConfig[];
+    globalMiddlewares?: any[];
+    loadBalancer?: 'round-robin' | 'weighted' | 'random' | 'least-connections';
+    enableLogging?: boolean;
+    enableMetrics?: boolean;
+}
+
+type TMiddlewareFunction = (req: any, res: any, next: () => void) => void | Promise<void>;
+
+declare class APIGateway {
+    private config;
+    private server;
+    private serviceRegistry;
+    private loadBalancer;
+    private httpClient;
+    private middlewareChain;
+    private routes;
+    private opticoreRoutes;
+    private registerRouter;
+    constructor(config: IGatewayConfig);
+    private initializeServices;
+    private initializeGlobalMiddlewares;
+    private initializeRoutes;
+    private buildOpticoreRoutes;
+    private handleGatewayRequest;
+    private extractServiceName;
+    private rewriteUrl;
+    private forwardRequest;
+    private sendResponse;
+    addRoute(routeConfig: IRouteConfig): void;
+    addMiddleware(middleware: TMiddlewareFunction): void;
+    registerService(service: any): void;
+    getOpticoreRoutes(): TFeatureRoutes[];
+    private parseRequestBody;
+    getExpressMiddleware(): (req: any, res: any, next: () => void) => void;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}
+
+interface IServiceInstance extends IServiceConfig {
+    healthy: boolean;
+    currentConnections: number;
+    lastHealthCheck: Date;
+    failureCount: number;
+    circuitState: 'closed' | 'open' | 'half-open';
+    circuitOpenTime?: Date;
+}
+
+type TGatewayContext = ICustomContext & {
+    serviceUrl?: string;
+    serviceInstance?: IServiceInstance;
+    gatewayStartTime?: number;
+};
+
+declare class GatewayRoute {
+    private readonly localLanguage;
+    private readonly config;
+    private standaloneRouter;
+    private collectionRouter;
+    private readonly routeHandler;
+    private logger;
+    /**
+     *
+     * @param config
+     * @param routeHandler
+     * @param localLanguage
+     */
+    constructor(config: IRouteConfig, routeHandler: TRouteHandler, localLanguage: string);
+    /**
+     * Method for creating a multi-router configuration
+     *
+     * @param controller
+     */
+    createMultipleRouterConfig(controller: any): IMultipleRouterConfig<TGatewayContext>;
+    /**
+     * Method for creating a router collection
+     *
+     * @param controller
+     * @param routes
+     */
+    createCollectionRouter(controller: any, routes: IMultipleRouterConfig<TGatewayContext>[]): void;
+    /**
+     * Get the standalone router
+     *
+     * @param strategy
+     * @param options
+     */
+    getStandaloneRoute(strategy?: string, options?: any): express.Router;
+    /**
+     * Get the definition of multiple routes
+     */
+    getMultipleRouteDefinition(): IMultipleRouteDefinition;
+    /**
+     *
+     */
+    getConfig(): IRouteConfig;
+    /**
+     * Utility method for creating an Opticore-compatible route
+     *
+     * @param path
+     * @param handler
+     */
+    static createOpticoreRouteDefinition(path: string, handler: TRouteHandler): {
+        path: string;
+        handler: any;
+    };
+}
+
+declare abstract class BaseMiddleware {
+    abstract handle(): TMiddlewareFunction;
+}
+declare class MiddlewareChain {
+    private middlewares;
+    add(middleware: TMiddlewareFunction): void;
+    execute(req: any, res: any, finalHandler: TMiddlewareFunction): Promise<void>;
+    getAll(): TMiddlewareFunction[];
+}
+
+/**
+ *
+ */
+declare class ServiceRegistry {
+    private services;
+    private serviceHealthChecks;
+    private circuitBreakers;
+    registerService(service: IServiceConfig): void;
+    private startHealthCheck;
+    getServiceInstances(serviceName: string): IServiceInstance[];
+    getHealthyInstances(serviceName: string): IServiceInstance[];
+    recordSuccess(serviceName: string, url: string): void;
+    recordFailure(serviceName: string, url: string): void;
+    deregisterService(serviceName: string, url: string): void;
+    getAllServices(): Map<string, IServiceInstance[]>;
+}
+
+type TLoadBalancingStrategy = 'round-robin' | 'weighted' | 'random' | 'least-connections';
+
+/**
+ *
+ */
+declare class LoadBalancer {
+    private strategy;
+    private counters;
+    constructor(strategy?: TLoadBalancingStrategy);
+    /**
+     *
+     * @param serviceName
+     * @param instances
+     */
+    selectInstance(serviceName: string, instances: IServiceInstance[]): IServiceInstance | null;
+    /**
+     *
+     * @param serviceName
+     * @param instances
+     * @private
+     */
+    private roundRobin;
+    /**
+     *
+     * @param instances
+     * @private
+     */
+    private random;
+    /**
+     *
+     * @param instances
+     * @private
+     */
+    private weighted;
+    /**
+     *
+     * @param instances
+     * @private
+     */
+    private leastConnections;
+    /**
+     *
+     * @param strategy
+     */
+    setStrategy(strategy: TLoadBalancingStrategy): void;
+}
+
+interface IHttpResponse {
+    status: number;
+    headers: Record<string, string | string[]>;
+    body: string;
+}
+
+interface IHttpRequestOptions {
+    method: string;
+    headers?: http.OutgoingHttpHeaders | http.OutgoingHttpHeader[];
+    body?: any;
+    timeout?: number;
+}
+
+declare class HttpClient {
+    /**
+     *
+     * @param url
+     * @param options
+     */
+    request(url: string, options: IHttpRequestOptions): Promise<IHttpResponse>;
+    /**
+     *
+     * @param method
+     * @private
+     */
+    private getDefaultHeaders;
+    /**
+     *
+     * @param req
+     * @param body
+     * @param headers
+     * @private
+     */
+    private writeRequestBody;
+    /**
+     *
+     * @param headers
+     * @private
+     */
+    private getContentType;
+    /**
+     *
+     * @param url
+     * @param headers
+     */
+    get(url: string, headers?: Record<string, string>): Promise<IHttpResponse>;
+    /**
+     *
+     * @param url
+     * @param body
+     * @param headers
+     */
+    post(url: string, body: any, headers?: Record<string, string>): Promise<IHttpResponse>;
+    /**
+     *
+     * @param url
+     * @param body
+     * @param headers
+     */
+    put(url: string, body: any, headers?: Record<string, string>): Promise<IHttpResponse>;
+    /**
+     *
+     * @param url
+     * @param headers
+     */
+    delete(url: string, headers?: Record<string, string>): Promise<IHttpResponse>;
+    /**
+     *
+     * @param url
+     * @param body
+     * @param headers
+     */
+    patch(url: string, body: any, headers?: Record<string, string>): Promise<IHttpResponse>;
+}
+
+declare class AuthMiddleware extends BaseMiddleware {
+    private apiKeys;
+    constructor(apiKeys?: string[]);
+    handle(): TMiddlewareFunction;
+}
+
+/**
+ *
+ */
+declare class RateLimitMiddleware extends BaseMiddleware {
+    private requestsPerWindow;
+    private windowMs;
+    private store;
+    constructor(requestsPerWindow?: number, windowMs?: number);
+    handle(): TMiddlewareFunction;
+}
+
+declare class LoggingMiddleware extends BaseMiddleware {
+    private logLevel;
+    constructor(logLevel?: 'info' | 'debug' | 'error');
+    handle(): TMiddlewareFunction;
+}
+
+declare class ValidationMiddleware extends BaseMiddleware {
+    private validator;
+    private target;
+    /**
+     * Crée un middleware de validation.
+     * @param schema - Le schéma de validation au format opticore-validator.
+     * @param target - La partie de la requête à valider (par défaut 'body').
+     */
+    constructor(schema: any, target?: 'body' | 'query' | 'params' | 'all');
+    handle(): TMiddlewareFunction;
+}
+
+export { APIGateway, AuthMiddleware, BaseMiddleware, GatewayRoute, HttpClient, type ICircuitBreakerConfig, type IGatewayConfig, type IRouteConfig, type IServiceConfig, LoadBalancer, LoggingMiddleware, MiddlewareChain, RateLimitMiddleware, ServiceRegistry, type TLoadBalancingStrategy, type TMiddlewareFunction, ValidationMiddleware };

package/dist/index.d.ts

@@ -0,0 +1,329 @@
+import { TFeatureRoutes, ICustomContext, TRouteHandler, IMultipleRouterConfig, IMultipleRouteDefinition } from 'opticore-router';
+import * as express from 'express';
+import * as http from 'node:http';
+
+interface IServiceConfig {
+    name: string;
+    url: string;
+    healthCheck?: string;
+    weight?: number;
+    timeout?: number;
+    retries?: number;
+}
+
+interface ICircuitBreakerConfig {
+    failureThreshold: number;
+    resetTimeout: number;
+    halfOpenMaxAttempts: number;
+}
+
+/**
+ *
+ */
+interface IRouteConfig {
+    path: string;
+    method: 'get' | 'post' | 'put' | 'delete' | 'patch' | 'options' | 'head';
+    target: string | string[];
+    middlewares?: any[];
+    timeout?: number;
+    retries?: number;
+    circuitBreaker?: ICircuitBreakerConfig;
+    serviceName?: string;
+}
+
+interface IGatewayConfig {
+    port: number;
+    services: IServiceConfig[];
+    routes: IRouteConfig[];
+    globalMiddlewares?: any[];
+    loadBalancer?: 'round-robin' | 'weighted' | 'random' | 'least-connections';
+    enableLogging?: boolean;
+    enableMetrics?: boolean;
+}
+
+type TMiddlewareFunction = (req: any, res: any, next: () => void) => void | Promise<void>;
+
+declare class APIGateway {
+    private config;
+    private server;
+    private serviceRegistry;
+    private loadBalancer;
+    private httpClient;
+    private middlewareChain;
+    private routes;
+    private opticoreRoutes;
+    private registerRouter;
+    constructor(config: IGatewayConfig);
+    private initializeServices;
+    private initializeGlobalMiddlewares;
+    private initializeRoutes;
+    private buildOpticoreRoutes;
+    private handleGatewayRequest;
+    private extractServiceName;
+    private rewriteUrl;
+    private forwardRequest;
+    private sendResponse;
+    addRoute(routeConfig: IRouteConfig): void;
+    addMiddleware(middleware: TMiddlewareFunction): void;
+    registerService(service: any): void;
+    getOpticoreRoutes(): TFeatureRoutes[];
+    private parseRequestBody;
+    getExpressMiddleware(): (req: any, res: any, next: () => void) => void;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}
+
+interface IServiceInstance extends IServiceConfig {
+    healthy: boolean;
+    currentConnections: number;
+    lastHealthCheck: Date;
+    failureCount: number;
+    circuitState: 'closed' | 'open' | 'half-open';
+    circuitOpenTime?: Date;
+}
+
+type TGatewayContext = ICustomContext & {
+    serviceUrl?: string;
+    serviceInstance?: IServiceInstance;
+    gatewayStartTime?: number;
+};
+
+declare class GatewayRoute {
+    private readonly localLanguage;
+    private readonly config;
+    private standaloneRouter;
+    private collectionRouter;
+    private readonly routeHandler;
+    private logger;
+    /**
+     *
+     * @param config
+     * @param routeHandler
+     * @param localLanguage
+     */
+    constructor(config: IRouteConfig, routeHandler: TRouteHandler, localLanguage: string);
+    /**
+     * Method for creating a multi-router configuration
+     *
+     * @param controller
+     */
+    createMultipleRouterConfig(controller: any): IMultipleRouterConfig<TGatewayContext>;
+    /**
+     * Method for creating a router collection
+     *
+     * @param controller
+     * @param routes
+     */
+    createCollectionRouter(controller: any, routes: IMultipleRouterConfig<TGatewayContext>[]): void;
+    /**
+     * Get the standalone router
+     *
+     * @param strategy
+     * @param options
+     */
+    getStandaloneRoute(strategy?: string, options?: any): express.Router;
+    /**
+     * Get the definition of multiple routes
+     */
+    getMultipleRouteDefinition(): IMultipleRouteDefinition;
+    /**
+     *
+     */
+    getConfig(): IRouteConfig;
+    /**
+     * Utility method for creating an Opticore-compatible route
+     *
+     * @param path
+     * @param handler
+     */
+    static createOpticoreRouteDefinition(path: string, handler: TRouteHandler): {
+        path: string;
+        handler: any;
+    };
+}
+
+declare abstract class BaseMiddleware {
+    abstract handle(): TMiddlewareFunction;
+}
+declare class MiddlewareChain {
+    private middlewares;
+    add(middleware: TMiddlewareFunction): void;
+    execute(req: any, res: any, finalHandler: TMiddlewareFunction): Promise<void>;
+    getAll(): TMiddlewareFunction[];
+}
+
+/**
+ *
+ */
+declare class ServiceRegistry {
+    private services;
+    private serviceHealthChecks;
+    private circuitBreakers;
+    registerService(service: IServiceConfig): void;
+    private startHealthCheck;
+    getServiceInstances(serviceName: string): IServiceInstance[];
+    getHealthyInstances(serviceName: string): IServiceInstance[];
+    recordSuccess(serviceName: string, url: string): void;
+    recordFailure(serviceName: string, url: string): void;
+    deregisterService(serviceName: string, url: string): void;
+    getAllServices(): Map<string, IServiceInstance[]>;
+}
+
+type TLoadBalancingStrategy = 'round-robin' | 'weighted' | 'random' | 'least-connections';
+
+/**
+ *
+ */
+declare class LoadBalancer {
+    private strategy;
+    private counters;
+    constructor(strategy?: TLoadBalancingStrategy);
+    /**
+     *
+     * @param serviceName
+     * @param instances
+     */
+    selectInstance(serviceName: string, instances: IServiceInstance[]): IServiceInstance | null;
+    /**
+     *
+     * @param serviceName
+     * @param instances
+     * @private
+     */
+    private roundRobin;
+    /**
+     *
+     * @param instances
+     * @private
+     */
+    private random;
+    /**
+     *
+     * @param instances
+     * @private
+     */
+    private weighted;
+    /**
+     *
+     * @param instances
+     * @private
+     */
+    private leastConnections;
+    /**
+     *
+     * @param strategy
+     */
+    setStrategy(strategy: TLoadBalancingStrategy): void;
+}
+
+interface IHttpResponse {
+    status: number;
+    headers: Record<string, string | string[]>;
+    body: string;
+}
+
+interface IHttpRequestOptions {
+    method: string;
+    headers?: http.OutgoingHttpHeaders | http.OutgoingHttpHeader[];
+    body?: any;
+    timeout?: number;
+}
+
+declare class HttpClient {
+    /**
+     *
+     * @param url
+     * @param options
+     */
+    request(url: string, options: IHttpRequestOptions): Promise<IHttpResponse>;
+    /**
+     *
+     * @param method
+     * @private
+     */
+    private getDefaultHeaders;
+    /**
+     *
+     * @param req
+     * @param body
+     * @param headers
+     * @private
+     */
+    private writeRequestBody;
+    /**
+     *
+     * @param headers
+     * @private
+     */
+    private getContentType;
+    /**
+     *
+     * @param url
+     * @param headers
+     */
+    get(url: string, headers?: Record<string, string>): Promise<IHttpResponse>;
+    /**
+     *
+     * @param url
+     * @param body
+     * @param headers
+     */
+    post(url: string, body: any, headers?: Record<string, string>): Promise<IHttpResponse>;
+    /**
+     *
+     * @param url
+     * @param body
+     * @param headers
+     */
+    put(url: string, body: any, headers?: Record<string, string>): Promise<IHttpResponse>;
+    /**
+     *
+     * @param url
+     * @param headers
+     */
+    delete(url: string, headers?: Record<string, string>): Promise<IHttpResponse>;
+    /**
+     *
+     * @param url
+     * @param body
+     * @param headers
+     */
+    patch(url: string, body: any, headers?: Record<string, string>): Promise<IHttpResponse>;
+}
+
+declare class AuthMiddleware extends BaseMiddleware {
+    private apiKeys;
+    constructor(apiKeys?: string[]);
+    handle(): TMiddlewareFunction;
+}
+
+/**
+ *
+ */
+declare class RateLimitMiddleware extends BaseMiddleware {
+    private requestsPerWindow;
+    private windowMs;
+    private store;
+    constructor(requestsPerWindow?: number, windowMs?: number);
+    handle(): TMiddlewareFunction;
+}
+
+declare class LoggingMiddleware extends BaseMiddleware {
+    private logLevel;
+    constructor(logLevel?: 'info' | 'debug' | 'error');
+    handle(): TMiddlewareFunction;
+}
+
+declare class ValidationMiddleware extends BaseMiddleware {
+    private validator;
+    private target;
+    /**
+     * Crée un middleware de validation.
+     * @param schema - Le schéma de validation au format opticore-validator.
+     * @param target - La partie de la requête à valider (par défaut 'body').
+     */
+    constructor(schema: any, target?: 'body' | 'query' | 'params' | 'all');
+    handle(): TMiddlewareFunction;
+}
+
+export { APIGateway, AuthMiddleware, BaseMiddleware, GatewayRoute, HttpClient, type ICircuitBreakerConfig, type IGatewayConfig, type IRouteConfig, type IServiceConfig, LoadBalancer, LoggingMiddleware, MiddlewareChain, RateLimitMiddleware, ServiceRegistry, type TLoadBalancingStrategy, type TMiddlewareFunction, ValidationMiddleware };