@natlibfi/melinda-rest-api-commons 6.0.1 → 6.2.0-alpha.0

package/.github/workflows/melinda-node-tests-and-publish.yml

@@ -28,7 +28,6 @@ jobs:
         cache: 'npm'
       env:
         NPM_CONFIG_IGNORE_SCRIPTS: true
-    - run: npm update
     - run: npm audit --package-lock-only --production --audit-level=moderate
     - run: npm i
     - run: npm test
@@ -41,8 +40,11 @@ jobs:
 
     steps:
       - uses: actions/checkout@v7
-      - uses: mikaelvesavuori/license-compliance-action@v1
+      - uses: mikaelvesavuori/license-compliance-action@v1.0.3
         with:
+          # default action list + BlueOak-1.0.0 (sax, via xml2js in
+          # marc-record-serializers) + MIT-0 — OSI-approved permissive
+          allow_licenses: 'MIT;ISC;0BSD;BSD-2-Clause;BSD-3-Clause;Apache-2.0;BlueOak-1.0.0;MIT-0'
           exclude_pattern: /^@natlibfi/
 
   njsscan:

package/README.md

@@ -35,6 +35,56 @@ Shared modules for microservices of Melinda rest api import system
 
 *IMPORT_JOB_STATEs: EMPTY or IN_QUEUE, PROCESSING -> final: DONE, ERROR, ABORT
 
+#### Timeout (ABORT) contract
+
+A queue item that has not made progress for longer than the timeout window is
+set to `ABORT` (with `errorStatus` 408 and `errorMessage`
+`Timeout in <state>`). The window is the time since the last write to the
+item's `modificationTime` (each Mongo write done by the importer -
+`pushMessages`, `pushIds`, `addBlobSize`, `setBlobSize`, `setState`,
+`setImportJobState` - refreshes it). The window defaults to **1 minute** and
+can be made longer with the `MONGO_TIMEOUT_MINUTES` env var, which large bulk
+imports (see the CHUNK_SIZE benchmark below: ~9248 records / ~597 sec) may
+need:
+
+```sh
+MONGO_TIMEOUT_MINUTES=10 # abort only after 10 minutes without progress
+```
+
+#### Full `QUEUE_ITEM_STATE` reference
+
+The flow tables above show the happy-path sequence per service. The full set of `queueItemState` values (see `src/constants.ts`):
+
+| State | Group | Meaning |
+|-------|-------|---------|
+| `VALIDATOR.PENDING_QUEUING` | VALIDATOR | Bulk job accepted (http); waiting to be picked up for validation. |
+| `VALIDATOR.PENDING_VALIDATION` | VALIDATOR | Prio job accepted (http); waiting to be picked up for validation. |
+| `VALIDATOR.QUEUING_IN_PROGRESS` | VALIDATOR | Validator is distributing records to the per-operation import queues. |
+| `VALIDATOR.UPLOADING` | VALIDATOR | Stream-bulk upload in progress (records written to the GridFS blob). |
+| `VALIDATOR.VALIDATING` | VALIDATOR | Validator is validating records. |
+| `VALIDATOR.WAITING_FOR_RECORDS` | VALIDATOR | Stream-bulk job: partial records received, waiting for the remainder. |
+| `IMPORTER.IN_QUEUE` | IMPORTER | Records are queued for import, awaiting the importer. |
+| `IMPORTER.IMPORTING` | IMPORTER | Importer has the job and is importing it. |
+| `IMPORTER.IN_PROCESS` | IMPORTER | Importer is processing the job. |
+| `DONE` | terminal | Job completed successfully. |
+| `ERROR` | terminal | Job failed; see `errorStatus` / `errorMessage`. |
+| `ABORT` | terminal | Job aborted (e.g. timeout on a stalled job; `errorStatus` 408). |
+
+#### Full `IMPORT_JOB_STATE` reference
+
+Each queue item also carries a per-operation `importJobState` subdocument (`CREATE` / `UPDATE` / `FIX`). The full set of values:
+
+| State | Meaning |
+|-------|---------|
+| `EMPTY` | No such operation in the job (coalesced default when the subdocument is absent). |
+| `QUEUING` | Validator is queuing this operation's records. |
+| `IN_QUEUE` | This operation's records are queued for import. |
+| `IMPORTING` | Importer is importing this operation. |
+| `PROCESSING` | Importer is processing this operation (record-load). |
+| `DONE` | This operation completed. |
+| `ERROR` | This operation failed. |
+| `ABORT` | This operation aborted (e.g. timeout). |
+
 ### CHUNK_SIZE
 Chunck size to execution time ratio (From file to queue: ~450 records in 15sec)
 
