amqplib 2.1.0 → 2.2.1

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Change log for amqplib
 
+## v2.2.1
+- Return the server acknowledgement from promise-based `channel.cancel`, matching the callback API (thanks [@edsonsims](https://github.com/edsonsims)).
+- Type `cancel` replies as `Replies.Cancel` (`{ consumerTag }`) in both the promise and callback API declarations, which previously claimed `Replies.Empty`.
+- Fix callback-based `waitForConfirms` never calling back when invoked after the confirm channel closed with unconfirmed messages; it now yields a `channel closed` error, matching the promise API (thanks [@youdie006](https://github.com/youdie006)).
+- `waitForConfirms` (both APIs) now always fails with `channel closed` after the channel closes with unconfirmed messages. Previously it reported success if every outstanding message had its own callback, or on any call after the first.
+- The callback API's `waitForConfirms` callback is now required in the TypeScript declarations, matching the docs. Calling it without one threw at runtime.
+- Replace `.npmignore` with a `files` allowlist in `package.json` so the published package no longer includes tests, tooling config, dotfiles or the defs generator. Install size drops from 577 kB to 358 kB (fixes #859, thanks [@rubiesonthesky](https://github.com/rubiesonthesky))
+
+## v2.2.0
+- Add `calculateDelay` recovery option for supplying a custom reconnect delay strategy, e.g. full jitter, decorrelated jitter or a fixed schedule. When set, `maxDelay` is not applied to its return value; when it throws or returns an invalid value, recovery gives up as if `maxRetries` were exhausted (fixes #855, thanks [@GiHoon1123](https://github.com/GiHoon1123))
+- The built-in reconnect delay no longer exceeds `maxDelay`. Previously the cap was applied before jitter, so delays could overshoot it by up to the jitter fraction. The exponential base is now capped at `maxDelay / (1 + jitter)` so the full jitter range fits under the cap; with default settings the steady-state delay is now spread over 20-30s rather than 24-36s
+- Channel operations attempted after recovery has given up (`reconnect-failed`) now reject with the failure instead of waiting forever
+- Add `initialMaxRetries` recovery option to bound retries before the first successful connection separately from `maxRetries`, so startup can fail fast while steady-state recovery retries indefinitely (fixes #856)
+
 ## v2.1.0
 - Add `waitForConnect` recovery option. When `false`, `connect` returns the recovering connection immediately instead of waiting for the first successful connection, so listeners for `connect`, `connect-failed` and `reconnect-scheduled` can be attached before the initial attempt, and `close()` can cancel it. Expose `waitForConnect()` on recovering connections to await the first connection (fixes #858)
 - Fix `setup` being run when `close()` is called while the initial connection attempt is in flight

package/README.md

@@ -210,6 +210,60 @@ callback is invoked immediately with the handle instead of after the first
 connection, and `waitForConnect(callback)` can be used to be notified once
 connected.
 
+### Custom delay strategy
+
+By default, reconnect delays follow an exponential backoff with jitter,
+controlled by `initialDelay`, `maxDelay`, `factor` and `jitter`. To use a
+different strategy entirely (full jitter, decorrelated jitter, a fixed step
+schedule, etc.), provide a `calculateDelay` function instead:
+
+```javascript
+const connection = await amqplib.connect('amqp://localhost', {
+  recovery: {
+    maxRetries: Infinity,
+    // Called with the reconnect attempt number, starting at 1.
+    // Must return the delay in milliseconds.
+    calculateDelay(attempt) {
+      return Math.min(30000, 100 * 2 ** (attempt - 1));
+    },
+  },
+});
+```
+
+`maxDelay` only bounds the built-in strategy. Once you provide `calculateDelay`,
+amqplib does not cap its return value - you're responsible for enforcing your
+own maximum, as the example above does with `Math.min`.
+
+When `calculateDelay` is absent, the built-in strategy is used. If it throws,
+or returns something other than a finite, non-negative number, amqplib does
+not fall back to the built-in strategy. Instead recovery gives up as if
+`maxRetries` had been exhausted: the initial `connect` rejects (or the
+callback receives the error), pending channel operations reject, and
+`reconnect-failed` is emitted with the error. A broken `calculateDelay` is a
+bug in caller-supplied code, so it is surfaced rather than papered over.
+
+### Separate retry budget for the initial connection
+
+By default `maxRetries` bounds every phase of recovery, including the attempts
+made before the first connection succeeds. To give the very first connection
+its own budget, set `initialMaxRetries`; once connected, `maxRetries` applies.
+A common production posture is to fail fast at startup, so a misconfigured or
+unreachable broker fails the deployment, while never giving up on a service
+that has already connected:
+
+```javascript
+const connection = await amqplib.connect('amqp://localhost', {
+  recovery: {
+    initialMaxRetries: 5, // give up (and reject connect) after 5 failed retries at startup
+    maxRetries: Infinity, // but keep reconnecting forever once connected
+  },
+});
+```
+
+When the initial budget is exhausted `connect` rejects (or the callback receives
+the error) and `reconnect-failed` is emitted. `initialMaxRetries` defaults to
+`maxRetries`, so behaviour is unchanged unless it is set.
+
 ## Error handling in event handlers
 
 If a user-supplied event handler throws a synchronous error, the throw will

package/callback_api.d.ts

@@ -103,7 +103,7 @@ export interface Channel extends events.EventEmitter {
     callback?: (err: Error, ok: Replies.Consume) => void,
   ): void;
 
-  cancel(consumerTag: string, callback?: (err: Error, ok: Replies.Empty) => void): void;
+  cancel(consumerTag: string, callback?: (err: Error, ok: Replies.Cancel) => void): void;
   get(queue: string, options?: Options.Get, callback?: (err: Error, ok: GetMessage | false) => void): void;
 
   ack(message: Message, allUpTo?: boolean): void;
@@ -132,7 +132,7 @@ export interface ConfirmChannel extends Channel {
     callback?: (err: Error, ok: Replies.Empty) => void,
   ): boolean;
 
-  waitForConfirms(callback?: (err?: Error) => void): void;
+  waitForConfirms(callback: (err?: Error) => void): void;
 }
 
 export declare class IllegalOperationError extends Error {
@@ -169,8 +169,15 @@ export interface RecoveryOptions {
   factor?: number;
   /** Jitter factor (0–1) applied to delay to avoid thundering herd. Default: 0.2 */
   jitter?: number;
-  /** Maximum number of reconnect attempts. Default: Infinity */
+  /** Maximum number of reconnect attempts. Also bounds the initial connection unless `initialMaxRetries` is set. Default: Infinity */
   maxRetries?: number;
+  /**
+   * Maximum number of retries before the first successful connection. Once
+   * connected, `maxRetries` applies instead. Lets startup fail fast against an
+   * unreachable broker while steady-state recovery keeps retrying.
+   * Default: the value of `maxRetries`
+   */
+  initialMaxRetries?: number;
   /** Optional setup function called after each successful connection */
   setup?: ((model: Connection) => Promise<void>) | ((model: Connection, done: (err?: Error) => void) => void);
   /**
@@ -179,6 +186,15 @@ export interface RecoveryOptions {
    * Use `waitForConnect()` to be notified of the first connection. Default: true
    */
   waitForConnect?: boolean;
+  /**
+   * Optional custom delay strategy. Called with the reconnect attempt number
+   * (starting at 1) and must return the delay in milliseconds. Falls back to
+   * the built-in exponential-backoff-with-jitter strategy when absent. If it
+   * throws, or returns something other than a finite, non-negative number,
+   * recovery gives up as if `maxRetries` were exhausted: the initial connection
+   * fails with the error and `reconnect-failed` is emitted.
+   */
+  calculateDelay?: (attempt: number) => number;
 }
 
 export interface RecoveringConnection extends events.EventEmitter {

package/index.d.ts

@@ -77,7 +77,7 @@ export interface Channel extends events.EventEmitter {
     options?: Options.Consume,
   ): Promise<Replies.Consume>;
 
-  cancel(consumerTag: string): Promise<Replies.Empty>;
+  cancel(consumerTag: string): Promise<Replies.Cancel>;
   get(queue: string, options?: Options.Get): Promise<GetMessage | false>;
 
   ack(message: Message, allUpTo?: boolean): void;
@@ -143,8 +143,15 @@ export interface RecoveryOptions {
   factor?: number;
   /** Jitter factor (0–1) applied to delay to avoid thundering herd. Default: 0.2 */
   jitter?: number;
-  /** Maximum number of reconnect attempts. Default: Infinity */
+  /** Maximum number of reconnect attempts. Also bounds the initial connection unless `initialMaxRetries` is set. Default: Infinity */
   maxRetries?: number;
+  /**
+   * Maximum number of retries before the first successful connection. Once
+   * connected, `maxRetries` applies instead. Lets startup fail fast against an
+   * unreachable broker while steady-state recovery keeps retrying.
+   * Default: the value of `maxRetries`
+   */
+  initialMaxRetries?: number;
   /** Optional setup function called after each successful connection */
   setup?: ((model: ChannelModel) => Promise<void>) | ((model: ChannelModel, done: (err?: Error) => void) => void);
   /**
@@ -154,6 +161,15 @@ export interface RecoveryOptions {
    * first connection. Default: true
    */
   waitForConnect?: boolean;
+  /**
+   * Optional custom delay strategy. Called with the reconnect attempt number
+   * (starting at 1) and must return the delay in milliseconds. Falls back to
+   * the built-in exponential-backoff-with-jitter strategy when absent. If it
+   * throws, or returns something other than a finite, non-negative number,
+   * recovery gives up as if `maxRetries` were exhausted: the initial connection
+   * fails with the error and `reconnect-failed` is emitted.
+   */
+  calculateDelay?: (attempt: number) => number;
 }
 
 export interface RecoveringChannelModel extends events.EventEmitter {

package/lib/callback_model.js

@@ -255,28 +255,9 @@ class ConfirmChannel extends Channel {
   }
 
   waitForConfirms(k) {
-    const awaiting = [];
-    const unconfirmed = this.unconfirmed;
-    unconfirmed.forEach((val, index) => {
-      if (val === null); // already confirmed
-      else {
-        const confirmed = new Promise((resolve, reject) => {
-          unconfirmed[index] = (err) => {
-            if (val) val(err);
-            if (err === null) resolve();
-            else reject(err);
-          };
-        });
-        awaiting.push(confirmed);
-      }
-    });
-    return Promise.all(awaiting).then(
-      () => {
-        k();
-      },
-      (err) => {
-        k(err);
-      },
+    this._waitForConfirms().then(
+      () => k(),
+      (err) => k(err),
     );
   }
 }

package/lib/channel.js

@@ -21,6 +21,7 @@ class Channel extends EventEmitter {
     // for unconfirmed messages
     this.lwm = 1; // the least, unconfirmed deliveryTag
     this.unconfirmed = []; // rolling window of delivery callbacks
+    this.closedWithUnconfirmed = false;
     this.on(
       'ack',
       this.handleConfirm.bind(this, (cb) => {
@@ -39,7 +40,10 @@ class Channel extends EventEmitter {
         const cb = this.unconfirmed[i];
         if (cb) cb(err);
       }
-      this.unconfirmed = this.unconfirmed.filter((cb) => cb === false);
+      // Remember that confirms were lost, so every later waitForConfirms
+      // fails, whether or not the messages had their own callbacks
+      this.closedWithUnconfirmed = this.unconfirmed.some((cb) => cb !== null);
+      this.unconfirmed = [];
     });
     // message frame state machine
     this.handleMessage = acceptDeliveryOrReturn;
@@ -243,6 +247,28 @@ class Channel extends EventEmitter {
     }
   }
 
+  // Resolves once every outstanding message is confirmed, and rejects on
+  // the first nack, or if the channel closes before all are confirmed.
+  // Shared by the promise and callback ConfirmChannel#waitForConfirms.
+  _waitForConfirms() {
+    if (this.closedWithUnconfirmed) return Promise.reject(new Error('channel closed'));
+    const awaiting = [];
+    const unconfirmed = this.unconfirmed;
+    unconfirmed.forEach((cb, index) => {
+      if (cb !== null) {
+        const confirmed = new Promise((resolve, reject) => {
+          unconfirmed[index] = (err) => {
+            if (cb) cb(err);
+            if (err === null) resolve();
+            else reject(err);
+          };
+        });
+        awaiting.push(confirmed);
+      }
+    });
+    return Promise.all(awaiting);
+  }
+
   pushConfirmCallback(cb) {
     // `null` is used specifically for marking already confirmed slots,
     // so I coerce `undefined` and `null` to false; functions are never

package/lib/channel_model.js

@@ -146,12 +146,9 @@ class Channel extends BaseChannel {
   }
 
   async cancel(consumerTag) {
-    await promisify((cb) => {
-      this._rpc(defs.BasicCancel, Args.cancel(consumerTag), defs.BasicCancelOk, cb);
-    })().then((ok) => {
-      this.unregisterConsumer(consumerTag);
-      return ok.fields;
-    });
+    const fields = await this.rpc(defs.BasicCancel, Args.cancel(consumerTag), defs.BasicCancelOk);
+    this.unregisterConsumer(consumerTag);
+    return fields;
   }
 
   get(queue, options) {
@@ -234,29 +231,7 @@ class ConfirmChannel extends Channel {
   }
 
   waitForConfirms() {
-    const awaiting = [];
-    const unconfirmed = this.unconfirmed;
-    unconfirmed.forEach((cb, index) => {
-      if (cb !== null) {
-        const confirmed = new Promise((resolve, reject) => {
-          unconfirmed[index] = (err) => {
-            if (cb) cb(err);
-            if (err === null) resolve();
-            else reject(err);
-          };
-        });
-        awaiting.push(confirmed);
-      }
-    });
-    // Channel closed
-    if (!this.pending) {
-      const err = new Error('channel closed');
-      while (unconfirmed.length > 0) {
-        const cb = unconfirmed.shift();
-        if (cb) cb(err);
-      }
-    }
-    return Promise.all(awaiting);
+    return this._waitForConfirms();
   }
 }
 

package/lib/properties.d.ts

@@ -19,6 +19,9 @@ export namespace Replies {
   interface Consume {
     consumerTag: string;
   }
+  interface Cancel {
+    consumerTag: string;
+  }
 }
 
 export namespace Options {

package/lib/recovery.js

@@ -8,6 +8,7 @@ const DEFAULT_RECOVERY = {
   maxRetries: Infinity,
   setup: null,
   waitForConnect: true,
+  calculateDelay: null,
 };
 
 function splitConnectionOptions(connOptions) {
@@ -43,22 +44,32 @@ function toFiniteNumber(value, fallback) {
   return Number.isFinite(n) ? n : fallback;
 }
 
+function toRetryCount(value, fallback) {
+  if (value == null) return fallback;
+  if (value === Infinity) return Infinity;
+  const n = toFiniteNumber(value, fallback);
+  return n < 0 ? 0 : n;
+}
+
 function normaliseRecoveryOptions(recovery) {
   const source = recovery === true ? {} : recovery || {};
   const initialDelay = Math.max(0, toFiniteNumber(source.initialDelay, DEFAULT_RECOVERY.initialDelay));
   const maxDelay = Math.max(initialDelay, toFiniteNumber(source.maxDelay, DEFAULT_RECOVERY.maxDelay));
   const factor = Math.max(1, toFiniteNumber(source.factor, DEFAULT_RECOVERY.factor));
   const jitter = Math.min(1, Math.max(0, toFiniteNumber(source.jitter, DEFAULT_RECOVERY.jitter)));
-  const parsedMaxRetries = source.maxRetries == null ? Infinity : toFiniteNumber(source.maxRetries, Infinity);
+  const maxRetries = toRetryCount(source.maxRetries, Infinity);
+  const initialMaxRetries = toRetryCount(source.initialMaxRetries, maxRetries);
 
   return {
     initialDelay,
     maxDelay,
     factor,
     jitter,
-    maxRetries: parsedMaxRetries < 0 ? 0 : parsedMaxRetries,
+    maxRetries,
+    initialMaxRetries,
     setup: typeof source.setup === 'function' ? source.setup : null,
     waitForConnect: source.waitForConnect !== false,
+    calculateDelay: typeof source.calculateDelay === 'function' ? source.calculateDelay : null,
   };
 }
 
@@ -67,13 +78,39 @@ function toError(err, fallbackMessage) {
   return new Error(err ? String(err) : fallbackMessage);
 }
 
-function calculateDelay(recovery, attempt) {
-  const base = Math.min(recovery.maxDelay, recovery.initialDelay * recovery.factor ** (attempt - 1));
+function calculateBuiltinDelay(recovery, attempt) {
+  // Capping the base at maxDelay and then clamping base+offset to maxDelay
+  // would put a point mass on maxDelay itself: once base saturates, every
+  // positive jitter draw (half of them) collapses onto the same value,
+  // defeating the point of jitter. Capping the base at
+  // maxDelay / (1 + jitter) instead means the maximum possible offset
+  // lands exactly on maxDelay, so the result never exceeds it without
+  // needing a final clamp - the distribution stays smooth right up to the cap.
+  const cappedBase = recovery.maxDelay / (1 + recovery.jitter);
+  const base = Math.min(cappedBase, recovery.initialDelay * recovery.factor ** (attempt - 1));
   const jitterPart = base * recovery.jitter;
   const offset = jitterPart > 0 ? Math.random() * jitterPart * 2 - jitterPart : 0;
   return Math.max(0, Math.round(base + offset));
 }
 
+// A custom `calculateDelay` that throws, or returns something other than a
+// finite, non-negative number, is a bug in caller-supplied code. Rather than
+// silently falling back to the built-in strategy, the error is treated as a
+// terminal recovery failure by the caller (see _scheduleReconnect), so it
+// surfaces immediately instead of manifesting as unexplained delay behavior.
+function calculateDelay(recovery, attempt) {
+  if (!recovery.calculateDelay) {
+    return calculateBuiltinDelay(recovery, attempt);
+  }
+
+  const custom = recovery.calculateDelay(attempt);
+  if (typeof custom === 'number' && Number.isFinite(custom) && custom >= 0) {
+    return Math.round(custom);
+  }
+
+  throw new Error(`calculateDelay must return a finite, non-negative number of milliseconds (got ${String(custom)})`);
+}
+
 function runSetup(setup, model) {
   if (!setup) return Promise.resolve();
 
@@ -118,6 +155,8 @@ class RecoveringCore extends EventEmitter {
     this._waiters = [];
     this._connecting = false;
     this._stopped = false;
+    this._failure = null;
+    this._connectedOnce = false;
     this._timer = null;
     this._attempt = 0;
 
@@ -205,7 +244,7 @@ class RecoveringCore extends EventEmitter {
 
   _waitForConnection() {
     if (this._model) return Promise.resolve(this._model);
-    if (this._stopped) return Promise.reject(new Error('Connection closed'));
+    if (this._stopped) return Promise.reject(this._failure || new Error('Connection closed'));
 
     return new Promise((resolve, reject) => {
       this._waiters.push({ resolve, reject });
@@ -277,6 +316,7 @@ class RecoveringCore extends EventEmitter {
 
       this._model = model;
       this._attempt = 0;
+      this._connectedOnce = true;
       this._bindModel(model);
       this._resolveInitialConnection();
       this._resolvePendingWaiters(model);
@@ -296,15 +336,24 @@ class RecoveringCore extends EventEmitter {
 
     if (this._timer) return;
 
-    if (this._attempt >= this._recovery.maxRetries) {
-      this._rejectInitialConnection(err);
-      this._rejectPendingWaiters(err);
-      this.emit('reconnect-failed', err);
+    const maxRetries = this._connectedOnce ? this._recovery.maxRetries : this._recovery.initialMaxRetries;
+    if (this._attempt >= maxRetries) {
+      this._abandonRecovery(err);
       return;
     }
 
     const attempt = this._attempt + 1;
-    const delay = calculateDelay(this._recovery, attempt);
+    let delay;
+    try {
+      delay = calculateDelay(this._recovery, attempt);
+    } catch (delayErr) {
+      // Both callers of _scheduleReconnect run from timers or socket events
+      // where a throw would either be an unhandled rejection or an uncaught
+      // exception. Give up recovery cleanly instead so the failure reaches the
+      // initial connect promise, pending channel waiters and 'reconnect-failed'.
+      this._abandonRecovery(toError(delayErr, 'calculateDelay failed'));
+      return;
+    }
     this._attempt = attempt;
 
     this.emit('reconnect-scheduled', { attempt, delay, error: err });
@@ -314,6 +363,18 @@ class RecoveringCore extends EventEmitter {
     }, delay);
   }
 
+  _abandonRecovery(err) {
+    // Recovery is over and cannot be restarted, so treat the connection as
+    // stopped. Remember why, so channel operations attempted afterwards
+    // reject with the underlying failure instead of waiting forever for a
+    // connection that will never arrive.
+    this._stopped = true;
+    this._failure = err;
+    this._rejectInitialConnection(err);
+    this._rejectPendingWaiters(err);
+    this.emit('reconnect-failed', err);
+  }
+
   _closeModelNoThrow(model) {
     return this._adapters.closeModel(model).catch(() => {});
   }

package/package.json

@@ -2,7 +2,7 @@
   "name": "amqplib",
   "homepage": "http://amqp-node.github.io/amqplib/",
   "main": "./channel_api.js",
-  "version": "2.1.0",
+  "version": "2.2.1",
   "types": "./index.d.ts",
   "exports": {
     ".": {
@@ -46,5 +46,15 @@
     "RabbitMQ"
   ],
   "author": "Michael Bridgen <mikeb@squaremobius.net>",
-  "license": "MIT"
+  "license": "MIT",
+  "files": [
+    "lib",
+    "examples",
+    "channel_api.js",
+    "callback_api.js",
+    "index.d.ts",
+    "callback_api.d.ts",
+    "CHANGELOG.md",
+    "LICENSE-MIT"
+  ]
 }

package/.claude/commands/lint-disable.md

@@ -1,9 +0,0 @@
-Please follow the following process when I ask you to disable a lint rule using /lint-disable $rule
-
-1. Create and change to a new branch. Ask for the branch name.
-2. If the rule is off by default, delete it (See https://biomejs.dev/linter/javascript/rules/ for rule details)
-3. If the rule is on by default, configure it to off in biome.json
-4. Update the project changelog
-5. Add the changes
-6. Commit the changes
-7. Push the changes

package/.claude/commands/lint-enable.md

@@ -1,12 +0,0 @@
-Please follow the following process when I ask you to enable a lint rule using /lint-enable $rule
-
-1. Create and change to a new branch. Ask for the branch name.
-2. Configure the rule to error in biome.json
-3. Run lint (npm run lint). If there are NO errors, goto step 8
-4. Use biome to SAFELY auto fix (npm run lint -- --fix). If there are errors stop and ask for instruction.
-5. Run the tests (npm test). If there are errors, stop and ask for instruction.
-6. If the rule defaults to error, delete it (See https://biomejs.dev/linter/javascript/rules/ for rule details)
-7. Update the project changelog
-8. Add the changes
-9. Commit the changes
-10. Push the changes

package/.claude/settings.local.json

@@ -1,7 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(gh pr *)"
-    ]
-  }
-}

package/.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,41 +0,0 @@
----
-name: Bug report / Support request
-about: Report a bug or ask for help
-title: ''
-labels: ''
-assignees: ''
-
----
-
-Before reporting a bug or requesting support please... 
-
-1. Read the troubleshooting guide
-
-   - https://amqp-node.github.io/amqplib/#troubleshooting
-
-2. Search for existing open and closed issues
-
-   - https://github.com/amqp-node/amqplib/issues?q=is%3Aissue+TYPE+YOUR+KEYWORDS+HERE
-
-3. Ensure you are familiar with the amqplib Channel API and RabbitMQ basics
-
-   - https://amqp-node.github.io/amqplib/channel_api.html
-   - https://www.cloudamqp.com/blog/part1-rabbitmq-for-beginners-what-is-rabbitmq.html
-   - https://www.rabbitmq.com/tutorials/amqp-concepts.html
-
-If the above does not help, please provide as much of the following information as is relevant...
-
-  - A clear and concise description of the problem
-  - RabbitMQ version
-  - amqplib version
-  - Node.js version
-  - The simplest possible code snippet that demonstrates the problem
-  - A stack trace
-
-Please format code snippets and/or stack traces using GitHub Markdown
-
-  - https://docs.github.com/en/get-started/writing-on-github/working-with-advanced-formatting/creating-and-highlighting-code-blocks).
-
-Thank you
-
-

package/.github/workflows/publish.yml

@@ -1,59 +0,0 @@
-name: Publish
-
-on:
-  release:
-    types: [created]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    services:
-      rabbitmq:
-        image: rabbitmq:4.2-alpine
-        ports:
-          - 5672:5672
-
-    strategy:
-      matrix:
-        node-version: [18.x, 20.x, 22.x, 24.x]
-        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
-
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Use Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v3
-        with:
-          node-version: ${{ matrix.node-version }}
-          cache: "npm"
-
-      - run: npm ci
-
-      - run: |
-          n=0
-          while :
-          do
-            sleep 5
-            echo 'HELO\n\n\n\n' | nc localhost 5672 | grep AMQP
-            [[ $? = 0 ]] && break || ((n++))
-            (( n >= 5 )) && break
-          done
-
-      - run: echo 'HELO\n\n\n\n' | nc localhost 5672 | grep AMQP
-
-      - run: make test
-
-  publish:
-    needs: build
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v4
-        with:
-          node-version: '20.x'
-          cache: "npm"
-          registry-url: https://registry.npmjs.org/
-      - run: npm ci
-      - run: npm publish --dry-run
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_AUTH_TOKEN }}