@nicnocquee/dataqueue 1.20.0 → 1.22.0

package/src/db-util.test.ts

@@ -1,10 +1,20 @@
-import { describe, it, expect, afterAll } from 'vitest';
+import { describe, it, expect, afterAll, vi } from 'vitest';
 import { createPool } from './db-util.js';
+import fs from 'fs';
 
 // Use a test schema name that is unlikely to exist
 const TEST_SCHEMA = 'testschema';
 const TEST_CONN = `postgres://postgres:postgres@localhost:5432/postgres?search_path=${TEST_SCHEMA}`;
 
+// Dummy PEM string for testing
+const DUMMY_PEM =
+  '-----BEGIN CERTIFICATE-----\nDUMMY\n-----END CERTIFICATE-----';
+
+// Helper to mock fs.readFileSync
+function mockReadFileSync(content: string) {
+  return vi.spyOn(fs, 'readFileSync').mockImplementation(() => content);
+}
+
 describe('createPool', () => {
   const pool = createPool({ connectionString: TEST_CONN });
 
@@ -22,4 +32,49 @@ describe('createPool', () => {
       client.release();
     }
   });
+
+  it('should use PEM string directly for ssl.ca', () => {
+    const pool = createPool({
+      connectionString: TEST_CONN,
+      ssl: { ca: DUMMY_PEM, rejectUnauthorized: true },
+    });
+    const ssl = pool.options.ssl;
+    if (typeof ssl === 'object' && ssl !== null) {
+      expect(ssl.ca).toBe(DUMMY_PEM);
+    } else {
+      throw new Error('ssl is not an object');
+    }
+    pool.end();
+  });
+
+  it('should load ca from file when using file:// path', () => {
+    const spy = mockReadFileSync(DUMMY_PEM);
+    const pool = createPool({
+      connectionString: TEST_CONN,
+      ssl: { ca: 'file:///dummy/path/ca.crt', rejectUnauthorized: true },
+    });
+    const ssl = pool.options.ssl;
+    if (typeof ssl === 'object' && ssl !== null) {
+      expect(spy).toHaveBeenCalledWith('/dummy/path/ca.crt', 'utf8');
+      expect(ssl.ca).toBe(DUMMY_PEM);
+    } else {
+      throw new Error('ssl is not an object');
+    }
+    pool.end();
+    spy.mockRestore();
+  });
+
+  it('should set rejectUnauthorized to false for self-signed certs', () => {
+    const pool = createPool({
+      connectionString: TEST_CONN,
+      ssl: { ca: DUMMY_PEM, rejectUnauthorized: false },
+    });
+    const ssl = pool.options.ssl;
+    if (typeof ssl === 'object' && ssl !== null) {
+      expect(ssl.rejectUnauthorized).toBe(false);
+    } else {
+      throw new Error('ssl is not an object');
+    }
+    pool.end();
+  });
 });

package/src/db-util.ts

@@ -1,31 +1,102 @@
 import { Pool } from 'pg';
 import { JobQueueConfig } from './types.js';
 import { parse } from 'pg-connection-string';
+import fs from 'fs';
 