@@ -63,6 +113,38 @@ Executed on test server using bridge to docker server and back to server
 | p_z07_priority_year | pZ07PriorityYear  | 1998        | 1990        | 2099        | 2099        | Override indexing priority                              |
 | p_redirection_field | pRedirectionField |             |             |             |             |                                                         |
 
+## TypeScript toolchain
+
+The source is TypeScript (Node >= 24, native type stripping for tests).
+
+- `npm run build` runs `tsc` (`tsconfig.json`): `src/` -> `dist/`, emitting
+  `.js` + `.js.map` + `.d.ts` + `.d.ts.map` for every module. The published
+  entry point stays `./dist/index.js`; the `.d.ts` files are additive for
+  TypeScript consumers.
+- `npm run typecheck` runs `tsc -p tsconfig.test.json` (typechecks `src/`
+  and `test/`, no emit).
+- `npm test` runs `npm run lint` then `npm run typecheck` then
+  `npm run test:base` (what CI runs).
+
+## Running the tests
+
+There are three test suites. The base suite runs anywhere; the two AMQP
+suites need a running RabbitMQ broker on `127.0.0.1:5672` (guest/guest) and
+are therefore excluded from the base glob and from CI. Tests are `.ts`
+files run directly by `node --test` (no loader).
+
+| Command                 | What it runs                                                        | Requirements          |
+|-------------------------|---------------------------------------------------------------------|-----------------------|
+| `npm run test:base`     | all `tests/**/*.test.ts` with coverage + thresholds                 | none                  |
+| `npm test`              | `npm run lint`, `npm run typecheck`, then `test:base` (what CI runs) | none                 |
+| `npm run test:local`    | `tests/amqp.*.localtest.ts`, AMQP operator against a live broker    | RabbitMQ on localhost |
+| `npm run test:healthcheck` | `tests/amqp.healthtest.ts`, healthCheck loop vs live broker      | RabbitMQ on localhost |
+
+`test:base` enforces minimum coverage thresholds via
+`--test-coverage-lines/--test-coverage-branches/--test-coverage-functions`
+(currently 88 / 88 / 90 over `src`); raise them in [`package.json`](package.json)
+as coverage grows.
+
 ## License and copyright
 
 Copyright (c) 2020-2026 **University Of Helsinki (The National Library Of Finland)**

package/dist/amqp.d.ts

@@ -0,0 +1,41 @@
+import { MarcRecord } from '@natlibfi/marc-record';
+import type { GetMessage, Message } from 'amqplib';
+export interface QueueItemRecordPayload {
+    headers: Record<string, unknown> | undefined;
+    records: MarcRecord[];
+    messages: Message[];
+}
+export interface QueueItemMessagePayload {
+    headers: Record<string, unknown> | undefined;
+    messages: Message[];
+}
+export interface CheckQueueParams {
+    queue: string;
+    style?: string;
+    toRecord?: boolean;
+    purge?: boolean;
+}
+export type CheckQueueResult = number | boolean | QueueItemMessagePayload | QueueItemRecordPayload | GetMessage;
+export interface SendToQueueParams {
+    queue?: string;
+    correlationId: string;
+    headers?: Record<string, unknown>;
+    data: unknown;
+}
+export interface AmqpOperator {
+    checkQueue: (params: CheckQueueParams) => Promise<CheckQueueResult>;
+    consumeChunk: (queue: string, toRecord: boolean) => Promise<false | QueueItemMessagePayload | QueueItemRecordPayload>;
+    consumeOne: (queue: string, toRecord: boolean) => Promise<false | GetMessage | QueueItemRecordPayload>;
+    ackMessages: (messages: Message[]) => void;
+    nackMessages: (messages: Message[]) => void;
+    sendToQueue: (params: SendToQueueParams) => Promise<void>;
+    removeQueue: (queue: string) => Promise<void>;
+    messagesToRecords: (messages: Message[]) => MarcRecord[];
+    closeChannel: () => Promise<void>;
+    closeConnection: () => Promise<void>;
+}
+export default function (AMQP_URL: string, runHealthCheck?: boolean, deps?: {
+    connection?: unknown;
+    channel?: unknown;
+}): Promise<AmqpOperator>;
+//# sourceMappingURL=amqp.d.ts.map

