qhttpx 1.8.5 → 1.8.11

package/src/core/buffer-pool.ts

@@ -1,96 +0,0 @@
-/**
- * Buffer pool for response bodies (small, medium, large).
- * Reuses allocated buffers to reduce GC pressure.
- */
-
-export type BufferPoolConfig = {
-  smallSize?: number; // Default: 4KB
-  mediumSize?: number; // Default: 64KB
-  largeSize?: number; // Default: 256KB
-  smallPoolSize?: number; // Number of small buffers to maintain
-  mediumPoolSize?: number; // Number of medium buffers to maintain
-  largePoolSize?: number; // Number of large buffers to maintain
-};
-
-export class BufferPool {
-  private readonly smallSize: number;
-  private readonly mediumSize: number;
-  private readonly largeSize: number;
-
-  private readonly smallBuffers: Buffer[] = [];
-  private readonly mediumBuffers: Buffer[] = [];
-  private readonly largeBuffers: Buffer[] = [];
-
-  private readonly smallPoolSize: number;
-  private readonly mediumPoolSize: number;
-  private readonly largePoolSize: number;
-
-  constructor(config: BufferPoolConfig = {}) {
-    this.smallSize = config.smallSize ?? 4096; // 4KB
-    this.mediumSize = config.mediumSize ?? 65536; // 64KB
-    this.largeSize = config.largeSize ?? 262144; // 256KB
-
-    this.smallPoolSize = config.smallPoolSize ?? 32;
-    this.mediumPoolSize = config.mediumPoolSize ?? 8;
-    this.largePoolSize = config.largePoolSize ?? 2;
-
-    // Preallocate buffers
-    for (let i = 0; i < this.smallPoolSize; i += 1) {
-      this.smallBuffers.push(Buffer.allocUnsafe(this.smallSize));
-    }
-    for (let i = 0; i < this.mediumPoolSize; i += 1) {
-      this.mediumBuffers.push(Buffer.allocUnsafe(this.mediumSize));
-    }
-    for (let i = 0; i < this.largePoolSize; i += 1) {
-      this.largeBuffers.push(Buffer.allocUnsafe(this.largeSize));
-    }
-  }
-
-  /**
-   * Acquire a buffer suitable for the given size.
-   * Returns a buffer from the appropriate pool.
-   */
-  acquire(size: number): Buffer {
-    if (size <= this.smallSize) {
-      return this.smallBuffers.pop() || Buffer.allocUnsafe(this.smallSize);
-    }
-    if (size <= this.mediumSize) {
-      return this.mediumBuffers.pop() || Buffer.allocUnsafe(this.mediumSize);
-    }
-    return this.largeBuffers.pop() || Buffer.allocUnsafe(this.largeSize);
-  }
-
-  /**
-   * Release a buffer back to the appropriate pool.
-   */
-  release(buffer: Buffer): void {
-    if (buffer.length === this.smallSize && this.smallBuffers.length < this.smallPoolSize) {
-      this.smallBuffers.push(buffer);
-    } else if (
-      buffer.length === this.mediumSize &&
-      this.mediumBuffers.length < this.mediumPoolSize
-    ) {
-      this.mediumBuffers.push(buffer);
-    } else if (
-      buffer.length === this.largeSize &&
-      this.largeBuffers.length < this.largePoolSize
-    ) {
-      this.largeBuffers.push(buffer);
-    }
-  }
-
-  /**
-   * Get the number of available buffers in each pool.
-   */
-  getPoolStatus(): {
-    small: number;
-    medium: number;
-    large: number;
-  } {
-    return {
-      small: this.smallBuffers.length,
-      medium: this.mediumBuffers.length,
-      large: this.largeBuffers.length,
-    };
-  }
-}

package/src/core/config.ts

