aziosxjs 0.4.1 → 1.0.0

package/src/core/Azios.ts

@@ -0,0 +1,184 @@
+import dispatchRequest from "./dispatchRequest"
+import { AziosRequestConfig } from "../types/config"
+import type { AziosInstance } from "../types/request"
+import type { AziosPlugin } from "../types/plugin"
+import InterceptorManager from "../interceptors/InterceptorManager"
+import PluginManager from "../plugins/pluginManager"
+import MiddlewareManager from "../middleware/middlewareManager"
+import { compose } from "../middleware/compose"
+
+/**
+ * Core Azios HTTP client class
+ * Production-grade implementation with plugin system, middleware, and interceptors
+ */
+export default class Azios {
+  defaults: AziosRequestConfig
+
+  interceptors: {
+    request: InterceptorManager<AziosRequestConfig>
+    response: InterceptorManager<any>
+  }
+
+  middlewares: MiddlewareManager
+  plugins: PluginManager
+
+  constructor(config: AziosRequestConfig) {
+    this.defaults = config
+
+    this.interceptors = {
+      request: new InterceptorManager(),
+      response: new InterceptorManager()
+    }
+
+    this.middlewares = new MiddlewareManager()
+    this.plugins = new PluginManager()
+  }
+
+  /**
+   * Register middleware using Koa-style middleware pattern
+   */
+  use(fn: any) {
+    this.middlewares.use(fn)
+  }
+
+  /**
+   * Install a plugin into this instance
+   * @throws Error if plugin is already installed or installation fails
+   */
+  async installPlugin(plugin: AziosPlugin): Promise<void> {
+    await this.plugins.install(plugin, this as any as AziosInstance)
+  }
+
+  /**
+   * Uninstall a plugin by name
+   */
+  async uninstallPlugin(pluginName: string): Promise<void> {
+    await this.plugins.uninstall(pluginName, this as any as AziosInstance)
+  }
+
+  /**
+   * Core request method - central request pipeline
+   */
+  async request(config: AziosRequestConfig): Promise<any> {
+    config = { ...this.defaults, ...config }
+
+    // -------------------------
+    // PLUGIN: PRE-REQUEST HOOKS
+    // -------------------------
+    config = await this.plugins.executeBeforeRequestHooks(config)
+
+    // -------------------------
+    // MIDDLEWARE PIPELINE
+    // -------------------------
+    const context = { config }
+    const fn = compose(this.middlewares.middlewares)
+    await fn(context)
+    config = context.config
+
+    // -------------------------
+    // INTERCEPTOR PIPELINE
+    // -------------------------
+    const chain: any[] = []
+
+    // Request interceptors (reverse order)
+    this.interceptors.request.forEach(interceptor => {
+      chain.unshift(interceptor.fulfilled, interceptor.rejected)
+    })
+
+    // Main dispatch
+    chain.push(dispatchRequest, undefined)
+
+    // Response interceptors (normal order)
+    this.interceptors.response.forEach(interceptor => {
+      chain.push(interceptor.fulfilled, interceptor.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)
+    } catch (error) {
+      // -------------------------
+      // PLUGIN: ERROR HOOKS
+      // -------------------------
+      if (error instanceof Error) {
+        throw await this.plugins.executeOnErrorHooks(error)
+      }
+      throw error
+    }
+  }
+
+  // =========================================
+  // HTTP METHODS
+  // =========================================
+
+  get(url: string, config?: AziosRequestConfig) {
+    return this.request({
+      ...config,
+      method: "GET",
+      url
+    })
+  }
+
+  post(url: string, data?: any, config?: AziosRequestConfig) {
+    return this.request({
+      ...config,
+      method: "POST",
+      url,
+      data
+    })
+  }
+
+  put(url: string, data?: any, config?: AziosRequestConfig) {
+    return this.request({
+      ...config,
+      method: "PUT",
+      url,
+      data
+    })
+  }
+
+  patch(url: string, data?: any, config?: AziosRequestConfig) {
+    return this.request({
+      ...config,
+      method: "PATCH",
+      url,
+      data
+    })
+  }
+
+  delete(url: string, config?: AziosRequestConfig) {
+    return this.request({
+      ...config,
+      method: "DELETE",
+      url
+    })
+  }
+
+  head(url: string, config?: AziosRequestConfig) {
+    return this.request({
+      ...config,
+      method: "HEAD",
+      url
+    })
+  }
+
+  options(url: string, config?: AziosRequestConfig) {
+    return this.request({
+      ...config,
+      method: "OPTIONS",
+      url
+    })
+  }
+}

package/src/core/createInstance.ts

@@ -0,0 +1,23 @@
+import Azios from "./Azios"
+import { AziosRequestConfig } from "../types/config"
+import { AziosInstance } from "../types/request"
+
+export function createInstance(config: AziosRequestConfig): AziosInstance {
+
+  const context = new Azios(config)
+
+  const instance = Azios.prototype.request.bind(context) as AziosInstance
+
+  Object.getOwnPropertyNames(Azios.prototype).forEach(method => {
+
+    if (method !== "constructor") {
+      ;(instance as any)[method] = (Azios.prototype as any)[method].bind(context)
+    }
+
+  })
+
+  // attach interceptors
+  instance.interceptors = context.interceptors
+
+  return instance
+}

package/src/core/dispatchRequest.ts

@@ -0,0 +1,111 @@
+import { AziosRequestConfig } from "../types/config"
+import { AziosResponse } from "../types/response"
+import buildURL from "../helpers/buildURL"
+import AziosError from "../errors/AziosError"
+import AdapterFactory from "../runtimes/AdapterFactory"
+
+import { getPending, setPending, removePending } from "./requestStore"
+import { getCache, setCache } from "../cache/memoryCache"
+import { schedule } from "../rateLimiter/rateLimiter"
+
+/**
+ * Sleep utility for retry delays
+ */
+function delay(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms))
+}
+
+/**
+ * Make a single HTTP request using the universal adapter
+ * This ensures cross-runtime compatibility
+ */
+async function makeRequest(config: AziosRequestConfig): Promise<AziosResponse> {
+  const adapter = AdapterFactory.getAdapter()
+  return adapter.request(config)
+}
+
+export default async function dispatchRequest(config: AziosRequestConfig) {
+
+  const requestKey =
+    `${config.method}-${config.url}-${JSON.stringify(config.params)}`
+
+  // -------------------------
+  // CACHE CHECK (Sprint 4)
+  // -------------------------
+
+  if (config.cache) {
+
+    const cached = getCache(requestKey)
+
+    if (cached) {
+      return cached
+    }
+
+  }
+
+  // -------------------------
+  // DEDUPLICATION (Sprint 3)
+  // -------------------------
+
+  const existing = getPending(requestKey)
+
+  if (existing) {
+    return existing
+  }
+
+  const retries = config.retry || 0
+  const retryDelay = config.retryDelay || 300
+
+  let attempt = 0
+
+  const promise = (async () => {
+
+    while (true) {
+
+      try {
+
+        const task = () => makeRequest(config)
+
+        const response = config.rateLimit
+          ? await schedule(task, config.rateLimit)
+          : await task()
+
+        // -------------------------
+        // CACHE STORE
+        // -------------------------
+
+        if (config.cache) {
+          setCache(requestKey, response, config.cacheTTL ?? 5000)
+        }
+
+        removePending(requestKey)
+
+        return response
+
+      } catch (err) {
+
+        if (attempt >= retries) {
+
+          removePending(requestKey)
+
+          throw err
+
+        }
+
+        attempt++
+
+        const backoff = retryDelay * Math.pow(2, attempt)
+
+        await delay(backoff)
+
+      }
+
+    }
+
+  })()
+
+  setPending(requestKey, promise)
+
+  return promise
+
+}