package/dist/amqp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"amqp.d.ts","sourceRoot":"","sources":["../src/amqp.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,UAAU,EAAC,MAAM,uBAAuB,CAAC;AAGjD,OAAO,KAAK,EAAwB,UAAU,EAAE,OAAO,EAAU,MAAM,SAAS,CAAC;AAcjF,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;IAC7C,OAAO,EAAE,UAAU,EAAE,CAAC;IACtB,QAAQ,EAAE,OAAO,EAAE,CAAC;CACrB;AAMD,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;IAC7C,QAAQ,EAAE,OAAO,EAAE,CAAC;CACrB;AAMD,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAOD,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,OAAO,GAAG,uBAAuB,GAAG,sBAAsB,GAAG,UAAU,CAAC;AAMhH,MAAM,WAAW,iBAAiB;IAChC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,IAAI,EAAE,OAAO,CAAC;CACf;AAKD,MAAM,WAAW,YAAY;IAC3B,UAAU,EAAE,CAAC,MAAM,EAAE,gBAAgB,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC;IACpE,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,KAAK,OAAO,CAAC,KAAK,GAAG,uBAAuB,GAAG,sBAAsB,CAAC,CAAC;IACtH,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,KAAK,OAAO,CAAC,KAAK,GAAG,UAAU,GAAG,sBAAsB,CAAC,CAAC;IACvG,WAAW,EAAE,CAAC,QAAQ,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;IAC3C,YAAY,EAAE,CAAC,QAAQ,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;IAC5C,WAAW,EAAE,CAAC,MAAM,EAAE,iBAAiB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1D,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9C,iBAAiB,EAAE,CAAC,QAAQ,EAAE,OAAO,EAAE,KAAK,UAAU,EAAE,CAAC;IACzD,YAAY,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAClC,eAAe,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACtC;AAiBD,yBAA+B,QAAQ,EAAE,MAAM,EAAE,cAAc,UAAQ,EAAE,IAAI,GAAE;IAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CA2ZpJ"}

package/dist/amqp.js

@@ -1,235 +1,259 @@
-import amqplib from "amqplib";
-import createDebugLogger from "debug";
-import { promisify, inspect } from "util";
-import httpStatus from "http-status";
-import { MarcRecord } from "@natlibfi/marc-record";
-import { Error as ApiError } from "@natlibfi/melinda-commons";
-import { createLogger } from "@natlibfi/melinda-backend-commons";
+import amqplib from 'amqplib';
+import createDebugLogger from 'debug';
+import { promisify, inspect } from 'util';
+import httpStatus from 'http-status';
+import { MarcRecord } from '@natlibfi/marc-record';
+import { createLogger, Error as ApiError } from '@natlibfi/melinda-commons';
 import { CHUNK_SIZE } from "./constants.js";
 import { logError } from "./utils.js";