@@ -1,60 +0,0 @@
-import type { QHTTPXOptions } from './types';
-
-export type LoadConfigOptions = {
-  env?: NodeJS.ProcessEnv;
-  defaults?: QHTTPXOptions;
-  prefix?: string;
-};
-
-export function loadConfig(options: LoadConfigOptions = {}): QHTTPXOptions {
-  const env = options.env ?? process.env;
-  const defaults = options.defaults ?? {};
-  const prefix = options.prefix ?? 'QHTTPX_';
-
-  const getNumber = (key: string): number | undefined => {
-    const value = env[prefix + key];
-    if (!value) {
-      return undefined;
-    }
-    const n = Number(value);
-    if (!Number.isFinite(n) || n <= 0) {
-      return undefined;
-    }
-    return n;
-  };
-
-  const getBoolean = (key: string): boolean | undefined => {
-    const value = env[prefix + key];
-    if (!value) {
-      return undefined;
-    }
-    const lower = value.toLowerCase();
-    if (lower === 'true' || lower === '1') {
-      return true;
-    }
-    if (lower === 'false' || lower === '0') {
-      return false;
-    }
-    return undefined;
-  };
-
-  const maxConcurrency = getNumber('MAX_CONCURRENCY');
-  const requestTimeoutMs = getNumber('REQUEST_TIMEOUT_MS');
-  const maxMemoryBytes = getNumber('MAX_MEMORY_BYTES');
-  const maxBodyBytes = getNumber('MAX_BODY_BYTES');
-  const keepAliveTimeoutMs = getNumber('KEEP_ALIVE_TIMEOUT_MS');
-  const headersTimeoutMs = getNumber('HEADERS_TIMEOUT_MS');
-  const metricsEnabled = getBoolean('METRICS_ENABLED');
-
-  return {
-    ...defaults,
-    maxConcurrency: maxConcurrency ?? defaults.maxConcurrency,
-    requestTimeoutMs: requestTimeoutMs ?? defaults.requestTimeoutMs,
-    maxMemoryBytes: maxMemoryBytes ?? defaults.maxMemoryBytes,
-    maxBodyBytes: maxBodyBytes ?? defaults.maxBodyBytes,
-    keepAliveTimeoutMs: keepAliveTimeoutMs ?? defaults.keepAliveTimeoutMs,
-    headersTimeoutMs: headersTimeoutMs ?? defaults.headersTimeoutMs,
-    metricsEnabled: metricsEnabled ?? defaults.metricsEnabled,
-  };
-}
-

package/src/core/fusion.ts

