@igxjs/node-components 1.0.8 → 1.0.10

package/components/http-handlers.js

@@ -141,6 +141,12 @@ const _getErrorMessage = (error, defaultMessage) => {
 };
 
 export const httpHelper = {
+  /**
+   * Format a string with placeholders
+   * @param {string} str String with {0}, {1}, etc. placeholders
+   * @param {...string} args Values to replace placeholders
+   * @returns {string} Formatted string
+   */
   format (str, ...args) {
     const matched = str.match(/{\d}/ig);
     matched.forEach((element, index) => {

package/components/jwt.js

@@ -1,51 +1,89 @@
+import crypto from 'node:crypto';
+
 import { jwtDecrypt, EncryptJWT } from 'jose';
 
+/**
+ * JwtManager configuration options
+ * Uses strict UPPERCASE naming convention with JWT_ prefix for all property names.
+ */
 export class JwtManager {
+  /** @type {string} JWE algorithm */
+  algorithm;
+  
+  /** @type {string} Encryption method */
+  encryption;
+  
+  /** @type {string} Token expiration time */
+  expirationTime;
+  
+  /** @type {number} Clock tolerance in seconds */
+  clockTolerance;
+  
+  /** @type {string} Hash algorithm for secret derivation */
+  secretHashAlgorithm;
+  
+  /** @type {string|null} Optional JWT issuer claim */
+  issuer;
+  
+  /** @type {string|null} Optional JWT audience claim */
+  audience;
+  
+  /** @type {string|null} Optional JWT subject claim */
+  subject;
   /**
    * Create a new JwtManager instance with configurable defaults
-   * @param {Object} options Configuration options
-   * @param {string} [options.algorithm='dir'] JWE algorithm (e.g., 'dir', 'A128KW', 'A192KW', 'A256KW')
-   * @param {string} [options.encryption='A256GCM'] JWE encryption method (e.g., 'A256GCM', 'A128GCM', 'A192GCM')
-   * @param {string} [options.expirationTime='10m'] Token expiration time (e.g., '10m', '1h', '7d')
-   * @param {number} [options.clockTolerance=30] Clock tolerance in seconds for token validation
-   * @param {string} [options.secretHashAlgorithm='SHA-256'] Hash algorithm for secret derivation
-   * @param {string} [options.issuer] Optional JWT issuer claim
-   * @param {string} [options.audience] Optional JWT audience claim
-   * @param {string} [options.subject] Optional JWT subject claim
+   * Constructor options use UPPERCASE naming convention with JWT_ prefix (e.g., JWT_ALGORITHM).
+   * 
+   * @typedef {Object} JwtManagerOptions JwtManager configuration options
+   * @property {string} [JWT_ALGORITHM='dir'] JWE algorithm (default: 'dir')
+   * @property {string} [JWT_ENCRYPTION='A256GCM'] Encryption method (default: 'A256GCM')
+   * @property {string} [JWT_EXPIRATION_TIME='10m'] Token expiration time (default: '10m')
+   * @property {string} [JWT_SECRET_HASH_ALGORITHM='SHA-256'] Hash algorithm (default: 'SHA-256')
+   * @property {string?} [JWT_ISSUER] Optional JWT issuer claim
+   * @property {string?} [JWT_AUDIENCE] Optional JWT audience claim
+   * @property {string?} [JWT_SUBJECT] Optional JWT subject claim
+   * @property {number} [JWT_CLOCK_TOLERANCE=30] Clock tolerance in seconds (default: 30)
+   * @param {JwtManagerOptions} options Configuration options
    */
   constructor(options = {}) {
-    this.algorithm = options.algorithm || 'dir';
-    this.encryption = options.encryption || 'A256GCM';
-    this.expirationTime = options.expirationTime || '10m';
-    this.clockTolerance = options.clockTolerance ?? 30;
-    this.secretHashAlgorithm = options.secretHashAlgorithm || 'SHA-256';
-    this.issuer = options.issuer;
-    this.audience = options.audience;
-    this.subject = options.subject;
+    this.algorithm = options.JWT_ALGORITHM || 'dir';
+    this.encryption = options.JWT_ENCRYPTION || 'A256GCM';
+    this.expirationTime = options.JWT_EXPIRATION_TIME || '10m';
+    this.secretHashAlgorithm = options.JWT_SECRET_HASH_ALGORITHM || 'SHA-256';
+    this.issuer = options.JWT_ISSUER;
+    this.audience = options.JWT_AUDIENCE;
+    this.subject = options.JWT_SUBJECT;
+    this.clockTolerance = options.JWT_CLOCK_TOLERANCE ?? 30;
   }
 
+  /**
+   * Encrypt method options (camelCase naming convention, uses instance defaults when not provided)
+   * 
+   * @typedef {Object} JwtEncryptOptions Encryption method options
+   * @property {string} [algorithm='dir'] JWE algorithm (overrides instance JWT_ALGORITHM)
+   * @property {string} [encryption='A256GCM'] Encryption method (overrides instance JWT_ENCRYPTION)
+   * @property {string} [expirationTime='10m'] Token expiration time (overrides instance JWT_EXPIRATION_TIME)
+   * @property {string} [secretHashAlgorithm='SHA-256'] Hash algorithm for secret derivation (overrides instance JWT_SECRET_HASH_ALGORITHM)
+   * @property {string?} [issuer] Optional JWT issuer claim (overrides instance JWT_ISSUER)
+   * @property {string?} [audience] Optional JWT audience claim (overrides instance JWT_AUDIENCE)
+   * @property {string?} [subject] Optional JWT subject claim (overrides instance JWT_SUBJECT)
+   */
   /**
    * Generate JWT token for user session
+   * 
    * @param {import('jose').JWTPayload} data User data payload
    * @param {string} secret Secret key or password for encryption
-   * @param {Object} [options] Per-call configuration overrides
-   * @param {string} [options.algorithm] Override default algorithm
-   * @param {string} [options.encryption] Override default encryption method
-   * @param {string} [options.expirationTime] Override default expiration time
-   * @param {string} [options.secretHashAlgorithm] Override default hash algorithm
-   * @param {string} [options.issuer] Override default issuer claim
-   * @param {string} [options.audience] Override default audience claim
-   * @param {string} [options.subject] Override default subject claim
+   * @param {JwtEncryptOptions} [options] Per-call configuration overrides (camelCase naming convention)
    * @returns {Promise<string>} Returns encrypted JWT token
    */
   async encrypt(data, secret, options = {}) {
-    const algorithm = options.algorithm || this.algorithm;
-    const encryption = options.encryption || this.encryption;
-    const expirationTime = options.expirationTime || this.expirationTime;
-    const secretHashAlgorithm = options.secretHashAlgorithm || this.secretHashAlgorithm;
-    const issuer = options.issuer || this.issuer;
-    const audience = options.audience || this.audience;
-    const subject = options.subject || this.subject;
+    const algorithm = options.algorithm ?? this.algorithm;
+    const encryption = options.encryption ?? this.encryption;
+    const expirationTime = options.expirationTime ?? this.expirationTime;
+    const secretHashAlgorithm = options.secretHashAlgorithm ?? this.secretHashAlgorithm;
+    const issuer = options.issuer ?? this.issuer;
+    const audience = options.audience ?? this.audience;
+    const subject = options.subject ?? this.subject;
 
     const secretHash = await crypto.subtle.digest(
       secretHashAlgorithm,
@@ -69,23 +107,29 @@ export class JwtManager {
   }
 
   /**
-   * Decrypt JWT token for user session
+   * Decrypt method options (camelCase naming convention, uses instance defaults when not provided)
+   * 
+   * @typedef {Object} JwtDecryptOptions Decryption method options
+   * @property {number} [clockTolerance=30] Clock tolerance in seconds (overrides instance JWT_CLOCK_TOLERANCE)
+   * @property {string} [secretHashAlgorithm='SHA-256'] Hash algorithm for secret derivation (overrides instance JWT_SECRET_HASH_ALGORITHM)
+   * @property {string?} [issuer] Optional JWT issuer claim for validation (overrides instance JWT_ISSUER)
+   * @property {string?} [audience] Optional JWT audience claim for validation (overrides instance JWT_AUDIENCE)
+   * @property {string?} [subject] Optional JWT subject claim for validation (overrides instance JWT_SUBJECT)
+   **/
+  /**
+   * Decrypt JWT
+   * 
    * @param {string} token JWT token to decrypt
    * @param {string} secret Secret key or password for decryption
-   * @param {Object} [options] Per-call configuration overrides
-   * @param {number} [options.clockTolerance] Override default clock tolerance
-   * @param {string} [options.secretHashAlgorithm] Override default hash algorithm
-   * @param {string} [options.issuer] Expected issuer claim for validation
-   * @param {string} [options.audience] Expected audience claim for validation
-   * @param {string} [options.subject] Expected subject claim for validation
-   * @returns {Promise<import('jose').JWTDecryptResult<import('jose').EncryptJWT>>} Returns decrypted JWT token
+   * @param {JwtDecryptOptions} [options] Per-call configuration overrides (camelCase naming convention)
+   * @returns {Promise<import('jose').JWTDecryptResult<import('jose').EncryptJWT>} Returns decrypted JWT token
    */
   async decrypt(token, secret, options = {}) {
     const clockTolerance = options.clockTolerance ?? this.clockTolerance;
-    const secretHashAlgorithm = options.secretHashAlgorithm || this.secretHashAlgorithm;
-    const issuer = options.issuer || this.issuer;
-    const audience = options.audience || this.audience;
-    const subject = options.subject || this.subject;
+    const secretHashAlgorithm = options.secretHashAlgorithm ?? this.secretHashAlgorithm;
+    const issuer = options.issuer ?? this.issuer;
+    const audience = options.audience ?? this.audience;
+    const subject = options.subject ?? this.subject;
 
     const secretHash = await crypto.subtle.digest(
       secretHashAlgorithm,
@@ -101,4 +145,4 @@ export class JwtManager {
 
     return await jwtDecrypt(token, new Uint8Array(secretHash), decryptOptions);
   }
-}
+}

package/components/session.js

@@ -2,13 +2,15 @@ import axios from 'axios';
 import session from 'express-session';
 import memStore from 'memorystore';
 import { RedisStore } from 'connect-redis';
-import { jwtDecrypt } from 'jose';
 
 import { CustomError, httpCodes, httpHelper, httpMessages } from './http-handlers.js';
+import { JwtManager } from './jwt.js';
 import { RedisManager } from './redis.js';
 
-const MemoryStore = memStore(session);
-
+/**
+ * Session configuration options
+ * Uses strict UPPERCASE naming convention for all property names
+ */
 export class SessionConfig {
   /** @type {string} */
   SSO_ENDPOINT_URL;
@@ -34,6 +36,23 @@ export class SessionConfig {
   REDIS_URL;
   /** @type {string} */
   REDIS_CERT_PATH;
+
+  /** @type {string} */
+  JWT_ALGORITHM;
+  /** @type {string} */
+  JWT_ENCRYPTION;
+  /** @type {string} */
+  JWT_EXPIRATION_TIME;
+  /** @type {number} */
+  JWT_CLOCK_TOLERANCE;
+  /** @type {string} */
+  JWT_SECRET_HASH_ALGORITHM;
+  /** @type {string} */
+  JWT_ISSUER;
+  /** @type {string} */
+  JWT_AUDIENCE;
+  /** @type {string} */
+  JWT_SUBJECT;
 }
 
 export class SessionManager {
@@ -45,6 +64,8 @@ export class SessionManager {
   #redisManager = null;
   /** @type {import('axios').AxiosInstance} */
   #idpRequest = null;
+  /** @type {import('./jwt.js').JwtManager} */
+  #jwtManager = null;
 
   /**
    * Create a new session manager
@@ -66,6 +87,15 @@ export class SessionManager {
       // Redis
       REDIS_URL: config.REDIS_URL,
       REDIS_CERT_PATH: config.REDIS_CERT_PATH,
+      // JWT Manager
+      JWT_ALGORITHM: config.JWT_ALGORITHM || 'dir',
+      JWT_ENCRYPTION: config.JWT_ENCRYPTION || 'A256GCM',
+      JWT_EXPIRATION_TIME: config.JWT_EXPIRATION_TIME || '10m',
+      JWT_CLOCK_TOLERANCE: config.JWT_CLOCK_TOLERANCE ?? 30,
+      JWT_SECRET_HASH_ALGORITHM: config.JWT_SECRET_HASH_ALGORITHM || 'SHA-256',
+      JWT_ISSUER: config.JWT_ISSUER,
+      JWT_AUDIENCE: config.JWT_AUDIENCE,
+      JWT_SUBJECT: config.JWT_SUBJECT,
     };
   }
 
@@ -126,6 +156,7 @@ export class SessionManager {
    */
   async setup(app, updateUser) {
     this.#redisManager = new RedisManager();
+    this.#jwtManager = new JwtManager(this.#config);
     // Identity Provider Request
     this.#idpRequest = axios.create({
       baseURL: this.#config.SSO_ENDPOINT_URL,
@@ -158,6 +189,7 @@ export class SessionManager {
   #memorySession() {
     // Memory Session
     console.log('### Using Memory as the Session Store ###');
+    const MemoryStore = memStore(session);
     return session({
       cookie: { maxAge: this.#config.SESSION_AGE, path: this.#config.SESSION_COOKIE_PATH, sameSite: false },
       store: new MemoryStore({}),
@@ -221,7 +253,7 @@ export class SessionManager {
    */
   #saveSession = async (request, jwt, initUser) => {
     /** @type {{ payload: { user: import('../models/types/user').UserModel, redirect_url: string } }} */
-    const { payload } = await this.#decryptJWT(jwt, this.#config.SSO_CLIENT_SECRET);
+    const { payload } = await this.#jwtManager.decrypt(jwt, this.#config.SSO_CLIENT_SECRET);
     if (payload?.user) {
       console.debug('### CALLBACK USER ###');
       request.session[this.#getSessionKey()] = initUser(payload.user);
@@ -365,18 +397,4 @@ export class SessionManager {
       return callback(null);
     });
   }
-
-  /**
-   * Decrypt JWT data for user session
-   * @param {string} data JWT data
-   * @param {string} input Input string for encryption
-   * @returns {Promise<import('jose').JWTDecryptResult<import('jose').EncryptJWT>>} Returns decrypted JWT payload
-   */
-  async #decryptJWT(data, input) {
-    const secret = await crypto.subtle.digest(
-      'SHA-256',
-      new TextEncoder().encode(input)
-    );
-    return await jwtDecrypt(data, new Uint8Array(secret), { clockTolerance: 30 });
-  }
 }

package/index.d.ts

@@ -1,12 +1,13 @@
 import 'express-session';
 
 import { AxiosError } from 'axios';
-import { EncryptJWT, JWTDecryptResult } from 'jose';
+import { EncryptJWT, JWTDecryptResult, JWTPayload } from 'jose';
 import { RedisClientType } from '@redis/client';
 import { Application, RequestHandler, Request, Response, NextFunction, Router } from 'express';
 
-// Session Configuration
+// Session Configuration - uses strict UPPERCASE naming convention for all property names
 export interface SessionConfig {
+  /** Identity Provider */
   SSO_ENDPOINT_URL?: string;
   SSO_CLIENT_ID?: string;
   SSO_CLIENT_SECRET?: string;
@@ -58,7 +59,7 @@ export interface SessionUser {
 export class SessionManager {
   /**
    * Constructor
-   * @param config - Session configuration
+   * @param config - Session configuration (uses strict UPPERCASE property names)
    */
   constructor(config: SessionConfig);
 
@@ -187,7 +188,7 @@ export class RedisManager {
 
   /**
    * Determine if the Redis server is connected
-   * @returns Returns true if Redis server is connected
+   * @returns Returns true if the Redis server is connected
    */
   isConnected(): Promise<boolean>;
 
@@ -198,57 +199,80 @@ export class RedisManager {
   disConnect(): Promise<void>;
 }
 
-// JWT Manager Configuration
+// JWT Manager Configuration - uses strict UPPERCASE naming convention with JWT_ prefix for all property names
 export interface JwtManagerOptions {
-  /** @type {string} JWE algorithm (default: 'dir') */
-  algorithm?: string;
-  /** @type {string} JWE encryption method (default: 'A256GCM') */
-  encryption?: string;
-  /** @type {string} Token expiration time (default: '10m') */
-  expirationTime?: string;
-  /** @type {number} Clock tolerance in seconds for token validation (default: 30) */
-  clockTolerance?: number;
-  /** @type {string} Hash algorithm for secret derivation (default: 'SHA-256') */
-  secretHashAlgorithm?: string;
-  /** @type {string} Optional JWT issuer claim */
-  issuer?: string;
-  /** @type {string} Optional JWT audience claim */
-  audience?: string;
-  /** @type {string} Optional JWT subject claim */
-  subject?: string;
+  /** JWE algorithm (default: 'dir') */
+  JWT_ALGORITHM?: string;
+  
+  /** JWE encryption method (default: 'A256GCM') */
+  JWT_ENCRYPTION?: string;
+  
+  /** Token expiration time (default: '10m') */
+  JWT_EXPIRATION_TIME?: string;
+  
+  /** Clock tolerance in seconds for token validation (default: 30) */
+  JWT_CLOCK_TOLERANCE?: number;
+  
+  /** Hash algorithm for secret derivation (default: 'SHA-256') */
+  JWT_SECRET_HASH_ALGORITHM?: string;
+  
+  /** Optional JWT issuer claim */
+  JWT_ISSUER?: string;
+  
+  /** Optional JWT audience claim */
+  JWT_AUDIENCE?: string;
+  
+  /** Optional JWT subject claim */
+  JWT_SUBJECT?: string;
 }
 
+/**
+ * Options for encrypt() method - uses camelCase naming convention
+ */
 export interface JwtEncryptOptions {
-  /** @type {string} Override default algorithm */
+  /** Override default algorithm */
   algorithm?: string;
-  /** @type {string} Override default encryption method */
+
+  /** Override default encryption method */
   encryption?: string;
-  /** @type {string} Override default expiration time */
+
+  /** Override default expiration time */
   expirationTime?: string;
-  /** @type {string} Override default hash algorithm */
+
+  /** Override default hash algorithm */
   secretHashAlgorithm?: string;
-  /** @type {string} Override default issuer claim */
+
+  /** Override default issuer claim */
   issuer?: string;
-  /** @type {string} Override default audience claim */
+
+  /** Override default audience claim */
   audience?: string;
-  /** @type {string} Override default subject claim */
+
+  /** Override default subject claim */
   subject?: string;
 }
 
+/**
+ * Options for decrypt() method - uses camelCase naming convention
+ */
 export interface JwtDecryptOptions {
-  /** @type {number} Override default clock tolerance */
+  /** Override default clock tolerance */
   clockTolerance?: number;
-  /** @type {string} Override default hash algorithm */
+
+  /** Override default hash algorithm */
   secretHashAlgorithm?: string;
-  /** @type {string} Expected issuer claim for validation */
+
+  /** Expected issuer claim for validation */
   issuer?: string;
-  /** @type {string} Expected audience claim for validation */
+
+  /** Expected audience claim for validation */
   audience?: string;
-  /** @type {string} Expected subject claim for validation */
+
+  /** Expected subject claim for validation */
   subject?: string;
 }
 
-export type DecryptedJWT = JWTDecryptResult<EncryptJWT>;
+export type JwtDecryptResult = JWTDecryptResult<EncryptJWT>;
 // JwtManager class for JWT encryption and decryption
 export class JwtManager {
   algorithm: string;
@@ -262,7 +286,7 @@ export class JwtManager {
 
   /**
    * Create a new JwtManager instance with configurable defaults
-   * @param options Configuration options
+   * @param options Configuration options (uses strict UPPERCASE with JWT_ prefix property names)
    */
   constructor(options?: JwtManagerOptions);
 
@@ -270,19 +294,19 @@ export class JwtManager {
    * Generate JWT token for user session
    * @param data User data payload
    * @param input Secret key or password for encryption
-   * @param options Per-call configuration overrides
+   * @param options Per-call configuration overrides (uses strict UPPERCASE with JWT_ prefix property names)
    * @returns Returns encrypted JWT token
    */
-  encrypt( JWTPayload, input: string, options?: JwtEncryptOptions): Promise<string>;
+  encrypt(data: JWTPayload, input: string, options?: JwtEncryptOptions): Promise<string>;
 
   /**
    * Decrypt JWT token for user session
    * @param token JWT token to decrypt
    * @param input Secret key or password for decryption
-   * @param options Per-call configuration overrides
+   * @param options Per-call configuration overrides (uses strict UPPERCASE with JWT_ prefix property names)
    * @returns Returns decrypted JWT token
    */
-  decrypt(token: string, input: string, options?: JwtDecryptOptions): Promise<DecryptedJWT>;
+  decrypt(token: string, input: string, options?: JwtDecryptOptions): Promise<JwtDecryptResult>;
 }
 
 // HTTP status code keys (exposed for type safety)
@@ -400,4 +424,4 @@ declare module 'express-session' {
     [key: string]: any;
     user?: SessionUser;
   }
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@igxjs/node-components",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "Node components for igxjs",
   "main": "index.js",
   "type": "module",
@@ -26,16 +26,23 @@
     "axios": "^1.13.6",
     "connect-redis": "^9.0.0",
     "express-session": "^1.19.0",
-    "jose": "^6.1.3",
+    "jose": "^6.2.0",
     "memorystore": "^1.6.7"
   },
   "devDependencies": {
     "chai": "^6.2.2",
     "express": "^5.2.1",
-    "mocha": "^11.0.1",
+    "mocha": "^12.0.0-beta-10",
     "sinon": "^21.0.2",
     "supertest": "^7.0.0"
   },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "components/",
+    "LICENSE",
+    "README.md"
+  ],
   "publishConfig": {
     "access": "public"
   },

package/.github/workflows/node.js.yml

@@ -1,31 +0,0 @@
-# This workflow will do a clean installation of node dependencies, cache/restore them, build the source code and run tests across different versions of node
-# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-nodejs
-
-name: Node.js CI
-
-on:
-  push:
-    branches: [ "main" ]
-  pull_request:
-    branches: [ "main" ]
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        node-version: [18.x, 20.x, 22.x]
-        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
-
-    steps:
-    - uses: actions/checkout@v4
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v4
-      with:
-        node-version: ${{ matrix.node-version }}
-        cache: 'npm'
-    - run: npm ci
-    - run: npm run build --if-present
-    - run: npm test

package/.github/workflows/npm-publish.yml

@@ -1,33 +0,0 @@
-# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
-# For more information see: https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages
-
-name: Node.js Package
-
-on:
-  release:
-    types: [created]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 20
-      - run: npm ci
-      - run: npm test
-
-  publish-npm:
-    needs: build
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 20
-          registry-url: https://registry.npmjs.org/
-      - run: npm ci
-      - run: npm publish
-        env:
-          NODE_AUTH_TOKEN: ${{secrets.npm_token}}

package/docs/README.md

@@ -1,54 +0,0 @@
-# Node Components Documentation
-
-Detailed documentation for `@igxjs/node-components` - shared components for Express.js applications.
-
-## 📚 Component Documentation
-
-### Core Modules
-
-- **[SessionManager](./session-manager.md)** - SSO session management with Redis and memory storage
-  - Configuration options and singleton pattern
-  - Complete setup and usage examples
-  - API reference for all methods
-
-- **[FlexRouter](./flex-router.md)** - Flexible routing utility for Express.js
-  - Context path and middleware management
-  - API versioning and route organization
-  - Advanced usage patterns
-
-- **[RedisManager](./redis-manager.md)** - Redis connection management
-  - TLS/SSL support
-  - Connection monitoring and error handling
-  - Direct Redis operations
-
-- **[JWT Manager](./jwt-manager.md)** - JWT encryption and decryption
-  - Secure token-based authentication
-  - Express.js integration patterns
-  - Refresh token implementation
-
-- **[HTTP Handlers](./http-handlers.md)** - Standardized error handling
-  - Custom error classes and middleware
-  - HTTP status codes and messages
-  - Axios error handling and validation helpers
-
-## 🚀 Quick Links
-
-- [Main README](../README.md) - Package overview and installation
-- [GitHub Repository](https://github.com/igxjs/node-components)
-
-## 💡 Getting Help
-
-If you need help:
-1. Check the relevant component documentation above
-2. Review the examples in each guide
-3. Look at the type definitions in `index.d.ts`
-4. Open an issue on GitHub
-
-## 📖 Documentation Structure
-
-Each component documentation includes:
-- Overview of features
-- Configuration options
-- Basic and advanced usage examples
-- Complete API reference
-- Related documentation links