@dbos-inc/dbos-sdk 2.10.15-preview → 2.10.17-preview

package/dist/src/system_database.js

@@ -72,62 +72,70 @@ class NotificationMap {
     }
 }
 async function insertWorkflowStatus(client, initStatus) {
-    const { rows } = await client.query(`INSERT INTO ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_status (
-      workflow_uuid,
-      status,
-      name,
-      class_name,
-      config_name,
-      queue_name,
-      authenticated_user,
-      assumed_role,
-      authenticated_roles,
-      request,
-      executor_id,
-      application_version,
-      application_id,
-      created_at,
-      recovery_attempts,
-      updated_at,
-      workflow_timeout_ms,
-      workflow_deadline_epoch_ms,
-      inputs
-    ) VALUES($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19)
-     ON CONFLICT (workflow_uuid)
-      DO UPDATE SET
-        recovery_attempts = workflow_status.recovery_attempts + 1,
-        updated_at = EXCLUDED.updated_at,
-        executor_id = EXCLUDED.executor_id 
-      RETURNING recovery_attempts, status, name, class_name, config_name, queue_name, workflow_deadline_epoch_ms`, [
-        initStatus.workflowUUID,
-        initStatus.status,
-        initStatus.workflowName,
-        initStatus.workflowClassName,
-        initStatus.workflowConfigName,
-        initStatus.queueName ?? null,
-        initStatus.authenticatedUser,
-        initStatus.assumedRole,
-        JSON.stringify(initStatus.authenticatedRoles),
-        JSON.stringify(initStatus.request),
-        initStatus.executorId,
-        initStatus.applicationVersion ?? null,
-        initStatus.applicationID,
-        initStatus.createdAt,
-        initStatus.status === workflow_1.StatusString.ENQUEUED ? 0 : 1,
-        initStatus.updatedAt ?? Date.now(),
-        initStatus.timeoutMS ?? null,
-        initStatus.deadlineEpochMS ?? null,
-        initStatus.input ?? null,
-    ]);
-    if (rows.length === 0) {
-        throw new Error(`Attempt to insert workflow ${initStatus.workflowUUID} failed`);
+    try {
+        const { rows } = await client.query(`INSERT INTO ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_status (
+        workflow_uuid,
+        status,
+        name,
+        class_name,
+        config_name,
+        queue_name,
+        authenticated_user,
+        assumed_role,
+        authenticated_roles,
+        request,
+        executor_id,
+        application_version,
+        application_id,
+        created_at,
+        recovery_attempts,
+        updated_at,
+        workflow_timeout_ms,
+        workflow_deadline_epoch_ms,
+        inputs,
+        deduplication_id,
+        priority
+      ) VALUES($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21)
+      ON CONFLICT (workflow_uuid)
+        DO UPDATE SET
+          recovery_attempts = workflow_status.recovery_attempts + 1,
+          updated_at = EXCLUDED.updated_at,
+          executor_id = EXCLUDED.executor_id 
+        RETURNING recovery_attempts, status, name, class_name, config_name, queue_name, workflow_deadline_epoch_ms`, [
+            initStatus.workflowUUID,
+            initStatus.status,
+            initStatus.workflowName,
+            initStatus.workflowClassName,
+            initStatus.workflowConfigName,
+            initStatus.queueName ?? null,
+            initStatus.authenticatedUser,
+            initStatus.assumedRole,
+            JSON.stringify(initStatus.authenticatedRoles),
+            JSON.stringify(initStatus.request),
+            initStatus.executorId,
+            initStatus.applicationVersion ?? null,
+            initStatus.applicationID,
+            initStatus.createdAt,
+            initStatus.status === workflow_1.StatusString.ENQUEUED ? 0 : 1,
+            initStatus.updatedAt ?? Date.now(),
+            initStatus.timeoutMS ?? null,
+            initStatus.deadlineEpochMS ?? null,
+            initStatus.input ?? null,
+            initStatus.deduplicationID ?? null,
+            initStatus.priority,
+        ]);
+        if (rows.length === 0) {
+            throw new Error(`Attempt to insert workflow ${initStatus.workflowUUID} failed`);
+        }
+        return rows[0];
+    }
+    catch (error) {
+        const err = error;
+        if (err.code === '23505') {
+            throw new error_1.DBOSQueueDuplicatedError(initStatus.workflowUUID, initStatus.queueName ?? '', initStatus.deduplicationID ?? '');
+        }
+        throw error;
     }
-    return rows[0];
-}
-async function deleteQueuedWorkflows(client, workflowID) {
-    await client.query(`DELETE FROM ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_queue  WHERE workflow_uuid = $1`, [
-        workflowID,
-    ]);
 }
 async function getWorkflowStatusValue(client, workflowID) {
     const { rows } = await client.query(`SELECT status FROM ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_status WHERE workflow_uuid=$1`, [workflowID]);
@@ -152,10 +160,16 @@ async function updateWorkflowStatus(client, workflowID, status, options = {}) {
     if (update.resetDeadline) {
         setClause += `, workflow_deadline_epoch_ms = NULL`;
     }
-    if (update.queueName) {
-        const param = args.push(update.queueName);
+    if (update.queueName !== undefined) {
+        const param = args.push(update.queueName ?? undefined);
         setClause += `, queue_name=$${param}`;
     }
+    if (update.resetDeduplicationID) {
+        setClause += `, deduplication_id = NULL`;
+    }
+    if (update.resetStartedAtEpochMs) {
+        setClause += `, started_at_epoch_ms = NULL`;
+    }
     const where = options.where ?? {};
     if (where.status) {
         const param = args.push(where.status);
@@ -215,6 +229,8 @@ function mapWorkflowStatus(row) {
         input: row.inputs,
         timeoutMS: row.workflow_timeout_ms ? Number(row.workflow_timeout_ms) : undefined,
         deadlineEpochMS: row.workflow_deadline_epoch_ms ? Number(row.workflow_deadline_epoch_ms) : undefined,
+        deduplicationID: row.deduplication_id ?? undefined,
+        priority: row.priority ?? 0,
     };
 }
 class PostgresSystemDatabase {
@@ -372,7 +388,9 @@ class PostgresSystemDatabase {
     async recordWorkflowOutput(workflowID, status) {
         const client = await this.pool.connect();
         try {
-            await updateWorkflowStatus(client, workflowID, workflow_1.StatusString.SUCCESS, { update: { output: status.output } });
+            await updateWorkflowStatus(client, workflowID, workflow_1.StatusString.SUCCESS, {
+                update: { output: status.output, resetDeduplicationID: true },
+            });
         }
         finally {
             client.release();
@@ -381,7 +399,9 @@ class PostgresSystemDatabase {
     async recordWorkflowError(workflowID, status) {
         const client = await this.pool.connect();
         try {
-            await updateWorkflowStatus(client, workflowID, workflow_1.StatusString.ERROR, { update: { error: status.error } });
+            await updateWorkflowStatus(client, workflowID, workflow_1.StatusString.ERROR, {
+                update: { error: status.error, resetDeduplicationID: true },
+            });
         }
         finally {
             client.release();
@@ -469,6 +489,8 @@ class PostgresSystemDatabase {
                 updatedAt: now,
                 timeoutMS: options.timeoutMS ?? workflowStatus.timeoutMS,
                 input: workflowStatus.input,
+                deduplicationID: undefined,
+                priority: 0,
             });
             if (startStep > 0) {
                 const query = `INSERT INTO ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.operation_outputs 
@@ -478,7 +500,6 @@ class PostgresSystemDatabase {
           WHERE workflow_uuid = $2 AND function_id < $3`;
                 await client.query(query, [newWorkflowID, workflowID, startStep]);
             }
-            await this.#enqueueWorkflow(client, newWorkflowID, utils_1.INTERNAL_QUEUE_NAME);
             await client.query('COMMIT');
             return newWorkflowID;
         }
@@ -810,9 +831,10 @@ class PostgresSystemDatabase {
                 await client.query('ROLLBACK');
                 return;
             }
-            // Remove workflow from queues table
-            await deleteQueuedWorkflows(client, workflowID);
-            await updateWorkflowStatus(client, workflowID, workflow_1.StatusString.CANCELLED);
+            // Set the workflow's status to CANCELLED and remove it from any queue it is on
+            await updateWorkflowStatus(client, workflowID, workflow_1.StatusString.CANCELLED, {
+                update: { queueName: null, resetDeduplicationID: true, resetStartedAtEpochMs: true },
+            });
             await client.query('COMMIT');
         }
         catch (error) {
@@ -859,17 +881,17 @@ class PostgresSystemDatabase {
                 }
                 return;
             }
-            // Remove the workflow from the queues table so resume can safely be called on an ENQUEUED workflow
-            await deleteQueuedWorkflows(client, workflowID);
+            // Set the workflow's status to ENQUEUED and reset recovery attempts and deadline.
             await updateWorkflowStatus(client, workflowID, workflow_1.StatusString.ENQUEUED, {
                 update: {
                     queueName: utils_1.INTERNAL_QUEUE_NAME,
                     resetRecoveryAttempts: true,
                     resetDeadline: true,
+                    resetDeduplicationID: true,
+                    resetStartedAtEpochMs: true,
                 },
                 throwOnFailure: false,
             });
-            await this.#enqueueWorkflow(client, workflowID, utils_1.INTERNAL_QUEUE_NAME);
             await client.query('COMMIT');
         }
         catch (error) {
@@ -1114,14 +1136,15 @@ class PostgresSystemDatabase {
     async listQueuedWorkflows(input) {
         const schemaName = dbos_executor_1.DBOSExecutor.systemDBSchemaName;
         const sortDesc = input.sortDesc ?? false; // By default, sort in ascending order
-        let query = this.knexDB(`${schemaName}.workflow_queue`)
-            .join(`${schemaName}.workflow_status`, `${schemaName}.workflow_queue.workflow_uuid`, `${schemaName}.workflow_status.workflow_uuid`)
+        let query = this.knexDB(`${schemaName}.workflow_status`)
+            .whereNotNull(`${schemaName}.workflow_status.queue_name`)
+            .whereIn(`${schemaName}.workflow_status.status`, [workflow_1.StatusString.ENQUEUED, workflow_1.StatusString.PENDING])
             .orderBy(`${schemaName}.workflow_status.created_at`, sortDesc ? 'desc' : 'asc');
         if (input.workflowName) {
-            query = query.whereRaw(`${schemaName}.workflow_status.name = ?`, [input.workflowName]);
+            query = query.where(`${schemaName}.workflow_status.name`, input.workflowName);
         }
         if (input.queueName) {
-            query = query.whereRaw(`${schemaName}.workflow_status.queue_name = ?`, [input.queueName]);
+            query = query.where(`${schemaName}.workflow_status.queue_name`, input.queueName);
         }
         if (input.startTime) {
             query = query.where(`${schemaName}.workflow_status.created_at`, '>=', new Date(input.startTime).getTime());
@@ -1130,7 +1153,7 @@ class PostgresSystemDatabase {
             query = query.where(`${schemaName}.workflow_status.created_at`, '<=', new Date(input.endTime).getTime());
         }
         if (input.status) {
-            query = query.whereRaw(`${schemaName}.workflow_status.status = ?`, [input.status]);
+            query = query.where(`${schemaName}.workflow_status.status`, input.status);
         }
         if (input.limit) {
             query = query.limit(input.limit);
@@ -1141,115 +1164,13 @@ class PostgresSystemDatabase {
         const rows = await query;
         return rows.map(mapWorkflowStatus);
     }
-    async getWorkflowQueue(input) {
-        // Create the initial query with a join to workflow_status table to get executor_id
-        let query = this.knexDB(`${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_queue as wq`)
-            .join(`${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_status as ws`, 'wq.workflow_uuid', '=', 'ws.workflow_uuid')
-            .orderBy('wq.created_at_epoch_ms', 'desc');
-        if (input.queueName) {
-            query = query.where('wq.queue_name', input.queueName);
-        }
-        if (input.startTime) {
-            query = query.where('wq.created_at_epoch_ms', '>=', new Date(input.startTime).getTime());
-        }
-        if (input.endTime) {
-            query = query.where('wq.created_at_epoch_ms', '<=', new Date(input.endTime).getTime());
-        }
-        if (input.limit) {
-            query = query.limit(input.limit);
-        }
-        const rows = await query
-            .select({
-            workflow_uuid: 'wq.workflow_uuid',
-            executor_id: 'ws.executor_id',
-            queue_name: 'wq.queue_name',
-            created_at_epoch_ms: 'wq.created_at_epoch_ms',
-            started_at_epoch_ms: 'wq.started_at_epoch_ms',
-            completed_at_epoch_ms: 'wq.completed_at_epoch_ms',
-        })
-            .then((rows) => rows);
-        const workflows = rows.map((row) => {
-            return {
-                workflowID: row.workflow_uuid,
-                executorID: row.executor_id,
-                queueName: row.queue_name,
-                createdAt: row.created_at_epoch_ms,
-                startedAt: row.started_at_epoch_ms,
-                completedAt: row.completed_at_epoch_ms,
-            };
-        });
-        return { workflows };
-    }
-    async #enqueueWorkflow(client, workflowID, queueName, enqueueOptions) {
-        const dedupID = enqueueOptions?.deduplicationID ?? null;
-        const priority = enqueueOptions?.priority ?? 0;
-        try {
-            await client.query(`INSERT INTO ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_queue (workflow_uuid, queue_name, deduplication_id, priority)
-        VALUES ($1, $2, $3, $4)
-        ON CONFLICT (workflow_uuid)
-        DO NOTHING;`, [workflowID, queueName, dedupID, priority]);
-        }
-        catch (error) {
-            const err = error;
-            if (err.code === '23505') {
-                // unique constraint violation (only expected for the INSERT query)
-                throw new error_1.DBOSQueueDuplicatedError(workflowID, queueName, dedupID ?? '');
-            }
-            this.logger.error(`Error enqueuing workflow ${workflowID} to queue ${queueName}`);
-            throw error;
-        }
-    }
-    async enqueueWorkflow(workflowId, queueName, enqueueOptions) {
-        const client = await this.pool.connect();
-        try {
-            await this.#enqueueWorkflow(client, workflowId, queueName, enqueueOptions);
-        }
-        finally {
-            client.release();
-        }
-    }
     async clearQueueAssignment(workflowID) {
-        const client = await this.pool.connect();
-        try {
-            await client.query('BEGIN ISOLATION LEVEL READ COMMITTED');
-            // Reset the start time in the queue to mark it as not started
-            const wqRes = await client.query(`UPDATE ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_queue
-         SET started_at_epoch_ms = NULL
-         WHERE workflow_uuid = $1 AND completed_at_epoch_ms IS NULL;`, [workflowID]);
-            // If no rows were affected, the workflow is not anymore in the queue or was already completed
-            if (wqRes.rowCount === 0) {
-                await client.query('ROLLBACK');
-                return false;
-            }
-            // Reset the status of the task to "ENQUEUED"
-            await updateWorkflowStatus(client, workflowID, workflow_1.StatusString.ENQUEUED);
-            await client.query('COMMIT');
-            return true;
-        }
-        catch (error) {
-            await client.query('ROLLBACK');
-            throw error;
-        }
-        finally {
-            client.release();
-        }
-    }
-    async dequeueWorkflow(workflowID, queue) {
-        const client = await this.pool.connect();
-        try {
-            if (queue.rateLimit) {
-                const time = Date.now();
-                await client.query(`UPDATE ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_queue
-           SET completed_at_epoch_ms = $2
-           WHERE workflow_uuid = $1;`, [workflowID, time]);
-            }
-            else {
-                await deleteQueuedWorkflows(client, workflowID);
-            }
-        }
-        finally {
-            client.release();
-        }
+        // Reset the status of the task from "PENDING" to "ENQUEUED"
+        const wqRes = await this.pool.query(`UPDATE ${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_status
+        SET started_at_epoch_ms = NULL, status = $2
+        WHERE workflow_uuid = $1 AND queue_name is NOT NULL AND status = $3`, [workflowID, workflow_1.StatusString.ENQUEUED, workflow_1.StatusString.PENDING]);
+        // If no rows were affected, the workflow is not anymore in the queue or was already completed
+        return (wqRes.rowCount ?? 0) > 0;
     }
     async findAndMarkStartableWorkflows(queue, executorID, appVersion) {
         const startTimeMs = Date.now();
@@ -1259,64 +1180,67 @@ class PostgresSystemDatabase {
             // If there is a rate limit, compute how many functions have started in its period.
             let numRecentQueries = 0;
             if (queue.rateLimit) {
-                const numRecentQueriesS = (await trx(`${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_queue`)
+                const numRecentQueriesS = (await trx(`${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_status`)
                     .count()
                     .where('queue_name', queue.name)
+                    .andWhere('status', '<>', workflow_1.StatusString.ENQUEUED)
                     .andWhere('started_at_epoch_ms', '>', startTimeMs - limiterPeriodMS)
                     .first()).count;
                 numRecentQueries = parseInt(`${numRecentQueriesS}`);
                 if (numRecentQueries >= queue.rateLimit.limitPerPeriod) {
-                    return claimedIDs;
+                    return [];
                 }
             }
             // Dequeue functions eligible for this worker and ordered by the time at which they were enqueued.
             // If there is a global or local concurrency limit N, select only the N oldest enqueued
             // functions, else select all of them.
-            // First lets figure out how many tasks are eligible for dequeue.
-            // This means figuring out how many unstarted tasks are within the local and global concurrency limits
-            const runningTasksSubquery = trx(`${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_queue as wq`)
-                .join(`${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_status as ws`, 'wq.workflow_uuid', '=', 'ws.workflow_uuid')
-                .select('ws.executor_id')
-                .count('* as task_count')
-                .where('wq.queue_name', queue.name)
-                .whereNotNull('wq.started_at_epoch_ms') // started
-                .whereNull('wq.completed_at_epoch_ms') // not completed
-                .groupBy('ws.executor_id');
-            const runningTasksResult = await runningTasksSubquery;
-            const runningTasksResultDict = {};
-            runningTasksResult.forEach((row) => {
-                runningTasksResultDict[row.executor_id] = Number(row.task_count);
-            });
-            const runningTasksForThisWorker = runningTasksResultDict[executorID] || 0;
             let maxTasks = Infinity;
-            if (queue.workerConcurrency !== undefined) {
-                maxTasks = Math.max(0, queue.workerConcurrency - runningTasksForThisWorker);
-            }
-            if (queue.concurrency !== undefined) {
-                const totalRunningTasks = Object.values(runningTasksResultDict).reduce((acc, val) => acc + val, 0);
-                if (totalRunningTasks > queue.concurrency) {
-                    this.logger.warn(`Total running tasks (${totalRunningTasks}) exceeds the global concurrency limit (${queue.concurrency})`);
+            if (queue.workerConcurrency !== undefined || queue.concurrency !== undefined) {
+                // Count how many workflows on this queue are currently PENDING both locally and globally.
+                const runningTasksSubquery = trx(`${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_status`)
+                    .select('executor_id')
+                    .count('* as task_count')
+                    .where('queue_name', queue.name)
+                    .andWhere('status', workflow_1.StatusString.PENDING)
+                    .groupBy('executor_id');
+                const runningTasksResult = await runningTasksSubquery;
+                const runningTasksResultDict = {};
+                runningTasksResult.forEach((row) => {
+                    runningTasksResultDict[row.executor_id] = Number(row.task_count);
+                });
+                const runningTasksForThisWorker = runningTasksResultDict[executorID] || 0;
+                if (queue.workerConcurrency !== undefined) {
+                    maxTasks = Math.max(0, queue.workerConcurrency - runningTasksForThisWorker);
+                }
+                if (queue.concurrency !== undefined) {
+                    const totalRunningTasks = Object.values(runningTasksResultDict).reduce((acc, val) => acc + val, 0);
+                    if (totalRunningTasks > queue.concurrency) {
+                        this.logger.warn(`Total running tasks (${totalRunningTasks}) exceeds the global concurrency limit (${queue.concurrency})`);
+                    }
+                    const availableTasks = Math.max(0, queue.concurrency - totalRunningTasks);
+                    maxTasks = Math.min(maxTasks, availableTasks);
                 }
-                const availableTasks = Math.max(0, queue.concurrency - totalRunningTasks);
-                maxTasks = Math.min(maxTasks, availableTasks);
             }
-            // Lookup tasks
-            let query = trx(`${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_queue as wq`)
-                .join(`${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_status as ws`, 'wq.workflow_uuid', '=', 'ws.workflow_uuid')
-                .whereNull('wq.completed_at_epoch_ms') // not completed
-                .whereNull('wq.started_at_epoch_ms') // not started
-                .andWhere('wq.queue_name', queue.name)
+            // Retrieve the first max_tasks workflows in the queue.
+            // Only retrieve workflows of the local version (or without version set)
+            let query = trx(`${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_status`)
+                .where('status', workflow_1.StatusString.ENQUEUED)
+                .andWhere('queue_name', queue.name)
                 .andWhere((b) => {
-                b.whereNull('ws.application_version').orWhere('ws.application_version', appVersion);
+                b.whereNull('application_version').orWhere('application_version', appVersion);
             })
-                .orderBy('wq.priority', 'asc')
-                .orderBy('wq.created_at_epoch_ms', 'asc')
                 .forUpdate()
                 .noWait();
+            if (queue.priorityEnabled) {
+                query = query.orderBy('priority', 'asc').orderBy('created_at', 'asc');
+            }
+            else {
+                query = query.orderBy('created_at', 'asc');
+            }
             if (maxTasks !== Infinity) {
                 query = query.limit(maxTasks);
             }
-            const rows = (await query.select(['wq.workflow_uuid as workflow_uuid']));
+            const rows = (await query.select(['workflow_uuid']));
             // Start the workflows
             const workflowIDs = rows.map((row) => row.workflow_uuid);
             for (const id of workflowIDs) {
@@ -1333,28 +1257,16 @@ class PostgresSystemDatabase {
                     status: workflow_1.StatusString.PENDING,
                     executor_id: executorID,
                     application_version: appVersion,
+                    started_at_epoch_ms: startTimeMs,
                     workflow_deadline_epoch_ms: trx.raw('CASE WHEN workflow_timeout_ms IS NOT NULL AND workflow_deadline_epoch_ms IS NULL THEN (EXTRACT(epoch FROM now()) * 1000)::bigint + workflow_timeout_ms ELSE workflow_deadline_epoch_ms END'),
                 });
                 if (res > 0) {
                     claimedIDs.push(id);
-                    await trx(`${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_queue`)
-                        .where('workflow_uuid', id)
-                        .update('started_at_epoch_ms', startTimeMs);
                 }
                 // If we did not update this record, probably someone else did.  Count in either case.
                 ++numRecentQueries;
             }
         }, { isolationLevel: 'repeatable read' });
-        // If we have a rate limit, garbage-collect all completed functions started
-        //   before the period. If there's no limiter, there's no need--they were
-        //   deleted on completion.
-        if (queue.rateLimit) {
-            await this.knexDB(`${dbos_executor_1.DBOSExecutor.systemDBSchemaName}.workflow_queue`)
-                .whereNotNull('completed_at_epoch_ms')
-                .andWhere('queue_name', queue.name)
-                .andWhere('started_at_epoch_ms', '<', startTimeMs - limiterPeriodMS)
-                .delete();
-        }
         // Return the IDs of all functions we marked started
         return claimedIDs;
     }