package/src/core/requestStore.ts

@@ -0,0 +1,13 @@
+const pendingRequests = new Map()
+
+export function getPending(key: string) {
+  return pendingRequests.get(key)
+}
+
+export function setPending(key: string, promise: Promise<any>) {
+  pendingRequests.set(key, promise)
+}
+
+export function removePending(key: string) {
+  pendingRequests.delete(key)
+}

package/src/errors/AziosError.ts

@@ -0,0 +1,26 @@
+export default class AziosError extends Error {
+
+  config: any
+  code?: string
+  request?: any
+  response?: any
+
+  constructor(
+    message: string,
+    code?: string,
+    config?: any,
+    request?: any,
+    response?: any
+  ) {
+
+    super(message)
+
+    this.name = "AziosError"
+    this.code = code
+    this.config = config
+    this.request = request
+    this.response = response
+
+  }
+
+}

package/src/helpers/buildURL.ts

@@ -0,0 +1,44 @@
+export default function buildURL(
+  url: string,
+  params?: Record<string, any>
+) {
+
+  if (!params) return url
+
+  const parts: string[] = []
+
+  Object.keys(params).forEach(key => {
+
+    const val = params[key]
+
+    if (val === null || typeof val === "undefined") {
+      return
+    }
+
+    if (Array.isArray(val)) {
+
+      val.forEach(v => {
+        parts.push(
+          `${encodeURIComponent(key)}=${encodeURIComponent(v)}`
+        )
+      })
+
+    } else {
+
+      parts.push(
+        `${encodeURIComponent(key)}=${encodeURIComponent(val)}`
+      )
+
+    }
+
+  })
+
+  if (parts.length === 0) return url
+
+  const serialized = parts.join("&")
+
+  return url.includes("?")
+    ? `${url}&${serialized}`
+    : `${url}?${serialized}`
+
+}

