aziosxjs 1.0.0 → 1.0.2

package/src/adapters/httpAdapter.ts

@@ -0,0 +1,152 @@
+import * as http from 'http'
+import * as https from 'https'
+import { URL } from 'url'
+import type { AziosRequestConfig } from '../types/config'
+import type { AziosResponse } from '../types/response'
+import { BaseAdapter } from '../runtimes/HttpAdapter'
+import AziosError from '../errors/AziosError'
+
+/**
+ * Node.js HTTP adapter using built-in http/https modules
+ * Compatible with Node.js 16+ (before global fetch was available)
+ */
+export class NodeHttpAdapter extends BaseAdapter {
+  /**
+   * Check if this adapter is supported (Node.js environment)
+   */
+  isSupported(): boolean {
+    // In Node.js, this adapter is always supported
+    return true
+  }
+
+  /**
+   * Execute HTTP request using Node.js http/https modules
+   */
+  async request(config: AziosRequestConfig): Promise<AziosResponse> {
+    if (!this.isSupported()) {
+      throw new AziosError(
+        'Node HTTP adapter is not supported in this runtime',
+        'UNSUPPORTED_RUNTIME',
+        config
+      )
+    }
+
+    // Check if request is already cancelled
+    if (config.signal && config.signal.aborted) {
+      throw new AziosError(
+        'Request aborted',
+        'ABORTED',
+        config
+      )
+    }
+
+    return new Promise((resolve, reject) => {
+      const { url, method = 'GET', headers = {}, data, timeout, signal } = config
+
+      const baseURL = config.baseURL || ''
+      const fullURL = new URL(baseURL + url)
+
+      // Add query parameters
+      if (config.params) {
+        Object.entries(config.params).forEach(([key, value]) => {
+          if (value !== null && value !== undefined) {
+            if (Array.isArray(value)) {
+              value.forEach(v => fullURL.searchParams.append(key, String(v)))
+            } else {
+              fullURL.searchParams.set(key, String(value))
+            }
+          }
+        })
+      }
+
+      const isHttps = fullURL.protocol === 'https:'
+      const client = isHttps ? https : http
+
+      const options: http.RequestOptions = {
+        hostname: fullURL.hostname,
+        port: fullURL.port || (isHttps ? 443 : 80),
+        path: fullURL.pathname + fullURL.search,
+        method: method.toUpperCase(),
+        headers: {
+          'Content-Type': 'application/json',
+          ...headers
+        }
+      }
+
+      // Handle timeout
+      let timeoutId: NodeJS.Timeout | undefined
+      if (timeout) {
+        timeoutId = setTimeout(() => {
+          req.destroy(new Error('Request timeout'))
+        }, timeout)
+      }
+
+      // Handle abort signal
+      if (signal) {
+        signal.addEventListener('abort', () => {
+          req.destroy(new Error('Request aborted'))
+        })
+      }
+
+      const req = client.request(options, (res) => {
+        let body = ''
+
+        res.on('data', (chunk) => {
+          body += chunk
+        })
+
+        res.on('end', () => {
+          if (timeoutId) {
+            clearTimeout(timeoutId)
+          }
+
+          let responseData: any = body
+
+          // Parse JSON if content-type is application/json
+          const contentType = res.headers['content-type']
+          if (contentType?.includes('application/json') && body) {
+            try {
+              responseData = JSON.parse(body)
+            } catch (e) {
+              // Keep as string if parsing fails
+            }
+          }
+
+          const response: AziosResponse = {
+            data: responseData,
+            status: res.statusCode || 200,
+            statusText: res.statusMessage || '',
+            headers: res.headers as Record<string, string>,
+            config
+          }
+
+          resolve(response)
+        })
+      })
+
+      req.on('error', (error) => {
+        if (timeoutId) {
+          clearTimeout(timeoutId)
+        }
+        const errorCode = error.message.includes('aborted') ? 'ABORTED' : 'NETWORK_ERROR'
+        reject(new AziosError(
+          `Request failed: ${error.message}`,
+          errorCode,
+          config,
+          undefined,
+          error
+        ))
+      })
+
+      // Send request body
+      if (data) {
+        const body = typeof data === 'string' ? data : JSON.stringify(data)
+        req.write(body)
+      }
+
+      req.end()
+    })
+  }
+}
+
+export default NodeHttpAdapter