@@ -1,210 +0,0 @@
-import type { QHTTPXContext } from './types';
-import { createHash } from 'crypto';
-
-export interface RequestFusionOptions {
-  windowMs?: number;
-  vary?: string[];
-}
-
-interface FusionResult {
-  type: 'json' | 'send' | 'html' | 'redirect';
-  payload: unknown;
-  status: number;
-  contentType?: string;
-}
-
-export class RequestFusion {
-  private inflight: Map<string, Promise<FusionResult>> = new Map();
-  private cache: Map<string, { result: FusionResult; expires: number }> = new Map();
-  private options: RequestFusionOptions;
-
-  constructor(options: boolean | RequestFusionOptions = {}) {
-    this.options = typeof options === 'boolean' ? {} : options;
-    if (!this.options.vary) {
-      this.options.vary = ['authorization', 'cookie'];
-    }
-  }
-
-  public async coalesce(ctx: QHTTPXContext, next: (ctx: QHTTPXContext) => Promise<void> | void): Promise<void> {
-    const key = this.getKey(ctx);
-
-    // 1. Check Cache (Short-lived "Micro-TTL")
-    if (this.options.windowMs && this.options.windowMs > 0) {
-      const cached = this.cache.get(key);
-      if (cached) {
-        if (Date.now() < cached.expires) {
-          this.applyResult(ctx, cached.result);
-          return;
-        } else {
-          this.cache.delete(key);
-        }
-      }
-    }
-
-    // 2. Check In-Flight
-    if (this.inflight.has(key)) {
-      try {
-        const result = await this.inflight.get(key)!;
-        this.applyResult(ctx, result);
-        return;
-      } catch (err) {
-        // If leader failed, we should probably fail too or retry?
-        // For now, let's propagate the error.
-        throw err;
-      }
-    }
-
-    // 3. Be the Leader
-    let resolve: (value: FusionResult) => void;
-    let reject: (reason?: unknown) => void;
-    const promise = new Promise<FusionResult>((res, rej) => {
-      resolve = res;
-      reject = rej;
-    });
-
-    this.inflight.set(key, promise);
-
-    // Hijack context methods to capture result
-    // Cast to any to allow overwriting readonly methods
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const mutableCtx = ctx as any;
-    
-    const originalJson = mutableCtx.json;
-    const originalSend = mutableCtx.send;
-    const originalHtml = mutableCtx.html;
-    const originalRedirect = mutableCtx.redirect;
-
-    let captured = false;
-
-    // Helper to cleanup and resolve
-    const finish = (result: FusionResult) => {
-      if (captured) return;
-      captured = true;
-      resolve(result);
-
-      // Cache if needed
-      if (this.options.windowMs && this.options.windowMs > 0) {
-        this.cache.set(key, {
-          result,
-          expires: Date.now() + this.options.windowMs
-        });
-        // Cleanup cache later
-        setTimeout(() => this.cache.delete(key), this.options.windowMs);
-      }
-
-      // Remove from inflight immediately (unless we rely on cache for window)
-      // Actually, if we have windowMs, we rely on cache.
-      // If windowMs=0, we remove immediately.
-      this.inflight.delete(key);
-    };
-
-    mutableCtx.json = (payload: unknown, status = 200) => {
-      finish({ type: 'json', payload, status });
-      return originalJson.call(ctx, payload, status);
-    };
-
-    mutableCtx.send = (payload: string | Buffer, status = 200) => {
-      finish({ type: 'send', payload, status });
-      return originalSend.call(ctx, payload, status);
-    };
-
-    mutableCtx.html = (payload: string, status = 200) => {
-      finish({ type: 'html', payload, status });
-      return originalHtml.call(ctx, payload, status);
-    };
-
-    mutableCtx.redirect = (url: string, status = 302) => {
-      finish({ type: 'redirect', payload: url, status });
-      return originalRedirect.call(ctx, url, status);
-    };
-
-    try {
-      await next(ctx);
-      // If next() completes but no response method was called, 
-      // it implies the handler might be async and forgot to await, 
-      // or it's a 404/middleware issue.
-      // If not captured yet, we can't resolve the followers properly.
-      // They will hang unless we reject or resolve with something.
-      // However, typical QHTTPX usage implies ctx.json/send is called.
-    } catch (err) {
-      reject!(err);
-      this.inflight.delete(key);
-      // Restore methods
-      mutableCtx.json = originalJson;
-      mutableCtx.send = originalSend;
-      mutableCtx.html = originalHtml;
-      mutableCtx.redirect = originalRedirect;
-      throw err;
-    }
-  }
-
-  private applyResult(ctx: QHTTPXContext, result: FusionResult) {
-    switch (result.type) {
-      case 'json':
-        ctx.json(result.payload, result.status);
-        break;
-      case 'send': {
-        if (typeof result.payload === 'string' || Buffer.isBuffer(result.payload)) {
-          ctx.send(result.payload as string | Buffer, result.status);
-        } else {
-          ctx.send(String(result.payload), result.status);
-        }
-        break;
-      }
-      case 'html': {
-        if (typeof result.payload === 'string') {
-          ctx.html(result.payload as string, result.status);
-        } else {
-          ctx.html(String(result.payload), result.status);
-        }
-        break;
-      }
-      case 'redirect': {
-        if (typeof result.payload === 'string') {
-          ctx.redirect(result.payload as string, result.status);
-        } else {
-          ctx.redirect(String(result.payload), result.status);
-        }
-        break;
-      }
-    }
-  }
-
-  private getKey(ctx: QHTTPXContext): string {
-    // Base: Method + Path
-    let data = `${ctx.req.method}|${ctx.url?.pathname}|`;
-
-    // Query
-    if (ctx.query) {
-      // Deterministic sort
-      const keys = Object.keys(ctx.query).sort();
-      for (const k of keys) {
-        data += `${k}=${ctx.query[k]}|`;
-      }
-    }
-
-    // Body (if parsed)
-    if (ctx.body) {
-      // We assume body is simple JSON.
-      // For objects, order matters for hashing.
-      // fast-json-stringify or JSON.stringify isn't always deterministic key order.
-      // But for performance, JSON.stringify is often "good enough" if keys aren't shuffled.
-      // For strict correctness, we should use a canonical stringify, but that's slow.
-      // Let's use JSON.stringify for now.
-      data += JSON.stringify(ctx.body);
-    }
-
-    // Vary Headers
-    if (this.options.vary) {
-      for (const header of this.options.vary) {
-        const val = ctx.req.headers[header.toLowerCase()];
-        if (val) {
-          data += `|${header}:${val}`;
-        }
-      }
-    }
-
-    // We hash it to keep the key size manageable
-    return createHash('sha1').update(data).digest('hex');
-  }
-}