package/src/index.ts

@@ -0,0 +1,64 @@
+import { createInstance } from "./core/createInstance"
+
+// Export main instance
+const azios = createInstance({
+  url: ""
+})
+
+// ============================================
+// Type Exports
+// ============================================
+
+export type { AziosRequestConfig } from "./types/config"
+export type { AziosResponse } from "./types/response"
+export type { AziosInstance } from "./types/request"
+export type { AziosPlugin, PluginHooks } from "./types/plugin"
+
+// ============================================
+// Class Exports
+// ============================================
+
+export { default as AziosError } from "./errors/AziosError"
+export { default as InterceptorManager } from "./interceptors/InterceptorManager"
+export { default as Azios } from "./core/Azios"
+export { createInstance } from "./core/createInstance"
+
+// ============================================
+// Plugin System Exports
+// ============================================
+
+export { default as PluginManager } from "./plugins/pluginManager"
+
+// ============================================
+// Middleware System Exports
+// ============================================
+
+export { default as MiddlewarePipeline } from "./middleware/MiddlewarePipeline"
+export type { RequestMiddleware, ResponseMiddleware } from "./middleware/MiddlewarePipeline"
+
+// ============================================
+// Runtime Support Exports
+// ============================================
+
+export {
+  detectRuntime,
+  currentRuntime,
+  isRuntime,
+  isServerRuntime,
+  isBrowserRuntime,
+  RuntimeType
+} from "./runtimes/detectRuntime"
+export { default as AdapterFactory } from "./runtimes/AdapterFactory"
+
+// ============================================
+// Cache & Rate Limit Exports
+// ============================================
+
+export { getCache, setCache, clearCache } from "./cache/memoryCache"
+export { schedule } from "./rateLimiter/rateLimiter"
+
+// ============================================
+// Default Export
+// ============================================
+
+export default azios

package/src/interceptors/InterceptorManager.ts

@@ -0,0 +1,30 @@
+type FulfilledFn<T> = (val: T) => T | Promise<T>
+type RejectedFn = (error: any) => any
+
+interface Interceptor<T> {
+  fulfilled: FulfilledFn<T>
+  rejected?: RejectedFn
+}
+
+export default class InterceptorManager<T> {
+
+  private handlers: Array<Interceptor<T> | null> = []
+
+  use(fulfilled: FulfilledFn<T>, rejected?: RejectedFn) {
+    this.handlers.push({
+      fulfilled,
+      rejected
+    })
+
+    return this.handlers.length - 1
+  }
+
+  forEach(fn: (interceptor: Interceptor<T>) => void) {
+    this.handlers.forEach(h => {
+      if (h !== null) {
+        fn(h)
+      }
+    })
+  }
+
+}

package/src/middleware/MiddlewarePipeline.ts