package/src/adapters/index.ts

@@ -0,0 +1 @@
+export { default as NodeHttpAdapter } from './httpAdapter'

package/src/auth/AuthManager.ts

@@ -0,0 +1,283 @@
+import type { AziosInstance } from "../types/request"
+import type { AziosRequestConfig } from "../types/config"
+import type { AziosResponse } from "../types/response"
+
+/**
+ * Token storage and refresh configuration
+ */
+export interface TokenConfig {
+  accessToken: string
+  refreshToken?: string
+  expiresIn?: number
+  tokenType?: string
+}
+
+/**
+ * Auth endpoints configuration
+ */
+export interface AuthEndpoints {
+  refreshUrl: string
+  logoutUrl?: string
+}
+
+/**
+ * Auth Manager - Handle authentication, token refresh, and 401 responses
+ * Production-grade auth system with automatic token refresh and global 401 handling
+ */
+export default class AuthManager {
+  private token: TokenConfig | null = null
+  private endpoints: AuthEndpoints | null = null
+  private instance: AziosInstance | null = null
+  private isRefreshing: boolean = false
+  private refreshSubscribers: ((token: string) => void)[] = []
+
+  /**
+   * Initialize the auth manager with endpoints
+   */
+  initialize(endpoints: AuthEndpoints): void {
+    this.endpoints = endpoints
+  }
+
+  /**
+   * Set the Azios instance for making refresh requests
+   */
+  setInstance(instance: AziosInstance): void {
+    this.instance = instance
+  }
+
+  /**
+   * Store token
+   */
+  setToken(token: TokenConfig): void {
+    this.token = token
+  }
+
+  /**
+   * Get current token
+   */
+  getToken(): TokenConfig | null {
+    return this.token
+  }
+
+  /**
+   * Get access token string
+   */
+  getAccessToken(): string | null {
+    return this.token?.accessToken || null
+  }
+
+  /**
+   * Check if token exists
+   */
+  hasToken(): boolean {
+    return this.token !== null && this.token.accessToken !== ""
+  }
+
+  /**
+   * Check if token is expired
+   */
+  isTokenExpired(): boolean {
+    if (!this.token || !this.token.expiresIn) {
+      return false
+    }
+
+    // Check if expiry time has passed (with 60s buffer)
+    return Date.now() > this.token.expiresIn - 60000
+  }
+
+  /**
+   * Clear token
+   */
+  clearToken(): void {
+    this.token = null
+    this.refreshSubscribers = []
+  }
+
+  /**
+   * Refresh the access token
+   */
+  async refreshAccessToken(): Promise<boolean> {
+    if (!this.instance || !this.endpoints) {
+      console.warn("AuthManager not properly initialized")
+      return false
+    }
+
+    if (!this.token?.refreshToken) {
+      console.warn("No refresh token available")
+      return false
+    }
+
+    try {
+      // Prevent multiple simultaneous refresh requests
+      if (this.isRefreshing) {
+        return new Promise(resolve => {
+          this.refreshSubscribers.push(() => {
+            resolve(true)
+          })
+        })
+      }
+
+      this.isRefreshing = true
+
+      const response = await this.instance.post(
+        this.endpoints.refreshUrl,
+        { refreshToken: this.token.refreshToken }
+      )
+
+      if (response.data?.accessToken) {
+        this.token = {
+          ...this.token,
+          accessToken: response.data.accessToken,
+          expiresIn: Date.now() + (response.data.expiresIn || 3600000)
+        }
+
+        // Notify all subscribers
+        this.refreshSubscribers.forEach(cb => cb(this.token!.accessToken))
+        this.refreshSubscribers = []
+
+        this.isRefreshing = false
+        return true
+      }
+
+      this.isRefreshing = false
+      return false
+    } catch (error) {
+      this.isRefreshing = false
+      console.error("Token refresh failed:", error)
+      return false
+    }
+  }
+
+  /**
+   * Get Authorization header value
+   */
+  getAuthHeader(): string | null {
+    if (!this.hasToken()) {
+      return null
+    }
+
+    const tokenType = this.token?.tokenType || "Bearer"
+    return `${tokenType} ${this.token?.accessToken}`
+  }
+
+  /**
+   * Attach auth header to request
+   */
+  attachAuthHeader(config: AziosRequestConfig): AziosRequestConfig {
+    const authHeader = this.getAuthHeader()
+
+    if (authHeader) {
+      return {
+        ...config,
+        headers: {
+          ...config.headers,
+          Authorization: authHeader
+        }
+      }
+    }
+
+    return config
+  }
+
+  /**
+   * Handle 401 response (unauthorized)
+   */
+  async handle401(config: AziosRequestConfig): Promise<boolean> {
+    if (!this.hasToken()) {
+      // No token to refresh
+      return false
+    }
+
+    const refreshed = await this.refreshAccessToken()
+
+    if (refreshed) {
+      // Update the failed request with new token
+      return true
+    }
+
+    // Token refresh failed, logout
+    await this.logout()
+    return false
+  }
+
+  /**
+   * Logout user
+   */
+  async logout(): Promise<void> {
+    if (this.instance && this.endpoints?.logoutUrl) {
+      try {
+        await this.instance.post(this.endpoints.logoutUrl)
+      } catch (error) {
+        console.error("Logout failed:", error)
+      }
+    }
+
+    this.clearToken()
+  }
+
+  /**
+   * Get auth status summary
+   */
+  getStatus(): {
+    authenticated: boolean
+    tokenExpired: boolean
+    refreshToken: boolean
+  } {
+    return {
+      authenticated: this.hasToken(),
+      tokenExpired: this.isTokenExpired(),
+      refreshToken: this.token?.refreshToken !== undefined
+    }
+  }
+}
+
+/**
+ * Create auth plugin that integrates with Azios
+ */
+export function createAuthPlugin(endpoints: AuthEndpoints) {
+  const authManager = new AuthManager()
+  authManager.initialize(endpoints)
+
+  return {
+    name: "auth",
+    version: "1.0.0",
+    hooks: {
+      onInstall: async (instance: AziosInstance) => {
+        authManager.setInstance(instance)
+
+        // Add response interceptor to handle 401
+        instance.interceptors.response.use(
+          (response: AziosResponse) => response,
+          async (error: any) => {
+            const originalRequest = error.config
+
+            // Check if error is 401 and retry hasn't been attempted
+            if (
+              error.response?.status === 401 &&
+              !originalRequest._retry &&
+              authManager.hasToken()
+            ) {
+              originalRequest._retry = true
+
+              try {
+                const refreshed = await authManager.handle401(originalRequest)
+
+                if (refreshed) {
+                  // Retry original request with new token
+                  const newConfig = authManager.attachAuthHeader(originalRequest)
+                  return instance.request(newConfig)
+                }
+              } catch (refreshError) {
+                console.error("Auth refresh failed:", refreshError)
+              }
+            }
+
+            throw error
+          }
+        )
+      }
+    }
+  }
+}
+
+export type { AuthManager }

