@pg-boss/dashboard 1.3.0 → 1.3.1

package/build/server/index.js

@@ -1568,7 +1568,8 @@ function createTableVersion(schema) {
     CREATE TABLE ${schema}.version (
       version int primary key,
       cron_on timestamp with time zone,
-      bam_on timestamp with time zone
+      bam_on timestamp with time zone,
+      flow_on timestamp with time zone
     )
   `;
 }
@@ -1843,6 +1844,7 @@ function createTableJobCommon(schema) {
     SELECT ${schema}.job_table_run($cmd$${createIndexJobThrottle(schema)}$cmd$, '${COMMON_JOB_TABLE}');
     SELECT ${schema}.job_table_run($cmd$${createIndexJobFetch(schema)}$cmd$, '${COMMON_JOB_TABLE}');
     SELECT ${schema}.job_table_run($cmd$${createIndexJobGroupConcurrency(schema)}$cmd$, '${COMMON_JOB_TABLE}');
+    SELECT ${schema}.job_table_run($cmd$${createIndexJobBlocking(schema)}$cmd$, '${COMMON_JOB_TABLE}');
 
     ALTER TABLE ${schema}.job ATTACH PARTITION ${schema}.${COMMON_JOB_TABLE} DEFAULT;
   `;
@@ -1860,6 +1862,7 @@ function createTableJobIndexes(schema, noDeferrableConstraints = false, noCoveri
     ${createIndexJobThrottle(schema)};
     ${createIndexJobFetch(schema, noCoveringIndex)};
     ${createIndexJobGroupConcurrency(schema)};
+    ${createIndexJobBlocking(schema)};
   `;
 }
 function createQueueFunction(schema, noPartitioning = false) {
@@ -1970,6 +1973,7 @@ function createQueueFunction(schema, noPartitioning = false) {
       EXECUTE ${schema}.job_table_format($cmd$${createIndexJobFetch(schema)}$cmd$, tablename);
       EXECUTE ${schema}.job_table_format($cmd$${createIndexJobThrottle(schema)}$cmd$, tablename);
       EXECUTE ${schema}.job_table_format($cmd$${createIndexJobGroupConcurrency(schema)}$cmd$, tablename);
+      EXECUTE ${schema}.job_table_format($cmd$${createIndexJobBlocking(schema)}$cmd$, tablename);
 
       IF options->>'policy' = 'short' THEN
         EXECUTE ${schema}.job_table_format($cmd$${createIndexJobPolicyShort(schema)}$cmd$, tablename);
@@ -2053,7 +2057,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, noCoveringIndex = false) {
-	return `CREATE INDEX job_i5 ON ${schema}.job (name, start_after) ${noCoveringIndex ? "" : "INCLUDE (priority, created_on, id) "}WHERE state < '${JOB_STATES.active}' AND NOT blocked`;
+	return `CREATE INDEX job_i5 ON ${schema}.job (name, start_after) 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}'`;
@@ -2067,6 +2071,9 @@ 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 createIndexJobBlocking(schema) {
+	return `CREATE INDEX job_i9 ON ${schema}.job (name, id) WHERE blocking AND state = '${JOB_STATES.completed}'`;
+}
 function trySetQueueMonitorTime(schema, queues, seconds) {
 	return trySetQueueTimestamp(schema, queues, "monitor_on", seconds);
 }
@@ -2079,6 +2086,9 @@ function trySetCronTime(schema, seconds) {
 function trySetBamTime(schema, seconds) {
 	return trySetTimestamp(schema, "bam_on", seconds);
 }
+function trySetFlowTime(schema, seconds) {
+	return trySetTimestamp(schema, "flow_on", seconds);
+}
 function trySetTimestamp(schema, column, seconds) {
 	return `
     UPDATE ${schema}.version
@@ -2163,7 +2173,7 @@ function deleteJobsById(schema, table) {
     WITH results as (
       DELETE FROM ${schema}.${table}
       WHERE name = $1
-        AND id IN (SELECT UNNEST($2::uuid[]))
+        AND id = ANY($2::uuid[])
       RETURNING 1
     )
     SELECT COUNT(*) from results
@@ -2426,7 +2436,7 @@ function completeJobsUpdate(schema, table, includeQueued) {
         blocked = ${includeQueued ? "false" : "blocked"},
         pending_dependencies = ${includeQueued ? "0" : "pending_dependencies"}
       WHERE name = $1
-        AND id IN (SELECT UNNEST($2::uuid[]))
+        AND id = ANY($2::uuid[])
         AND ${includeQueued ? `state < '${JOB_STATES.completed}'` : `state = '${JOB_STATES.active}'`}`;
 }
 function lockedChildrenCte(schema) {
@@ -2450,24 +2460,11 @@ function unblockChildrenUpdate(schema) {
 }
 function completeJobs(schema, table, includeQueued) {
 	return `
-    WITH completed AS (
+    WITH results AS (
       ${completeJobsUpdate(schema, table, includeQueued)}
-      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
-    ),
-    ${lockedChildrenCte(schema)},
-    unblocked AS (
-      ${unblockChildrenUpdate(schema)}
       RETURNING 1
     )
-    SELECT COUNT(*) FROM completed
+    SELECT COUNT(*) FROM results
   `;
 }
 function completeJobsWithOutputs(schema, table) {
@@ -2475,7 +2472,7 @@ function completeJobsWithOutputs(schema, table) {
     WITH input AS (
       SELECT * FROM json_to_recordset($2::json) AS x (id uuid, output jsonb)
     ),
-    completed AS (
+    results AS (
       UPDATE ${schema}.${table} j
       SET completed_on = now(),
         state = '${JOB_STATES.completed}',
@@ -2484,22 +2481,9 @@ function completeJobsWithOutputs(schema, table) {
       WHERE j.name = $1
         AND j.id = i.id
         AND j.state = '${JOB_STATES.active}'
-      RETURNING j.name, j.id, j.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
-    ),
-    ${lockedChildrenCte(schema)},
-    unblocked AS (
-      ${unblockChildrenUpdate(schema)}
       RETURNING 1
     )
-    SELECT COUNT(*) FROM completed
+    SELECT COUNT(*) FROM results
   `;
 }
 function completeJobsWithOutputsDistributed(schema, table) {
@@ -2515,7 +2499,7 @@ function completeJobsWithOutputsDistributed(schema, table) {
     WHERE j.name = $1
       AND j.id = i.id
       AND j.state = '${JOB_STATES.active}'
-    RETURNING j.id, j.blocking
+    RETURNING j.id
   `;
 }
 function cancelJobs(schema, table) {
@@ -2525,7 +2509,7 @@ function cancelJobs(schema, table) {
       SET completed_on = now(),
         state = '${JOB_STATES.cancelled}'
       WHERE name = $1
-        AND id IN (SELECT UNNEST($2::uuid[]))
+        AND id = ANY($2::uuid[])
         AND state < '${JOB_STATES.completed}'
       RETURNING 1
     )
@@ -2539,7 +2523,7 @@ function resumeJobs(schema, table) {
       SET completed_on = NULL,
         state = '${JOB_STATES.created}'
       WHERE name = $1
-        AND id IN (SELECT UNNEST($2::uuid[]))
+        AND id = ANY($2::uuid[])
         AND state = '${JOB_STATES.cancelled}'
       RETURNING 1
     )
@@ -2553,7 +2537,7 @@ function restoreJobs(schema, table) {
         started_on = NULL,
         heartbeat_on = NULL
     WHERE name = $1
-      AND id IN (SELECT UNNEST($2::uuid[]))
+      AND id = ANY($2::uuid[])
   `;
 }
 function insertJobs(schema, { table, name, returnId = true, notify = false }) {
@@ -2668,7 +2652,7 @@ function insertFlowJobs(schema, { table, name }, jobs) {
   `;
 }
 function failJobsById(schema, table) {
-	return failJobs(schema, table, `name = $1 AND id IN (SELECT UNNEST($2::uuid[])) AND state < '${JOB_STATES.completed}'`, "$3::jsonb");
+	return failJobs(schema, table, `name = $1 AND id = ANY($2::uuid[]) AND state < '${JOB_STATES.completed}'`, "$3::jsonb");
 }
 function failJobsByTimeout(schema, table, queues, noAdvisoryLocks) {
 	return locked(schema, failJobs(schema, table, `state = '${JOB_STATES.active}'
@@ -2687,7 +2671,7 @@ function touchJobs(schema, table) {
       UPDATE ${schema}.${table}
       SET heartbeat_on = now()
       WHERE name = $1
-        AND id IN (SELECT UNNEST($2::uuid[]))
+        AND id = ANY($2::uuid[])
         AND state = '${JOB_STATES.active}'
       RETURNING 1
     )
@@ -2891,13 +2875,13 @@ function deadLetterJobsByIdWithOutputs(schema, table) {
 }
 function selectJobsToFailById(schema, table) {
 	return {
-		text: `SELECT * FROM ${schema}.${table} WHERE name = $1 AND id IN (SELECT UNNEST($2::uuid[])) AND state < '${JOB_STATES.completed}'`,
+		text: `SELECT * FROM ${schema}.${table} WHERE name = $1 AND id = ANY($2::uuid[]) AND state < '${JOB_STATES.completed}'`,
 		values: []
 	};
 }
 function deleteJobsToFail(schema, table) {
 	return {
-		text: `DELETE FROM ${schema}.${table} WHERE name = $1 AND id IN (SELECT UNNEST($2::uuid[]))`,
+		text: `DELETE FROM ${schema}.${table} WHERE name = $1 AND id = ANY($2::uuid[])`,
 		values: []
 	};
 }
@@ -2922,14 +2906,14 @@ function selectJobsToFailByHeartbeat(schema, table, queues) {
 }
 function deleteJobsByIds(schema, table) {
 	return {
-		text: `DELETE FROM ${schema}.${table} WHERE id IN (SELECT UNNEST($1::uuid[]))`,
+		text: `DELETE FROM ${schema}.${table} WHERE id = ANY($1::uuid[])`,
 		values: []
 	};
 }
 function completeJobsDistributed(schema, table, includeQueued) {
 	return `
     ${completeJobsUpdate(schema, table, includeQueued)}
-    RETURNING id, blocking
+    RETURNING id
   `;
 }
 function decrementDependents(schema) {
@@ -2938,13 +2922,75 @@ function decrementDependents(schema) {
       SELECT d.child_name, d.child_id, COUNT(*)::int AS n
       FROM ${schema}.job_dependency d
       WHERE d.parent_name = $1
-        AND d.parent_id IN (SELECT UNNEST($2::uuid[]))
+        AND d.parent_id = ANY($2::uuid[])
       GROUP BY d.child_name, d.child_id
     ),
     ${lockedChildrenCte(schema)}
     ${unblockChildrenUpdate(schema)}
   `;
 }
+var FLOW_BATCH_SIZE = 1e3;
+function resolveFlowJobs(schema, table, names) {
+	return {
+		text: `
+    WITH locked_parents AS (
+      SELECT j.name, j.id
+      FROM ${schema}.${table} j
+      WHERE j.blocking
+        AND j.state = '${JOB_STATES.completed}'
+        AND j.name = ANY($1::text[])
+      ORDER BY j.name, j.id
+      FOR UPDATE OF j SKIP LOCKED
+      LIMIT ${FLOW_BATCH_SIZE}
+    ),
+    decremented AS (
+      SELECT d.child_name, d.child_id, COUNT(*)::int AS n
+      FROM ${schema}.job_dependency d
+      JOIN locked_parents p ON d.parent_name = p.name
+        AND d.parent_id = p.id
+      GROUP BY d.child_name, d.child_id
+    ),
+    ${lockedChildrenCte(schema)},
+    unblocked AS (
+      ${unblockChildrenUpdate(schema)}
+      RETURNING 1
+    ),
+    cleared AS (
+      UPDATE ${schema}.${table} j
+      SET blocking = false
+      FROM locked_parents p
+      WHERE j.name = p.name
+        AND j.id = p.id
+      RETURNING 1
+    )
+    SELECT COUNT(*)::int AS resolved FROM cleared
+  `,
+		values: [names]
+	};
+}
+function selectBlockingParents(schema, table, names, noSkipLocked) {
+	return {
+		text: `
+      SELECT name, id
+      FROM ${schema}.${table}
+      WHERE blocking
+        AND state = '${JOB_STATES.completed}'
+        AND name = ANY($1::text[])
+      ORDER BY name, id
+      FOR UPDATE${noSkipLocked ? "" : " SKIP LOCKED"}
+      LIMIT ${FLOW_BATCH_SIZE}
+    `,
+		values: [names]
+	};
+}
+function clearBlocking(schema) {
+	return `
+    UPDATE ${schema}.job
+    SET blocking = false
+    WHERE name = $1
+      AND id = ANY($2::uuid[])
+  `;
+}
 function insertRetryJob(schema, table) {
 	return `
     INSERT INTO ${schema}.${table} (
@@ -2986,7 +3032,7 @@ function retryJobs(schema, table) {
       SET state = '${JOB_STATES.retry}',
         retry_limit = retry_limit + 1
       WHERE name = $1
-        AND id IN (SELECT UNNEST($2::uuid[]))
+        AND id = ANY($2::uuid[])
         AND state = '${JOB_STATES.failed}'
       RETURNING 1
     )
@@ -3464,6 +3510,7 @@ function getConfig(value) {
 	applyOpsConfig(config);
 	applyScheduleConfig(config);
 	applyBamConfig(config);
+	applyFlowConfig(config);
 	validateWarningConfig(config);
 	return config;
 }
@@ -3566,6 +3613,11 @@ function applyBamConfig(config) {
 	assert(!("bamIntervalSeconds" in config) || config.bamIntervalSeconds >= minInterval, `configuration assert: bamIntervalSeconds must be at least ${minInterval} seconds`);
 	config.bamIntervalSeconds = config.bamIntervalSeconds || 60;
 }
+function applyFlowConfig(config) {
+	const minInterval = config.__test__bypass_flow_interval_check ? .5 : 1;
+	assert(!("flowIntervalSeconds" in config) || config.flowIntervalSeconds >= minInterval, `configuration assert: flowIntervalSeconds must be at least ${minInterval} seconds`);
+	config.flowIntervalSeconds = config.flowIntervalSeconds || 5;
+}
 //#endregion
 //#region ../../src/migrationStore.ts
 function formatJobTable(command, table) {
@@ -4113,6 +4165,92 @@ var createQueueFn = {
     END;
     $$
     LANGUAGE plpgsql;
+  `,
+	33: (schema) => `
+    CREATE OR REPLACE FUNCTION ${schema}.create_queue(queue_name text, options jsonb)
+    RETURNS VOID AS
+    $$
+    DECLARE
+      tablename varchar := CASE WHEN options->>'partition' = 'true'
+                            THEN 'j' || encode(sha224(queue_name::bytea), 'hex')
+                            ELSE 'job_common'
+                            END;
+      queue_created_on timestamptz;
+    BEGIN
+
+      WITH q as (
+        INSERT INTO ${schema}.queue (
+          name,
+          policy,
+          retry_limit,
+          retry_delay,
+          retry_backoff,
+          retry_delay_max,
+          expire_seconds,
+          retention_seconds,
+          deletion_seconds,
+          warning_queued,
+          dead_letter,
+          partition,
+          table_name,
+          heartbeat_seconds,
+          notify
+        )
+        VALUES (
+          queue_name,
+          options->>'policy',
+          COALESCE((options->>'retryLimit')::int, 2),
+          COALESCE((options->>'retryDelay')::int, 0),
+          COALESCE((options->>'retryBackoff')::bool, false),
+          (options->>'retryDelayMax')::int,
+          COALESCE((options->>'expireInSeconds')::int, 900),
+          COALESCE((options->>'retentionSeconds')::int, 1209600),
+          COALESCE((options->>'deleteAfterSeconds')::int, 604800),
+          COALESCE((options->>'warningQueueSize')::int, 0),
+          options->>'deadLetter',
+          COALESCE((options->>'partition')::bool, false),
+          tablename,
+          (options->>'heartbeatSeconds')::int,
+          COALESCE((options->>'notify')::bool, false)
+        )
+        ON CONFLICT DO NOTHING
+        RETURNING created_on
+      )
+      SELECT created_on into queue_created_on from q;
+
+      IF queue_created_on IS NULL OR options->>'partition' IS DISTINCT FROM 'true' THEN
+        RETURN;
+      END IF;
+
+      EXECUTE format('CREATE TABLE ${schema}.%I (LIKE ${schema}.job INCLUDING DEFAULTS)', tablename);
+
+      EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD PRIMARY KEY (name, id)$cmd$, tablename);
+      EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT q_fkey FOREIGN KEY (name) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED$cmd$, tablename);
+      EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT dlq_fkey FOREIGN KEY (dead_letter) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED$cmd$, tablename);
+
+      EXECUTE ${schema}.job_table_format($cmd$CREATE INDEX job_i5 ON ${schema}.job (name, start_after) WHERE state < 'active' AND NOT blocked$cmd$, tablename);
+      EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i4 ON ${schema}.job (name, singleton_on, COALESCE(singleton_key, '')) WHERE state <> 'cancelled' AND singleton_on IS NOT NULL$cmd$, tablename);
+      EXECUTE ${schema}.job_table_format($cmd$CREATE INDEX job_i7 ON ${schema}.job (name, group_id) WHERE state = 'active' AND group_id IS NOT NULL$cmd$, tablename);
+      EXECUTE ${schema}.job_table_format($cmd$CREATE INDEX job_i9 ON ${schema}.job (name, id) WHERE blocking AND state = 'completed'$cmd$, tablename);
+
+      IF options->>'policy' = 'short' THEN
+        EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i1 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state = 'created' AND policy = 'short'$cmd$, tablename);
+      ELSIF options->>'policy' = 'singleton' THEN
+        EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i2 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state = 'active' AND policy = 'singleton'$cmd$, tablename);
+      ELSIF options->>'policy' = 'stately' THEN
+        EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i3 ON ${schema}.job (name, state, COALESCE(singleton_key, '')) WHERE state <= 'active' AND policy = 'stately'$cmd$, tablename);
+      ELSIF options->>'policy' = 'exclusive' THEN
+        EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i6 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state <= 'active' AND policy = 'exclusive'$cmd$, tablename);
+      ELSIF options->>'policy' = 'key_strict_fifo' THEN
+        EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i8 ON ${schema}.job (name, singleton_key) WHERE state IN ('active', 'retry', 'failed') AND policy = 'key_strict_fifo'$cmd$, tablename);
+        EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT job_key_strict_fifo_singleton_key_check CHECK (NOT (policy = 'key_strict_fifo' AND singleton_key IS NULL))$cmd$, tablename);
+      END IF;
+
+      EXECUTE format('ALTER TABLE ${schema}.%I ADD CONSTRAINT cjc CHECK (name=%L)', tablename, queue_name);
+      EXECUTE format('ALTER TABLE ${schema}.job ATTACH PARTITION ${schema}.%I FOR VALUES IN (%L)', tablename, queue_name);
+    END;
+    $$
+    LANGUAGE plpgsql;
   `
 };
 function getAll(schema) {
@@ -4361,6 +4499,25 @@ function getAll(schema) {
 				createQueueFn[31](schema),
 				`ALTER TABLE ${schema}.queue DROP COLUMN notify`
 			]
+		},
+		{
+			release: "12.22.0",
+			version: 33,
+			previous: 32,
+			install: [
+				`ALTER TABLE ${schema}.version ADD COLUMN IF NOT EXISTS flow_on timestamp with time zone`,
+				`SELECT ${schema}.job_table_run($cmd$CREATE INDEX job_i9 ON ${schema}.job (name, id) WHERE blocking AND state = 'completed'$cmd$)`,
+				`SELECT ${schema}.job_table_run($cmd$DROP INDEX IF EXISTS ${schema}.job_i5$cmd$)`,
+				`SELECT ${schema}.job_table_run($cmd$CREATE INDEX job_i5 ON ${schema}.job (name, start_after) WHERE state < 'active' AND NOT blocked$cmd$)`,
+				createQueueFn[33](schema)
+			],
+			uninstall: [
+				createQueueFn[32](schema),
+				`SELECT ${schema}.job_table_run($cmd$DROP INDEX IF EXISTS ${schema}.job_i5$cmd$)`,
+				`SELECT ${schema}.job_table_run($cmd$CREATE INDEX job_i5 ON ${schema}.job (name, start_after) INCLUDE (priority, created_on, id) WHERE state < 'active' AND NOT blocked$cmd$)`,
+				`SELECT ${schema}.job_table_run($cmd$DROP INDEX IF EXISTS ${schema}.job_i9$cmd$)`,
+				`ALTER TABLE ${schema}.version DROP COLUMN flow_on`
+			]
 		}
 	];
 }
@@ -4368,7 +4525,7 @@ function getAll(schema) {
 //#region ../../src/contractor.ts
 var schemaVersion = {
 	name: "pg-boss",
-	version: "12.21.0",
+	version: "12.22.0",
 	description: "Queueing jobs in Postgres from Node.js like a boss",
 	type: "module",
 	main: "./dist/index.js",
@@ -4376,7 +4533,7 @@ var schemaVersion = {
 	bin: { "pg-boss": "./dist/cli.js" },
 	engines: { "node": ">=22.12.0" },
 	dependencies: {
-		"cron-parser": "^5.6.0",
+		"cron-parser": "^5.6.1",
 		"pg": "^8.22.0",
 		"serialize-error": "^13.0.1"
 	},
@@ -4424,7 +4581,7 @@ var schemaVersion = {
 		"docs": "npm run docs:dev --prefix docs",
 		"docs:readme": "node ./scripts/sync-readme.js"
 	},
-	pgboss: { "schema": 32 },
+	pgboss: { "schema": 33 },
 	repository: {
 		"type": "git",
 		"url": "git+https://github.com/timgit/pg-boss.git"
@@ -4938,7 +5095,7 @@ var NUMERIC_QUEUE_FIELDS = [
 	"activeCount",
 	"totalCount"
 ];
-var events$4 = {
+var events$5 = {
 	error: "error",
 	wip: "wip"
 };
@@ -4947,7 +5104,7 @@ function rethrowWriteError(err) {
 	throw err;
 }
 var Manager = class extends EventEmitter {
-	events = events$4;
+	events = events$5;
 	db;
 	config;
 	wipTs;
@@ -5110,17 +5267,15 @@ var Manager = class extends EventEmitter {
 			output: this.mapCompletionDataArg(item.output)
 		}));
 		const ids = items.map((item) => item.id);
-		if (this.config.noMultiMutationCte) return this.withDistributedTransaction(this.db, async (tx) => {
+		if (this.config.noMultiMutationCte) {
 			const sql = completeJobsWithOutputsDistributed(this.config.schema, table);
-			const { rows } = await tx.executeSql(sql, [name, JSON.stringify(payload)]);
-			const blockingIds = rows.filter((row) => row.blocking).map((row) => row.id);
-			if (blockingIds.length > 0) await tx.executeSql(decrementDependents(this.config.schema), [name, blockingIds]);
+			const { rows } = await this.db.executeSql(sql, [name, JSON.stringify(payload)]);
 			return {
 				jobs: ids,
 				requested: ids.length,
 				affected: rows.length
 			};
-		});
+		}
 		const sql = completeJobsWithOutputs(this.config.schema, table);
 		const result = await this.db.executeSql(sql, [name, JSON.stringify(payload)]);
 		return this.mapCommandResponse(ids, result);
@@ -5208,7 +5363,7 @@ var Manager = class extends EventEmitter {
 				try {
 					await this.touch(name, jobIds);
 				} catch (err) {
-					this.emit(events$4.error, err);
+					this.emit(events$5.error, err);
 				}
 			}, intervalMs);
 		}
@@ -5245,7 +5400,7 @@ var Manager = class extends EventEmitter {
 			if (now - this.wipTs < 2e3) return;
 			const wip = this.getWipData();
 			if (wip.some((w) => w.count > 0)) {
-				this.emit(events$4.wip, wip);
+				this.emit(events$5.wip, wip);
 				this.wipTs = now;
 			}
 		}, 2e3);
@@ -5260,7 +5415,7 @@ var Manager = class extends EventEmitter {
 				return acc;
 			}, {});
 		} catch (error) {
-			emit && this.emit(events$4.error, {
+			emit && this.emit(events$5.error, {
 				...error,
 				message: error.message,
 				stack: error.stack
@@ -5340,7 +5495,7 @@ var Manager = class extends EventEmitter {
 				this.emitWip(name);
 			};
 			const onError = (error) => {
-				this.emit(events$4.error, {
+				this.emit(events$5.error, {
 					...error,
 					message: error.message,
 					stack: error.stack,
@@ -5379,7 +5534,7 @@ var Manager = class extends EventEmitter {
 		if (!INTERNAL_QUEUES[name]) {
 			const now = Date.now();
 			if (now - this.wipTs > 2e3) {
-				this.emit(events$4.wip, this.getWipData());
+				this.emit(events$5.wip, this.getWipData());
 				this.wipTs = now;
 			}
 		}
@@ -5714,24 +5869,17 @@ var Manager = class extends EventEmitter {
 		return fn(db);
 	}
 	async completeDistributed(name, ids, outputData, table, db, includeQueued) {
-		return this.withDistributedTransaction(db, async (tx) => {
-			const completeSql = completeJobsDistributed(this.config.schema, table, includeQueued);
-			const { rows } = await tx.executeSql(completeSql, [
-				name,
-				ids,
-				outputData
-			]);
-			const blockingIds = rows.filter((row) => row.blocking).map((row) => row.id);
-			if (blockingIds.length > 0) {
-				const decrementSql = decrementDependents(this.config.schema);
-				await tx.executeSql(decrementSql, [name, blockingIds]);
-			}
-			return {
-				jobs: ids,
-				requested: ids.length,
-				affected: rows.length
-			};
-		});
+		const sql = completeJobsDistributed(this.config.schema, table, includeQueued);
+		const { rows } = await db.executeSql(sql, [
+			name,
+			ids,
+			outputData
+		]);
+		return {
+			jobs: ids,
+			requested: ids.length,
+			affected: rows.length
+		};
 	}
 	async fail(name, id, data, options = {}) {
 		assertQueueName(name);
@@ -5775,6 +5923,26 @@ var Manager = class extends EventEmitter {
 		const select = selectJobsToFailByHeartbeat(this.config.schema, table, queues);
 		return this.expireJobsDistributed(table, select, { value: { message: "job heartbeat timeout" } });
 	}
+	async resolveFlowJobsDistributed(table, names) {
+		const select = selectBlockingParents(this.config.schema, table, names, this.config.noSkipLocked);
+		return this.withDistributedTransaction(this.db, async (tx) => {
+			const { rows } = await tx.executeSql(select.text, select.values);
+			if (rows.length === 0) return 0;
+			const idsByName = /* @__PURE__ */ new Map();
+			for (const row of rows) {
+				const list = idsByName.get(row.name) || [];
+				list.push(row.id);
+				idsByName.set(row.name, list);
+			}
+			const decrementSql = decrementDependents(this.config.schema);
+			const clearSql = clearBlocking(this.config.schema);
+			for (const [name, ids] of idsByName) {
+				await tx.executeSql(decrementSql, [name, ids]);
+				await tx.executeSql(clearSql, [name, ids]);
+			}
+			return rows.length;
+		});
+	}
 	async expireJobsDistributed(table, select, outputData) {
 		return this.withDistributedTransaction(this.db, async (tx) => {
 			const { rows: jobs } = await tx.executeSql(select.text, []);
@@ -6099,7 +6267,7 @@ var Manager = class extends EventEmitter {
 };
 //#endregion
 //#region ../../src/boss.ts
-var events$3 = {
+var events$4 = {
 	error: "error",
 	warning: "warning"
 };
@@ -6125,7 +6293,7 @@ var Boss = class extends EventEmitter {
 	#db;
 	#config;
 	#manager;
-	events = events$3;
+	events = events$4;
 	constructor(db, manager, config) {
 		super();
 		this.#db = db;
@@ -6160,8 +6328,8 @@ var Boss = class extends EventEmitter {
 			db: this.#db,
 			schema: this.#config.schema,
 			persistWarnings: this.#config.persistWarnings,
-			warningEvent: events$3.warning,
-			errorEvent: events$3.error
+			warningEvent: events$4.warning,
+			errorEvent: events$4.error
 		};
 	}
 	async #executeQuery(query) {
@@ -6190,7 +6358,7 @@ var Boss = class extends EventEmitter {
 			!this.#stopped && await this.supervise(queues);
 			!this.#stopped && await this.#maintainWarnings();
 		} catch (err) {
-			this.emit(events$3.error, err);
+			this.emit(events$4.error, err);
 		} finally {
 			this.#maintaining = false;
 		}
@@ -6268,7 +6436,7 @@ var Boss = class extends EventEmitter {
 };
 //#endregion
 //#region ../../src/bam.ts
-var events$2 = {
+var events$3 = {
 	error: "error",
 	bam: "bam"
 };
@@ -6278,7 +6446,7 @@ var Bam = class extends EventEmitter {
 	#pollInterval;
 	#db;
 	#config;
-	events = events$2;
+	events = events$3;
 	constructor(db, config) {
 		super();
 		this.#db = db;
@@ -6314,7 +6482,7 @@ var Bam = class extends EventEmitter {
 			const { rows } = await this.#db.executeSql(sql);
 			if (rows.length === 1) await this.#processCommands();
 		} catch (err) {
-			this.emit(events$2.error, err);
+			this.emit(events$3.error, err);
 		} finally {
 			this.#working = false;
 		}
@@ -6323,7 +6491,7 @@ var Bam = class extends EventEmitter {
 		if (this.#stopped) return;
 		const entry = await this.#getNextCommand();
 		if (!entry || this.#stopped) return;
-		this.emit(events$2.bam, {
+		this.emit(events$3.bam, {
 			id: entry.id,
 			name: entry.name,
 			status: "in_progress",
@@ -6334,7 +6502,7 @@ var Bam = class extends EventEmitter {
 			await this.#db.executeSql(entry.command);
 			if (this.#stopped) return;
 			await this.#markCompleted(entry.id);
-			this.emit(events$2.bam, {
+			this.emit(events$3.bam, {
 				id: entry.id,
 				name: entry.name,
 				status: "completed",
@@ -6344,8 +6512,8 @@ var Bam = class extends EventEmitter {
 		} catch (err) {
 			if (this.#stopped) return;
 			await this.#markFailed(entry.id, err);
-			this.emit(events$2.error, err);
-			this.emit(events$2.bam, {
+			this.emit(events$3.error, err);
+			this.emit(events$3.bam, {
 				id: entry.id,
 				name: entry.name,
 				status: "failed",
@@ -6370,6 +6538,111 @@ var Bam = class extends EventEmitter {
 	}
 };
 //#endregion
+//#region ../../src/navigator.ts
+var events$2 = {
+	error: "error",
+	flow: "flow"
+};
+var MAX_BATCHES_PER_PASS = 100;
+var Navigator = class extends EventEmitter {
+	#stopped;
+	#stopping;
+	#working;
+	#pollInterval;
+	#db;
+	#manager;
+	#config;
+	events = events$2;
+	constructor(db, manager, config) {
+		super();
+		this.#db = db;
+		this.#manager = manager;
+		this.#config = config;
+		this.#stopped = true;
+		this.#stopping = false;
+		this.#working = false;
+	}
+	get working() {
+		return this.#working;
+	}
+	async start() {
+		if (!this.#stopped) return;
+		this.#stopped = false;
+		this.#stopping = false;
+		setImmediate(() => this.#onPoll());
+		this.#pollInterval = setInterval(() => this.#onPoll(), this.#config.flowIntervalSeconds * 1e3);
+	}
+	async stop() {
+		if (this.#stopped) return;
+		this.#stopping = true;
+		this.#stopped = true;
+		if (this.#pollInterval) {
+			clearInterval(this.#pollInterval);
+			this.#pollInterval = void 0;
+		}
+		while (this.#working) await delay(10);
+	}
+	async #onPoll() {
+		if (this.#stopped || this.#working) return;
+		this.#working = true;
+		try {
+			if (this.#config.__test__throw_flow) throw new Error(this.#config.__test__throw_flow);
+			if (this.#config.__test__delay_flow_ms) await delay(this.#config.__test__delay_flow_ms);
+			const gate = trySetFlowTime(this.#config.schema, this.#config.flowIntervalSeconds);
+			const { rows } = await this.#db.executeSql(gate);
+			if (rows.length === 1) await this.#resolve();
+		} catch (err) {
+			this.emit(events$2.error, err);
+		} finally {
+			this.#working = false;
+		}
+	}
+	async resolveNow() {
+		while (this.#working) await delay(10);
+		if (this.#stopping) return;
+		this.#working = true;
+		try {
+			await this.#resolve();
+		} finally {
+			this.#working = false;
+		}
+	}
+	async #resolve() {
+		const queueGroups = (await this.#manager.getQueues()).reduce((acc, q) => {
+			acc[q.table] = acc[q.table] || {
+				table: q.table,
+				names: []
+			};
+			acc[q.table].names.push(q.name);
+			return acc;
+		}, {});
+		for (const group of Object.values(queueGroups)) {
+			if (this.#stopping) return;
+			const { table } = group;
+			const names = [...group.names];
+			while (names.length) {
+				if (this.#stopping) return;
+				const chunk = names.splice(0, 100);
+				let batches = 0;
+				let resolved = 0;
+				do {
+					if (this.#stopping) return;
+					resolved = this.#config.noMultiMutationCte ? await this.#manager.resolveFlowJobsDistributed(table, chunk) : await this.#resolveStandard(table, chunk);
+					if (resolved > 0) this.emit(events$2.flow, {
+						table,
+						resolved
+					});
+				} while (resolved >= 1e3 && ++batches < MAX_BATCHES_PER_PASS && !this.#stopping);
+			}
+		}
+	}
+	async #resolveStandard(table, names) {
+		const query = resolveFlowJobs(this.#config.schema, table, names);
+		const { rows } = await this.#db.executeSql(query.text, query.values);
+		return Number(rows[0]?.resolved ?? 0);
+	}
+};
+//#endregion
 //#region ../../src/notifier.ts
 var events$1 = {
 	error: "error",
@@ -6450,7 +6723,7 @@ var Db = class extends EventEmitter {
 	constructor(config) {
 		super();
 		config.application_name = config.application_name || "pgboss";
-		config.connectionTimeoutMillis = config.connectionTimeoutMillis || 1e4;
+		config.connectionTimeoutMillis ??= 1e4;
 		this.config = config;
 		this._pgbdb = true;
 		this.opened = false;
@@ -6551,7 +6824,8 @@ var events = Object.freeze({
 	warning: "warning",
 	wip: "wip",
 	stopped: "stopped",
-	bam: "bam"
+	bam: "bam",
+	flow: "flow"
 });
 var PgBoss = class extends EventEmitter {
 	#stoppingOn;
@@ -6565,6 +6839,7 @@ var PgBoss = class extends EventEmitter {
 	#manager;
 	#timekeeper;
 	#bam;
+	#navigator;
 	#notifier;
 	constructor(value) {
 		super();
@@ -6581,18 +6856,21 @@ var PgBoss = class extends EventEmitter {
 		const timekeeper = new Timekeeper(db, manager, config);
 		manager.timekeeper = timekeeper;
 		const bam = new Bam(db, config);
+		const navigator = new Navigator(db, manager, config);
 		const notifier = new Notifier(db, manager, config);
 		manager.notifier = notifier;
 		this.#promoteEvents(manager);
 		this.#promoteEvents(boss);
 		this.#promoteEvents(timekeeper);
 		this.#promoteEvents(bam);
+		this.#promoteEvents(navigator);
 		this.#promoteEvents(notifier);
 		this.#boss = boss;
 		this.#contractor = contractor;
 		this.#manager = manager;
 		this.#timekeeper = timekeeper;
 		this.#bam = bam;
+		this.#navigator = navigator;
 		this.#notifier = notifier;
 	}
 	#promoteEvents(emitter) {
@@ -6608,7 +6886,10 @@ var PgBoss = class extends EventEmitter {
 			else await this.#contractor.check();
 			await this.#manager.start();
 			if (this.#config.useListenNotify) await this.#notifier.start();
-			if (this.#config.supervise) await this.#boss.start();
+			if (this.#config.supervise) {
+				await this.#boss.start();
+				await this.#navigator.start();
+			}
 			if (this.#config.schedule) await this.#timekeeper.start();
 			if (this.#config.migrate) await this.#bam.start();
 		} catch (err) {
@@ -6641,6 +6922,7 @@ var PgBoss = class extends EventEmitter {
 		await this.#manager.stop();
 		await this.#timekeeper.stop();
 		await this.#boss.stop();
+		await this.#navigator.stop();
 		await this.#bam.stop();
 		const shutdown = async () => {
 			await this.#manager.failWip();
@@ -6754,7 +7036,7 @@ var PgBoss = class extends EventEmitter {
 		return this.#manager.deleteQueue(name);
 	}
 	getQueues(names) {
-		return this.#manager.getQueues();
+		return this.#manager.getQueues(names);
 	}
 	getQueue(name) {
 		return this.#manager.getQueue(name);
@@ -6768,12 +7050,18 @@ var PgBoss = class extends EventEmitter {
 	isBamWorking() {
 		return this.#bam.working;
 	}
+	isResolvingFlow() {
+		return this.#navigator.working;
+	}
 	isCheckingSkew() {
 		return this.#timekeeper.checkingSkew;
 	}
 	supervise(name) {
 		return this.#boss.supervise(name);
 	}
+	resolveFlow() {
+		return this.#navigator.resolveNow();
+	}
 	getWipData(options) {
 		return this.#manager.getWipData(options);
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pg-boss/dashboard",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "Web dashboard for monitoring and managing pg-boss job queues",
   "keywords": [
     "pg-boss",
@@ -53,7 +53,7 @@
     "isbot": "^5.1.44",
     "lucide-react": "^1.21.0",
     "pg": "^8.22.0",
-    "pg-boss": "^12.21.0",
+    "pg-boss": "^12.22.0",
     "react": "^19.2.7",
     "react-dom": "^19.2.7",
     "react-router": "^8.0.1",