-// Create a database connection pool
+/**
+ * Helper to load a PEM string or file. Only values starting with 'file://' are loaded from file.
+ */
+function loadPemOrFile(value?: string): string | undefined {
+  if (!value) return undefined;
+  if (value.startsWith('file://')) {
+    const filePath = value.slice(7);
+    return fs.readFileSync(filePath, 'utf8');
+  }
+  return value;
+}
+
+/**
+ * Create a database connection pool with flexible SSL certificate loading.
+ *
+ * SSL config example (for local file paths):
+ *   ssl: {
+ *     ca: process.env.PGSSLROOTCERT, // PEM string or 'file://...'
+ *     cert: process.env.PGSSLCERT,   // optional, PEM string or 'file://...'
+ *     key: process.env.PGSSLKEY,     // optional, PEM string or 'file://...'
+ *     rejectUnauthorized: true
+ *   }
+ */
 export const createPool = (config: JobQueueConfig['databaseConfig']): Pool => {
   let searchPath: string | undefined;
+  let ssl: any = undefined;
+  let customCA: string | undefined;
+  let sslmode: string | undefined;
+
   if (config.connectionString) {
-    // Parse the connection string to extract search_path from query params
     try {
       const url = new URL(config.connectionString);
       searchPath = url.searchParams.get('search_path') || undefined;
+      sslmode = url.searchParams.get('sslmode') || undefined;
+      if (sslmode === 'no-verify') {
+        ssl = { rejectUnauthorized: false };
+      }
     } catch (e) {
-      // fallback: try pg-connection-string parse (for non-standard URLs)
       const parsed = parse(config.connectionString);
       if (parsed.options) {
-        // options might look like '-c search_path=myschema'
         const match = parsed.options.match(/search_path=([^\s]+)/);
         if (match) {
           searchPath = match[1];
         }
       }
+      sslmode = typeof parsed.sslmode === 'string' ? parsed.sslmode : undefined;
+      if (sslmode === 'no-verify') {
+        ssl = { rejectUnauthorized: false };
+      }
     }
   }
 
-  const pool = new Pool(config);
+  // Flexible SSL loading: only support file:// for file loading
+  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 = undefined;
+    }
+    const caValue =
+      typeof customCA === 'string' ? loadPemOrFile(customCA) : undefined;
+    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 !== undefined
+          ? config.ssl.rejectUnauthorized
+          : true,
+    };
+  }
+
+  // Warn if both sslmode (any value) and a custom CA are set
+  if (sslmode && customCA) {
+    const warning = `\n\n\x1b[33m**************************************************\n\u26A0\uFE0F  WARNING: SSL CONFIGURATION ISSUE\n**************************************************\nBoth sslmode ('${sslmode}') is set in the connection string\nand a custom CA is provided (via config.ssl.ca or PGSSLROOTCERT).\nThis combination may cause connection failures or unexpected behavior.\n\nRecommended: Remove sslmode from the connection string when using a custom CA.\n**************************************************\x1b[0m\n`;
+    console.warn(warning);
+  }
+
+  const pool = new Pool({
+    ...config,
+    ...(ssl ? { ssl } : {}),
+  });
 
