add missing JSDocs

Author: noxify

packages/adapter-drizzle/src/postgres-adapter.ts

@@ -16,6 +16,7 @@ type DrizzleDatabase =
 /**
  * PostgreSQL adapter for the queue system using Drizzle ORM.
  * Supports PostgreSQL databases through Drizzle ORM with node-postgres, postgres.js, or PGlite.
+ * Provides persistent job storage with ACID transactions and optimized job selection.
  *
  * @example
  * ```typescript
@@ -25,6 +26,7 @@ type DrizzleDatabase =
  * const pool = new Pool({ connectionString: "postgresql://..." })
  * const db = drizzle(pool)
  * const adapter = new PostgresQueueAdapter(db)
+ * const queue = new Queue(adapter, { name: "my-queue" })
  * ```
  */
 export class PostgresQueueAdapter extends BaseQueueAdapter {

packages/adapter-prisma/src/postgres-adapter.ts

@@ -7,14 +7,16 @@ import type { QueueJobModel as QueueJob } from "./generated/prisma/models"
 /**
  * PostgreSQL adapter for the queue system using Prisma ORM.
  * Uses raw SQL with SKIP LOCKED for critical job selection methods to prevent race conditions.
+ * Provides persistent job storage with type-safe database operations and automatic migrations.
  *
  * @example
  * ```typescript
  * import { PrismaClient } from '@prisma/client'
  * import { PostgresPrismaQueueAdapter } from '@vorsteh-queue/adapter-prisma'
  *
  * const prisma = new PrismaClient()
- * const queue = new Queue(new PostgresPrismaQueueAdapter(prisma), { name: "my-queue" })
+ * const adapter = new PostgresPrismaQueueAdapter(prisma)
+ * const queue = new Queue(adapter, { name: "my-queue" })
  * ```
  */
 export class PostgresPrismaQueueAdapter extends BaseQueueAdapter {

packages/core/src/adapters/base.ts

@@ -9,29 +9,95 @@ export abstract class BaseQueueAdapter implements QueueAdapter {
 
   /**
    * Set the queue name. Called by the Queue class during initialization.
+   *
    * @internal
    */
   setQueueName(queueName: string): void {
     this.queueName = queueName
   }
 
+  /** Connect to the database/storage backend */
   abstract connect(): Promise<void>
+
+  /** Disconnect from the database/storage backend */
   abstract disconnect(): Promise<void>
+
+  /**
+   * Add a new job to the queue storage
+   *
+   * @param job - Job data without id and createdAt
+   * @returns Promise resolving to the created job with id and createdAt
+   */
   abstract addJob<TJobPayload, TJobResult = unknown>(
     job: Omit<BaseJob<TJobPayload, TJobResult>, "id" | "createdAt">,
   ): Promise<BaseJob<TJobPayload, TJobResult>>
+
+  /**
+   * Update job status and optionally set error or result
+   *
+   * @param id - Job ID to update
+   * @param status - New job status
+   * @param error - Optional error data for failed jobs
+   * @param result - Optional result data for completed jobs
+   */
   abstract updateJobStatus(
     id: string,
     status: JobStatus,
     error?: unknown,
     result?: unknown,
   ): Promise<void>
+
+  /**
+   * Update job progress percentage
+   *
+   * @param id - Job ID to update
+   * @param progress - Progress percentage (0-100)
+   */
   abstract updateJobProgress(id: string, progress: number): Promise<void>
+
+  /**
+   * Increment job attempt counter
+   *
+   * @param id - Job ID to update
+   */
   abstract incrementJobAttempts(id: string): Promise<void>
+
+  /**
+   * Get queue statistics by job status
+   *
+   * @returns Promise resolving to queue statistics
+   */
   abstract getQueueStats(): Promise<QueueStats>
+
+  /**
+   * Clear jobs from the queue
+   *
+   * @param status - Optional status filter, clears all jobs if not provided
+   * @returns Promise resolving to number of jobs cleared
+   */
   abstract clearJobs(status?: JobStatus): Promise<number>
+
+  /**
+   * Clean up old jobs, keeping only the most recent N jobs
+   *
+   * @param status - Job status to clean up
+   * @param keepCount - Number of jobs to keep
+   * @returns Promise resolving to number of jobs cleaned up
+   */
   abstract cleanupJobs(status: JobStatus, keepCount: number): Promise<number>
+
+  /**
+   * Get the number of pending jobs in the queue
+   * @returns Promise resolving to number of pending jobs
+   */
   abstract size(): Promise<number>
+
+  /**
+   * Execute a function within a database transaction
+   *
+   * @param fn - Function to execute in transaction
+   * @returns Promise resolving to the function's return value
+   */
   abstract transaction<TResult>(fn: () => Promise<TResult>): Promise<TResult>
 
   /**
@@ -54,9 +120,29 @@ export abstract class BaseQueueAdapter implements QueueAdapter {
     return this.getPendingJobByPriority()
   }
 
+  /**
+   * Get a delayed job that is ready to be processed
+   *
+   * @param now - Current timestamp to compare against processAt
+   * @returns Promise resolving to ready delayed job or null
+   * @protected
+   */
   protected abstract getDelayedJobReady(now: Date): Promise<BaseJob | null>
+
+  /**
+   * Get the next pending job ordered by priority and creation time
+   *
+   * @returns Promise resolving to next pending job or null
+   * @protected
+   */
   protected abstract getPendingJobByPriority(): Promise<BaseJob | null>
 
+  /**
+   * Generate a unique job ID
+   *
+   * @returns Unique string identifier
+   * @protected
+   */
   protected generateId(): string {
     return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`
   }

packages/core/src/adapters/memory.ts

@@ -2,6 +2,16 @@ import type { BaseJob, JobStatus, QueueStats } from "../../types"
 import { serializeError } from "../utils/error"
 import { BaseQueueAdapter } from "./base"
 
+/**
+ * In-memory queue adapter for testing and development.
+ * Stores all job data in memory - data is lost when the process exits.
+ * 
+ * @example
+ * ```typescript
+ * const adapter = new MemoryQueueAdapter()
+ * const queue = new Queue(adapter, { name: "test-queue" })
+ * ```
+ */
 export class MemoryQueueAdapter extends BaseQueueAdapter {
   private jobs = new Map<string, BaseJob>()
   private connected = false

packages/core/src/core/job-wrapper.ts

@@ -7,6 +7,11 @@ export function createJobWrapper<TJobPayload>(
 ): JobWithProgress<TJobPayload> {
   return {
     ...job,
+    /**
+     * Updates the progress value of the job in the queue
+     * @param value - The progress value to set (between 0 and 100)
+     * @returns Promise that resolves when the progress is updated
+     */
     updateProgress: async (value: number): Promise<void> => {
       await queue.updateJobProgress(job.id, value)
     },