smart-pool 1.0.0

package/src/heap.js

@@ -0,0 +1,130 @@
+/**
+ * A Binary Max-Heap
+ */
+export class PriorityHeap {
+  constructor() {
+    this.heap = [];
+  }
+
+  _compare(a, b) {
+    if (a.priority !== b.priority) {
+      return a.priority - b.priority;
+    }
+    return b.seq - a.seq;
+  }
+
+  push(item) {
+    this.heap.push(item);
+    this._bubbleUp();
+  }
+
+  pop() {
+    const size = this.heap.length;
+    if (size === 0) return null;
+    if (size === 1) return this.heap.pop();
+    const top = this.heap[0];
+    this.heap[0] = this.heap.pop();
+    this._bubbleDown(0);
+    return top;
+  }
+
+  peek() {
+    return this.heap[0] || null;
+  }
+
+  clear() {
+    this.heap = [];
+  }
+
+  remove(predicate) {
+    const initialSize = this.heap.length;
+    this.heap = this.heap.filter((item) => !predicate(item));
+    if (this.heap.length !== initialSize) {
+      this._rebuild();
+      return true;
+    }
+    return false;
+  }
+
+  adjustPriorities(threshold, amount, isDecay = false) {
+    const size = this.heap.length;
+    if (size <= 1) return;
+
+    let changed = false;
+    const targetPriority = isDecay
+      ? this.heap.reduce((min, item) => Math.min(min, item.priority), Infinity)
+      : this.heap.reduce(
+          (max, item) => Math.max(max, item.priority),
+          -Infinity
+        );
+
+    for (let i = 0; i < size; i++) {
+      const item = this.heap[i];
+      const isEligible = isDecay
+        ? item.priority > targetPriority
+        : item.priority < targetPriority;
+
+      if (isEligible) {
+        item.cycles = (item.cycles || 0) + 1;
+        if (item.cycles >= threshold) {
+          item.priority = targetPriority;
+          item.cycles = 0;
+          changed = true;
+        }
+      } else {
+        item.cycles = 0;
+      }
+    }
+
+    if (changed) this._rebuild();
+  }
+
+  size() {
+    return this.heap.length;
+  }
+
+  _rebuild() {
+    const length = this.heap.length;
+    for (let i = (length >> 1) - 1; i >= 0; i--) {
+      this._bubbleDown(i);
+    }
+  }
+
+  _bubbleUp() {
+    let index = this.heap.length - 1;
+    const element = this.heap[index];
+    while (index > 0) {
+      let parentIdx = (index - 1) >> 1;
+      if (this._compare(element, this.heap[parentIdx]) <= 0) break;
+      this.heap[index] = this.heap[parentIdx];
+      index = parentIdx;
+    }
+    this.heap[index] = element;
+  }
+
+  _bubbleDown(index = 0) {
+    const length = this.heap.length;
+    const element = this.heap[index];
+    while (true) {
+      let leftChildIdx = (index << 1) + 1;
+      let rightChildIdx = (index << 1) + 2;
+      let swap = null;
+
+      if (leftChildIdx < length) {
+        if (this._compare(this.heap[leftChildIdx], element) > 0)
+          swap = leftChildIdx;
+      }
+
+      if (rightChildIdx < length) {
+        const compareTo = swap === null ? element : this.heap[leftChildIdx];
+        if (this._compare(this.heap[rightChildIdx], compareTo) > 0)
+          swap = rightChildIdx;
+      }
+
+      if (swap === null) break;
+      this.heap[index] = this.heap[swap];
+      index = swap;
+    }
+    this.heap[index] = element;
+  }
+}

package/src/index.d.ts

@@ -0,0 +1,118 @@
+export interface RateLimit {
+  interval: number;
+  tasksPerInterval: number;
+}
+
+export interface TaskOptions {
+  priority?: number;
+  weight?: number;
+  type?: string;
+  cacheKey?: string;
+  batchKey?: string;
+  id?: string | number;
+  tags?: string[];
+  metadata?: Record<string, any>;
+  dependsOn?: (string | number)[];
+  deadline?: number;
+  signal?: AbortSignal;
+  timeout?: number;
+  retryCount?: number;
+  retryDelay?: number;
+  worker?: {
+    path: string;
+    data?: any;
+  };
+}
+
+export interface Metrics {
+  totalTasks: number;
+  successfulTasks: number;
+  failedTasks: number;
+  throughput: string;
+  errorRate: string;
+  percentiles: {
+    p50: string;
+    p90: string;
+    p99: string;
+  };
+}
+
+export interface WorkerHealth {
+  path: string;
+  busy: boolean;
+  active: boolean;
+}
+
+export interface GlobalOptions {
+  maxQueueSize?: number;
+  workerPoolSize?: number;
+  workerPathWhitelist?: string[];
+  batchSize?: number;
+  batchTimeout?: number;
+  rateLimits?: Record<string, RateLimit>;
+  circuitThreshold?: number;
+  circuitResetTimeout?: number;
+  retryCount?: number;
+  initialRetryDelay?: number;
+  retryFactor?: number;
+  maxRetryDelay?: number;
+  adaptive?: boolean;
+  minConcurrency?: number;
+  maxConcurrency?: number;
+  interval?: number;
+  tasksPerInterval?: number;
+  agingThreshold?: number;
+  agingBoost?: number;
+  decayThreshold?: number;
+  decayAmount?: number;
+  maxLatencyHistory?: number;
+  maxErrorHistory?: number;
+  completedTaskCleanupMs?: number;
+  emitter?: any;
+  onEnqueue?: (task: any) => void;
+  onDequeue?: (task: any) => void;
+  beforeExecute?: (task: any) => void;
+  afterExecute?: (
+    task: any,
+    profile: {
+      duration: number;
+      memoryDelta: number;
+      status: string;
+      error?: string;
+    }
+  ) => void;
+}
+
+export interface PoolInstance {
+  <T>(task: () => Promise<T>, options?: number | TaskOptions): Promise<T>;
+  activeCount: number;
+  pendingCount: number;
+  currentLoad: number;
+  concurrency: number;
+  isDraining: boolean;
+  isPaused: boolean;
+  metrics: Metrics;
+  pause(): void;
+  resume(): void;
+  cancel(
+    query: { id?: string | number; tag?: string } | ((task: any) => boolean)
+  ): number;
+  onIdle(): Promise<{ errors: Error[]; failed: boolean; metrics: Metrics }>;
+  drain(): Promise<{ errors: Error[]; failed: boolean; metrics: Metrics }>;
+  setConcurrency(limit: number): void;
+  peek(): any;
+  clear(): Promise<void>;
+  remove(predicate: (item: any) => boolean): boolean;
+  map<T, R>(
+    items: T[],
+    fn: (item: T) => Promise<R>,
+    opts?: number | TaskOptions
+  ): Promise<R[]>;
+  getWorkerHealth(): WorkerHealth[];
+  useQueue(name: string, concurrency?: number): PoolInstance;
+}
+
+export default function leap(
+  initialConcurrency: number,
+  globalOptions?: GlobalOptions
+): PoolInstance;