@holo-js/queue-db 0.1.4 → 0.1.5

package/dist/index.d.ts

@@ -20,7 +20,6 @@ type StoredFailedQueueJobRow = {
     exception: unknown;
     failed_at: unknown;
 };
-declare function isPlainObject(value: unknown): value is Record<string, unknown>;
 declare function assertQueueJsonValue(value: unknown, path: string, seen?: Set<unknown>): asserts value is QueueJsonValue;
 declare function normalizeIdentifierPath(value: string, label: string): string;
 declare function quoteIdentifierPath(dialect: Dialect, path: string): string;
@@ -34,7 +33,7 @@ declare function parseStoredQueueEnvelope(value: unknown): QueueJobEnvelope<Queu
 declare function parseStoredFailedQueueJobRow(row: StoredFailedQueueJobRow): QueueFailedJobRecord;
 declare function serializeQueueJson(value: unknown): string;
 declare function ensureConnectionReady(connection: DatabaseContext): Promise<DatabaseContext>;
-
+declare function resolveDatabaseConnection(name: string): DatabaseContext;
 declare const queueDatabaseInternals: {
     assertQueueJsonValue: typeof assertQueueJsonValue;
     coerceOptionalInteger: typeof coerceOptionalInteger;
@@ -42,13 +41,13 @@ declare const queueDatabaseInternals: {
     coerceRequiredString: typeof coerceRequiredString;
     createPlaceholderList: typeof createPlaceholderList;
     ensureConnectionReady: typeof ensureConnectionReady;
-    isPlainObject: typeof isPlainObject;
     normalizeIdentifierPath: typeof normalizeIdentifierPath;
     parseStoredFailedQueueJobRow: typeof parseStoredFailedQueueJobRow;
-    parseStoredQueueEnvelope: typeof parseStoredQueueEnvelope;
     parseStoredPayload: typeof parseStoredPayload;
+    parseStoredQueueEnvelope: typeof parseStoredQueueEnvelope;
     parseStoredQueueJobRow: typeof parseStoredQueueJobRow;
     quoteIdentifierPath: typeof quoteIdentifierPath;
+    resolveDatabaseConnection: typeof resolveDatabaseConnection;
     serializeQueueJson: typeof serializeQueueJson;
 };
 
@@ -58,6 +57,7 @@ declare class DatabaseQueueDriverError extends Error {
 }
 declare function wrapDatabaseError(connectionName: string, action: string, error: unknown): DatabaseQueueDriverError;
 declare function normalizeQueueNames(queueNames: readonly string[] | undefined, fallbackQueueName: string): readonly string[];
+declare function createPlaceholders(connection: DatabaseContext, count: number, startIndex?: number): readonly string[];
 declare class DatabaseQueueDriver implements QueueAsyncDriver {
     private readonly connection;
     private readonly context;
@@ -85,6 +85,7 @@ declare class DatabaseQueueDriver implements QueueAsyncDriver {
 }
 declare const databaseQueueDriverFactory: QueueDriverFactory<NormalizedQueueDatabaseConnectionConfig>;
 declare const databaseQueueDriverInternals: {
+    createPlaceholders: typeof createPlaceholders;
     normalizeDatabaseErrorMessage: typeof normalizeDatabaseErrorMessage;
     normalizeQueueNames: typeof normalizeQueueNames;
     wrapDatabaseError: typeof wrapDatabaseError;
@@ -95,10 +96,15 @@ declare function getFailedStoreConnection(): Promise<{
     connection: DatabaseContext;
     tableName: string;
 } | null>;
+declare function loadFailedJobs(failedStore: {
+    connection: DatabaseContext;
+    tableName: string;
+}, id?: string): Promise<readonly QueueFailedJobRecord[]>;
 declare const queueDbFailedJobStore: QueueFailedJobStore;
 declare const queueDbFailedStoreInternals: {
     getFailedStoreConfig: typeof getFailedStoreConfig;
     getFailedStoreConnection: typeof getFailedStoreConnection;
+    loadFailedJobs: typeof loadFailedJobs;
 };
 
 declare function createQueueDbRuntimeOptions(): Readonly<{

package/dist/index.mjs

@@ -1,4 +1,5 @@
 // src/database.ts
+import { connectionAsyncContext, DB } from "@holo-js/db";
 function isPlainObject(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     return false;
@@ -93,16 +94,16 @@ function parseStoredPayload(value, label) {
   return parsed;
 }
 function parseStoredQueueJobRow(row) {
-  return Object.freeze({
-    id: coerceRequiredString(row.id, "Stored queue job id"),
-    name: coerceRequiredString(row.job, "Stored queue job name"),
-    connection: coerceRequiredString(row.connection, "Stored queue job connection"),
-    queue: coerceRequiredString(row.queue, "Stored queue job queue"),
+  return parseStoredQueueEnvelope({
+    id: row.id,
+    name: row.job,
+    connection: row.connection,
+    queue: row.queue,
     payload: parseStoredPayload(row.payload, "Stored queue job payload"),
-    attempts: coerceRequiredInteger(row.attempts, "Stored queue job attempts"),
-    maxAttempts: coerceRequiredInteger(row.max_attempts, "Stored queue job max attempts"),
-    ...typeof row.available_at === "undefined" || row.available_at === null ? {} : { availableAt: coerceRequiredInteger(row.available_at, "Stored queue job availability") },
-    createdAt: coerceRequiredInteger(row.created_at, "Stored queue job creation time")
+    attempts: row.attempts,
+    maxAttempts: row.max_attempts,
+    availableAt: row.available_at,
+    createdAt: row.created_at
   });
 }
 function parseStoredQueueEnvelope(value) {
@@ -142,6 +143,13 @@ async function ensureConnectionReady(connection) {
   await connection.initialize();
   return connection;
 }
+function resolveDatabaseConnection(name) {
+  const active = connectionAsyncContext.getActive()?.connection;
+  if (active && active.getConnectionName() === name) {
+    return active;
+  }
+  return DB.connection(name);
+}
 var queueDatabaseInternals = {
   assertQueueJsonValue,
   coerceOptionalInteger,
@@ -149,20 +157,18 @@ var queueDatabaseInternals = {
   coerceRequiredString,
   createPlaceholderList,
   ensureConnectionReady,
-  isPlainObject,
   normalizeIdentifierPath,
   parseStoredFailedQueueJobRow,
-  parseStoredQueueEnvelope,
   parseStoredPayload,
+  parseStoredQueueEnvelope,
   parseStoredQueueJobRow,
   quoteIdentifierPath,
+  resolveDatabaseConnection,
   serializeQueueJson
 };
 
 // src/drivers/database.ts
 import { randomUUID } from "crypto";
-import { DB } from "@holo-js/db";
-import { connectionAsyncContext } from "@holo-js/db";
 function normalizeDatabaseErrorMessage(error) {
   if (error instanceof Error) {
     return error.message;
@@ -192,31 +198,24 @@ function normalizeQueueNames(queueNames, fallbackQueueName) {
   return Object.freeze(normalized.length > 0 ? normalized : [fallbackQueueName]);
 }
 function createPlaceholders(connection, count, startIndex = 1) {
-  return queueDatabaseInternals.createPlaceholderList(connection.getDialect(), count, startIndex).split(", ");
-}
-function resolveDatabaseConnection(name) {
-  const active = connectionAsyncContext.getActive()?.connection;
-  if (active && active.getConnectionName() === name) {
-    return active;
-  }
-  return DB.connection(name);
+  return createPlaceholderList(connection.getDialect(), count, startIndex).split(", ");
 }
 var DatabaseQueueDriver = class {
   constructor(connection, context) {
     this.connection = connection;
     this.context = context;
     this.name = connection.name;
-    this.tableName = queueDatabaseInternals.normalizeIdentifierPath(connection.table, "Queue table name");
+    this.tableName = normalizeIdentifierPath(connection.table, "Queue table name");
   }
   name;
   driver = "database";
   mode = "async";
   tableName;
   async getConnection() {
-    return queueDatabaseInternals.ensureConnectionReady(resolveDatabaseConnection(this.connection.connection));
+    return ensureConnectionReady(resolveDatabaseConnection(this.connection.connection));
   }
   getQuotedTable(connection) {
-    return queueDatabaseInternals.quoteIdentifierPath(connection.getDialect(), this.tableName);
+    return quoteIdentifierPath(connection.getDialect(), this.tableName);
   }
   getExpiredReservationCutoff(now) {
     return now - this.connection.retryAfter * 1e3;
@@ -225,7 +224,7 @@ var DatabaseQueueDriver = class {
     return Object.freeze({
       reservationId,
       reservedAt,
-      envelope: queueDatabaseInternals.parseStoredQueueJobRow(row)
+      envelope: parseStoredQueueJobRow(row)
     });
   }
   async dispatch(job) {
@@ -240,7 +239,7 @@ var DatabaseQueueDriver = class {
           job.name,
           job.connection,
           job.queue,
-          queueDatabaseInternals.serializeQueueJson(job.payload),
+          serializeQueueJson(job.payload),
           job.attempts,
           job.maxAttempts,
           job.availableAt ?? job.createdAt,
@@ -277,7 +276,7 @@ var DatabaseQueueDriver = class {
               break;
             }
             const reservationId = `${input.workerId}:${randomUUID()}`;
-            const nextAttempts = queueDatabaseInternals.coerceRequiredInteger(row.attempts, "Stored queue job attempts") + 1;
+            const nextAttempts = coerceRequiredInteger(row.attempts, "Stored queue job attempts") + 1;
             const [
               reservedAtPlaceholder,
               reservationPlaceholder,
@@ -378,6 +377,7 @@ var databaseQueueDriverFactory = {
   }
 };
 var databaseQueueDriverInternals = {
+  createPlaceholders,
   normalizeDatabaseErrorMessage,
   normalizeQueueNames,
   wrapDatabaseError
@@ -385,39 +385,49 @@ var databaseQueueDriverInternals = {
 
 // src/failed.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { DB as DB2 } from "@holo-js/db";
-import { connectionAsyncContext as connectionAsyncContext2 } from "@holo-js/db";
 import { getQueueRuntime } from "@holo-js/queue";
 function getFailedStoreConfig() {
   return getQueueRuntime().config.failed;
 }
-function resolveDatabaseConnection2(name) {
-  const active = connectionAsyncContext2.getActive()?.connection;
-  if (active && active.getConnectionName() === name) {
-    return active;
-  }
-  return DB2.connection(name);
-}
 async function getFailedStoreConnection() {
   const config = getFailedStoreConfig();
   if (config === false) {
     return null;
   }
-  const tableName = queueDatabaseInternals.normalizeIdentifierPath(config.table, "Failed jobs table name");
-  const connection = await queueDatabaseInternals.ensureConnectionReady(resolveDatabaseConnection2(config.connection));
+  const tableName = normalizeIdentifierPath(config.table, "Failed jobs table name");
+  const connection = await ensureConnectionReady(resolveDatabaseConnection(config.connection));
   return {
     connection,
     tableName
   };
 }
+async function loadFailedJobs(failedStore, id) {
+  const quotedTable = quoteIdentifierPath(failedStore.connection.getDialect(), failedStore.tableName);
+  const dialect = failedStore.connection.getDialect();
+  const filter = typeof id === "string" ? {
+    clause: ` WHERE id = ${dialect.createPlaceholder(1)}`,
+    bindings: [id],
+    source: "queue:failed:load"
+  } : {
+    clause: "",
+    bindings: void 0,
+    source: "queue:failed:list"
+  };
+  const result = await failedStore.connection.queryCompiled({
+    sql: `SELECT id, job_id, payload, exception, failed_at FROM ${quotedTable}${filter.clause} ORDER BY failed_at DESC, id DESC`,
+    bindings: filter.bindings,
+    source: filter.source
+  });
+  return Object.freeze(result.rows.map((row) => parseStoredFailedQueueJobRow(row)));
+}
 var queueDbFailedJobStore = {
   async persistFailedJob(reserved, error) {
     const failedStore = await getFailedStoreConnection();
     if (!failedStore) {
       return null;
     }
-    const quotedTable = queueDatabaseInternals.quoteIdentifierPath(failedStore.connection.getDialect(), failedStore.tableName);
-    const placeholders = queueDatabaseInternals.createPlaceholderList(failedStore.connection.getDialect(), 7);
+    const quotedTable = quoteIdentifierPath(failedStore.connection.getDialect(), failedStore.tableName);
+    const placeholders = createPlaceholderList(failedStore.connection.getDialect(), 7);
     const record = Object.freeze({
       id: randomUUID2(),
       jobId: reserved.envelope.id,
@@ -433,7 +443,7 @@ var queueDbFailedJobStore = {
         reserved.envelope.name,
         reserved.envelope.connection,
         reserved.envelope.queue,
-        queueDatabaseInternals.serializeQueueJson(reserved.envelope),
+        serializeQueueJson(reserved.envelope),
         record.exception,
         record.failedAt
       ],
@@ -446,28 +456,16 @@ var queueDbFailedJobStore = {
     if (!failedStore) {
       return Object.freeze([]);
     }
-    const quotedTable = queueDatabaseInternals.quoteIdentifierPath(failedStore.connection.getDialect(), failedStore.tableName);
-    const result = await failedStore.connection.queryCompiled({
-      sql: `SELECT id, job_id, payload, exception, failed_at FROM ${quotedTable} ORDER BY failed_at DESC, id DESC`,
-      source: "queue:failed:list"
-    });
-    return Object.freeze(result.rows.map((row) => queueDatabaseInternals.parseStoredFailedQueueJobRow(row)));
+    return loadFailedJobs(failedStore);
   },
   async retryFailedJobs(identifier, retry) {
     const failedStore = await getFailedStoreConnection();
     if (!failedStore) {
       return 0;
     }
-    const quotedTable = queueDatabaseInternals.quoteIdentifierPath(failedStore.connection.getDialect(), failedStore.tableName);
+    const quotedTable = quoteIdentifierPath(failedStore.connection.getDialect(), failedStore.tableName);
     const dialect = failedStore.connection.getDialect();
-    const records = await (identifier === "all" ? await this.listFailedJobs() : (() => {
-      const placeholder = dialect.createPlaceholder(1);
-      return failedStore.connection.queryCompiled({
-        sql: `SELECT id, job_id, payload, exception, failed_at FROM ${quotedTable} WHERE id = ${placeholder}`,
-        bindings: [identifier],
-        source: "queue:failed:load"
-      }).then((result) => Object.freeze(result.rows.map((row) => queueDatabaseInternals.parseStoredFailedQueueJobRow(row))));
-    })());
+    const records = await loadFailedJobs(failedStore, identifier === "all" ? void 0 : identifier);
     let retried = 0;
     for (const record of records) {
       await retry(record);
@@ -486,7 +484,7 @@ var queueDbFailedJobStore = {
     if (!failedStore) {
       return false;
     }
-    const quotedTable = queueDatabaseInternals.quoteIdentifierPath(failedStore.connection.getDialect(), failedStore.tableName);
+    const quotedTable = quoteIdentifierPath(failedStore.connection.getDialect(), failedStore.tableName);
     const placeholder = failedStore.connection.getDialect().createPlaceholder(1);
     const result = await failedStore.connection.executeCompiled({
       sql: `DELETE FROM ${quotedTable} WHERE id = ${placeholder}`,
@@ -500,7 +498,7 @@ var queueDbFailedJobStore = {
     if (!failedStore) {
       return 0;
     }
-    const quotedTable = queueDatabaseInternals.quoteIdentifierPath(failedStore.connection.getDialect(), failedStore.tableName);
+    const quotedTable = quoteIdentifierPath(failedStore.connection.getDialect(), failedStore.tableName);
     const result = await failedStore.connection.executeCompiled({
       sql: `DELETE FROM ${quotedTable}`,
       source: "queue:failed:flush"
@@ -510,7 +508,8 @@ var queueDbFailedJobStore = {
 };
 var queueDbFailedStoreInternals = {
   getFailedStoreConfig,
-  getFailedStoreConnection
+  getFailedStoreConnection,
+  loadFailedJobs
 };
 
 // src/runtime.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holo-js/queue-db",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Holo-JS Framework - DB-backed integrations for @holo-js/queue",
   "type": "module",
   "license": "MIT",
@@ -23,13 +23,13 @@
     "test": "vitest --run"
   },
   "dependencies": {
-    "@holo-js/db": "^0.1.4",
-    "@holo-js/queue": "^0.1.4"
+    "@holo-js/db": "^0.1.5",
+    "@holo-js/queue": "^0.1.5"
   },
   "devDependencies": {
     "@types/node": "^22.10.2",
     "tsup": "^8.3.5",
     "typescript": "^5.7.2",
-    "vitest": "^2.1.8"
+    "vitest": "^4.1.5"
   }
 }