package/src/core/logger.ts

@@ -1,70 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import pino from 'pino';
-
-export type LogLevel = 'fatal' | 'error' | 'warn' | 'info' | 'debug' | 'trace';
-
-export interface LoggerOptions {
-  level?: LogLevel;
-  pretty?: boolean;
-  name?: string;
-}
-
-export class Logger {
-  private pino: pino.Logger;
-
-  constructor(options: LoggerOptions = {}) {
-    const isDev = process.env.NODE_ENV !== 'production';
-    const pretty = options.pretty ?? isDev;
-
-    this.pino = pino({
-      name: options.name || 'qhttpx',
-      level: options.level || 'info',
-      transport: pretty
-        ? {
-            target: 'pino-pretty',
-            options: {
-              colorize: true,
-              translateTime: 'HH:MM:ss Z',
-              ignore: 'pid,hostname',
-            },
-          }
-        : undefined,
-    });
-  }
-
-  info(msg: string, ...args: any[]): void;
-  info(obj: object, msg?: string, ...args: any[]): void;
-  info(arg1: string | object, ...args: any[]): void {
-    this.pino.info(arg1 as any, ...args);
-  }
-
-  error(msg: string, ...args: any[]): void;
-  error(obj: object, msg?: string, ...args: any[]): void;
-  error(arg1: string | object, ...args: any[]): void {
-    this.pino.error(arg1 as any, ...args);
-  }
-
-  warn(msg: string, ...args: any[]): void;
-  warn(obj: object, msg?: string, ...args: any[]): void;
-  warn(arg1: string | object, ...args: any[]): void {
-    this.pino.warn(arg1 as any, ...args);
-  }
-
-  debug(msg: string, ...args: any[]): void;
-  debug(obj: object, msg?: string, ...args: any[]): void;
-  debug(arg1: string | object, ...args: any[]): void {
-    this.pino.debug(arg1 as any, ...args);
-  }
-
-  fatal(msg: string, ...args: any[]): void;
-  fatal(obj: object, msg?: string, ...args: any[]): void;
-  fatal(arg1: string | object, ...args: any[]): void {
-    this.pino.fatal(arg1 as any, ...args);
-  }
-
-  child(bindings: pino.Bindings): Logger {
-    const child = new Logger();
-    child.pino = this.pino.child(bindings);
-    return child;
-  }
-}

package/src/core/metrics.ts

