@getstrata/core 2.2.14 → 2.2.16

package/dist/index.js

@@ -125,6 +125,10 @@ function getDefaultDatabaseQuery() {
   }
   return query;
 }
+function isDefaultDatabaseConnection(connection) {
+  const { pool, query } = defaultConnectionState();
+  return connection !== null && (connection === pool || connection === query);
+}
 function resetDefaultDatabasePoolForTests() {
   const holder = defaultConnectionState();
   holder.pool = null;
@@ -5781,6 +5785,31 @@ class RepositoryQuery {
 // ../../src/core/database/baseRepository.ts
 init_transaction();
 init_transactionControl();
+function listOrders(orderBy) {
+  if (!orderBy)
+    return [];
+  if (Array.isArray(orderBy))
+    return orderBy.map(readOrder);
+  if ("column" in orderBy)
+    return [readOrder(orderBy)];
+  return Object.entries(orderBy).flatMap(([column, direction]) => {
+    if (direction === undefined)
+      return [];
+    return [
+      {
+        column,
+        direction: String(direction).toUpperCase() === "DESC" ? "desc" : "asc"
+      }
+    ];
+  });
+}
+function readOrder(order) {
+  return {
+    column: String(order.column),
+    direction: String(order.direction).toUpperCase() === "DESC" ? "desc" : "asc",
+    ...order.nulls === undefined ? {} : { nulls: order.nulls }
+  };
+}
 
 class BaseRepository {
   table;
@@ -5824,6 +5853,10 @@ class BaseRepository {
       joins: options.joins,
       groupBy: options.groupBy
     }, whereNodes);
+    const meta = buildPaginationMeta({ page, perPage, total });
+    if (total === 0) {
+      return { data: [], meta };
+    }
     const offset = (page - 1) * perPage;
     const data = await this.findAll({
       ...queryOptions,
@@ -5834,13 +5867,19 @@ class BaseRepository {
     });
     return {
       data,
-      meta: buildPaginationMeta({ page, perPage, total })
+      meta
     };
   }
   async chunk(count, callback, options = {}) {
     if (!Number.isInteger(count) || count <= 0) {
       throw new Error("Chunk size must be a positive integer.");
     }
+    if (this.primaryKeySeekDirection(options) === "asc") {
+      const seekOptions = { ...options };
+      delete seekOptions.orderBy;
+      await this.chunkById(count, async (rows) => await callback(rows) === false ? false : undefined, seekOptions);
+      return;
+    }
     let offset = 0;
     while (true) {
       const rows = await this.findAll({
@@ -6125,6 +6164,17 @@ class BaseRepository {
       return entity;
     }));
   }
+  primaryKeySeekDirection(options) {
+    if (options.joins?.length || options.groupBy || options.having || options.select?.length || options.offset !== undefined || options.limit !== undefined || options.lock) {
+      return null;
+    }
+    const orders = listOrders(options.orderBy ?? this.table.defaultOrderBy);
+    const order = orders[0];
+    if (orders.length !== 1 || !order || order.nulls || order.column !== this.table.primaryKey) {
+      return null;
+    }
+    return order.direction;
+  }
   withConnection(connection) {
     const clone = Object.create(Object.getPrototypeOf(this));
     Object.assign(clone, this);
@@ -7599,7 +7649,12 @@ import { isDeepStrictEqual } from "util";
 init_deferredModelEvents();
 
 // ../../src/core/database/relationQuery.ts
+init_boundConnection();
+init_connectionContext();
+init_defaultConnection();
 init_dialect();
+init_repositoryConnection();
+init_transaction();
 function asWhere(where) {
   return where;
 }
@@ -7869,6 +7924,26 @@ class BelongsToRelationQuery {
     });
   }
 }
+function pivotIdKey(id) {
+  return typeof id === "number" || typeof id === "bigint" ? String(id) : id;
+}
+function hasRepeatedId(ids) {
+  const seen = new Set;
+  for (const id of ids) {
+    const key = pivotIdKey(id);
+    if (seen.has(key))
+      return true;
+    seen.add(key);
+  }
+  return false;
+}
+function canBatchPivotToggle(ids) {
+  return ids.every((id) => typeof id === "bigint" && id >= BigInt(Number.MIN_SAFE_INTEGER) && id <= BigInt(Number.MAX_SAFE_INTEGER) || typeof id === "number" && Number.isSafeInteger(id) || typeof id === "string" && /^(?:0|-?[1-9]\d*)$/.test(id) && Number.isSafeInteger(Number(id)));
+}
+function isConfiguredConnection(connection) {
+  const bound = getBoundDatabaseConnection();
+  return connection === repositoryConnection || (bound ? connection === bound : isDefaultDatabaseConnection(connection));
+}
 
 class BelongsToManyRelationQuery {
   parent;
@@ -7910,7 +7985,20 @@ class BelongsToManyRelationQuery {
     return { sql, params: extra.params };
   }
   connection() {
-    return this.parent.getRepository().getConnection();
+    const connection = this.parent.getRepository().getConnection();
+    return isConfiguredConnection(connection) ? getActiveDatabaseConnection(connection) : connection;
+  }
+  async atomically(work) {
+    const connection = this.connection();
+    if (isConfiguredConnection(connection) || hasActiveDatabaseConnection() && connection === getActiveDatabaseConnection(connection)) {
+      await runInTransaction(work);
+      return;
+    }
+    if (typeof connection.begin !== "function") {
+      await work(connection);
+      return;
+    }
+    await connection.begin(work);
   }
   async get() {
     const query = await this.relatedQuery();
@@ -7948,36 +8036,72 @@ class BelongsToManyRelationQuery {
   }
   async attach(ids) {
     const list = Array.isArray(ids) ? ids : [ids];
-    const parentId = this.parent.get(this.relation.parentKey);
-    const extraKeys = Object.keys(this.pivotValues);
-    const extraColumns = extraKeys.length > 0 ? `, ${extraKeys.map((key) => quoteIdentifier(key)).join(", ")}` : "";
-    const extraPlaceholders = extraKeys.map((_, index) => `$${index + 3}`).join(", ");
-    const extraValues = extraKeys.map((key) => this.pivotValues[key]);
-    for (const id of list) {
-      await this.connection().unsafe(extraKeys.length > 0 ? `INSERT INTO ${quoteIdentifier(this.relation.pivotTable)} (${quoteIdentifier(String(this.relation.foreignPivotKey))}, ${quoteIdentifier(String(this.relation.relatedPivotKey))}${extraColumns}) VALUES ($1, $2, ${extraPlaceholders})` : `INSERT INTO ${quoteIdentifier(this.relation.pivotTable)} (${quoteIdentifier(String(this.relation.foreignPivotKey))}, ${quoteIdentifier(String(this.relation.relatedPivotKey))}) VALUES ($1, $2)`, [parentId, id, ...extraValues]);
-    }
+    if (list.length === 0)
+      return;
+    await this.atomically((connection) => this.insertPivotRows(connection, list));
   }
   async toggle(ids) {
     const list = Array.isArray(ids) ? ids : [ids];
-    const parentId = this.parent.get(this.relation.parentKey);
-    for (const id of list) {
-      const existing = await this.connection().unsafe(`SELECT 1 FROM ${quoteIdentifier(this.relation.pivotTable)} WHERE ${quoteIdentifier(String(this.relation.foreignPivotKey))} = $1 AND ${quoteIdentifier(String(this.relation.relatedPivotKey))} = $2 LIMIT 1`, [parentId, id]);
-      if (existing.length > 0) {
-        await this.detach(id);
-      } else {
-        await this.attach(id);
+    if (list.length === 0)
+      return;
+    await this.atomically(async (connection) => {
+      if (!canBatchPivotToggle(list) || hasRepeatedId(list)) {
+        for (const id of list)
+          await this.toggleOne(connection, id);
+        return;
       }
-    }
+      const parentId = this.parent.get(this.relation.parentKey);
+      const relatedColumn = quoteIdentifier(String(this.relation.relatedPivotKey));
+      const parentColumn = quoteIdentifier(String(this.relation.foreignPivotKey));
+      const placeholders = list.map((_, index) => currentSqlDialect().placeholder(index + 2));
+      const existing = await connection.unsafe(`SELECT ${relatedColumn} FROM ${quoteIdentifier(this.relation.pivotTable)} WHERE ${parentColumn} = ${currentSqlDialect().placeholder(1)} AND ${relatedColumn} IN (${placeholders.join(", ")})`, [parentId, ...list]);
+      const existingIds = new Set(existing.map((row) => pivotIdKey(row[String(this.relation.relatedPivotKey)])));
+      const present = list.filter((id) => existingIds.has(pivotIdKey(id)));
+      const missing = list.filter((id) => !existingIds.has(pivotIdKey(id)));
+      if (present.length > 0)
+        await this.deletePivotRows(connection, present);
+      if (missing.length > 0)
+        await this.insertPivotRows(connection, missing);
+    });
   }
   async detach(ids) {
     const parentId = this.parent.get(this.relation.parentKey);
     if (ids === undefined) {
-      await this.connection().unsafe(`DELETE FROM ${quoteIdentifier(this.relation.pivotTable)} WHERE ${quoteIdentifier(String(this.relation.foreignPivotKey))} = $1`, [parentId]);
+      await this.connection().unsafe(`DELETE FROM ${quoteIdentifier(this.relation.pivotTable)} WHERE ${quoteIdentifier(String(this.relation.foreignPivotKey))} = ${currentSqlDialect().placeholder(1)}`, [parentId]);
       return;
     }
     const list = Array.isArray(ids) ? ids : [ids];
-    const placeholders = list.map((_, index) => `$${index + 2}`).join(", ");
-    await this.connection().unsafe(`DELETE FROM ${quoteIdentifier(this.relation.pivotTable)} WHERE ${quoteIdentifier(String(this.relation.foreignPivotKey))} = $1 AND ${quoteIdentifier(String(this.relation.relatedPivotKey))} IN (${placeholders})`, [parentId, ...list]);
+    if (list.length === 0)
+      return;
+    await this.deletePivotRows(this.connection(), list);
+  }
+  async toggleOne(connection, id) {
+    const parentId = this.parent.get(this.relation.parentKey);
+    const existing = await connection.unsafe(`SELECT 1 FROM ${quoteIdentifier(this.relation.pivotTable)} WHERE ${quoteIdentifier(String(this.relation.foreignPivotKey))} = ${currentSqlDialect().placeholder(1)} AND ${quoteIdentifier(String(this.relation.relatedPivotKey))} = ${currentSqlDialect().placeholder(2)} LIMIT 1`, [parentId, id]);
+    if (existing.length > 0)
+      await this.deletePivotRows(connection, [id]);
+    else
+      await this.insertPivotRows(connection, [id]);
+  }
+  async insertPivotRows(connection, list) {
+    const parentId = this.parent.get(this.relation.parentKey);
+    const extraKeys = Object.keys(this.pivotValues);
+    const extraColumns = extraKeys.length > 0 ? `, ${extraKeys.map((key) => quoteIdentifier(key)).join(", ")}` : "";
+    const extraValues = extraKeys.map((key) => this.pivotValues[key]);
+    const width = 2 + extraKeys.length;
+    const tuples = list.map((_, row) => {
+      const slots = Array.from({ length: width }, (__, column) => currentSqlDialect().placeholder(row * width + column + 1));
+      return `(${slots.join(", ")})`;
+    });
+    const params = [];
+    for (const id of list)
+      params.push(parentId, id, ...extraValues);
+    await connection.unsafe(`INSERT INTO ${quoteIdentifier(this.relation.pivotTable)} (${quoteIdentifier(String(this.relation.foreignPivotKey))}, ${quoteIdentifier(String(this.relation.relatedPivotKey))}${extraColumns}) VALUES ${tuples.join(", ")}`, params);
+  }
+  async deletePivotRows(connection, list) {
+    const parentId = this.parent.get(this.relation.parentKey);
+    const placeholders = list.map((_, index) => currentSqlDialect().placeholder(index + 2));
+    await connection.unsafe(`DELETE FROM ${quoteIdentifier(this.relation.pivotTable)} WHERE ${quoteIdentifier(String(this.relation.foreignPivotKey))} = ${currentSqlDialect().placeholder(1)} AND ${quoteIdentifier(String(this.relation.relatedPivotKey))} IN (${placeholders.join(", ")})`, [parentId, ...list]);
   }
   async sync(ids) {
     await this.detach();
@@ -8568,10 +8692,20 @@ function applyCasts(values, casts, direction) {
     return result;
   }
   return (async () => {
+    const hashes = [];
     for (const [key, cast] of entries) {
-      if (key in result && cast)
-        result[key] = await dehydrateValue(result[key], cast);
+      if (!(key in result) || !cast)
+        continue;
+      if (cast === "hashed") {
+        const current = result[key];
+        hashes.push(hashCastValue(current).then((hashed) => {
+          result[key] = hashed;
+        }));
+        continue;
+      }
+      result[key] = dehydrateValue(result[key], cast);
     }
+    await Promise.all(hashes);
     return result;
   })();
 }
@@ -14184,21 +14318,6 @@ redis.call('XDEL', KEYS[1], ARGV[2])
 if #redis.call('XPENDING', KEYS[1], ARGV[1], '-', '+', 1, ARGV[3]) == 0 then redis.call('XGROUP', 'DELCONSUMER', KEYS[1], ARGV[1], ARGV[3]) end
 return 1
 `;
-var PROMOTE_RETRIES = `
-local kinds = {'stream','zset'}
-for i=1,2 do
-  local kind = redis.call('TYPE', KEYS[i]).ok
-  if kind ~= 'none' and kind ~= kinds[i] then return redis.error_reply('Invalid stream retry promotion key type') end
-end
-local now = redis.call('TIME')
-local due = tonumber(now[1])*1000 + math.floor(tonumber(now[2])/1000)
-local entries = redis.call('ZRANGE', KEYS[2], '-inf', due, 'BYSCORE', 'LIMIT', 0, 100)
-for _, payload in ipairs(entries) do
-  redis.call('XADD', KEYS[1], '*', 'payload', payload)
-  redis.call('ZREM', KEYS[2], payload)
-end
-return #entries
-`;
 async function scheduleStreamRetry(client, key, reservation, envelope, delayMs) {
   if (!Number.isSafeInteger(delayMs) || delayMs < 0 || delayMs > Number.MAX_SAFE_INTEGER / 2)
     throw new Error("Invalid Streams retry delay");
@@ -14220,8 +14339,93 @@ async function scheduleStreamRetry(client, key, reservation, envelope, delayMs)
   if (Number(scheduled) !== 1)
     throw new Error("Queue lease lost while scheduling retry");
 }
-async function promoteStreamRetries(client, key) {
-  return Number(await client.send("EVAL", [PROMOTE_RETRIES, "2", streamQueueKey(key), streamRetryKey(key)]));
+var POLL_STREAM_PRIORITIES = `
+local group = ARGV[1]
+local owner = ARGV[2]
+local visibility = ARGV[3]
+local function payloadOf(fields)
+  for index = 1, #fields, 2 do
+    if fields[index] == 'payload' and type(fields[index + 1]) == 'string' then return fields[index + 1] end
+  end
+  return ''
+end
+local cursors = {}
+for i = 1, #KEYS / 2 do cursors[i] = ARGV[3 + i] end
+for i = 1, #KEYS / 2 do
+  local stream = KEYS[(i - 1) * 2 + 1]
+  local retries = KEYS[(i - 1) * 2 + 2]
+  local cursor = ARGV[3 + i]
+  local streamKind = redis.call('TYPE', stream).ok
+  local retryKind = redis.call('TYPE', retries).ok
+  if streamKind ~= 'none' and streamKind ~= 'stream' then return redis.error_reply('Invalid stream retry promotion key type') end
+  if retryKind ~= 'none' and retryKind ~= 'zset' then return redis.error_reply('Invalid stream retry promotion key type') end
+  if streamKind == 'stream' then
+    local now = redis.call('TIME')
+    local due = tonumber(now[1]) * 1000 + math.floor(tonumber(now[2]) / 1000)
+    local ready = redis.call('ZRANGE', retries, '-inf', due, 'BYSCORE', 'LIMIT', 0, 100)
+    for _, payload in ipairs(ready) do
+      redis.call('XADD', stream, '*', 'payload', payload)
+      redis.call('ZREM', retries, payload)
+    end
+    local window = redis.call('XPENDING', stream, group, cursor, '+', 10)
+    local claimed = redis.call('XAUTOCLAIM', stream, group, owner, visibility, cursor, 'COUNT', 1)
+    for _, entry in ipairs(window) do
+      if entry[2] ~= owner and #redis.call('XPENDING', stream, group, '-', '+', 1, entry[2]) == 0 then
+        redis.call('XGROUP', 'DELCONSUMER', stream, group, entry[2])
+      end
+    end
+    if #redis.call('XPENDING', stream, group, '-', '+', 1, owner) == 0 then
+      redis.call('XGROUP', 'DELCONSUMER', stream, group, owner)
+    end
+    cursors[i] = claimed[1]
+    if #claimed[2] > 0 then
+      return {'1', tostring(i), claimed[2][1][1], payloadOf(claimed[2][1][2]), unpack(cursors)}
+    end
+    local fresh = redis.call('XREADGROUP', 'GROUP', group, owner, 'COUNT', 1, 'STREAMS', stream, '>')
+    if not fresh and #redis.call('XPENDING', stream, group, '-', '+', 1, owner) == 0 then
+      redis.call('XGROUP', 'DELCONSUMER', stream, group, owner)
+    end
+    if fresh and #fresh > 0 and #fresh[1][2] > 0 then
+      return {'1', tostring(i), fresh[1][2][1][1], payloadOf(fresh[1][2][1][2]), unpack(cursors)}
+    end
+  end
+end
+return {'0', unpack(cursors)}
+`;
+async function pollStreamPriorities(client, queueKeys, owner, cursors) {
+  const keys = [];
+  for (const key of queueKeys)
+    keys.push(streamQueueKey(key), streamRetryKey(key));
+  const raw = await client.send("EVAL", [
+    POLL_STREAM_PRIORITIES,
+    String(keys.length),
+    ...keys,
+    STREAM_GROUP,
+    owner,
+    String(readQueueVisibilityMs()),
+    ...cursors
+  ]);
+  if (!Array.isArray(raw))
+    throw new Error("Invalid Redis stream poll response");
+  const flag = String(raw[0]);
+  const cursorCount = queueKeys.length;
+  if (flag === "0") {
+    if (raw.length !== cursorCount + 1)
+      throw new Error("Invalid Redis stream poll response");
+    return { cursors: raw.slice(1).map(String), hit: null };
+  }
+  if (flag !== "1" || raw.length !== cursorCount + 4)
+    throw new Error("Invalid Redis stream poll response");
+  const index = Number(raw[1]);
+  if (!Number.isInteger(index) || index < 1 || index > queueKeys.length)
+    throw new Error("Invalid Redis stream poll response");
+  return {
+    cursors: raw.slice(4).map(String),
+    hit: {
+      index: index - 1,
+      reservation: { id: String(raw[2]), owner, payload: String(raw[3]) }
+    }
+  };
 }
 async function readStreamQueueDepth(client, key) {
   return Number(await client.send("EVAL", [
@@ -14270,20 +14474,6 @@ end
 if #redis.call('XPENDING', KEYS[1], ARGV[1], '-', '+', 1, ARGV[3]) == 0 then redis.call('XGROUP', 'DELCONSUMER', KEYS[1], ARGV[1], ARGV[3]) end
 return acknowledged
 `;
-var CLAIM_STREAM = `
-local window = redis.call('XPENDING', KEYS[1], ARGV[1], ARGV[4], '+', 10)
-local claimed = redis.call('XAUTOCLAIM', KEYS[1], ARGV[1], ARGV[2], ARGV[3], ARGV[4], 'COUNT', 1)
-for _, entry in ipairs(window) do
-  if entry[2] ~= ARGV[2] and #redis.call('XPENDING', KEYS[1], ARGV[1], '-', '+', 1, entry[2]) == 0 then redis.call('XGROUP', 'DELCONSUMER', KEYS[1], ARGV[1], entry[2]) end
-end
-if #redis.call('XPENDING', KEYS[1], ARGV[1], '-', '+', 1, ARGV[2]) == 0 then redis.call('XGROUP', 'DELCONSUMER', KEYS[1], ARGV[1], ARGV[2]) end
-return claimed
-`;
-var READ_STREAM = `
-local entries = redis.call('XREADGROUP', 'GROUP', ARGV[1], ARGV[2], 'COUNT', 1, 'STREAMS', KEYS[1], '>')
-if not entries and #redis.call('XPENDING', KEYS[1], ARGV[1], '-', '+', 1, ARGV[2]) == 0 then redis.call('XGROUP', 'DELCONSUMER', KEYS[1], ARGV[1], ARGV[2]) end
-return entries
-`;
 async function ensureStreamGroup(client, key) {
   await assertLegacyDrained(client, key);
   try {
@@ -14293,17 +14483,6 @@ async function ensureStreamGroup(client, key) {
       throw error;
   }
 }
-function readStreamEntry(value, owner) {
-  if (!Array.isArray(value) || typeof value[0] !== "string" || !Array.isArray(value[1]))
-    throw new Error("Invalid Redis stream entry response");
-  const fields = value[1];
-  let payload;
-  for (let index = 0;index < fields.length; index += 2) {
-    if (fields[index] === "payload" && typeof fields[index + 1] === "string")
-      payload = fields[index + 1];
-  }
-  return { id: value[0], owner, payload: payload ?? "" };
-}
 async function updateStreamReservation(client, key, reservation, action, controlKey) {
   return Number(await client.send("EVAL", [
     UPDATE_STREAM,
@@ -14320,35 +14499,6 @@ async function updateStreamReservation(client, key, reservation, action, control
     controlKey ? "1" : "0"
   ])) === 1;
 }
-async function reserveStreamJob(client, key, owner, cursor = "0-0") {
-  const claimed = await client.send("EVAL", [
-    CLAIM_STREAM,
-    "1",
-    streamQueueKey(key),
-    STREAM_GROUP,
-    owner,
-    String(readQueueVisibilityMs()),
-    cursor
-  ]);
-  if (!Array.isArray(claimed) || typeof claimed[0] !== "string" || !Array.isArray(claimed[1]))
-    throw new Error("Invalid Redis XAUTOCLAIM response");
-  const nextCursor = claimed[0];
-  if (claimed[1].length > 0)
-    return { reservation: readStreamEntry(claimed[1][0], owner), cursor: nextCursor };
-  const fresh = await client.send("EVAL", [
-    READ_STREAM,
-    "1",
-    streamQueueKey(key),
-    STREAM_GROUP,
-    owner
-  ]);
-  if (fresh === null)
-    return { reservation: null, cursor: nextCursor };
-  if (!Array.isArray(fresh) || !Array.isArray(fresh[0]) || !Array.isArray(fresh[0][1]))
-    throw new Error("Invalid Redis XREADGROUP response");
-  return { reservation: readStreamEntry(fresh[0][1][0], owner), cursor: nextCursor };
-}
-
 class RedisStreamsQueue {
   client;
   constructor(redisUrl) {
@@ -14446,12 +14596,6 @@ class RedisStreamsWorker {
       await ensureStreamGroup(this.client, key);
     this.initialized = true;
   }
-  async reserve(key) {
-    await promoteStreamRetries(this.client, key);
-    const result = await reserveStreamJob(this.client, key, this.owner, this.cursors.get(key));
-    this.cursors.set(key, result.cursor);
-    return result.reservation;
-  }
   async processNext() {
     if (this.processing)
       throw new Error("Queue worker already processing a job.");
@@ -14468,13 +14612,19 @@ class RedisStreamsWorker {
     await this.initialize();
     const deadline = performance.now() + this.timeoutSeconds * 1000;
     do {
-      for (const key of this.queueKeys) {
-        if (this.stopping)
-          return false;
-        const reservation = await this.reserve(key);
-        if (!reservation)
-          continue;
-        await this.handle(key, reservation);
+      if (this.stopping)
+        return false;
+      const polled = await pollStreamPriorities(this.client, this.queueKeys, this.owner, this.queueKeys.map((key) => this.cursors.get(key) ?? "0-0"));
+      this.queueKeys.forEach((key, index) => {
+        const cursor = polled.cursors[index];
+        if (cursor)
+          this.cursors.set(key, cursor);
+      });
+      if (polled.hit) {
+        const key = this.queueKeys[polled.hit.index];
+        if (!key)
+          throw new Error("Invalid Redis stream poll response");
+        await this.handle(key, polled.hit.reservation);
         return true;
       }
       if (performance.now() >= deadline || this.stopping)
@@ -14701,25 +14851,69 @@ for _, record in ipairs(redis.call('LRANGE', KEYS[2], 0, -1)) do
 end
 return reclaimed
 `;
+var POLL_LIST_PRIORITIES = `${SCRIPT_HEADER}
+local owner = ARGV[1]
+local visibility = ARGV[2]
+local reservationId = ARGV[3]
+local reclaim = ARGV[4] == '1'
+local function reclaimQueue(listKey, processingKey, leaseKey)
+  local err = checkType(listKey, 'list') or checkType(processingKey, 'list') or checkType(leaseKey, 'hash')
+  if err then return err end
+  local now = nowMs()
+  for _, record in ipairs(redis.call('LRANGE', processingKey, 0, -1)) do
+    local payload, field = record, record
+    local modern = false
+    local ok, reservation = pcall(cjson.decode, record)
+    if ok and type(reservation) == 'table' and reservation.strataReservation == 1 then
+      payload, field, modern = reservation.payload, reservation.id, true
+    end
+    local raw = redis.call('HGET', leaseKey, field)
+    local expired = true
+    if raw then
+      if modern then
+        local leaseOk, lease = pcall(cjson.decode, raw)
+        expired = not leaseOk or type(lease) ~= 'table' or not tonumber(lease.expiresAt) or tonumber(lease.expiresAt) <= now
+      else
+        local reservedAt = tonumber(raw)
+        expired = not reservedAt or now - reservedAt >= tonumber(visibility)
+      end
+    end
+    if expired then
+      redis.call('LPUSH', listKey, payload)
+      redis.call('LREM', processingKey, 1, record)
+      redis.call('HDEL', leaseKey, field)
+    end
+  end
+end
+local function reserveQueue(listKey, processingKey, leaseKey)
+  local err = checkType(listKey, 'list') or checkType(processingKey, 'list') or checkType(leaseKey, 'hash')
+  if err then return err end
+  local payload = redis.call('LINDEX', listKey, -1)
+  if not payload then return nil end
+  local record = cjson.encode({strataReservation=1, id=reservationId, owner=owner, payload=payload})
+  local lease = cjson.encode({owner=owner, expiresAt=nowMs()+tonumber(visibility)})
+  redis.call('LPUSH', processingKey, record)
+  redis.call('HSET', leaseKey, reservationId, lease)
+  redis.call('RPOP', listKey)
+  return record
+end
+local count = #KEYS / 3
+if reclaim then
+  for i = 1, count do
+    local err = reclaimQueue(KEYS[(i - 1) * 3 + 1], KEYS[(i - 1) * 3 + 2], KEYS[(i - 1) * 3 + 3])
+    if err then return err end
+  end
+end
+for i = 1, count do
+  local record = reserveQueue(KEYS[(i - 1) * 3 + 1], KEYS[(i - 1) * 3 + 2], KEYS[(i - 1) * 3 + 3])
+  if type(record) == 'string' then return {'1', tostring(i), record} end
+  if record then return record end
+end
+return {'0'}
+`;
 function queueInvalidKey(queueKey) {
   return `${queueKey}:invalid`;
 }
-async function reserveQueueJob(client, queueKey, owner) {
-  const raw = await client.send("EVAL", [
-    RESERVE_JOB,
-    "3",
-    queueKey,
-    queueProcessingKey(queueKey),
-    queueProcessingLeaseKey(queueKey),
-    crypto.randomUUID(),
-    owner,
-    String(readQueueVisibilityMs())
-  ]);
-  if (typeof raw !== "string")
-    return null;
-  const reservation = JSON.parse(raw);
-  return { ...reservation, record: raw };
-}
 async function updateQueueReservation(client, queueKey, reservation, action) {
   return Number(await client.send("EVAL", [
     RENEW_OR_ACK,
@@ -14735,21 +14929,41 @@ async function updateQueueReservation(client, queueKey, reservation, action) {
     reservation.payload
   ])) === 1;
 }
-async function reclaimExpiredQueueReservations(client, queueKeys = QUEUE_KEYS) {
-  let reclaimed = 0;
+async function pollListPriorities(client, queueKeys, owner, reservationId, reclaim) {
+  const keys = [];
   for (const key of queueKeys) {
-    reclaimed += Number(await client.send("EVAL", [
-      RECLAIM_JOBS,
-      "3",
-      key,
-      queueProcessingKey(key),
-      queueProcessingLeaseKey(key),
-      String(readQueueVisibilityMs())
-    ]));
+    keys.push(key, queueProcessingKey(key), queueProcessingLeaseKey(key));
   }
-  return reclaimed;
+  const raw = await client.send("EVAL", [
+    POLL_LIST_PRIORITIES,
+    String(keys.length),
+    ...keys,
+    owner,
+    String(readQueueVisibilityMs()),
+    reservationId,
+    reclaim ? "1" : "0"
+  ]);
+  if (!Array.isArray(raw))
+    throw new Error("Invalid Redis list poll response");
+  const flag = String(raw[0]);
+  if (flag === "0") {
+    if (raw.length !== 1)
+      throw new Error("Invalid Redis list poll response");
+    return null;
+  }
+  if (flag !== "1" || raw.length !== 3)
+    throw new Error("Invalid Redis list poll response");
+  const index = Number(raw[1]);
+  const record = raw[2];
+  if (!Number.isInteger(index) || index < 1 || index > queueKeys.length || typeof record !== "string") {
+    throw new Error("Invalid Redis list poll response");
+  }
+  const queueKey = queueKeys[index - 1];
+  if (!queueKey)
+    throw new Error("Invalid Redis list poll response");
+  const reservation = JSON.parse(record);
+  return { queueKey, reservation: { ...reservation, record } };
 }
-
 class RedisQueue {
   client;
   constructor(redisUrl) {
@@ -14795,14 +15009,14 @@ class QueueWorker {
   }
   async reserve() {
     const deadline = performance.now() + this.timeoutSeconds * 1000;
+    let reclaim = true;
     do {
-      for (const key of this.queueKeys) {
-        if (this.stopping)
-          return null;
-        const reservation = await reserveQueueJob(this.client, key, this.owner);
-        if (reservation)
-          return { queueKey: key, reservation };
-      }
+      if (this.stopping)
+        return null;
+      const reserved = await pollListPriorities(this.client, this.queueKeys, this.owner, crypto.randomUUID(), reclaim);
+      reclaim = false;
+      if (reserved)
+        return reserved;
       if (this.stopping || performance.now() >= deadline)
         return null;
       await Bun.sleep(Math.min(100, Math.max(1, deadline - performance.now())));
@@ -14812,7 +15026,6 @@ class QueueWorker {
   async processNext() {
     if (this.stopping)
       return false;
-    await reclaimExpiredQueueReservations(this.client, this.queueKeys);
     const reserved = await this.reserve();
     if (!reserved)
       return false;
@@ -16579,6 +16792,7 @@ export {
   installGracefulShutdownSignals,
   isBlockedHostname,
   isBlockedIpAddress,
+  isDefaultDatabaseConnection,
   isEtagEnabled,
   isGlobalAdmin,
   isHtmxRequest,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getstrata/core",
-  "version": "2.2.14",
+  "version": "2.2.16",
   "description": "Strata Bun framework public API",
   "type": "module",
   "license": "MIT",