@@ -0,0 +1,155 @@
+import type { AziosRequestConfig } from '../types/config'
+import type { AziosResponse } from '../types/response'
+
+/**
+ * Middleware handler types
+ * Supports async middleware in the style of Koa
+ */
+export type RequestMiddleware = (
+  config: AziosRequestConfig,
+  next: () => Promise<AziosResponse>
+) => Promise<AziosResponse>
+
+export type ResponseMiddleware = (
+  response: AziosResponse,
+  next: () => Promise<AziosResponse>
+) => Promise<AziosResponse>
+
+/**
+ * Composition utility for middleware chaining
+ * Implements Koa-style middleware flow control
+ */
+export class MiddlewarePipeline {
+  private requestMiddleware: RequestMiddleware[] = []
+  private responseMiddleware: ResponseMiddleware[] = []
+
+  /**
+   * Add request middleware
+   * Middleware will execute in registration order
+   */
+  useRequest(middleware: RequestMiddleware): this {
+    this.requestMiddleware.push(middleware)
+    return this
+  }
+
+  /**
+   * Add response middleware
+   * Middleware will execute in registration order
+   */
+  useResponse(middleware: ResponseMiddleware): this {
+    this.responseMiddleware.push(middleware)
+    return this
+  }
+
+  /**
+   * Compose request middleware with proper async error handling
+   */
+  private composeRequest(): RequestMiddleware {
+    const middleware = this.requestMiddleware
+
+    return async (config: AziosRequestConfig, next: () => Promise<AziosResponse>) => {
+      let index = -1
+
+      const dispatch = async (i: number): Promise<AziosResponse> => {
+        if (i <= index) {
+          throw new Error('next() called multiple times in middleware')
+        }
+
+        index = i
+
+        try {
+          if (i < middleware.length) {
+            return await middleware[i](config, () => dispatch(i + 1))
+          } else {
+            return await next()
+          }
+        } catch (err) {
+          throw err
+        }
+      }
+
+      return dispatch(0)
+    }
+  }
+
+  /**
+   * Compose response middleware with proper async error handling
+   */
+  private composeResponse(): ResponseMiddleware {
+    const middleware = this.responseMiddleware
+
+    return async (response: AziosResponse, next: () => Promise<AziosResponse>) => {
+      let index = -1
+
+      const dispatch = async (i: number): Promise<AziosResponse> => {
+        if (i <= index) {
+          throw new Error('next() called multiple times in middleware')
+        }
+
+        index = i
+
+        try {
+          if (i < middleware.length) {
+            return await middleware[i](response, () => dispatch(i + 1))
+          } else {
+            return await next()
+          }
+        } catch (err) {
+          throw err
+        }
+      }
+
+      return dispatch(0)
+    }
+  }
+
+  /**
+   * Execute request middleware pipeline
+   */
+  async executeRequestMiddleware(
+    config: AziosRequestConfig,
+    next: () => Promise<AziosResponse>
+  ): Promise<AziosResponse> {
+    if (this.requestMiddleware.length === 0) {
+      return next()
+    }
+
+    const composed = this.composeRequest()
+    return composed(config, next)
+  }
+
+  /**
+   * Execute response middleware pipeline
+   */
+  async executeResponseMiddleware(
+    response: AziosResponse,
+    next: () => Promise<AziosResponse>
+  ): Promise<AziosResponse> {
+    if (this.responseMiddleware.length === 0) {
+      return next()
+    }
+
+    const composed = this.composeResponse()
+    return composed(response, next)
+  }
+
+  /**
+   * Clear all middleware
+   */
+  clear(): void {
+    this.requestMiddleware = []
+    this.responseMiddleware = []
+  }
+
+  /**
+   * Get registered middleware count
+   */
+  getMiddlewareCount(): { request: number; response: number } {
+    return {
+      request: this.requestMiddleware.length,
+      response: this.responseMiddleware.length
+    }
+  }
+}
+
+export default MiddlewarePipeline

package/src/middleware/compose.ts

@@ -0,0 +1,33 @@
+export function compose(middleware: any[]) {
+
+  return function (context: any) {
+
+    let index = -1
+
+    function dispatch(i: number): Promise<any> {
+
+      if (i <= index) {
+        return Promise.reject(new Error("next() called multiple times"))
+      }
+
+      index = i
+
+      const fn = middleware[i]
+
+      if (!fn) return Promise.resolve()
+
+      try {
+        return Promise.resolve(
+          fn(context, () => dispatch(i + 1))
+        )
+      } catch (err) {
+        return Promise.reject(err)
+      }
+
+    }
+
+    return dispatch(0)
+
+  }
+
+}

package/src/middleware/middlewareManager.ts

@@ -0,0 +1,9 @@
+export default class MiddlewareManager {
+
+  middlewares: any[] = []
+
+  use(fn: any) {
+    this.middlewares.push(fn)
+  }
+
+}