@@ -1,166 +0,0 @@
-import type { TaskEngine, TaskMetrics } from './tasks';
-import { Scheduler } from './scheduler';
-
-export type LatencySnapshot = {
-  p50: number | null;
-  p95: number | null;
-  p99: number | null;
-};
-
-export type MetricsSnapshot = {
-  totalRequests: number;
-  inFlightRequests: number;
-  totalErrors: number;
-  totalTimeouts: number;
-  requestsPerSecond: number;
-  latency: LatencySnapshot;
-  scheduler: {
-    inFlight: number;
-  };
-  tasks?: TaskMetrics;
-  memory: {
-    rssBytes: number;
-    heapUsedBytes: number;
-  };
-};
-
-export class Metrics {
-  private readonly scheduler: Scheduler;
-
-  private readonly taskEngine?: TaskEngine;
-
-  private readonly latencies: number[] = [];
-
-  private readonly maxLatencies: number;
-
-  private readonly enabled: boolean;
-
-  private totalRequests = 0;
-
-  private inFlightRequests = 0;
-
-  private totalErrors = 0;
-
-  private totalTimeouts = 0;
-
-  constructor(
-    scheduler: Scheduler,
-    options: { maxLatencies?: number; enabled?: boolean } = {},
-    taskEngine?: TaskEngine,
-  ) {
-    this.scheduler = scheduler;
-    this.taskEngine = taskEngine;
-    this.maxLatencies = options.maxLatencies ?? 1000;
-    this.enabled = options.enabled ?? true;
-  }
-
-  onRequestStart(): void {
-    if (!this.enabled) {
-      return;
-    }
-    this.inFlightRequests += 1;
-  }
-
-  onRequestEnd(durationMs: number, statusCode: number): void {
-    if (!this.enabled) {
-      return;
-    }
-    this.totalRequests += 1;
-    if (this.inFlightRequests > 0) {
-      this.inFlightRequests -= 1;
-    }
-    if (statusCode >= 500) {
-      this.totalErrors += 1;
-    }
-    this.recordLatency(durationMs);
-  }
-
-  onTimeout(): void {
-    if (!this.enabled) {
-      return;
-    }
-    this.totalTimeouts += 1;
-  }
-
-  snapshot(): MetricsSnapshot {
-    const uptime = process.uptime();
-    const requestsPerSecond =
-      uptime > 0 ? this.totalRequests / uptime : this.totalRequests;
-
-    const latency = this.latencySnapshot();
-
-    const memoryUsage = process.memoryUsage();
-
-    let tasks: TaskMetrics | undefined;
-    if (this.taskEngine) {
-      tasks = this.taskEngine.getMetrics();
-    }
-
-    return {
-      totalRequests: this.totalRequests,
-      inFlightRequests: this.inFlightRequests,
-      totalErrors: this.totalErrors,
-      totalTimeouts: this.totalTimeouts,
-      requestsPerSecond,
-      latency,
-      scheduler: {
-        inFlight: this.scheduler.getCurrentInFlight(),
-      },
-      tasks,
-      memory: {
-        rssBytes: memoryUsage.rss,
-        heapUsedBytes: memoryUsage.heapUsed,
-      },
-    };
-  }
-
-  private recordLatency(durationMs: number): void {
-    if (!this.enabled) {
-      return;
-    }
-    if (!Number.isFinite(durationMs) || durationMs < 0) {
-      return;
-    }
-    this.latencies.push(durationMs);
-    if (this.latencies.length > this.maxLatencies) {
-      this.latencies.shift();
-    }
-  }
-
-  private latencySnapshot(): LatencySnapshot {
-    if (this.latencies.length === 0) {
-      return {
-        p50: null,
-        p95: null,
-        p99: null,
-      };
-    }
-
-    const sorted = [...this.latencies].sort((a, b) => a - b);
-
-    const p50 = this.percentile(sorted, 0.5);
-    const p95 = this.percentile(sorted, 0.95);
-    const p99 = this.percentile(sorted, 0.99);
-
-    return {
-      p50,
-      p95,
-      p99,
-    };
-  }
-
-  private percentile(sorted: number[], p: number): number {
-    if (sorted.length === 0) {
-      return 0;
-    }
-    if (p <= 0) {
-      return sorted[0];
-    }
-    if (p >= 1) {
-      return sorted[sorted.length - 1];
-    }
-    const index = Math.floor(p * (sorted.length - 1));
-    return sorted[index];
-  }
-}
-

package/src/core/resources.ts

@@ -1,38 +0,0 @@
-import os from 'os';
-
-export type WorkerSetting = 'auto' | number;
-
-export function calculateWorkerCount(setting: WorkerSetting): number {
-  if (typeof setting === 'number') {
-    if (!Number.isFinite(setting) || setting <= 0) {
-      return 1;
-    }
-    return Math.floor(setting);
-  }
-
-  const cpuCount = os.cpus().length || 1;
-  return Math.max(1, cpuCount);
-}
-
-export type ResourceThresholds = {
-  maxRssBytes?: number;
-};
-
-export type ResourceSample = {
-  rssBytes: number;
-};
-
-export function isResourceOverloaded(
-  sample: ResourceSample,
-  thresholds: ResourceThresholds,
-): boolean {
-  if (
-    thresholds.maxRssBytes !== undefined &&
-    sample.rssBytes > thresholds.maxRssBytes
-  ) {
-    return true;
-  }
-
-  return false;
-}
-