pg-boss 12.18.2 → 12.19.0

package/dist/plans.js

@@ -1,11 +1,14 @@
-const DEFAULT_SCHEMA = 'pgboss';
-const MIGRATE_RACE_MESSAGE = 'division by zero';
-const CREATE_RACE_MESSAGE = 'already exists';
+export const PG_ERROR = {
+    divisionByZero: '22012'
+};
+export const DEFAULT_SCHEMA = 'pgboss';
+export const MIGRATE_RACE_MESSAGE = 'division by zero';
+export const CREATE_RACE_MESSAGE = 'already exists';
 const SINGLE_QUOTE_REGEX = /'/g;
 const FIFTEEN_MINUTES = 60 * 15;
 const FORTEEN_DAYS = 60 * 60 * 24 * 14;
 const SEVEN_DAYS = 60 * 60 * 24 * 7;
-const JOB_STATES = Object.freeze({
+export const JOB_STATES = Object.freeze({
     created: 'created',
     retry: 'retry',
     active: 'active',
@@ -13,7 +16,7 @@ const JOB_STATES = Object.freeze({
     cancelled: 'cancelled',
     failed: 'failed'
 });
-const QUEUE_POLICIES = Object.freeze({
+export const QUEUE_POLICIES = Object.freeze({
     standard: 'standard',
     short: 'short',
     singleton: 'singleton',
@@ -32,7 +35,7 @@ const QUEUE_DEFAULTS = {
     partition: false
 };
 const COMMON_JOB_TABLE = 'job_common';
-function create(schema, version, options) {
+export function create(schema, version, options) {
     const commands = [
         options?.createSchema ? createSchema(schema) : '',
         createEnumJobState(schema),
@@ -49,6 +52,8 @@ function create(schema, version, options) {
         createTableJobCommon(schema),
         createTableWarning(schema),
         createIndexWarning(schema),
+        createTableJobDependency(schema),
+        createIndexJobDependencyParent(schema),
         createQueueFunction(schema),
         deleteQueueFunction(schema),
         insertVersion(schema, version)
@@ -154,7 +159,7 @@ function createTableBam(schema) {
     )
   `;
 }
-function createTableWarning(schema) {
+export function createTableWarning(schema) {
     return `
     CREATE TABLE ${schema}.warning (
       id uuid PRIMARY KEY default gen_random_uuid(),
@@ -165,9 +170,23 @@ function createTableWarning(schema) {
     )
   `;
 }
-function createIndexWarning(schema) {
+export function createIndexWarning(schema) {
     return `CREATE INDEX warning_i1 ON ${schema}.warning (created_on DESC)`;
 }
+export function createTableJobDependency(schema) {
+    return `
+    CREATE TABLE ${schema}.job_dependency (
+      child_name text NOT NULL,
+      child_id uuid NOT NULL,
+      parent_name text NOT NULL,
+      parent_id uuid NOT NULL,
+      PRIMARY KEY (child_name, child_id, parent_name, parent_id)
+    )
+  `;
+}
+export function createIndexJobDependencyParent(schema) {
+    return `CREATE INDEX IF NOT EXISTS job_dep_parent_idx ON ${schema}.job_dependency (parent_name, parent_id)`;
+}
 function jobTableFormatFunction(schema) {
     return `
     CREATE FUNCTION ${schema}.job_table_format(command text, table_name text)
@@ -286,7 +305,10 @@ function createTableJob(schema) {
       dead_letter text,
       policy text,
       heartbeat_on timestamp with time zone,
-      heartbeat_seconds int
+      heartbeat_seconds int,
+      blocked boolean not null default false,
+      blocking boolean not null default false,
+      pending_dependencies int not null default 0
     ) PARTITION BY LIST (name)
   `;
 }
@@ -310,6 +332,9 @@ const JOB_COLUMNS_ALL = `${JOB_COLUMNS_MIN},
   completed_on as "completedOn",
   keep_until as "keepUntil",
   dead_letter as "deadLetter",
+  blocked,
+  blocking,
+  pending_dependencies as "pendingDependencies",
   output
 `;
 function createTableJobCommon(schema) {
@@ -443,11 +468,11 @@ function deleteQueueFunction(schema) {
     LANGUAGE plpgsql;
   `;
 }
-function createQueue(schema, name, options) {
+export function createQueue(schema, name, options) {
     const sql = `SELECT ${schema}.create_queue('${name}', '${JSON.stringify(options)}'::jsonb)`;
     return locked(schema, sql, 'create-queue');
 }
-function deleteQueue(schema, name) {
+export function deleteQueue(schema, name) {
     const sql = `SELECT ${schema}.delete_queue('${name}')`;
     return locked(schema, sql, 'delete-queue');
 }
@@ -473,7 +498,7 @@ function createIndexJobThrottle(schema) {
     return `CREATE UNIQUE INDEX job_i4 ON ${schema}.job (name, singleton_on, COALESCE(singleton_key, '')) WHERE state <> '${JOB_STATES.cancelled}' AND singleton_on IS NOT NULL`;
 }
 function createIndexJobFetch(schema) {
-    return `CREATE INDEX job_i5 ON ${schema}.job (name, start_after) INCLUDE (priority, created_on, id) WHERE state < '${JOB_STATES.active}'`;
+    return `CREATE INDEX job_i5 ON ${schema}.job (name, start_after) INCLUDE (priority, created_on, id) WHERE state < '${JOB_STATES.active}' AND NOT blocked`;
 }
 function createIndexJobPolicyExclusive(schema) {
     return `CREATE UNIQUE INDEX job_i6 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state <= '${JOB_STATES.active}' AND policy = '${QUEUE_POLICIES.exclusive}'`;
@@ -487,16 +512,16 @@ function createCheckConstraintKeyStrictFifo(schema) {
 function createIndexJobGroupConcurrency(schema) {
     return `CREATE INDEX job_i7 ON ${schema}.job (name, group_id) WHERE state = '${JOB_STATES.active}' AND group_id IS NOT NULL`;
 }
-function trySetQueueMonitorTime(schema, queues, seconds) {
+export function trySetQueueMonitorTime(schema, queues, seconds) {
     return trySetQueueTimestamp(schema, queues, 'monitor_on', seconds);
 }
-function trySetQueueDeletionTime(schema, queues, seconds) {
+export function trySetQueueDeletionTime(schema, queues, seconds) {
     return trySetQueueTimestamp(schema, queues, 'maintain_on', seconds);
 }
-function trySetCronTime(schema, seconds) {
+export function trySetCronTime(schema, seconds) {
     return trySetTimestamp(schema, 'cron_on', seconds);
 }
-function trySetBamTime(schema, seconds) {
+export function trySetBamTime(schema, seconds) {
     return trySetTimestamp(schema, 'bam_on', seconds);
 }
 function trySetTimestamp(schema, column, seconds) {
@@ -519,7 +544,7 @@ function trySetQueueTimestamp(schema, queues, column, seconds) {
         values: [queues]
     };
 }
-function updateQueue(schema, { deadLetter } = {}) {
+export function updateQueue(schema, { deadLetter } = {}) {
     return `
     WITH options as (SELECT $2::jsonb as data)
     UPDATE ${schema}.queue SET
@@ -544,7 +569,7 @@ function updateQueue(schema, { deadLetter } = {}) {
     WHERE name = $1
   `;
 }
-function getQueues(schema, names) {
+export function getQueues(schema, names) {
     const hasNames = names && names.length > 0;
     return {
         text: `
@@ -576,7 +601,7 @@ function getQueues(schema, names) {
         values: hasNames ? [names] : []
     };
 }
-function deleteJobsById(schema, table) {
+export function deleteJobsById(schema, table) {
     return `
     WITH results as (
       DELETE FROM ${schema}.${table}
@@ -587,25 +612,25 @@ function deleteJobsById(schema, table) {
     SELECT COUNT(*) from results
   `;
 }
-function deleteQueuedJobs(schema, table) {
+export function deleteQueuedJobs(schema, table) {
     return `DELETE from ${schema}.${table} WHERE name = $1 and state < '${JOB_STATES.active}'`;
 }
-function deleteStoredJobs(schema, table) {
+export function deleteStoredJobs(schema, table) {
     return `DELETE from ${schema}.${table} WHERE name = $1 and state > '${JOB_STATES.active}'`;
 }
-function truncateTable(schema, table) {
+export function truncateTable(schema, table) {
     return `TRUNCATE ${schema}.${table}`;
 }
-function deleteAllJobs(schema, table) {
+export function deleteAllJobs(schema, table) {
     return `DELETE from ${schema}.${table} WHERE name = $1`;
 }
-function getSchedules(schema) {
+export function getSchedules(schema) {
     return `SELECT * FROM ${schema}.schedule ORDER BY name, key`;
 }
-function getSchedulesByQueue(schema) {
+export function getSchedulesByQueue(schema) {
     return `SELECT * FROM ${schema}.schedule WHERE name = $1 AND COALESCE(key, '') = $2`;
 }
-function schedule(schema) {
+export function schedule(schema) {
     return `
     INSERT INTO ${schema}.schedule (name, key, cron, timezone, data, options)
     VALUES ($1, $2, $3, $4, $5, $6)
@@ -617,14 +642,14 @@ function schedule(schema) {
       updated_on = now()
   `;
 }
-function unschedule(schema) {
+export function unschedule(schema) {
     return `
     DELETE FROM ${schema}.schedule
     WHERE name = $1
       AND COALESCE(key, '') = $2
   `;
 }
-function subscribe(schema) {
+export function subscribe(schema) {
     return `
     INSERT INTO ${schema}.subscription (event, name)
     VALUES ($1, $2)
@@ -634,28 +659,28 @@ function subscribe(schema) {
       updated_on = now()
   `;
 }
-function unsubscribe(schema) {
+export function unsubscribe(schema) {
     return `
     DELETE FROM ${schema}.subscription
     WHERE event = $1 and name = $2
   `;
 }
-function getQueuesForEvent(schema) {
+export function getQueuesForEvent(schema) {
     return `
     SELECT name FROM ${schema}.subscription
     WHERE event = $1
   `;
 }
-function getTime() {
+export function getTime() {
     return "SELECT round(date_part('epoch', now()) * 1000) as time";
 }
-function insertWarning(schema) {
+export function insertWarning(schema) {
     return `
     INSERT INTO ${schema}.warning (type, message, data)
     VALUES ($1, $2, $3)
   `;
 }
-function getWarnings(schema) {
+export function getWarnings(schema) {
     return `
     SELECT
       id,
@@ -669,29 +694,29 @@ function getWarnings(schema) {
     LIMIT $2 OFFSET $3
   `;
 }
-function getWarningsCount(schema) {
+export function getWarningsCount(schema) {
     return `
     SELECT COUNT(*)::int as count
     FROM ${schema}.warning
     WHERE ($1::text IS NULL OR type = $1)
   `;
 }
-function deleteOldWarnings(schema, days) {
+export function deleteOldWarnings(schema, days) {
     return `
     DELETE FROM ${schema}.warning
     WHERE created_on < now() - interval '${days} days'
   `;
 }
-function getVersion(schema) {
+export function getVersion(schema) {
     return `SELECT version from ${schema}.version`;
 }
-function setVersion(schema, version) {
+export function setVersion(schema, version) {
     return `UPDATE ${schema}.version SET version = '${version}'`;
 }
-function versionTableExists(schema) {
+export function versionTableExists(schema) {
     return `SELECT to_regclass('${schema}.version') as name`;
 }
-function insertVersion(schema, version) {
+export function insertVersion(schema, version) {
     return `INSERT INTO ${schema}.version(version) VALUES ('${version}')`;
 }
 function buildFetchParams(options) {
@@ -745,7 +770,7 @@ function buildFetchParams(options) {
     }
     return { values, ignoreSingletonsParam, ignoreGroupsParam, defaultGroupLimitParam, tiersParam, minPriorityParam, maxPriorityParam };
 }
-function fetchNextJob(options) {
+export function fetchNextJob(options) {
     const { schema, table, name, policy, limit, includeMetadata, priority = true, orderByCreatedOn = true, ignoreStartAfter = false, groupConcurrency, minPriority, maxPriority } = options;
     const singletonFetch = limit > 1 && (policy === QUEUE_POLICIES.singleton || policy === QUEUE_POLICIES.stately);
     const hasIgnoreSingletons = options.ignoreSingletons != null && options.ignoreSingletons.length > 0;
@@ -782,6 +807,7 @@ function fetchNextJob(options) {
     const whereConditions = [
         `j.name = '${name}'`,
         `j.state < '${JOB_STATES.active}'`,
+        'NOT j.blocked',
         !ignoreStartAfter ? 'j.start_after < now()' : '',
         hasIgnoreSingletons ? `j.singleton_key <> ALL(${params.ignoreSingletonsParam})` : '',
         hasIgnoreGroups ? `(j.group_id IS NULL OR j.group_id <> ALL(${params.ignoreGroupsParam}))` : '',
@@ -858,25 +884,52 @@ function fetchNextJob(options) {
         values: params.values
     };
 }
-function completeJobs(schema, table, includeQueued) {
-    const stateFilter = includeQueued
-        ? `state < '${JOB_STATES.completed}'`
-        : `state = '${JOB_STATES.active}'`;
+export function completeJobs(schema, table, includeQueued) {
     return `
-    WITH results AS (
+    WITH completed AS (
       UPDATE ${schema}.${table}
       SET completed_on = now(),
         state = '${JOB_STATES.completed}',
-        output = $3::jsonb
+        output = $3::jsonb,
+        blocked = ${includeQueued ? 'false' : 'blocked'},
+        pending_dependencies = ${includeQueued ? '0' : 'pending_dependencies'}
       WHERE name = $1
         AND id IN (SELECT UNNEST($2::uuid[]))
-        AND ${stateFilter}
-      RETURNING *
+        AND ${includeQueued
+        ? `state < '${JOB_STATES.completed}'`
+        : `state = '${JOB_STATES.active}'`}
+      RETURNING name, id, blocking
+    ),
+    decremented AS (
+      SELECT d.child_name, d.child_id, COUNT(*)::int AS n
+      FROM ${schema}.job_dependency d
+      JOIN completed c ON c.blocking
+        AND d.parent_name = c.name
+        AND d.parent_id = c.id
+      GROUP BY d.child_name, d.child_id
+    ),
+    locked_children AS (
+      SELECT j.name, j.id, d.n
+      FROM ${schema}.job j
+      JOIN decremented d ON d.child_name = j.name
+        AND d.child_id = j.id
+      WHERE j.blocked
+      ORDER BY j.name, j.id
+      FOR UPDATE OF j
+    ),
+    unblocked AS (
+      UPDATE ${schema}.job j
+      SET pending_dependencies = GREATEST(j.pending_dependencies - lc.n, 0),
+          blocked = GREATEST(j.pending_dependencies - lc.n, 0) > 0
+      FROM locked_children lc
+      WHERE j.name = lc.name
+        AND j.id = lc.id
+      RETURNING 1
     )
-    SELECT COUNT(*) FROM results
+    SELECT COUNT(*) FROM completed
   `;
 }
-function cancelJobs(schema, table) {
+export function cancelJobs(schema, table) {
     return `
     WITH results as (
       UPDATE ${schema}.${table}
@@ -890,7 +943,7 @@ function cancelJobs(schema, table) {
     SELECT COUNT(*) from results
   `;
 }
-function resumeJobs(schema, table) {
+export function resumeJobs(schema, table) {
     return `
     WITH results as (
       UPDATE ${schema}.${table}
@@ -904,7 +957,7 @@ function resumeJobs(schema, table) {
     SELECT COUNT(*) from results
   `;
 }
-function restoreJobs(schema, table) {
+export function restoreJobs(schema, table) {
     return `
     UPDATE ${schema}.${table}
     SET state = '${JOB_STATES.created}',
@@ -914,7 +967,7 @@ function restoreJobs(schema, table) {
       AND id IN (SELECT UNNEST($2::uuid[]))
   `;
 }
-function insertJobs(schema, { table, name, returnId = true }) {
+export function insertJobs(schema, { table, name, returnId = true }) {
     const sql = `
     INSERT INTO ${schema}.${table} (
       id,
@@ -935,7 +988,10 @@ function insertJobs(schema, { table, name, returnId = true }) {
       retry_delay_max,
       policy,
       dead_letter,
-      heartbeat_seconds
+      heartbeat_seconds,
+      blocked,
+      blocking,
+      pending_dependencies
     )
     SELECT
       COALESCE(id, gen_random_uuid()) as id,
@@ -959,7 +1015,10 @@ function insertJobs(schema, { table, name, returnId = true }) {
       COALESCE("retryDelayMax", q.retry_delay_max) as retry_delay_max,
       q.policy,
       COALESCE("deadLetter", q.dead_letter) as dead_letter,
-      COALESCE("heartbeatSeconds", q.heartbeat_seconds) as heartbeat_seconds
+      COALESCE("heartbeatSeconds", q.heartbeat_seconds) as heartbeat_seconds,
+      COALESCE(blocked, false) as blocked,
+      COALESCE(blocking, false) as blocking,
+      COALESCE("pendingDependencies", 0) as pending_dependencies
     FROM (
       SELECT *,
         CASE
@@ -984,7 +1043,10 @@ function insertJobs(schema, { table, name, returnId = true }) {
         "deleteAfterSeconds" integer,
         "retentionSeconds" integer,
         "deadLetter" text,
-        "heartbeatSeconds" integer
+        "heartbeatSeconds" integer,
+        blocked boolean,
+        blocking boolean,
+        "pendingDependencies" integer
       )
     ) j
     JOIN ${schema}.queue q ON q.name = '${name}'
@@ -993,19 +1055,19 @@ function insertJobs(schema, { table, name, returnId = true }) {
   `;
     return sql;
 }
-function failJobsById(schema, table) {
+export function failJobsById(schema, table) {
     const where = `name = $1 AND id IN (SELECT UNNEST($2::uuid[])) AND state < '${JOB_STATES.completed}'`;
     const output = '$3::jsonb';
     return failJobs(schema, table, where, output);
 }
-function failJobsByTimeout(schema, table, queues) {
+export function failJobsByTimeout(schema, table, queues) {
     const where = `state = '${JOB_STATES.active}'
             AND (started_on + expire_seconds * interval '1s') < now()
             AND name = ANY(${serializeArrayParam(queues)})`;
     const output = '\'{ "value": { "message": "job timed out" } }\'::jsonb';
     return locked(schema, failJobs(schema, table, where, output), table + 'failJobsByTimeout');
 }
-function failJobsByHeartbeat(schema, table, queues) {
+export function failJobsByHeartbeat(schema, table, queues) {
     const where = `state = '${JOB_STATES.active}'
             AND heartbeat_seconds IS NOT NULL
             AND (heartbeat_on + heartbeat_seconds * interval '1s') < now()
@@ -1013,7 +1075,7 @@ function failJobsByHeartbeat(schema, table, queues) {
     const output = '\'{ "value": { "message": "job heartbeat timeout" } }\'::jsonb';
     return locked(schema, failJobs(schema, table, where, output), table + 'failJobsByHeartbeat');
 }
-function touchJobs(schema, table) {
+export function touchJobs(schema, table) {
     return `
     WITH results AS (
       UPDATE ${schema}.${table}
@@ -1060,7 +1122,10 @@ function failJobs(schema, table, where, output) {
         output,
         dead_letter,
         heartbeat_on,
-        heartbeat_seconds
+        heartbeat_seconds,
+        blocked,
+        blocking,
+        pending_dependencies
       )
       SELECT
         id,
@@ -1100,7 +1165,10 @@ function failJobs(schema, table, where, output) {
         ${output},
         dead_letter,
         NULL as heartbeat_on,
-        heartbeat_seconds
+        heartbeat_seconds,
+        blocked,
+        blocking,
+        pending_dependencies
       FROM deleted_jobs
       ON CONFLICT DO NOTHING
       RETURNING *
@@ -1132,7 +1200,10 @@ function failJobs(schema, table, where, output) {
         output,
         dead_letter,
         heartbeat_on,
-        heartbeat_seconds
+        heartbeat_seconds,
+        blocked,
+        blocking,
+        pending_dependencies
       )
       SELECT
         id,
@@ -1160,7 +1231,10 @@ function failJobs(schema, table, where, output) {
         ${output},
         dead_letter,
         NULL as heartbeat_on,
-        heartbeat_seconds
+        heartbeat_seconds,
+        blocked,
+        blocking,
+        pending_dependencies
       FROM deleted_jobs
       WHERE id NOT IN (SELECT id from retried_jobs)
       RETURNING *
@@ -1188,7 +1262,7 @@ function failJobs(schema, table, where, output) {
     SELECT COUNT(*) FROM results
   `;
 }
-function deletion(schema, table, queues) {
+export function deletion(schema, table, queues) {
     const sql = `
     DELETE FROM ${schema}.${table}
     WHERE name = ANY(${serializeArrayParam(queues)})
@@ -1201,7 +1275,7 @@ function deletion(schema, table, queues) {
   `;
     return locked(schema, sql, table + 'deletion');
 }
-function retryJobs(schema, table) {
+export function retryJobs(schema, table) {
     return `
     WITH results as (
       UPDATE ${schema}.job
@@ -1215,7 +1289,7 @@ function retryJobs(schema, table) {
     SELECT COUNT(*) from results
   `;
 }
-function getQueueStats(schema, table, queues) {
+export function getQueueStats(schema, table, queues) {
     return {
         text: `
     SELECT
@@ -1232,7 +1306,7 @@ function getQueueStats(schema, table, queues) {
         values: [queues]
     };
 }
-function cacheQueueStats(schema, table, queues) {
+export function cacheQueueStats(schema, table, queues) {
     const statsQuery = getQueueStats(schema, table, queues);
     // Serialize the $1 parameter for use in locked() multi-statement query
     const statsText = statsQuery.text.replace('$1::text[]', serializeArrayParam(queues));
@@ -1258,31 +1332,37 @@ function cacheQueueStats(schema, table, queues) {
     return locked(schema, sql, 'queue-stats');
 }
 // Serialize a string array for embedding directly in SQL as PostgreSQL array literal
-function serializeArrayParam(values) {
+export function serializeArrayParam(values) {
     const escaped = values.map(v => `'${v.replace(SINGLE_QUOTE_REGEX, "''")}'`);
     return `ARRAY[${escaped.join(',')}]::text[]`;
 }
-function locked(schema, query, key) {
+// Serialize a JSON-serializable value for embedding directly in SQL as a quoted literal
+export function serializeJsonParam(value) {
+    return `'${JSON.stringify(value).replace(SINGLE_QUOTE_REGEX, "''")}'`;
+}
+export function transaction(query) {
     const sql = Array.isArray(query) ? query.join(';\n') : query;
     return `
     BEGIN;
     SET LOCAL lock_timeout = 30000;
     SET LOCAL idle_in_transaction_session_timeout = 30000;
-    ${advisoryLock(schema, key)};
     ${sql};
     COMMIT;
   `;
 }
+export function locked(schema, query, key) {
+    return transaction([advisoryLock(schema, key), ...(Array.isArray(query) ? query : [query])]);
+}
 function advisoryLock(schema, key) {
     return `SELECT pg_advisory_xact_lock(
       ('x' || encode(sha224((current_database() || '.pgboss.${schema}${key || ''}')::bytea), 'hex'))::bit(64)::bigint
   )`;
 }
-function assertMigration(schema, version) {
+export function assertMigration(schema, version) {
     // raises 'division by zero' if already on desired schema version
     return `SELECT version::int/(version::int-${version}) from ${schema}.version`;
 }
-function findJobs(schema, table, options) {
+export function findJobs(schema, table, options) {
     const { queued, byKey, byData, byId } = options;
     let paramIndex = 1;
     const whereConditions = [];
@@ -1308,7 +1388,7 @@ function findJobs(schema, table, options) {
       ${whereConditions.join('\n      ')}
     `;
 }
-function getJobById(schema, table) {
+export function getJobById(schema, table) {
     return `
     SELECT ${JOB_COLUMNS_ALL}
     FROM ${schema}.${table}
@@ -1316,7 +1396,50 @@ function getJobById(schema, table) {
       AND id = $2
     `;
 }
-function getBlockedKeys(schema, table) {
+export function insertDependencies(schema) {
+    return `
+    INSERT INTO ${schema}.job_dependency (child_name, child_id, parent_name, parent_id)
+    SELECT child_name, child_id, parent_name, parent_id
+    FROM json_to_recordset($1::json) AS x (
+      child_name text,
+      child_id uuid,
+      parent_name text,
+      parent_id uuid
+    )
+    ON CONFLICT DO NOTHING
+  `;
+}
+export function getDependencies(schema) {
+    return `
+    SELECT parent_name as "parentName", parent_id as "parentId"
+    FROM ${schema}.job_dependency
+    WHERE child_name = $1 AND child_id = $2
+  `;
+}
+export function getDependents(schema) {
+    return `
+    SELECT child_name as "childName", child_id as "childId"
+    FROM ${schema}.job_dependency
+    WHERE parent_name = $1 AND parent_id = $2
+  `;
+}
+export function cleanupDependencies(schema, table, queues) {
+    const sql = `
+    DELETE FROM ${schema}.job_dependency
+    WHERE (child_name = ANY(${serializeArrayParam(queues)})
+      AND NOT EXISTS (
+        SELECT 1 FROM ${schema}.${table} j
+        WHERE j.name = child_name AND j.id = child_id
+      ))
+    OR (parent_name = ANY(${serializeArrayParam(queues)})
+      AND NOT EXISTS (
+        SELECT 1 FROM ${schema}.${table} j
+        WHERE j.name = parent_name AND j.id = parent_id
+      ))
+  `;
+    return locked(schema, sql, table + 'cleanupDependencies');
+}
+export function getBlockedKeys(schema, table) {
     return `
     SELECT DISTINCT singleton_key as "singletonKey"
     FROM ${schema}.${table}
@@ -1325,7 +1448,7 @@ function getBlockedKeys(schema, table) {
       AND policy = '${QUEUE_POLICIES.key_strict_fifo}'
     `;
 }
-function getNextBamCommand(schema) {
+export function getNextBamCommand(schema) {
     return `
     UPDATE ${schema}.bam
     SET status = 'in_progress', started_on = now()
@@ -1340,14 +1463,14 @@ function getNextBamCommand(schema) {
               created_on as "createdOn", started_on as "startedOn", completed_on as "completedOn"
   `;
 }
-function setBamCompleted(schema, id) {
+export function setBamCompleted(schema, id) {
     return `
     UPDATE ${schema}.bam
     SET status = 'completed', completed_on = now()
     WHERE id = '${id}'
   `;
 }
-function setBamFailed(schema, id, error) {
+export function setBamFailed(schema, id, error) {
     const escapedError = error.replace(/'/g, "''");
     return `
     UPDATE ${schema}.bam
@@ -1355,14 +1478,14 @@ function setBamFailed(schema, id, error) {
     WHERE id = '${id}'
   `;
 }
-function getBamStatus(schema) {
+export function getBamStatus(schema) {
     return `
     SELECT status, count(*)::int as count, max(created_on) as "lastCreatedOn"
     FROM ${schema}.bam
     GROUP BY status
   `;
 }
-function getBamEntries(schema) {
+export function getBamEntries(schema) {
     return `
     SELECT id, name, version, status, queue, table_name as "table", command, error,
            created_on as "createdOn", started_on as "startedOn", completed_on as "completedOn"
@@ -1370,4 +1493,3 @@ function getBamEntries(schema) {
     ORDER BY version, created_on
   `;
 }
-export { create, insertVersion, getVersion, setVersion, versionTableExists, fetchNextJob, completeJobs, cancelJobs, resumeJobs, restoreJobs, retryJobs, findJobs, deleteJobsById, deleteAllJobs, deleteQueuedJobs, deleteStoredJobs, truncateTable, failJobsById, failJobsByTimeout, failJobsByHeartbeat, touchJobs, insertJobs, getTime, getSchedules, getSchedulesByQueue, schedule, unschedule, subscribe, unsubscribe, getQueuesForEvent, deletion, cacheQueueStats, updateQueue, createQueue, deleteQueue, getQueues, getQueueStats, trySetQueueMonitorTime, trySetQueueDeletionTime, trySetCronTime, trySetBamTime, locked, assertMigration, getJobById, insertWarning, getWarnings, getWarningsCount, deleteOldWarnings, createTableWarning, createIndexWarning, getBlockedKeys, getNextBamCommand, setBamCompleted, setBamFailed, getBamStatus, getBamEntries, serializeArrayParam, QUEUE_POLICIES, JOB_STATES, MIGRATE_RACE_MESSAGE, CREATE_RACE_MESSAGE, DEFAULT_SCHEMA, };