@dbos-inc/dbos-sdk 4.28.11-preview → 4.28.12-preview

package/dist/src/system_database.js

@@ -15,7 +15,6 @@ const pg_1 = require("pg");
 const error_1 = require("./error");
 const workflow_1 = require("./workflow");
 const utils_1 = require("./utils");
-const wfqueue_1 = require("./wfqueue");
 const crypto_1 = require("crypto");
 const utils_2 = require("./utils");
 const database_utils_1 = require("./database_utils");
@@ -76,7 +75,6 @@ const QUEUE_COLUMN_BY_FIELD = {
     workerConcurrency: 'worker_concurrency',
     rateLimitMax: 'rate_limit_max',
     rateLimitPeriodSec: 'rate_limit_period_sec',
-    priorityEnabled: 'priority_enabled',
     partitionQueue: 'partition_queue',
     partitionConcurrency: 'partition_concurrency',
     partitionWorkerConcurrency: 'partition_worker_concurrency',
@@ -84,7 +82,7 @@ const QUEUE_COLUMN_BY_FIELD = {
     partitionRateLimitPeriodSec: 'partition_rate_limit_period_sec',
     pollingIntervalSec: 'polling_interval_sec',
 };
-const QUEUE_COLUMNS = 'name, concurrency, worker_concurrency, rate_limit_max, rate_limit_period_sec, priority_enabled, partition_queue, ' +
+const QUEUE_COLUMNS = 'name, concurrency, worker_concurrency, rate_limit_max, rate_limit_period_sec, ' +
     'partition_concurrency, partition_worker_concurrency, partition_rate_limit_max, partition_rate_limit_period_sec, ' +
     'polling_interval_sec, application_name';
 function queueRecordFromRow(row) {
@@ -94,8 +92,9 @@ function queueRecordFromRow(row) {
         workerConcurrency: row.worker_concurrency,
         rateLimitMax: row.rate_limit_max,
         rateLimitPeriodSec: row.rate_limit_period_sec,
-        priorityEnabled: row.priority_enabled,
-        partitionQueue: row.partition_queue,
+        partitionQueue: row.partition_concurrency !== null ||
+            row.partition_worker_concurrency !== null ||
+            (row.partition_rate_limit_max !== null && row.partition_rate_limit_period_sec !== null),
         partitionConcurrency: row.partition_concurrency,
         partitionWorkerConcurrency: row.partition_worker_concurrency,
         partitionRateLimitMax: row.partition_rate_limit_max,
@@ -2591,15 +2590,14 @@ class SystemDatabase {
     }
     async findAndMarkStartableWorkflows(queue, executorID, appVersion, queuePartitionKey, localRunningCount = 0, partitionLocalRunningCount = 0) {
         const claimedIDs = [];
-        const limits = (0, wfqueue_1.resolveQueueLimits)(queue);
         const partitionParams = queuePartitionKey !== undefined ? [queuePartitionKey] : [];
         // Shares a concurrency or rate limit budget with other executors.
-        const hasSharedBudget = limits.globalConcurrency !== undefined ||
-            limits.partitionConcurrency !== undefined ||
-            limits.rateLimit !== undefined ||
-            limits.partitionRateLimit !== undefined;
+        const hasSharedBudget = queue.concurrency !== undefined ||
+            queue.partitionConcurrency !== undefined ||
+            queue.rateLimit !== undefined ||
+            queue.partitionRateLimit !== undefined;
         // Shares that budget across partitions too, so sweeps of different partitions read disjoint rows and could each spend it.
-        const hasWriteSkew = queuePartitionKey !== undefined && (limits.globalConcurrency !== undefined || limits.rateLimit !== undefined);
+        const hasWriteSkew = queuePartitionKey !== undefined && (queue.concurrency !== undefined || queue.rateLimit !== undefined);
         const client = await this.#connect();
         try {
             // Default to READ COMMITTED except with a budget shared across executors
@@ -2640,42 +2638,42 @@ class SystemDatabase {
             };
             // Compute maxTasks, the number of workflows startable under every flow control limit on this queue.
             let maxTasks = Infinity;
-            if (limits.workerConcurrency !== undefined) {
+            if (queue.workerConcurrency !== undefined) {
                 // Use the in-memory registry for this worker's running count — avoids a DB round trip.
-                maxTasks = Math.min(maxTasks, Math.max(0, limits.workerConcurrency - localRunningCount));
+                maxTasks = Math.min(maxTasks, Math.max(0, queue.workerConcurrency - localRunningCount));
             }
-            if (limits.partitionWorkerConcurrency !== undefined) {
-                maxTasks = Math.min(maxTasks, Math.max(0, limits.partitionWorkerConcurrency - partitionLocalRunningCount));
+            if (queue.partitionWorkerConcurrency !== undefined) {
+                maxTasks = Math.min(maxTasks, Math.max(0, queue.partitionWorkerConcurrency - partitionLocalRunningCount));
             }
             if (maxTasks <= 0) {
                 await client.query('COMMIT');
                 return claimedIDs;
             }
-            if (limits.rateLimit !== undefined) {
+            if (queue.rateLimit !== undefined) {
                 // Bound the claim by the limiter's remaining slots so a backlogged queue locks only what it can start.
-                maxTasks = Math.min(maxTasks, await rateLimitRemaining(limits.rateLimit, false));
+                maxTasks = Math.min(maxTasks, await rateLimitRemaining(queue.rateLimit, false));
             }
-            if (limits.partitionRateLimit !== undefined) {
-                maxTasks = Math.min(maxTasks, await rateLimitRemaining(limits.partitionRateLimit, true));
+            if (queue.partitionRateLimit !== undefined) {
+                maxTasks = Math.min(maxTasks, await rateLimitRemaining(queue.partitionRateLimit, true));
             }
             if (maxTasks <= 0) {
                 await client.query('COMMIT');
                 return claimedIDs;
             }
-            if (limits.globalConcurrency !== undefined) {
+            if (queue.concurrency !== undefined) {
                 // Global concurrency still requires a DB query since other workers may be running workflows too.
                 const totalRunningTasks = await pendingCount(false);
-                if (totalRunningTasks > limits.globalConcurrency) {
-                    this.logger.warn(`Total running tasks (${totalRunningTasks}) exceeds the global concurrency limit (${limits.globalConcurrency})`);
+                if (totalRunningTasks > queue.concurrency) {
+                    this.logger.warn(`Total running tasks (${totalRunningTasks}) exceeds the global concurrency limit (${queue.concurrency})`);
                 }
-                maxTasks = Math.min(maxTasks, Math.max(0, limits.globalConcurrency - totalRunningTasks));
+                maxTasks = Math.min(maxTasks, Math.max(0, queue.concurrency - totalRunningTasks));
             }
-            if (limits.partitionConcurrency !== undefined) {
+            if (queue.partitionConcurrency !== undefined) {
                 const partitionRunningTasks = await pendingCount(true);
-                if (partitionRunningTasks > limits.partitionConcurrency) {
-                    this.logger.warn(`Total running tasks (${partitionRunningTasks}) on partition ${queuePartitionKey} of queue ${queue.name} exceeds the partition concurrency limit (${limits.partitionConcurrency})`);
+                if (partitionRunningTasks > queue.partitionConcurrency) {
+                    this.logger.warn(`Total running tasks (${partitionRunningTasks}) on partition ${queuePartitionKey} of queue ${queue.name} exceeds the partition concurrency limit (${queue.partitionConcurrency})`);
                 }
-                maxTasks = Math.min(maxTasks, Math.max(0, limits.partitionConcurrency - partitionRunningTasks));
+                maxTasks = Math.min(maxTasks, Math.max(0, queue.partitionConcurrency - partitionRunningTasks));
             }
             // Return immediately if there are no available tasks due to flow control limits
             if (maxTasks <= 0) {
@@ -2718,7 +2716,7 @@ class SystemDatabase {
                     workflow_1.StatusString.PENDING,
                     executorID,
                     appVersion,
-                    limits.rateLimit !== undefined || limits.partitionRateLimit !== undefined,
+                    queue.rateLimit !== undefined || queue.partitionRateLimit !== undefined,
                     workflowIDs,
                     workflow_1.StatusString.ENQUEUED,
                     // Claim an unclaimed row for this application; a nameless dequeuer leaves ownership untouched.
@@ -2765,14 +2763,13 @@ class SystemDatabase {
     partitionedDequeueSweepCap = 8192;
     /** Dequeue each partition's head-of-line workflow in one transaction, at most {@link partitionedDequeueSweepCap} per sweep; only valid for partition-concurrency-1 queues with no queue-wide limit. */
     async findAndMarkStartablePartitionedWorkflows(queue, executorID, appVersion, maxTasks = Infinity) {
-        const limits = (0, wfqueue_1.resolveQueueLimits)(queue);
-        if (limits.partitionConcurrency !== 1 ||
-            limits.globalConcurrency !== undefined ||
-            limits.rateLimit !== undefined ||
-            limits.partitionRateLimit !== undefined) {
+        if (queue.partitionConcurrency !== 1 ||
+            queue.concurrency !== undefined ||
+            queue.rateLimit !== undefined ||
+            queue.partitionRateLimit !== undefined) {
             throw new error_1.DBOSError(`Batched partitioned dequeue requires a queue with partition concurrency 1 and no queue-wide concurrency or rate limit: ${queue.name}`);
         }
-        // partitionWorkerConcurrency needs no handling here: any value above 0 is capped at partition concurrency 1, which the PENDING gate already enforces globally, and 0 makes the caller's maxTasks 0.
+        // partitionWorkerConcurrency needs no handling here: it cannot exceed partition concurrency 1, which the PENDING gate already enforces globally.
         const client = await this.#connect();
         try {
             await client.query('BEGIN');
@@ -4061,14 +4058,14 @@ class SystemDatabase {
            priority_enabled, partition_queue, partition_concurrency, partition_worker_concurrency,
            partition_rate_limit_max, partition_rate_limit_period_sec,
            polling_interval_sec, updated_at, application_name)
-         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14)
+         -- priority_enabled is vestigial: every queue dispatches in priority order.
+         VALUES ($1, $2, $3, $4, $5, TRUE, $6, $7, $8, $9, $10, $11, $12, $13)
          ${onConflict}`, [
                 record.name,
                 record.concurrency,
                 record.workerConcurrency,
                 record.rateLimitMax,
                 record.rateLimitPeriodSec,
-                record.priorityEnabled,
                 record.partitionQueue,
                 record.partitionConcurrency,
                 record.partitionWorkerConcurrency,