package/src/core/Azios.ts

@@ -6,6 +6,7 @@ import InterceptorManager from "../interceptors/InterceptorManager"
 import PluginManager from "../plugins/pluginManager"
 import MiddlewareManager from "../middleware/middlewareManager"
 import { compose } from "../middleware/compose"
+import RequestMonitor from "../monitoring/RequestMonitor"
 
 /**
  * Core Azios HTTP client class
@@ -21,6 +22,7 @@ export default class Azios {
 
   middlewares: MiddlewareManager
   plugins: PluginManager
+  monitor: RequestMonitor
 
   constructor(config: AziosRequestConfig) {
     this.defaults = config
@@ -32,6 +34,7 @@ export default class Azios {
 
     this.middlewares = new MiddlewareManager()
     this.plugins = new PluginManager()
+    this.monitor = new RequestMonitor(100, false) // Disabled by default
   }
 
   /**
@@ -63,52 +66,69 @@ export default class Azios {
     config = { ...this.defaults, ...config }
 
     // -------------------------
-    // PLUGIN: PRE-REQUEST HOOKS
+    // MONITORING: START TRACKING
     // -------------------------
-    config = await this.plugins.executeBeforeRequestHooks(config)
+    const requestId = this.monitor.startRequest(config)
 
-    // -------------------------
-    // MIDDLEWARE PIPELINE
-    // -------------------------
-    const context = { config }
-    const fn = compose(this.middlewares.middlewares)
-    await fn(context)
-    config = context.config
+    try {
+      // -------------------------
+      // PLUGIN: PRE-REQUEST HOOKS
+      // -------------------------
+      config = await this.plugins.executeBeforeRequestHooks(config)
 
-    // -------------------------
-    // INTERCEPTOR PIPELINE
-    // -------------------------
-    const chain: any[] = []
+      // -------------------------
+      // MIDDLEWARE PIPELINE
+      // -------------------------
+      const context = { config }
+      const fn = compose(this.middlewares.middlewares)
+      await fn(context)
+      config = context.config
 
-    // Request interceptors (reverse order)
-    this.interceptors.request.forEach(interceptor => {
-      chain.unshift(interceptor.fulfilled, interceptor.rejected)
-    })
+      // -------------------------
+      // INTERCEPTOR PIPELINE
+      // -------------------------
+      const chain: any[] = []
 
-    // Main dispatch
-    chain.push(dispatchRequest, undefined)
+      // Request interceptors (reverse order)
+      this.interceptors.request.forEach(interceptor => {
+        chain.unshift(interceptor.fulfilled, interceptor.rejected)
+      })
 
-    // Response interceptors (normal order)
-    this.interceptors.response.forEach(interceptor => {
-      chain.push(interceptor.fulfilled, interceptor.rejected)
-    })
+      // Main dispatch
+      chain.push(dispatchRequest, undefined)
 
-    let promise = Promise.resolve(config)
+      // Response interceptors (normal order)
+      this.interceptors.response.forEach(interceptor => {
+        chain.push(interceptor.fulfilled, interceptor.rejected)
+      })
 
-    while (chain.length) {
-      const fulfilled = chain.shift()
-      const rejected = chain.shift()
-      promise = promise.then(fulfilled, rejected)
-    }
+      let promise = Promise.resolve(config)
+
+      while (chain.length) {
+        const fulfilled = chain.shift()
+        const rejected = chain.shift()
+        promise = promise.then(fulfilled, rejected)
+      }
 
-    try {
       const response = await promise as any
 
       // -------------------------
       // PLUGIN: POST-RESPONSE HOOKS
       // -------------------------
-      return await this.plugins.executeAfterResponseHooks(response)
+      const finalResponse = await this.plugins.executeAfterResponseHooks(response)
+
+      // -------------------------
+      // MONITORING: END TRACKING (SUCCESS)
+      // -------------------------
+      this.monitor.endRequest(requestId, config, finalResponse)
+
+      return finalResponse
     } catch (error) {
+      // -------------------------
+      // MONITORING: END TRACKING (ERROR)
+      // -------------------------
+      this.monitor.endRequestWithError(requestId, config, error)
+
       // -------------------------
       // PLUGIN: ERROR HOOKS
       // -------------------------

package/src/index.ts

@@ -5,6 +5,8 @@ const azios = createInstance({
   url: ""
 })
 
+export default azios
+
 // ============================================
 // Type Exports
 // ============================================
@@ -48,17 +50,25 @@ export {
   isBrowserRuntime,
   RuntimeType
 } from "./runtimes/detectRuntime"
-export { default as AdapterFactory } from "./runtimes/AdapterFactory"
 
 // ============================================
-// Cache & Rate Limit Exports
+// NEW: Monitoring System Exports
 // ============================================
 
-export { getCache, setCache, clearCache } from "./cache/memoryCache"
-export { schedule } from "./rateLimiter/rateLimiter"
+export { default as RequestMonitor } from "./monitoring/RequestMonitor"
+export type { RequestLog } from "./monitoring/RequestMonitor"
 
 // ============================================
-// Default Export
+// NEW: Authentication System Exports
 // ============================================
 
-export default azios
+export { default as AuthManager, createAuthPlugin } from "./auth/AuthManager"
+export type { TokenConfig, AuthEndpoints, AuthManager as IAuthManager } from "./auth/AuthManager"
+export { default as AdapterFactory } from "./runtimes/AdapterFactory"
+
+// ============================================
+// Cache & Rate Limit Exports
+// ============================================
+
+export { getCache, setCache, clearCache } from "./cache/memoryCache"
+export { schedule } from "./rateLimiter/rateLimiter"