@nicnocquee/dataqueue 1.21.0 → 1.24.0

package/dist/index.js

@@ -1,6 +1,8 @@
 import { AsyncLocalStorage } from 'async_hooks';
+import { Worker } from 'worker_threads';
 import { Pool } from 'pg';
 import { parse } from 'pg-connection-string';
+import fs from 'fs';
 
 // src/types.ts
 var JobEventType = /* @__PURE__ */ ((JobEventType2) => {
@@ -10,6 +12,7 @@ var JobEventType = /* @__PURE__ */ ((JobEventType2) => {
   JobEventType2["Failed"] = "failed";
   JobEventType2["Cancelled"] = "cancelled";
   JobEventType2["Retried"] = "retried";
+  JobEventType2["Edited"] = "edited";
   return JobEventType2;
 })(JobEventType || {});
 var FailureReason = /* @__PURE__ */ ((FailureReason3) => {
@@ -53,6 +56,7 @@ var addJob = async (pool, {
   priority = 0,
   runAt = null,
   timeoutMs = void 0,
+  forceKillOnTimeout = false,
   tags = void 0
 }) => {
   const client = await pool.connect();
@@ -61,8 +65,8 @@ var addJob = async (pool, {
     if (runAt) {
       result = await client.query(
         `INSERT INTO job_queue 
-          (job_type, payload, max_attempts, priority, run_at, timeout_ms, tags) 
-         VALUES ($1, $2, $3, $4, $5, $6, $7) 
+          (job_type, payload, max_attempts, priority, run_at, timeout_ms, force_kill_on_timeout, tags) 
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8) 
          RETURNING id`,
         [
           jobType,
@@ -71,6 +75,7 @@ var addJob = async (pool, {
           priority,
           runAt,
           timeoutMs ?? null,
+          forceKillOnTimeout ?? false,
           tags ?? null
         ]
       );
@@ -80,8 +85,8 @@ var addJob = async (pool, {
     } else {
       result = await client.query(
         `INSERT INTO job_queue 
-          (job_type, payload, max_attempts, priority, timeout_ms, tags) 
-         VALUES ($1, $2, $3, $4, $5, $6) 
+          (job_type, payload, max_attempts, priority, timeout_ms, force_kill_on_timeout, tags) 
+         VALUES ($1, $2, $3, $4, $5, $6, $7) 
          RETURNING id`,
         [
           jobType,
@@ -89,6 +94,7 @@ var addJob = async (pool, {
           maxAttempts,
           priority,
           timeoutMs ?? null,
+          forceKillOnTimeout ?? false,
           tags ?? null
         ]
       );
@@ -113,7 +119,7 @@ var getJob = async (pool, id) => {
   const client = await pool.connect();
   try {
     const result = await client.query(
-      `SELECT id, job_type AS "jobType", payload, status, max_attempts AS "maxAttempts", attempts, priority, run_at AS "runAt", timeout_ms AS "timeoutMs", created_at AS "createdAt", updated_at AS "updatedAt", started_at AS "startedAt", completed_at AS "completedAt", last_failed_at AS "lastFailedAt", locked_at AS "lockedAt", locked_by AS "lockedBy", error_history AS "errorHistory", failure_reason AS "failureReason", next_attempt_at AS "nextAttemptAt", last_failed_at AS "lastFailedAt", last_retried_at AS "lastRetriedAt", last_cancelled_at AS "lastCancelledAt", pending_reason AS "pendingReason" FROM job_queue WHERE id = $1`,
+      `SELECT id, job_type AS "jobType", payload, status, max_attempts AS "maxAttempts", attempts, priority, run_at AS "runAt", timeout_ms AS "timeoutMs", force_kill_on_timeout AS "forceKillOnTimeout", created_at AS "createdAt", updated_at AS "updatedAt", started_at AS "startedAt", completed_at AS "completedAt", last_failed_at AS "lastFailedAt", locked_at AS "lockedAt", locked_by AS "lockedBy", error_history AS "errorHistory", failure_reason AS "failureReason", next_attempt_at AS "nextAttemptAt", last_failed_at AS "lastFailedAt", last_retried_at AS "lastRetriedAt", last_cancelled_at AS "lastCancelledAt", pending_reason AS "pendingReason", tags FROM job_queue WHERE id = $1`,
       [id]
     );
     if (result.rows.length === 0) {
@@ -126,6 +132,7 @@ var getJob = async (pool, id) => {
       ...job,
       payload: job.payload,
       timeoutMs: job.timeoutMs,
+      forceKillOnTimeout: job.forceKillOnTimeout,
       failureReason: job.failureReason
     };
   } catch (error) {
@@ -139,7 +146,7 @@ var getJobsByStatus = async (pool, status, limit = 100, offset = 0) => {
   const client = await pool.connect();
   try {
     const result = await client.query(
-      `SELECT id, job_type AS "jobType", payload, status, max_attempts AS "maxAttempts", attempts, priority, run_at AS "runAt", timeout_ms AS "timeoutMs", created_at AS "createdAt", updated_at AS "updatedAt", started_at AS "startedAt", completed_at AS "completedAt", last_failed_at AS "lastFailedAt", locked_at AS "lockedAt", locked_by AS "lockedBy", error_history AS "errorHistory", failure_reason AS "failureReason", next_attempt_at AS "nextAttemptAt", last_failed_at AS "lastFailedAt", last_retried_at AS "lastRetriedAt", last_cancelled_at AS "lastCancelledAt", pending_reason AS "pendingReason" FROM job_queue WHERE status = $1 ORDER BY created_at DESC LIMIT $2 OFFSET $3`,
+      `SELECT id, job_type AS "jobType", payload, status, max_attempts AS "maxAttempts", attempts, priority, run_at AS "runAt", timeout_ms AS "timeoutMs", force_kill_on_timeout AS "forceKillOnTimeout", created_at AS "createdAt", updated_at AS "updatedAt", started_at AS "startedAt", completed_at AS "completedAt", last_failed_at AS "lastFailedAt", locked_at AS "lockedAt", locked_by AS "lockedBy", error_history AS "errorHistory", failure_reason AS "failureReason", next_attempt_at AS "nextAttemptAt", last_failed_at AS "lastFailedAt", last_retried_at AS "lastRetriedAt", last_cancelled_at AS "lastCancelledAt", pending_reason AS "pendingReason" FROM job_queue WHERE status = $1 ORDER BY created_at DESC LIMIT $2 OFFSET $3`,
       [status, limit, offset]
     );
     log(`Found ${result.rows.length} jobs by status ${status}`);
@@ -147,6 +154,7 @@ var getJobsByStatus = async (pool, status, limit = 100, offset = 0) => {
       ...job,
       payload: job.payload,
       timeoutMs: job.timeoutMs,
+      forceKillOnTimeout: job.forceKillOnTimeout,
       failureReason: job.failureReason
     }));
   } catch (error) {
@@ -192,7 +200,7 @@ var getNextBatch = async (pool, workerId, batchSize = 10, jobType) => {
         LIMIT $2
         FOR UPDATE SKIP LOCKED
       )
-      RETURNING id, job_type AS "jobType", payload, status, max_attempts AS "maxAttempts", attempts, priority, run_at AS "runAt", timeout_ms AS "timeoutMs", created_at AS "createdAt", updated_at AS "updatedAt", started_at AS "startedAt", completed_at AS "completedAt", last_failed_at AS "lastFailedAt", locked_at AS "lockedAt", locked_by AS "lockedBy", error_history AS "errorHistory", failure_reason AS "failureReason", next_attempt_at AS "nextAttemptAt", last_retried_at AS "lastRetriedAt", last_cancelled_at AS "lastCancelledAt", pending_reason AS "pendingReason"
+      RETURNING id, job_type AS "jobType", payload, status, max_attempts AS "maxAttempts", attempts, priority, run_at AS "runAt", timeout_ms AS "timeoutMs", force_kill_on_timeout AS "forceKillOnTimeout", created_at AS "createdAt", updated_at AS "updatedAt", started_at AS "startedAt", completed_at AS "completedAt", last_failed_at AS "lastFailedAt", locked_at AS "lockedAt", locked_by AS "lockedBy", error_history AS "errorHistory", failure_reason AS "failureReason", next_attempt_at AS "nextAttemptAt", last_retried_at AS "lastRetriedAt", last_cancelled_at AS "lastCancelledAt", pending_reason AS "pendingReason"
     `,
       params
     );
@@ -204,7 +212,8 @@ var getNextBatch = async (pool, workerId, batchSize = 10, jobType) => {
     return result.rows.map((job) => ({
       ...job,
       payload: job.payload,
-      timeoutMs: job.timeoutMs
+      timeoutMs: job.timeoutMs,
+      forceKillOnTimeout: job.forceKillOnTimeout
     }));
   } catch (error) {
     log(`Error getting next batch: ${error}`);
@@ -337,6 +346,198 @@ var cancelJob = async (pool, jobId) => {
     client.release();
   }
 };
+var editJob = async (pool, jobId, updates) => {
+  const client = await pool.connect();
+  try {
+    const updateFields = [];
+    const params = [];
+    let paramIdx = 1;
+    if (updates.payload !== void 0) {
+      updateFields.push(`payload = $${paramIdx++}`);
+      params.push(updates.payload);
+    }
+    if (updates.maxAttempts !== void 0) {
+      updateFields.push(`max_attempts = $${paramIdx++}`);
+      params.push(updates.maxAttempts);
+    }
+    if (updates.priority !== void 0) {
+      updateFields.push(`priority = $${paramIdx++}`);
+      params.push(updates.priority);
+    }
+    if (updates.runAt !== void 0) {
+      if (updates.runAt === null) {
+        updateFields.push(`run_at = NOW()`);
+      } else {
+        updateFields.push(`run_at = $${paramIdx++}`);
+        params.push(updates.runAt);
+      }
+    }
+    if (updates.timeoutMs !== void 0) {
+      updateFields.push(`timeout_ms = $${paramIdx++}`);
+      params.push(updates.timeoutMs ?? null);
+    }
+    if (updates.tags !== void 0) {
+      updateFields.push(`tags = $${paramIdx++}`);
+      params.push(updates.tags ?? null);
+    }
+    if (updateFields.length === 0) {
+      log(`No fields to update for job ${jobId}`);
+      return;
+    }
+    updateFields.push(`updated_at = NOW()`);
+    params.push(jobId);
+    const query = `
+      UPDATE job_queue
+      SET ${updateFields.join(", ")}
+      WHERE id = $${paramIdx} AND status = 'pending'
+    `;
+    await client.query(query, params);
+    const metadata = {};
+    if (updates.payload !== void 0) metadata.payload = updates.payload;
+    if (updates.maxAttempts !== void 0)
+      metadata.maxAttempts = updates.maxAttempts;
+    if (updates.priority !== void 0) metadata.priority = updates.priority;
+    if (updates.runAt !== void 0) metadata.runAt = updates.runAt;
+    if (updates.timeoutMs !== void 0) metadata.timeoutMs = updates.timeoutMs;
+    if (updates.tags !== void 0) metadata.tags = updates.tags;
+    await recordJobEvent(pool, jobId, "edited" /* Edited */, metadata);
+    log(`Edited job ${jobId}: ${JSON.stringify(metadata)}`);
+  } catch (error) {
+    log(`Error editing job ${jobId}: ${error}`);
+    throw error;
+  } finally {
+    client.release();
+  }
+};
+var editAllPendingJobs = async (pool, filters = void 0, updates) => {
+  const client = await pool.connect();
+  try {
+    const updateFields = [];
+    const params = [];
+    let paramIdx = 1;
+    if (updates.payload !== void 0) {
+      updateFields.push(`payload = $${paramIdx++}`);
+      params.push(updates.payload);
+    }
+    if (updates.maxAttempts !== void 0) {
+      updateFields.push(`max_attempts = $${paramIdx++}`);
+      params.push(updates.maxAttempts);
+    }
+    if (updates.priority !== void 0) {
+      updateFields.push(`priority = $${paramIdx++}`);
+      params.push(updates.priority);
+    }
+    if (updates.runAt !== void 0) {
+      if (updates.runAt === null) {
+        updateFields.push(`run_at = NOW()`);
+      } else {
+        updateFields.push(`run_at = $${paramIdx++}`);
+        params.push(updates.runAt);
+      }
+    }
+    if (updates.timeoutMs !== void 0) {
+      updateFields.push(`timeout_ms = $${paramIdx++}`);
+      params.push(updates.timeoutMs ?? null);
+    }
+    if (updates.tags !== void 0) {
+      updateFields.push(`tags = $${paramIdx++}`);
+      params.push(updates.tags ?? null);
+    }
+    if (updateFields.length === 0) {
+      log(`No fields to update for batch edit`);
+      return 0;
+    }
+    updateFields.push(`updated_at = NOW()`);
+    let query = `
+      UPDATE job_queue
+      SET ${updateFields.join(", ")}
+      WHERE status = 'pending'`;
+    if (filters) {
+      if (filters.jobType) {
+        query += ` AND job_type = $${paramIdx++}`;
+        params.push(filters.jobType);
+      }
+      if (filters.priority !== void 0) {
+        query += ` AND priority = $${paramIdx++}`;
+        params.push(filters.priority);
+      }
+      if (filters.runAt) {
+        if (filters.runAt instanceof Date) {
+          query += ` AND run_at = $${paramIdx++}`;
+          params.push(filters.runAt);
+        } else if (typeof filters.runAt === "object") {
+          const ops = filters.runAt;
+          if (ops.gt) {
+            query += ` AND run_at > $${paramIdx++}`;
+            params.push(ops.gt);
+          }
+          if (ops.gte) {
+            query += ` AND run_at >= $${paramIdx++}`;
+            params.push(ops.gte);
+          }
+          if (ops.lt) {
+            query += ` AND run_at < $${paramIdx++}`;
+            params.push(ops.lt);
+          }
+          if (ops.lte) {
+            query += ` AND run_at <= $${paramIdx++}`;
+            params.push(ops.lte);
+          }
+          if (ops.eq) {
+            query += ` AND run_at = $${paramIdx++}`;
+            params.push(ops.eq);
+          }
+        }
+      }
+      if (filters.tags && filters.tags.values && filters.tags.values.length > 0) {
+        const mode = filters.tags.mode || "all";
+        const tagValues = filters.tags.values;
+        switch (mode) {
+          case "exact":
+            query += ` AND tags = $${paramIdx++}`;
+            params.push(tagValues);
+            break;
+          case "all":
+            query += ` AND tags @> $${paramIdx++}`;
+            params.push(tagValues);
+            break;
+          case "any":
+            query += ` AND tags && $${paramIdx++}`;
+            params.push(tagValues);
+            break;
+          case "none":
+            query += ` AND NOT (tags && $${paramIdx++})`;
+            params.push(tagValues);
+            break;
+          default:
+            query += ` AND tags @> $${paramIdx++}`;
+            params.push(tagValues);
+        }
+      }
+    }
+    query += "\nRETURNING id";
+    const result = await client.query(query, params);
+    const editedCount = result.rowCount || 0;
+    const metadata = {};
+    if (updates.payload !== void 0) metadata.payload = updates.payload;
+    if (updates.maxAttempts !== void 0)
+      metadata.maxAttempts = updates.maxAttempts;
+    if (updates.priority !== void 0) metadata.priority = updates.priority;
+    if (updates.runAt !== void 0) metadata.runAt = updates.runAt;
+    if (updates.timeoutMs !== void 0) metadata.timeoutMs = updates.timeoutMs;
+    if (updates.tags !== void 0) metadata.tags = updates.tags;
+    for (const row of result.rows) {
+      await recordJobEvent(pool, row.id, "edited" /* Edited */, metadata);
+    }
+    log(`Edited ${editedCount} pending jobs: ${JSON.stringify(metadata)}`);
+    return editedCount;
+  } catch (error) {
+    log(`Error editing pending jobs: ${error}`);
+    throw error;
+  } finally {
+    client.release();
+  }
+};
 var cancelAllUpcomingJobs = async (pool, filters) => {
   const client = await pool.connect();
   try {
@@ -424,14 +625,15 @@ var getAllJobs = async (pool, limit = 100, offset = 0) => {
   const client = await pool.connect();
   try {
     const result = await client.query(
-      `SELECT id, job_type AS "jobType", payload, status, max_attempts AS "maxAttempts", attempts, priority, run_at AS "runAt", timeout_ms AS "timeoutMs", created_at AS "createdAt", updated_at AS "updatedAt", started_at AS "startedAt", completed_at AS "completedAt", last_failed_at AS "lastFailedAt", locked_at AS "lockedAt", locked_by AS "lockedBy", error_history AS "errorHistory", failure_reason AS "failureReason", next_attempt_at AS "nextAttemptAt", last_failed_at AS "lastFailedAt", last_retried_at AS "lastRetriedAt", last_cancelled_at AS "lastCancelledAt", pending_reason AS "pendingReason" FROM job_queue ORDER BY created_at DESC LIMIT $1 OFFSET $2`,
+      `SELECT id, job_type AS "jobType", payload, status, max_attempts AS "maxAttempts", attempts, priority, run_at AS "runAt", timeout_ms AS "timeoutMs", force_kill_on_timeout AS "forceKillOnTimeout", created_at AS "createdAt", updated_at AS "updatedAt", started_at AS "startedAt", completed_at AS "completedAt", last_failed_at AS "lastFailedAt", locked_at AS "lockedAt", locked_by AS "lockedBy", error_history AS "errorHistory", failure_reason AS "failureReason", next_attempt_at AS "nextAttemptAt", last_failed_at AS "lastFailedAt", last_retried_at AS "lastRetriedAt", last_cancelled_at AS "lastCancelledAt", pending_reason AS "pendingReason" FROM job_queue ORDER BY created_at DESC LIMIT $1 OFFSET $2`,
       [limit, offset]
     );
     log(`Found ${result.rows.length} jobs (all)`);
     return result.rows.map((job) => ({
       ...job,
       payload: job.payload,
-      timeoutMs: job.timeoutMs
+      timeoutMs: job.timeoutMs,
+      forceKillOnTimeout: job.forceKillOnTimeout
     }));
   } catch (error) {
     log(`Error getting all jobs: ${error}`);
@@ -532,6 +734,7 @@ var getJobsByTags = async (pool, tags, mode = "all", limit = 100, offset = 0) =>
       ...job,
       payload: job.payload,
       timeoutMs: job.timeoutMs,
+      forceKillOnTimeout: job.forceKillOnTimeout,
       failureReason: job.failureReason
     }));
   } catch (error) {
@@ -546,7 +749,7 @@ var getJobsByTags = async (pool, tags, mode = "all", limit = 100, offset = 0) =>
 var getJobs = async (pool, filters, limit = 100, offset = 0) => {
   const client = await pool.connect();
   try {
-    let query = `SELECT id, job_type AS "jobType", payload, status, max_attempts AS "maxAttempts", attempts, priority, run_at AS "runAt", timeout_ms AS "timeoutMs", created_at AS "createdAt", updated_at AS "updatedAt", started_at AS "startedAt", completed_at AS "completedAt", last_failed_at AS "lastFailedAt", locked_at AS "lockedAt", locked_by AS "lockedBy", error_history AS "errorHistory", failure_reason AS "failureReason", next_attempt_at AS "nextAttemptAt", last_failed_at AS "lastFailedAt", last_retried_at AS "lastRetriedAt", last_cancelled_at AS "lastCancelledAt", pending_reason AS "pendingReason", tags FROM job_queue`;
+    let query = `SELECT id, job_type AS "jobType", payload, status, max_attempts AS "maxAttempts", attempts, priority, run_at AS "runAt", timeout_ms AS "timeoutMs", force_kill_on_timeout AS "forceKillOnTimeout", created_at AS "createdAt", updated_at AS "updatedAt", started_at AS "startedAt", completed_at AS "completedAt", last_failed_at AS "lastFailedAt", locked_at AS "lockedAt", locked_by AS "lockedBy", error_history AS "errorHistory", failure_reason AS "failureReason", next_attempt_at AS "nextAttemptAt", last_failed_at AS "lastFailedAt", last_retried_at AS "lastRetriedAt", last_cancelled_at AS "lastCancelledAt", pending_reason AS "pendingReason", tags FROM job_queue`;
     const params = [];
     let where = [];
     let paramIdx = 1;
@@ -625,6 +828,7 @@ var getJobs = async (pool, filters, limit = 100, offset = 0) => {
       ...job,
       payload: job.payload,
       timeoutMs: job.timeoutMs,
+      forceKillOnTimeout: job.forceKillOnTimeout,
       failureReason: job.failureReason
     }));
   } catch (error) {
@@ -634,8 +838,178 @@ var getJobs = async (pool, filters, limit = 100, offset = 0) => {
     client.release();
   }
 };
-
-// src/processor.ts
+function validateHandlerSerializable(handler, jobType) {
+  try {
+    const handlerString = handler.toString();
+    if (handlerString.includes("this.") && !handlerString.match(/\([^)]*this[^)]*\)/)) {
+      throw new Error(
+        `Handler for job type "${jobType}" uses 'this' context which cannot be serialized. Use a regular function or avoid 'this' references when forceKillOnTimeout is enabled.`
+      );
+    }
+    if (handlerString.includes("[native code]")) {
+      throw new Error(
+        `Handler for job type "${jobType}" contains native code which cannot be serialized. Ensure your handler is a plain function when forceKillOnTimeout is enabled.`
+      );
+    }
+    try {
+      new Function("return " + handlerString);
+    } catch (parseError) {
+      throw new Error(
+        `Handler for job type "${jobType}" cannot be serialized: ${parseError instanceof Error ? parseError.message : String(parseError)}. When using forceKillOnTimeout, handlers must be serializable functions without closures over external variables.`
+      );
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      throw error;
+    }
+    throw new Error(
+      `Failed to validate handler serialization for job type "${jobType}": ${String(error)}`
+    );
+  }
+}
+async function runHandlerInWorker(handler, payload, timeoutMs, jobType) {
+  validateHandlerSerializable(handler, jobType);
+  return new Promise((resolve, reject) => {
+    const workerCode = `
+      (function() {
+        const { parentPort, workerData } = require('worker_threads');
+        const { handlerCode, payload, timeoutMs } = workerData;
+        
+        // Create an AbortController for the handler
+        const controller = new AbortController();
+        const signal = controller.signal;
+        
+        // Set up timeout
+        const timeoutId = setTimeout(() => {
+          controller.abort();
+          parentPort.postMessage({ type: 'timeout' });
+        }, timeoutMs);
+        
+        try {
+          // Execute the handler
+          // Note: This uses Function constructor which requires the handler to be serializable.
+          // The handler should be validated before reaching this point.
+          let handlerFn;
+          try {
+            // Wrap handlerCode in parentheses to ensure it's treated as an expression
+            // This handles both arrow functions and regular functions
+            const wrappedCode = handlerCode.trim().startsWith('async') || handlerCode.trim().startsWith('function')
+              ? handlerCode
+              : '(' + handlerCode + ')';
+            handlerFn = new Function('return ' + wrappedCode)();
+          } catch (parseError) {
+            clearTimeout(timeoutId);
+            parentPort.postMessage({
+              type: 'error',
+              error: {
+                message: 'Handler cannot be deserialized in worker thread. ' +
+                  'Ensure your handler is a standalone function without closures over external variables. ' +
+                  'Original error: ' + (parseError instanceof Error ? parseError.message : String(parseError)),
+                stack: parseError instanceof Error ? parseError.stack : undefined,
+                name: 'SerializationError',
+              },
+            });
+            return;
+          }
+          
+          // Ensure handlerFn is actually a function
+          if (typeof handlerFn !== 'function') {
+            clearTimeout(timeoutId);
+            parentPort.postMessage({
+              type: 'error',
+              error: {
+                message: 'Handler deserialization did not produce a function. ' +
+                  'Ensure your handler is a valid function when forceKillOnTimeout is enabled.',
+                name: 'SerializationError',
+              },
+            });
+            return;
+          }
+          
+          handlerFn(payload, signal)
+            .then(() => {
+              clearTimeout(timeoutId);
+              parentPort.postMessage({ type: 'success' });
+            })
+            .catch((error) => {
+              clearTimeout(timeoutId);
+              parentPort.postMessage({
+                type: 'error',
+                error: {
+                  message: error.message,
+                  stack: error.stack,
+                  name: error.name,
+                },
+              });
+            });
+        } catch (error) {
+          clearTimeout(timeoutId);
+          parentPort.postMessage({
+            type: 'error',
+            error: {
+              message: error.message,
+              stack: error.stack,
+              name: error.name,
+            },
+          });
+        }
+      })();
+    `;
+    const worker = new Worker(workerCode, {
+      eval: true,
+      workerData: {
+        handlerCode: handler.toString(),
+        payload,
+        timeoutMs
+      }
+    });
+    let resolved = false;
+    worker.on("message", (message) => {
+      if (resolved) return;
+      resolved = true;
+      if (message.type === "success") {
+        resolve();
+      } else if (message.type === "timeout") {
+        const timeoutError = new Error(
+          `Job timed out after ${timeoutMs} ms and was forcefully terminated`
+        );
+        timeoutError.failureReason = "timeout" /* Timeout */;
+        reject(timeoutError);
+      } else if (message.type === "error") {
+        const error = new Error(message.error.message);
+        error.stack = message.error.stack;
+        error.name = message.error.name;
+        reject(error);
+      }
+    });
+    worker.on("error", (error) => {
+      if (resolved) return;
+      resolved = true;
+      reject(error);
+    });
+    worker.on("exit", (code) => {
+      if (resolved) return;
+      if (code !== 0) {
+        resolved = true;
+        reject(new Error(`Worker stopped with exit code ${code}`));
+      }
+    });
+    setTimeout(() => {
+      if (!resolved) {
+        resolved = true;
+        worker.terminate().then(() => {
+          const timeoutError = new Error(
+            `Job timed out after ${timeoutMs} ms and was forcefully terminated`
+          );
+          timeoutError.failureReason = "timeout" /* Timeout */;
+          reject(timeoutError);
+        }).catch((err) => {
+          reject(err);
+        });
+      }
+    }, timeoutMs + 100);
+  });
+}
 async function processJobWithHandlers(pool, job, jobHandlers) {
   const handler = jobHandlers[job.jobType];
   if (!handler) {
@@ -653,26 +1027,31 @@ async function processJobWithHandlers(pool, job, jobHandlers) {
     return;
   }
   const timeoutMs = job.timeoutMs ?? void 0;
+  const forceKillOnTimeout = job.forceKillOnTimeout ?? false;
   let timeoutId;
   const controller = new AbortController();
   try {
-    const jobPromise = handler(job.payload, controller.signal);
-    if (timeoutMs && timeoutMs > 0) {
-      await Promise.race([
-        jobPromise,
-        new Promise((_, reject) => {
-          timeoutId = setTimeout(() => {
-            controller.abort();
-            const timeoutError = new Error(
-              `Job timed out after ${timeoutMs} ms`
-            );
-            timeoutError.failureReason = "timeout" /* Timeout */;
-            reject(timeoutError);
-          }, timeoutMs);
-        })
-      ]);
+    if (forceKillOnTimeout && timeoutMs && timeoutMs > 0) {
+      await runHandlerInWorker(handler, job.payload, timeoutMs, job.jobType);
     } else {
-      await jobPromise;
+      const jobPromise = handler(job.payload, controller.signal);
+      if (timeoutMs && timeoutMs > 0) {
+        await Promise.race([
+          jobPromise,
+          new Promise((_, reject) => {
+            timeoutId = setTimeout(() => {
+              controller.abort();
+              const timeoutError = new Error(
+                `Job timed out after ${timeoutMs} ms`
+              );
+              timeoutError.failureReason = "timeout" /* Timeout */;
+              reject(timeoutError);
+            }, timeoutMs);
+          })
+        ]);
+      } else {
+        await jobPromise;
+      }
     }
     if (timeoutId) clearTimeout(timeoutId);
     await completeJob(pool, job.id);
@@ -805,12 +1184,27 @@ var createProcessor = (pool, handlers, options = {}) => {
     isRunning: () => running
   };
 };
+function loadPemOrFile(value) {
+  if (!value) return void 0;
+  if (value.startsWith("file://")) {
+    const filePath = value.slice(7);
+    return fs.readFileSync(filePath, "utf8");
+  }
+  return value;
+}
 var createPool = (config) => {
   let searchPath;
+  let ssl = void 0;
+  let customCA;
+  let sslmode;
   if (config.connectionString) {
     try {
       const url = new URL(config.connectionString);
       searchPath = url.searchParams.get("search_path") || void 0;
+      sslmode = url.searchParams.get("sslmode") || void 0;
+      if (sslmode === "no-verify") {
+        ssl = { rejectUnauthorized: false };
+      }
     } catch (e) {
       const parsed = parse(config.connectionString);
       if (parsed.options) {
@@ -819,9 +1213,52 @@ var createPool = (config) => {
           searchPath = match[1];
         }
       }
+      sslmode = typeof parsed.sslmode === "string" ? parsed.sslmode : void 0;
+      if (sslmode === "no-verify") {
+        ssl = { rejectUnauthorized: false };
+      }
+    }
+  }
+  if (config.ssl) {
+    if (typeof config.ssl.ca === "string") {
+      customCA = config.ssl.ca;
+    } else if (typeof process.env.PGSSLROOTCERT === "string") {
+      customCA = process.env.PGSSLROOTCERT;
+    } else {
+      customCA = void 0;
     }
+    const caValue = typeof customCA === "string" ? loadPemOrFile(customCA) : void 0;
+    ssl = {
+      ...ssl,
+      ...caValue ? { ca: caValue } : {},
+      cert: loadPemOrFile(
+        typeof config.ssl.cert === "string" ? config.ssl.cert : process.env.PGSSLCERT
+      ),
+      key: loadPemOrFile(
+        typeof config.ssl.key === "string" ? config.ssl.key : process.env.PGSSLKEY
+      ),
+      rejectUnauthorized: config.ssl.rejectUnauthorized !== void 0 ? config.ssl.rejectUnauthorized : true
+    };
   }
-  const pool = new Pool(config);
+  if (sslmode && customCA) {
+    const warning = `
+
+\x1B[33m**************************************************
+\u26A0\uFE0F  WARNING: SSL CONFIGURATION ISSUE
+**************************************************
+Both sslmode ('${sslmode}') is set in the connection string
+and a custom CA is provided (via config.ssl.ca or PGSSLROOTCERT).
+This combination may cause connection failures or unexpected behavior.
+
+Recommended: Remove sslmode from the connection string when using a custom CA.
+**************************************************\x1B[0m
+`;
+    console.warn(warning);
+  }
+  const pool = new Pool({
+    ...config,
+    ...ssl ? { ssl } : {}
+  });
   if (searchPath) {
     pool.on("connect", (client) => {
       client.query(`SET search_path TO ${searchPath}`);
@@ -830,6 +1267,75 @@ var createPool = (config) => {
   return pool;
 };
 
+// src/handler-validation.ts
+function validateHandlerSerializable2(handler, jobType) {
+  try {
+    const handlerString = handler.toString();
+    const typeLabel = jobType ? `job type "${jobType}"` : "handler";
+    if (handlerString.includes("this.") && !handlerString.match(/\([^)]*this[^)]*\)/)) {
+      return {
+        isSerializable: false,
+        error: `Handler for ${typeLabel} uses 'this' context which cannot be serialized. Use a regular function or avoid 'this' references when forceKillOnTimeout is enabled.`
+      };
+    }
+    if (handlerString.includes("[native code]")) {
+      return {
+        isSerializable: false,
+        error: `Handler for ${typeLabel} contains native code which cannot be serialized. Ensure your handler is a plain function when forceKillOnTimeout is enabled.`
+      };
+    }
+    try {
+      new Function("return " + handlerString);
+    } catch (parseError) {
+      return {
+        isSerializable: false,
+        error: `Handler for ${typeLabel} cannot be serialized: ${parseError instanceof Error ? parseError.message : String(parseError)}. When using forceKillOnTimeout, handlers must be serializable functions without closures over external variables.`
+      };
+    }
+    const hasPotentialClosure = /const\s+\w+\s*=\s*[^;]+;\s*async\s*\(/.test(handlerString) || /let\s+\w+\s*=\s*[^;]+;\s*async\s*\(/.test(handlerString);
+    if (hasPotentialClosure) {
+      return {
+        isSerializable: true,
+        // Still serializable, but might have issues
+        error: `Warning: Handler for ${typeLabel} may have closures over external variables. Test thoroughly with forceKillOnTimeout enabled. If the handler fails to execute in a worker thread, ensure all dependencies are imported within the handler function.`
+      };
+    }
+    return { isSerializable: true };
+  } catch (error) {
+    return {
+      isSerializable: false,
+      error: `Failed to validate handler serialization${jobType ? ` for job type "${jobType}"` : ""}: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function testHandlerSerialization(handler, jobType) {
+  const basicValidation = validateHandlerSerializable2(handler, jobType);
+  if (!basicValidation.isSerializable) {
+    return basicValidation;
+  }
+  try {
+    const handlerString = handler.toString();
+    const handlerFn = new Function("return " + handlerString)();
+    const testPromise = handlerFn({}, new AbortController().signal);
+    const timeoutPromise = new Promise(
+      (_, reject) => setTimeout(() => reject(new Error("Handler test timeout")), 100)
+    );
+    try {
+      await Promise.race([testPromise, timeoutPromise]);
+    } catch (execError) {
+      if (execError instanceof Error && execError.message === "Handler test timeout") {
+        return { isSerializable: true };
+      }
+    }
+    return { isSerializable: true };
+  } catch (error) {
+    return {
+      isSerializable: false,
+      error: `Handler failed serialization test: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+
 // src/index.ts
 var initJobQueue = (config) => {
   const { databaseConfig } = config;
@@ -863,6 +1369,14 @@ var initJobQueue = (config) => {
       (jobId) => cancelJob(pool, jobId),
       config.verbose ?? false
     ),
+    editJob: withLogContext(
+      (jobId, updates) => editJob(pool, jobId, updates),
+      config.verbose ?? false
+    ),
+    editAllPendingJobs: withLogContext(
+      (filters, updates) => editAllPendingJobs(pool, filters, updates),
+      config.verbose ?? false
+    ),
     cancelAllUpcomingJobs: withLogContext(
       (filters) => cancelAllUpcomingJobs(pool, filters),
       config.verbose ?? false
@@ -891,6 +1405,6 @@ var withLogContext = (fn, verbose) => (...args) => {
   return fn(...args);
 };
 
-export { FailureReason, JobEventType, initJobQueue };
+export { FailureReason, JobEventType, initJobQueue, testHandlerSerialization, validateHandlerSerializable2 as validateHandlerSerializable };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map