-  // If search_path is specified, set it for every new connection
   if (searchPath) {
     pool.on('connect', (client) => {
       client.query(`SET search_path TO ${searchPath}`);

package/src/index.ts

@@ -10,6 +10,7 @@ import {
   reclaimStuckJobs,
   getJobEvents,
   getJobsByTags,
+  getJobs,
 } from './queue.js';
 import { createProcessor } from './processor.js';
 import {
@@ -56,6 +57,21 @@ export const initJobQueue = <PayloadMap = any>(
         getAllJobs<PayloadMap, any>(pool, limit, offset),
       config.verbose ?? false,
     ),
+    getJobs: withLogContext(
+      (
+        filters?: {
+          jobType?: string;
+          priority?: number;
+          runAt?:
+            | Date
+            | { gt?: Date; gte?: Date; lt?: Date; lte?: Date; eq?: Date };
+          tags?: { values: string[]; mode?: import('./types.js').TagQueryMode };
+        },
+        limit?: number,
+        offset?: number,
+      ) => getJobs<PayloadMap, any>(pool, filters, limit, offset),
+      config.verbose ?? false,
+    ),
     retryJob: (jobId: number) => retryJob(pool, jobId),
     cleanupOldJobs: (daysToKeep?: number) => cleanupOldJobs(pool, daysToKeep),
     cancelJob: withLogContext(
@@ -66,7 +82,9 @@ export const initJobQueue = <PayloadMap = any>(
       (filters?: {
         jobType?: string;
         priority?: number;
-        runAt?: Date;
+        runAt?:
+          | Date
+          | { gt?: Date; gte?: Date; lt?: Date; lte?: Date; eq?: Date };
         tags?: { values: string[]; mode?: import('./types.js').TagQueryMode };
       }) => cancelAllUpcomingJobs(pool, filters),
       config.verbose ?? false,

package/src/queue.test.ts

@@ -748,3 +748,452 @@ describe('tags feature', () => {
     expect(job3?.status).toBe('cancelled');
   });
 });
+
+describe('cancelAllUpcomingJobs with runAt object filter', () => {
+  let pool: Pool;
+  let dbName: string;
+
+  beforeEach(async () => {
+    const setup = await createTestDbAndPool();
+    pool = setup.pool;
+    dbName = setup.dbName;
+  });
+
+  afterEach(async () => {
+    await pool.end();
+    await destroyTestDb(dbName);
+  });
+
+  it('should cancel jobs with runAt > filter (gt)', async () => {
+    const now = new Date();
+    const past = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+    const future = new Date(now.getTime() + 24 * 60 * 60 * 1000);
+    const jobIdPast = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'past@example.com' },
+        runAt: past,
+      },
+    );
+    const jobIdNow = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'now@example.com' },
+        runAt: now,
+      },
+    );
+    const jobIdFuture = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'future@example.com' },
+        runAt: future,
+      },
+    );
+    const cancelled = await queue.cancelAllUpcomingJobs(pool, {
+      runAt: { gt: now },
+    });
+    expect(cancelled).toBe(1);
+    const jobPast = await queue.getJob(pool, jobIdPast);
+    const jobNow = await queue.getJob(pool, jobIdNow);
+    const jobFuture = await queue.getJob(pool, jobIdFuture);
+    expect(jobPast?.status).toBe('pending');
+    expect(jobNow?.status).toBe('pending');
+    expect(jobFuture?.status).toBe('cancelled');
+  });
+
+  it('should cancel jobs with runAt >= filter (gte)', async () => {
+    const now = new Date();
+    const past = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+    const future = new Date(now.getTime() + 24 * 60 * 60 * 1000);
+    const jobIdPast = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'past@example.com' },
+        runAt: past,
+      },
+    );
+    const jobIdNow = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'now@example.com' },
+        runAt: now,
+      },
+    );
+    const jobIdFuture = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'future@example.com' },
+        runAt: future,
+      },
+    );
+    const cancelled = await queue.cancelAllUpcomingJobs(pool, {
+      runAt: { gte: now },
+    });
+    expect(cancelled).toBe(2);
+    const jobPast = await queue.getJob(pool, jobIdPast);
+    const jobNow = await queue.getJob(pool, jobIdNow);
+    const jobFuture = await queue.getJob(pool, jobIdFuture);
+    expect(jobPast?.status).toBe('pending');
+    expect(jobNow?.status).toBe('cancelled');
+    expect(jobFuture?.status).toBe('cancelled');
+  });
+
+  it('should cancel jobs with runAt < filter (lt)', async () => {
+    const now = new Date();
+    const past = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+    const future = new Date(now.getTime() + 24 * 60 * 60 * 1000);
+    const jobIdPast = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'past@example.com' },
+        runAt: past,
+      },
+    );
+    const jobIdNow = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'now@example.com' },
+        runAt: now,
+      },
+    );
+    const jobIdFuture = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'future@example.com' },
+        runAt: future,
+      },
+    );
+    const cancelled = await queue.cancelAllUpcomingJobs(pool, {
+      runAt: { lt: now },
+    });
+    expect(cancelled).toBe(1);
+    const jobPast = await queue.getJob(pool, jobIdPast);
+    const jobNow = await queue.getJob(pool, jobIdNow);
+    const jobFuture = await queue.getJob(pool, jobIdFuture);
+    expect(jobPast?.status).toBe('cancelled');
+    expect(jobNow?.status).toBe('pending');
+    expect(jobFuture?.status).toBe('pending');
+  });
+
+  it('should cancel jobs with runAt <= filter (lte)', async () => {
+    const now = new Date();
+    const past = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+    const future = new Date(now.getTime() + 24 * 60 * 60 * 1000);
+    const jobIdPast = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'past@example.com' },
+        runAt: past,
+      },
+    );
+    const jobIdNow = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'now@example.com' },
+        runAt: now,
+      },
+    );
+    const jobIdFuture = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'future@example.com' },
+        runAt: future,
+      },
+    );
+    const cancelled = await queue.cancelAllUpcomingJobs(pool, {
+      runAt: { lte: now },
+    });
+    expect(cancelled).toBe(2);
+    const jobPast = await queue.getJob(pool, jobIdPast);
+    const jobNow = await queue.getJob(pool, jobIdNow);
+    const jobFuture = await queue.getJob(pool, jobIdFuture);
+    expect(jobPast?.status).toBe('cancelled');
+    expect(jobNow?.status).toBe('cancelled');
+    expect(jobFuture?.status).toBe('pending');
+  });
+
+  it('should cancel jobs with runAt eq filter (eq)', async () => {
+    const now = new Date();
+    const past = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+    const future = new Date(now.getTime() + 24 * 60 * 60 * 1000);
+    const jobIdPast = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'past@example.com' },
+        runAt: past,
+      },
+    );
+    const jobIdNow = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'now@example.com' },
+        runAt: now,
+      },
+    );
+    const jobIdFuture = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'future@example.com' },
+        runAt: future,
+      },
+    );
+    const cancelled = await queue.cancelAllUpcomingJobs(pool, {
+      runAt: { eq: now },
+    });
+    expect(cancelled).toBe(1);
+    const jobPast = await queue.getJob(pool, jobIdPast);
+    const jobNow = await queue.getJob(pool, jobIdNow);
+    const jobFuture = await queue.getJob(pool, jobIdFuture);
+    expect(jobPast?.status).toBe('pending');
+    expect(jobNow?.status).toBe('cancelled');
+    expect(jobFuture?.status).toBe('pending');
+  });
+});
+
+describe('getJobs', () => {
+  let pool: Pool;
+  let dbName: string;
+
+  beforeEach(async () => {
+    const setup = await createTestDbAndPool();
+    pool = setup.pool;
+    dbName = setup.dbName;
+  });
+
+  afterEach(async () => {
+    await pool.end();
+    await destroyTestDb(dbName);
+  });
+
+  it('should filter by jobType', async () => {
+    const id1 = await queue.addJob<{ a: { n: number }; b: { n: number } }, 'a'>(
+      pool,
+      { jobType: 'a', payload: { n: 1 } },
+    );
+    const id2 = await queue.addJob<{ a: { n: number }; b: { n: number } }, 'b'>(
+      pool,
+      { jobType: 'b', payload: { n: 2 } },
+    );
+    const jobs = await queue.getJobs(pool, { jobType: 'a' });
+    expect(jobs.map((j) => j.id)).toContain(id1);
+    expect(jobs.map((j) => j.id)).not.toContain(id2);
+  });
+
+  it('should filter by priority', async () => {
+    const id1 = await queue.addJob<{ a: { n: number } }, 'a'>(pool, {
+      jobType: 'a',
+      payload: { n: 1 },
+      priority: 1,
+    });
+    const id2 = await queue.addJob<{ a: { n: number } }, 'a'>(pool, {
+      jobType: 'a',
+      payload: { n: 2 },
+      priority: 2,
+    });
+    const jobs = await queue.getJobs(pool, { priority: 2 });
+    expect(jobs.map((j) => j.id)).toContain(id2);
+    expect(jobs.map((j) => j.id)).not.toContain(id1);
+  });
+
+  it('should filter by runAt', async () => {
+    const runAt = new Date(Date.UTC(2030, 0, 1, 12, 0, 0, 0));
+    const id1 = await queue.addJob<{ a: { n: number } }, 'a'>(pool, {
+      jobType: 'a',
+      payload: { n: 1 },
+      runAt,
+    });
+    const id2 = await queue.addJob<{ a: { n: number } }, 'a'>(pool, {
+      jobType: 'a',
+      payload: { n: 2 },
+    });
+    const jobs = await queue.getJobs(pool, { runAt });
+    expect(jobs.map((j) => j.id)).toContain(id1);
+    expect(jobs.map((j) => j.id)).not.toContain(id2);
+  });
+
+  it('should filter jobs using runAt with gt/gte/lt/lte/eq', async () => {
+    const now = new Date();
+    const past = new Date(now.getTime() - 24 * 60 * 60 * 1000); // 1 day ago
+    const future = new Date(now.getTime() + 24 * 60 * 60 * 1000); // 1 day ahead
+    const jobIdPast = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'past@example.com' },
+        runAt: past,
+      },
+    );
+    const jobIdNow = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'now@example.com' },
+        runAt: now,
+      },
+    );
+    const jobIdFuture = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'future@example.com' },
+        runAt: future,
+      },
+    );
+    // eq
+    let jobs = await queue.getJobs(pool, { runAt: now });
+    expect(jobs.map((j) => j.id)).toContain(jobIdNow);
+    // gt
+    jobs = await queue.getJobs(pool, { runAt: { gt: now } });
+    expect(jobs.map((j) => j.id)).toContain(jobIdFuture);
+    expect(jobs.map((j) => j.id)).not.toContain(jobIdNow);
+    // gte
+    jobs = await queue.getJobs(pool, { runAt: { gte: now } });
+    expect(jobs.map((j) => j.id)).toContain(jobIdNow);
+    expect(jobs.map((j) => j.id)).toContain(jobIdFuture);
+    // lt
+    jobs = await queue.getJobs(pool, { runAt: { lt: now } });
+    expect(jobs.map((j) => j.id)).toContain(jobIdPast);
+    expect(jobs.map((j) => j.id)).not.toContain(jobIdNow);
+    // lte
+    jobs = await queue.getJobs(pool, { runAt: { lte: now } });
+    expect(jobs.map((j) => j.id)).toContain(jobIdPast);
+    expect(jobs.map((j) => j.id)).toContain(jobIdNow);
+  });
+
+  it('should filter by tags (all mode)', async () => {
+    const id1 = await queue.addJob<{ a: { n: number } }, 'a'>(pool, {
+      jobType: 'a',
+      payload: { n: 1 },
+      tags: ['foo', 'bar'],
+    });
+    const id2 = await queue.addJob<{ a: { n: number } }, 'a'>(pool, {
+      jobType: 'a',
+      payload: { n: 2 },
+      tags: ['foo'],
+    });
+    const jobs = await queue.getJobs(pool, {
+      tags: { values: ['foo', 'bar'], mode: 'all' },
+    });
+    expect(jobs.map((j) => j.id)).toContain(id1);
+    expect(jobs.map((j) => j.id)).not.toContain(id2);
+  });
+
+  it('should filter by tags (any mode)', async () => {
+    const id1 = await queue.addJob<{ a: { n: number } }, 'a'>(pool, {
+      jobType: 'a',
+      payload: { n: 1 },
+      tags: ['foo'],
+    });
+    const id2 = await queue.addJob<{ a: { n: number } }, 'a'>(pool, {
+      jobType: 'a',
+      payload: { n: 2 },
+      tags: ['bar'],
+    });
+    const jobs = await queue.getJobs(pool, {
+      tags: { values: ['foo', 'bar'], mode: 'any' },
+    });
+    expect(jobs.map((j) => j.id)).toContain(id1);
+    expect(jobs.map((j) => j.id)).toContain(id2);
+  });
+
+  it('should filter by tags (exact mode)', async () => {
+    const id1 = await queue.addJob<{ a: { n: number } }, 'a'>(pool, {
+      jobType: 'a',
+      payload: { n: 1 },
+      tags: ['foo', 'bar'],
+    });
+    const id2 = await queue.addJob<{ a: { n: number } }, 'a'>(pool, {
+      jobType: 'a',
+      payload: { n: 2 },
+      tags: ['foo', 'bar', 'baz'],
+    });
+    const jobs = await queue.getJobs(pool, {
+      tags: { values: ['foo', 'bar'], mode: 'exact' },
+    });
+    expect(jobs.map((j) => j.id)).toContain(id1);
+    expect(jobs.map((j) => j.id)).not.toContain(id2);
+  });
+
+  it('should filter by tags (none mode)', async () => {
+    const id1 = await queue.addJob<{ a: { n: number } }, 'a'>(pool, {
+      jobType: 'a',
+      payload: { n: 1 },
+      tags: ['foo'],
+    });
+    const id2 = await queue.addJob<{ a: { n: number } }, 'a'>(pool, {
+      jobType: 'a',
+      payload: { n: 2 },
+      tags: ['bar'],
+    });
+    const id3 = await queue.addJob<{ a: { n: number } }, 'a'>(pool, {
+      jobType: 'a',
+      payload: { n: 3 },
+      tags: ['baz'],
+    });
+    const jobs = await queue.getJobs(pool, {
+      tags: { values: ['foo', 'bar'], mode: 'none' },
+    });
+    expect(jobs.map((j) => j.id)).toContain(id3);
+    expect(jobs.map((j) => j.id)).not.toContain(id1);
+    expect(jobs.map((j) => j.id)).not.toContain(id2);
+  });
+
+  it('should support pagination', async () => {
+    const ids = [];
+    for (let i = 0; i < 5; i++) {
+      ids.push(
+        await queue.addJob<{ a: { n: number } }, 'a'>(pool, {
+          jobType: 'a',
+          payload: { n: i },
+        }),
+      );
+    }
+    const firstTwo = await queue.getJobs(pool, {}, 2, 0);
+    const nextTwo = await queue.getJobs(pool, {}, 2, 2);
+    expect(firstTwo.length).toBe(2);
+    expect(nextTwo.length).toBe(2);
+    const firstIds = firstTwo.map((j) => j.id);
+    const nextIds = nextTwo.map((j) => j.id);
+    expect(firstIds.some((id) => nextIds.includes(id))).toBe(false);
+  });
+
+  it('should filter by a combination of filters', async () => {
+    const runAt = new Date(Date.UTC(2030, 0, 1, 12, 0, 0, 0));
+    const id1 = await queue.addJob<{ a: { n: number } }, 'a'>(pool, {
+      jobType: 'a',
+      payload: { n: 1 },
+      priority: 1,
+      runAt,
+      tags: ['foo', 'bar'],
+    });
+    const id2 = await queue.addJob<{ a: { n: number } }, 'a'>(pool, {
+      jobType: 'a',
+      payload: { n: 2 },
+      priority: 2,
+      tags: ['foo'],
+    });
+    const jobs = await queue.getJobs(pool, {
+      jobType: 'a',
+      priority: 1,
+      runAt,
+      tags: { values: ['foo', 'bar'], mode: 'all' },
+    });
+    expect(jobs.map((j) => j.id)).toContain(id1);
+    expect(jobs.map((j) => j.id)).not.toContain(id2);
+  });
+});