-export default async function(AMQP_URL, runHealthCheck = false) {
-  const logger = createLogger();
-  const debug = createDebugLogger("@natlibfi/melinda-rest-api-commons:amqp");
-  const debugHC = debug.extend("HC");
-  const debugData = debug.extend("data");
-  const setTimeoutPromise = promisify(setTimeout);
-  debug(`Creating an AMQP operator to ${AMQP_URL}`);
-  const connection = await amqplib.connect(AMQP_URL);
-  const channel = await connection.createChannel();
-  const healthCheckLoop = runHealthCheck ? healthCheck() : false;
-  debug(`Connection: ${connection}`);
-  debug(`Channel: ${channel}`);
-  debug(`HealthCheckLoop: ${healthCheckLoop ? "Running health check" : "Not running health check"}`);
-  return { checkQueue, consumeChunk, consumeOne, ackMessages, nackMessages, sendToQueue, removeQueue, messagesToRecords, closeChannel, closeConnection };
-  async function closeChannel() {
-    debug(`Closing channel`);
-    await channel.close();
-    debug(`Channel: ${channel}`);
-  }
-  async function closeConnection() {
-    debug(`Closing connection`);
-    await connection.close();
+export default async function (AMQP_URL, runHealthCheck = false, deps = {}) {
+    const logger = createLogger();
+    const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons:amqp');
+    const debugHC = debug.extend('HC');
+    const debugData = debug.extend('data');
+    const setTimeoutPromise = promisify(setTimeout);
+    debug(`Creating an AMQP operator to ${AMQP_URL}`);
+    const connection = deps.connection ?? await amqplib.connect(AMQP_URL);
+    const channel = deps.channel ?? await connection.createChannel();
+    let healthCheckRunning = runHealthCheck;
+    const healthCheckLoop = runHealthCheck ? healthCheck() : false;
     debug(`Connection: ${connection}`);
-  }
-  async function healthCheck(wait = false) {
-    if (wait) {
-      await setTimeoutPromise(wait);
-      return healthCheck(false);
+    debug(`Channel: ${channel}`);
+    debug(`HealthCheckLoop: ${healthCheckLoop ? 'Running health check' : 'Not running health check'}`);
+    return { checkQueue, consumeChunk, consumeOne, ackMessages, nackMessages, sendToQueue, removeQueue, messagesToRecords, closeChannel, closeConnection };
+    async function closeChannel() {
+        healthCheckRunning = false;
+        debug(`Closing channel`);
+        await channel.close();
+        debug(`Channel: ${channel}`);
     }
-    try {
-      debugHC(`Health checking amqp by asserting a queue`);
-      await channel.assertQueue("HEALTHCHECK", { durable: false });
-      debugHC(`Waiting 200ms before running healthCheck next`);
-      return healthCheck(200);
-    } catch (error) {
-      debugHC(`HealthCheck error ${JSON.stringify(error)}`);
-      handleAmqpErrors(error);
+    async function closeConnection() {
+        healthCheckRunning = false;
+        debug(`Closing connection`);
+        await connection.close();
+        debug(`Connection: ${connection}`);
     }
-  }
-  async function checkQueue({ queue, style = "basic", toRecord = true, purge = false }) {
-    debug(`checkQueue: ${queue}, Style: ${style}, toRecord: ${toRecord}, Purge: ${purge}`);
-    try {
-      errorUndefinedQueue(queue);
-      const channelInfo = await channel.assertQueue(queue, { durable: true });
-      if (purge) {
-        await purgeQueue(purge);
-        logger.verbose(`Queue ${queue} has purged ${channelInfo.messageCount} messages`);
-        debug(`Queue ${queue} has purged ${channelInfo.messageCount} messages`);
-        return checkQueue({ queue, style });
-      }
-      if (style === "messages") {
-        return channelInfo.messageCount;
-      }
-      if (style === "one") {
-        if (checkMessageCount(channelInfo)) {
-          return consumeOne(queue, toRecord);
-        }
-        return false;
-      }
-      if (style === "basic") {
-        if (checkMessageCount(channelInfo)) {
-          return consumeChunk(queue, toRecord);
-        }
-        return false;
-      }
-      throw new ApiError(httpStatus.INTERNAL_SERVER_ERROR, `CheckQueue does not recognize style ${style}`);
-    } catch (error) {
-      handleAmqpErrors(error);
+    async function healthCheck(wait = false) {
+        if (!healthCheckRunning) {
+            debugHC(`HealthCheck cancelled, not running`);
+            return false;
+        }
+        if (wait) {
+            await setTimeoutPromise(wait);
+            return healthCheck(false);
+        }
+        try {
+            debugHC(`Health checking amqp by asserting a queue`);
+            await channel.assertQueue('HEALTHCHECK', { durable: false });
+            debugHC(`Waiting 200ms before running healthCheck next`);
+            return healthCheck(200);
+        }
+        catch (error) {
+            debugHC(`HealthCheck error ${JSON.stringify(error)}`);
+            if (!healthCheckRunning) {
+                debugHC(`HealthCheck cancelled while erroring, not throwing`);
+                return false;
+            }
+            handleAmqpErrors(error);
+        }
     }
-    function checkMessageCount(channelInfo) {
-      if (channelInfo.messageCount < 1) {
-        debug(`checkQueue: ${channelInfo.messageCount} - ${queue} is empty`);
-        return false;
-      }
-      debug(`Queue ${queue} has ${channelInfo.messageCount} messages`);
-      return true;
+    async function checkQueue({ queue, style = 'basic', toRecord = true, purge = false }) {
+        debug(`checkQueue: ${queue}, Style: ${style}, toRecord: ${toRecord}, Purge: ${purge}`);
+        try {
+            errorUndefinedQueue(queue);
+            const channelInfo = await channel.assertQueue(queue, { durable: true });
+            if (purge) {
+                await purgeQueue(purge);
+                logger.verbose(`Queue ${queue} has purged ${channelInfo.messageCount} messages`);
+                debug(`Queue ${queue} has purged ${channelInfo.messageCount} messages`);
+                return checkQueue({ queue, style });
+            }
+            if (style === 'messages') {
+                return channelInfo.messageCount;
+            }
+            if (style === 'one') {
+                if (checkMessageCount(channelInfo)) {
+                    return consumeOne(queue, toRecord);
+                }
+                return false;
+            }
+            if (style === 'basic') {
+                if (checkMessageCount(channelInfo)) {
+                    return consumeChunk(queue, toRecord);
+                }
+                return false;
+            }
+            throw new ApiError(httpStatus.INTERNAL_SERVER_ERROR, `CheckQueue does not recognize style ${style}`);
+        }
+        catch (error) {
+            handleAmqpErrors(error);
+        }
+        function checkMessageCount(channelInfo) {
+            if (channelInfo.messageCount < 1) {
+                debug(`checkQueue: ${channelInfo.messageCount} - ${queue} is empty`);
+                return false;
+            }
+            debug(`Queue ${queue} has ${channelInfo.messageCount} messages`);
+            return true;
+        }
+        function purgeQueue(purge) {
+            debug(`Purging queue: ${queue}, purge: ${purge}`);
+            if (purge) {
+                return channel.purgeQueue(queue);
+            }
+            return undefined;
+        }
     }
-    function purgeQueue(purge2) {
-      debug(`Purging queue: ${queue}, purge: ${purge2}`);
-      if (purge2) {
-        return channel.purgeQueue(queue);
-      }
+    async function consumeChunk(queue, toRecord) {
+        debug(`Prepared to consumeChunk from queue: ${queue}`);
+        try {
+            await channel.assertQueue(queue, { durable: true });
+            const messages = await getData(queue);
+            if (messages.length === 0) {
+                debug(`consumeChunk: queue ${queue} drained, returning false`);
+                return false;
+            }
+            const headers = getHeaderInfo(messages[0]);
+            debug(`consumeChunk (${messages ? messages.length : '0'} from queue ${queue}) ${toRecord ? 'to records' : 'just messages'}`);
+            if (toRecord) {
+                const records = messagesToRecords(messages);
+                return { headers, records, messages };
+            }
+            return { headers, messages };
+        }
+        catch (error) {
+            handleAmqpErrors(error);
+        }
     }
-  }
-  async function consumeChunk(queue, toRecord) {
-    debug(`Prepared to consumeChunk from queue: ${queue}`);
-    try {
-      await channel.assertQueue(queue, { durable: true });
-      const messages = await getData(queue);
-      const headers = getHeaderInfo(messages[0]);
-      debug(`consumeChunk (${messages ? messages.length : "0"} from queue ${queue}) ${toRecord ? "to records" : "just messages"}`);
-      if (toRecord) {
-        const records = await messagesToRecords(messages);
-        return { headers, records, messages };
-      }
-      return { headers, messages };
-    } catch (error) {
-      handleAmqpErrors(error);
+    async function consumeOne(queue, toRecord) {
+        debug(`Prepared to consumeOne from queue: ${queue}`);
+        try {
+            await channel.assertQueue(queue, { durable: true });
+            const message = await channel.get(queue);
+            debugData(`Message: ${inspect(message, { colors: true, maxArrayLength: 3, depth: 3 })}`);
+            debug(`consumeOne from queue: ${queue} ${toRecord ? 'to records' : 'just the message'}`);
+            if (message) {
+                if (toRecord) {
+                    const headers = getHeaderInfo(message);
+                    const records = messagesToRecords([message]);
+                    return { headers, records, messages: [message] };
+                }
+                return message;
+            }
+            return false;
+        }
+        catch (error) {
+            handleAmqpErrors(error);
+        }
+    }
+    function ackMessages(messages) {
+        messages.forEach(message => {
+            debug(`Ack message ${message.properties.correlationId}`);
+            channel.ack(message);
+        });
+    }
+    function nackMessages(messages) {
+        messages.forEach(message => {
+            debug(`Nack message ${message.properties.correlationId}`);
+            channel.nack(message);
+        });
     }
-  }
-  async function consumeOne(queue, toRecord) {
-    debug(`Prepared to consumeOne from queue: ${queue}`);
-    try {
-      await channel.assertQueue(queue, { durable: true });
-      const message = await channel.get(queue);
-      debugData(`Message: ${inspect(message, { colors: true, maxArrayLength: 3, depth: 3 })}`);
-      debug(`consumeOne from queue: ${queue} ${toRecord ? "to records" : "just the message"}`);
-      if (message) {
-        if (toRecord) {
-          const headers = getHeaderInfo(message);
-          const records = messagesToRecords([message]);
-          return { headers, records, messages: [message] };
-        }
-        return message;
-      }
-      return false;
-    } catch (error) {
-      handleAmqpErrors(error);
+    async function sendToQueue({ queue, correlationId, headers, data }) {
+        debug(`sendToQueue`);
+        try {
+            debug(`Queue ${queue}`);
+            debug(`CorrelationId ${correlationId}`);
+            debugData(`Data ${JSON.stringify(data)}`);
+            debug(`Headers ${JSON.stringify(headers)}`);
+            errorUndefinedQueue(queue);
+            debug(`Asserting queue: ${queue}`);
+            await channel.assertQueue(queue, { durable: true });
+            debug(`Actually sendToQueue: ${queue}`);
+            await channel.sendToQueue(queue, Buffer.from(JSON.stringify({ data })), {
+                correlationId,
+                persistent: true,
+                headers
+            });
+            debug(`Send message for ${correlationId} to queue: ${queue}`);
+        }
+        catch (error) {
+            const errorToThrow = error;
+            debug(`SendToQueue errored: ${JSON.stringify(error)}`);
+            handleAmqpErrors(errorToThrow);
+        }
     }
-  }
-  function ackMessages(messages) {
-    messages.forEach((message) => {
-      debug(`Ack message ${message.properties.correlationId}`);
-      channel.ack(message);
-    });
-  }
-  function nackMessages(messages) {
-    messages.forEach((message) => {
-      debug(`Nack message ${message.properties.correlationId}`);
-      channel.nack(message);
-    });
-  }
-  async function sendToQueue({ queue, correlationId, headers, data }) {
-    debug(`sendToQueue`);
-    try {
-      debug(`Queue ${queue}`);
-      debug(`CorrelationId ${correlationId}`);
-      debugData(`Data ${JSON.stringify(data)}`);
-      debug(`Headers ${JSON.stringify(headers)}`);
-      errorUndefinedQueue(queue);
-      debug(`Asserting queue: ${queue}`);
-      await channel.assertQueue(queue, { durable: true });
-      debug(`Actually sendToQueue: ${queue}`);
-      await channel.sendToQueue(
-        queue,
-        Buffer.from(JSON.stringify({ data })),
-        {
-          correlationId,
-          persistent: true,
-          headers
-        }
-      );
-      debug(`Send message for ${correlationId} to queue: ${queue}`);
-    } catch (error) {
-      const errorToThrow = error;
-      debug(`SendToQueue errored: ${JSON.stringify(error)}`);
-      handleAmqpErrors(errorToThrow);
+    async function removeQueue(queue) {
+        let tempChannel;
+        try {
+            tempChannel = await connection.createChannel();
+            logger.verbose(`Removing queue ${queue}.`);
+            debug(`Removing queue ${queue}.`);
+            await tempChannel.deleteQueue(queue);
+        }
+        finally {
+            if (tempChannel) {
+                await tempChannel.close();
+            }
+        }
     }
-  }
-  async function removeQueue(queue) {
-    const tempChannel = await connection.createChannel();
-    logger.verbose(`Removing queue ${queue}.`);
-    debug(`Removing queue ${queue}.`);
-    await tempChannel.deleteQueue(queue);
-    if (tempChannel) {
-      await tempChannel.close();
-      return;
+    function messagesToRecords(messages) {
+        debug(`Parsing messages (${messages.length}) to records`);
+        return messages.map(message => {
+            const content = JSON.parse(message.content.toString());
+            return new MarcRecord(content.data, { subfieldValues: false });
+        });
     }
-    return;
-  }
-  function messagesToRecords(messages) {
-    debug(`Parsing messages (${messages.length}) to records`);
-    return messages.map((message) => {
-      const content = JSON.parse(message.content.toString());
-      return new MarcRecord(content.data, { subfieldValues: false });
-    });
-  }
-  async function getData(queue) {
-    debug(`Getting queue data from ${queue}`);
-    try {
-      const { messageCount } = await channel.checkQueue(queue);
-      debug(`There is ${messageCount} messages in queue ${queue}`);
-      const messagesToGet = messageCount >= CHUNK_SIZE ? CHUNK_SIZE : messageCount;
-      debug(`Getting ${messagesToGet} messages from queue ${queue}`);
-      const messages = await pump(messagesToGet);
-      debug(`Returning ${messages.length} unique messages`);
-      return messages;
-    } catch (error) {
-      handleAmqpErrors(error);
+    async function getData(queue) {
+        debug(`Getting queue data from ${queue}`);
+        try {
+            const { messageCount } = await channel.checkQueue(queue);
+            debug(`There is ${messageCount} messages in queue ${queue}`);
+            const messagesToGet = messageCount >= CHUNK_SIZE ? CHUNK_SIZE : messageCount;
+            debug(`Getting ${messagesToGet} messages from queue ${queue}`);
+            const messages = await pump(messagesToGet);
+            debug(`Returning ${messages.length} unique messages`);
+            return messages;
+        }
+        catch (error) {
+            handleAmqpErrors(error);
+        }
+        async function pump(count, results = [], identifiers = []) {
+            if (count === 0) {
+                return results;
+            }
+            const message = await channel.get(queue);
+            if (!message) {
+                return results;
+            }
+            const identifier = {
+                correlationId: message.properties.correlationId,
+                deliveryTag: message.fields.deliveryTag
+            };
+            const isDuplicate = identifiers.some(i => i.correlationId === identifier.correlationId && i.deliveryTag === identifier.deliveryTag);
+            if (isDuplicate) {
+                return pump(count - 1, results, identifiers);
+            }
+            return pump(count - 1, results.concat(message), identifiers.concat(identifier));
+        }
     }
-    async function pump(count, results = [], identifiers = []) {
-      if (count === 0) {
-        return results;
-      }
-      const message = await channel.get(queue);
-      const identifier = {
-        correlationId: message.properties.correlationId,
-        deliveryTag: message.fields.deliveryTag
-      };
-      if (identifiers.includes(identifier)) {
-        return pump(count - 1, results, identifiers);
-      }
-      return pump(count - 1, results.concat(message), identifiers.concat(identifier));
+    function getHeaderInfo(data) {
+        return data.properties.headers;
     }
-  }
-  function getHeaderInfo(data) {
-    return data.properties.headers;
-  }
-  function errorUndefinedQueue(queue) {
-    if (queue === void 0 || queue === "" || queue === null) {
-      throw new ApiError(httpStatus.INTERNAL_SERVER_ERROR, `Undefined queue!`);
+    function errorUndefinedQueue(queue) {
+        if (queue === undefined || queue === '' || queue === null) {
+            throw new ApiError(httpStatus.INTERNAL_SERVER_ERROR, `Undefined queue!`);
+        }
     }
-  }
-  function handleAmqpErrors(error) {
-    const newError = error;
-    debug(`HandleAmqpErrors got an error: ${JSON.stringify(error)}`);
-    if (error instanceof ApiError) {
-      debug(`We have an ApiError`);
-      throw new ApiError(newError.status, newError.payload);
+    function handleAmqpErrors(error) {
+        const newError = error;
+        debug(`HandleAmqpErrors got an error: ${JSON.stringify(error)}`);
+        if (error instanceof ApiError) {
+            debug(`We have an ApiError`);
+            throw new ApiError(error.status, error.payload);
+        }
+        debug(`We have a non-ApiError`);
+        logError(error);
+        throw newError;
     }
-    debug(`We have a non-ApiError`);
-    logError(error);
-    throw newError;
-  }
 }
-//# sourceMappingURL=amqp.js.map
+//# sourceMappingURL=amqp.js.map