@onlineapps/mq-client-core 2.0.1 → 3.0.0

package/src/transports/transportFactory.js

@@ -6,6 +6,7 @@
  */
 
 const RabbitMQClient = require('./rabbitmqClient');
+const { ValidationError } = require('../utils/errorHandler');
 
 /**
  * Factory method: returns a transport instance based on config.type.
@@ -16,7 +17,10 @@ const RabbitMQClient = require('./rabbitmqClient');
  */
 function create(config) {
   if (!config || !config.type) {
-    throw new Error('Transport type is required in configuration');
+    throw new ValidationError(
+      '[transportFactory] Transport type is required in configuration - Expected: config.type naming a supported transport. '
+        + "Fix: pass { type: 'rabbitmq', … } to the client constructor."
+    );
   }
 
   switch (config.type.toLowerCase()) {
@@ -24,7 +28,10 @@ function create(config) {
       return new RabbitMQClient(config);
 
     default:
-      throw new Error(`Unsupported transport type: ${config.type}`);
+      throw new ValidationError(
+        `[transportFactory] Unsupported transport type: ${config.type} - Expected: one of the implemented transports ('rabbitmq'). `
+          + "Fix: set config.type to 'rabbitmq'."
+      );
   }
 }
 

package/src/utils/errorHandler.js

@@ -31,20 +31,61 @@ class ValidationError extends Error {
  * Thrown when client cannot connect to broker.
  * - message: description of what went wrong
  * - cause: original error object
+ * - code: machine-readable classification, for the receivers that must decide what an
+ *   error MEANS. A decision taken on the message text breaks the moment somebody
+ *   rewords the sentence, and nothing reports it (`architecture-principles.md` §3).
  */
 class ConnectionError extends Error {
   /**
    * @param {string} message
-   * @param {Error} cause
+   * @param {Error} [cause]
+   * @param {string} [code] one of the codes below
    */
-  constructor(message, cause) {
+  constructor(message, cause, code) {
     super(message);
     this.name = 'ConnectionError';
     this.cause = cause;
+    this.code = code;
     Error.captureStackTrace(this, ConnectionError);
   }
 }
 
+/**
+ * The broker connection dropped while the client still wanted it.
+ *
+ * It is a STATE, not the failure of whatever observed it: while a reconnect is in
+ * flight this is the normal condition of the very thing being waited for, so
+ * `RabbitMQClient._waitForReconnection()` skips it and keeps waiting. The wait also
+ * skips anything carrying a publish classification (`utils/publishErrors.js` sets
+ * `retryable` on every error it produces, retryable or not): that reports somebody
+ * else's message, not this connection (d.435, widened to the whole rail in d.435b).
+ * Everything else — an error with no classification at all — ends that wait.
+ */
+const CONNECTION_CLOSED_UNEXPECTEDLY = 'CONNECTION_CLOSED_UNEXPECTEDLY';
+
+/**
+ * The single definition of that error — both connection close handlers emit exactly
+ * this, and the reconnect wait recognises it by `error.code`, never by its wording.
+ *
+ * Measured defect it closes (d.153a → d.164): the handlers emitted
+ * `new Error('RabbitMQ connection closed unexpectedly')` while the wait asked
+ * `message.includes('Connection closed unexpectedly')` — a capital `C` apart, so the
+ * substring never matched and the branch that was written to ignore this error had
+ * never once run.
+ *
+ * @returns {ConnectionError}
+ */
+function connectionClosedUnexpectedly() {
+  return new ConnectionError(
+    '[RabbitMQClient] Connection closed unexpectedly - '
+      + 'Expected: the broker connection to stay open until disconnect() closes it. '
+      + 'Fix: check the broker is up and reachable; the client reconnects on its own until '
+      + 'RABBITMQ_MAX_RECONNECT_ATTEMPTS is spent and then emits connection:fatal.',
+    undefined,
+    CONNECTION_CLOSED_UNEXPECTEDLY
+  );
+}
+
 /**
  * PublishError
  * Thrown when publishing a message fails.
@@ -73,22 +114,56 @@ class PublishError extends Error {
  * - message: description
  * - queue: queue name associated with the consumer
  * - cause: original error
+ * - code: machine-readable class of the refusal, for the caller that must decide
+ *   what to DO about it. Absent when the failure belongs to no named class —
+ *   never a catch-all value, because "I do not know which of these it is" and
+ *   "it is this one" are different answers.
  */
 class ConsumeError extends Error {
   /**
    * @param {string} message
    * @param {string} queue
-   * @param {Error} cause
+   * @param {Error} [cause]
+   * @param {string} [code] one of the consumer codes below
    */
-  constructor(message, queue, cause) {
+  constructor(message, queue, cause, code) {
     super(message);
     this.name = 'ConsumeError';
     this.queue = queue;
     this.cause = cause;
+    if (code !== undefined) this.code = code;
     Error.captureStackTrace(this, ConsumeError);
   }
 }
 
+/**
+ * The two classes of refusal `consume()` makes before a consumer is attached,
+ * as codes rather than as sentences.
+ *
+ * They exist because those two refusals ask the reader for OPPOSITE actions, and
+ * until 2026-09-14 they arrived wearing the same sentence: `BaseClient.consume()`
+ * rewrote every failure as "the queue to exist before consume() attaches to it",
+ * which for a queue with no declared dead-letter route is false in every clause —
+ * the queue exists, creating it changes nothing, and its owning service is not
+ * who has to act. The true sentence survived only in `error.cause`, where a log
+ * line does not look.
+ *
+ * A caller decides on the CODE. Deciding on the wording breaks the moment somebody
+ * rewords the sentence, and nothing reports the break (`architecture-principles.md`
+ * §3) — the defect d.164 measured, where a reconnect wait compared strings and its
+ * branch had never once run.
+ */
+
+/** The queue does not exist. Its owner creates it; the consumer never does. */
+const CONSUMER_QUEUE_MISSING = 'CONSUMER_QUEUE_MISSING';
+
+/**
+ * The queue exists, and `queueConfig` declares no dead-letter route for it, so
+ * the delivery policy has nowhere to reject a spent message to (d.259). The fix
+ * is a declaration, not a queue.
+ */
+const CONSUMER_DEAD_LETTER_ROUTE_MISSING = 'CONSUMER_DEAD_LETTER_ROUTE_MISSING';
+
 /**
  * SerializationError
  * Thrown when JSON serialization or deserialization fails.
@@ -114,8 +189,12 @@ class SerializationError extends Error {
 module.exports = {
   ValidationError,
   ConnectionError,
+  CONNECTION_CLOSED_UNEXPECTEDLY,
+  connectionClosedUnexpectedly,
   PublishError,
   ConsumeError,
+  CONSUMER_QUEUE_MISSING,
+  CONSUMER_DEAD_LETTER_ROUTE_MISSING,
   SerializationError,
 };
 

package/src/utils/nearestKey.js

@@ -0,0 +1,101 @@
+'use strict';
+
+/**
+ * "Did you mean this one" — the one implementation of it in this package.
+ *
+ * It lived inside `BaseClient.js` from d.291b, where the config schema first
+ * refused an undeclared key by name. d.396c gave `assertQueue()` the same duty
+ * for its own option set, and a second copy of an edit distance would be a
+ * second rail for one concern (`change-discipline.md` § One rail per concern) —
+ * so the pair moved here and both callers require it. The behaviour is
+ * unchanged; the tests that pinned it (`tests/unit/config-schema-refuses-unknown-key.test.js`)
+ * still read it through `BaseClient`.
+ */
+
+/**
+ * Edit distance between two names, compared case-insensitively.
+ *
+ * The classic Levenshtein recurrence over one rolling row. It exists for ONE
+ * purpose — turning "this key is not declared" into "did you mean this one" — so
+ * it is deliberately the plainest metric there is: same inputs, same answer, no
+ * dictionary, no heuristics to explain (`automation-gates.md` §1 requirement 1).
+ *
+ * @param {string} a
+ * @param {string} b
+ * @returns {number} insertions + deletions + substitutions between the two.
+ */
+function editDistance(a, b) {
+  const from = a.toLowerCase();
+  const to = b.toLowerCase();
+  let previous = Array.from({ length: to.length + 1 }, (_, j) => j);
+
+  for (let i = 1; i <= from.length; i += 1) {
+    const row = [i];
+    for (let j = 1; j <= to.length; j += 1) {
+      row[j] = Math.min(
+        previous[j] + 1,
+        row[j - 1] + 1,
+        previous[j - 1] + (from[i - 1] === to[j - 1] ? 0 : 1)
+      );
+    }
+    previous = row;
+  }
+
+  return previous[to.length];
+}
+
+/**
+ * The declared key a written name is closest to, or `null` when nothing is close
+ * enough to name.
+ *
+ * The budget is a third of the longer of the two names, rounded up: `prefech` ->
+ * `prefetch` (distance 1) is a typo worth pointing at, `queue` -> `type`
+ * (distance 4 over a 5-character name) is not, and a guess that far off steers a
+ * reader away from the real answer, which is that the key is not a key at all.
+ * Ties keep the FIRST declared key, so the sentence does not change with the
+ * iteration order of an object (`automation-gates.md` §1 requirement 1).
+ *
+ * @param {string} written - The key the caller wrote.
+ * @param {string[]} declaredKeys - Every key the schema declares, subclass keys included.
+ * @returns {string|null}
+ */
+function nearestDeclaredKey(written, declaredKeys) {
+  let nearest = null;
+  let nearestDistance = Infinity;
+
+  for (const candidate of declaredKeys) {
+    const distance = editDistance(written, candidate);
+    if (distance < nearestDistance) {
+      nearestDistance = distance;
+      nearest = candidate;
+    }
+  }
+
+  if (nearest === null) {
+    return null;
+  }
+
+  const budget = Math.ceil(Math.max(written.length, nearest.length) / 3);
+  return nearestDistance <= budget ? nearest : null;
+}
+
+/**
+ * The undeclared keys of an object, each named together with the declared key it
+ * is closest to — the half of the refusal sentence both callers share.
+ *
+ * @param {string[]} unknownKeys - Keys the declared set does not contain.
+ * @param {string[]} declaredKeys - The declared set.
+ * @returns {string} e.g. `"persistent" (no declared key is close to it)`
+ */
+function nameUnknownKeys(unknownKeys, declaredKeys) {
+  return unknownKeys
+    .map((key) => {
+      const nearest = nearestDeclaredKey(key, declaredKeys);
+      return nearest === null
+        ? `"${key}" (no declared key is close to it)`
+        : `"${key}" (the closest declared key is "${nearest}")`;
+    })
+    .join(', ');
+}
+
+module.exports = { editDistance, nearestDeclaredKey, nameUnknownKeys };

package/src/utils/publishErrors.js

@@ -36,8 +36,8 @@ class QueueNotFoundError extends PermanentPublishError {
    * @param {string} queueName
    * @param {boolean} isInfrastructure
    * @param {Error} [cause]
-   * @param {('infrastructure'|'business'|'unknown')} [kind] - Which ownership rule
-   *   was violated. Defaults to `'infrastructure'`/`'unknown'` from
+   * @param {('infrastructure'|'business'|'unowned'|'unknown')} [kind] - Which ownership
+   *   rule was violated. Defaults to `'infrastructure'`/`'unknown'` from
    *   `isInfrastructure`, so existing two- and three-argument callers are unchanged.
    */
   constructor(queueName, isInfrastructure, cause, kind) {
@@ -45,19 +45,42 @@ class QueueNotFoundError extends PermanentPublishError {
     let baseMessage;
     if (resolvedKind === 'infrastructure') {
       baseMessage =
-        `Cannot publish to infrastructure queue ${queueName}: queue does not exist. ` +
-        'Infrastructure queues must be created explicitly with correct arguments ' +
-        '(TTL, max-length, etc.) before publishing.';
+        `[RabbitMQClient] Cannot publish to infrastructure queue ${queueName}: queue does not exist. ` +
+        'Expected: infrastructure queues are created explicitly, with the arguments queueConfig ' +
+        'prescribes (TTL, max-length, …), before anything publishes to them. ' +
+        'Fix: start the infrastructure service that owns the queue — it calls ' +
+        'initInfrastructureQueues() from @onlineapps/infrastructure-tools — and publish afterwards.';
     } else if (resolvedKind === 'business') {
       baseMessage =
-        `Cannot publish to business queue ${queueName}: queue does not exist. ` +
+        `[RabbitMQClient] Cannot publish to business queue ${queueName}: queue does not exist. ` +
         'Expected: business queues are created by their owning service via ' +
         'setupServiceQueues() AFTER successful registration, with the arguments ' +
         'queueConfig prescribes (TTL, DLQ). Fix: call setupServiceQueues() before ' +
         'publishing — publishing must never create the queue, because sendToQueue() ' +
         'would create it with default arguments (no TTL, no DLQ).';
+    } else if (resolvedKind === 'unowned') {
+      // A name the central config classifies as NEITHER infrastructure nor
+      // business. Nothing declares it, so nothing may bring it into being: a
+      // queue created here would carry no TTL and no dead-letter route, and
+      // `consume()` refuses a queue with no declared route (d.259) — publishable
+      // and unconsumable, which is not a queue anybody can use. The owner's
+      // decision says how a genuinely new family of queues arrives instead:
+      // a template in queueConfig first, "never a generic create-anything
+      // method" (`docs/governance/confirmations/mq-consumer-contract.md` 006).
+      baseMessage =
+        `[RabbitMQClient] Queue ${queueName} has no owner in queueConfig - ` +
+        'Expected: every queue to come into being from a declaration — an infrastructure queue from ' +
+        'the service that owns it at boot, a business queue from setupServiceQueues() over the ' +
+        'queueConfig template. A publisher declares neither, and this name matches neither. ' +
+        'Fix: add a template for this name to src/config/queueConfig.js (confirmation ' +
+        'mq-consumer-contract 003) and let its owner declare it, or publish to a queue that ' +
+        'already has one.';
     } else {
-      baseMessage = `Queue ${queueName} does not exist`;
+      baseMessage =
+        `[RabbitMQClient] Queue ${queueName} does not exist - Expected: the queue to have been created by whoever owns it. ` +
+        'Fix: the owner is not known at this point, so identify it from the queue name — an infrastructure prefix ' +
+        '(workflow./registry./infrastructure./monitoring.) means an infrastructure service, anything else means the ' +
+        'business service the first name segment belongs to.';
     }
     super(baseMessage, cause);
     this.name = 'QueueNotFoundError';
@@ -93,14 +116,72 @@ function missingInfrastructureQueueMessage(queueName) {
     + '@onlineapps/infrastructure-tools.';
 }
 
+/**
+ * The message a CONSUMER gets when the central config holds no DEFINITION for the
+ * queue it must attach to — a configuration defect, never a runtime condition.
+ *
+ * ONE producer for both classes of name. The sentence differs in exactly two
+ * places — which part of `queueConfig` must declare the name, and what a reader
+ * adds there — and writing that difference as a ternary at the `new ConsumeError`
+ * call site puts the whole message where no test can reach it
+ * (`tests/unit/error-message-contract.test.js`: a non-literal argument must be a
+ * named `…Message()` producer, checked at runtime beside its siblings).
+ *
+ * @param {string} queueName - The queue whose definition is missing.
+ * @param {boolean} isInfrastructure - Whether the name is an infrastructure one.
+ *   Required, and required to be a boolean: a missing third state would be
+ *   rendered as "business" by a falsy value, which is the wrong instruction.
+ * @returns {string}
+ */
+function missingQueueDefinitionMessage(queueName, isInfrastructure) {
+  if (!queueName) {
+    throw new Error('[publishErrors] queueName is required - Expected the name of the queue whose definition is missing');
+  }
+
+  if (typeof isInfrastructure !== 'boolean') {
+    throw new Error(
+      '[publishErrors] isInfrastructure is required - Expected: a boolean saying which part of queueConfig '
+        + 'must declare the name. Fix: pass queueConfig.isInfrastructureQueue(queueName).'
+    );
+  }
+
+  return isInfrastructure
+    ? `[RabbitMQClient] No queue definition for infrastructure queue "${queueName}" - `
+      + 'Expected: queueConfig defines every infrastructure queue that is consumed. '
+      + 'Fix: add the queue to src/config/queueConfig.js, or consume the name the owning service declares.'
+    : `[RabbitMQClient] No queue definition for business queue "${queueName}" - `
+      + 'Expected: queueConfig defines a template for every business queue type (workflow, queue, dlq). '
+      + 'Fix: add the template to src/config/queueConfig.js, or consume the name the owning service declares.';
+}
+
 /**
  * Best-effort klasifikace chyb z publishu do specializovaných typů.
  * Vrací původní chybu, pokud neodpovídá žádnému známému patternu.
  *
+ * The queue name comes from the CALLER, and is required. The missing-queue branch
+ * below used to invent it — `new QueueNotFoundError('unknown', …)` — and the
+ * invented name does not stay in the message: the error reaches `RecoveryWorker`
+ * through the client's `error` channel, which reports it by `error.queueName`
+ * ("Cannot create queue 'unknown'"), naming nothing anybody can act on. Every
+ * caller has the real name in hand (`_publishOnce(queue, …)`,
+ * `publishToMonitoringResilient(…, queueName, …)`), so it is asked for at entry
+ * (`architecture-principles.md` §4) rather than guessed in one branch (§3, and the
+ * same defect this package retired for the workflow id in d.416).
+ *
  * @param {Error} err
+ * @param {string} queueName - The queue whose publish failed.
  * @returns {Error} - buď speciální error, nebo původní err
  */
-function classifyPublishError(err) {
+function classifyPublishError(err, queueName) {
+  if (typeof queueName !== 'string' || queueName === '') {
+    throw new Error(
+      '[publishErrors] classifyPublishError requires the queue name - '
+        + 'Expected: the caller names the queue whose publish failed, so a missing-queue error '
+        + 'carries a real name instead of an invented one. '
+        + 'Fix: pass it as the second argument, e.g. classifyPublishError(err, queue).'
+    );
+  }
+
   if (!err) {
     return err;
   }
@@ -118,8 +199,11 @@ function classifyPublishError(err) {
 
   // Queue neexistuje – trvalý problém, nerozbitný retry
   if (message.includes('queue does not exist') || message.includes('no queue') || err.code === 404) {
-    // Nevíme, zda je to infra/biz – necháme isInfrastructure=false, publish vrstva si může dovodit sama
-    return new QueueNotFoundError('unknown', false, err);
+    // Which section of queueConfig owns the name is not known here — that lookup
+    // belongs to the publish path, which asks it before this classification is ever
+    // reached — so the error carries the name and `kind: 'unknown'`, whose message
+    // tells the reader how to identify the owner from it.
+    return new QueueNotFoundError(queueName, false, err);
   }
 
   // Typicky transientní problémy connection/channel
@@ -143,6 +227,7 @@ function classifyPublishError(err) {
 
 module.exports = {
   missingInfrastructureQueueMessage,
+  missingQueueDefinitionMessage,
   TransientPublishError,
   PermanentPublishError,
   QueueNotFoundError,

package/src/utils/redactCredentials.js

@@ -0,0 +1,106 @@
+'use strict';
+
+/**
+ * redactCredentials.js
+ *
+ * ONE rail for making a broker connection target safe to log. Both connect
+ * paths (BaseClient and the RabbitMQ transport) pass their target through this
+ * function before it reaches stdout; nothing else in this package renders a
+ * host, a URL or a config object into a log line.
+ *
+ * Why it exists: the full AMQP URL — password included — was printed on every
+ * boot, so the broker account was readable in container stdout and, through the
+ * monitoring consumer, in Loki (measured 2026-09-07 on api_service_hello).
+ *
+ * `redactUrl` returns the URL with the WHOLE userinfo removed: what stays is
+ * scheme, host, port, vhost and query — the part a reader of the log actually
+ * came for. The account NAME goes with the password, because it is the other
+ * half of the same credential, and because this is the redaction semantics the
+ * platform already writes: `shared/service-common/src/redactUrl.js`
+ * (d.245/d.245b, Redis) and `shared/connector/conn-orch-registry/src/redactUrl.js`
+ * (d.446, AMQP). Until d.448 this module masked the password only, which made
+ * two semantics for one concern — two rails (`change-discipline.md` § One rail
+ * per concern). `src/index.js` exports the function so the dependants import it
+ * instead of keeping a local copy.
+ *
+ * A value that is not a parseable URL is answered with a fixed placeholder
+ * rather than echoed: an unparseable string is exactly the case where nobody can
+ * say whether it holds a credential, and echoing it would be the leak this
+ * helper exists to prevent.
+ */
+
+const UNPARSEABLE_PLACEHOLDER = '<unparseable-url>';
+
+/**
+ * Strip userinfo (`user:password@`) from a connection URL.
+ *
+ * @param {string} url - connection URL, e.g. `amqp://oa_dev:secret@queuer:5672/vhost`
+ * @returns {string} the URL without userinfo, e.g. `amqp://queuer:5672/vhost`,
+ *   or `<unparseable-url>` when the input is not a URL.
+ */
+function redactUrl(url) {
+  if (typeof url !== 'string' || url.length === 0) {
+    return UNPARSEABLE_PLACEHOLDER;
+  }
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch (_) {
+    return UNPARSEABLE_PLACEHOLDER;
+  }
+  // `new URL('api_services_queuer:5672')` SUCCEEDS — it reads `api_services_queuer:`
+  // as the scheme and `5672` as an opaque path, so the value comes back with an
+  // empty host and no userinfo to strip. Without this guard such a value would be
+  // echoed verbatim, which is the leak this helper exists to prevent.
+  if (!parsed.host) {
+    return UNPARSEABLE_PLACEHOLDER;
+  }
+  parsed.username = '';
+  parsed.password = '';
+  return parsed.href;
+}
+
+/**
+ * Makes a connection target safe to log.
+ *
+ * ONE shape, because this client has one: `host` is a non-empty URL STRING,
+ * declared so by `config/configSchema.js`, resolved from `RABBITMQ_URL` when the
+ * caller omits it, and refused by the transport constructor when it is anything
+ * else (d.292 §2/§3). Until d.311 this module also carried `redactOptions()` for
+ * amqplib's options-object target — a branch no input could reach any more, kept
+ * alive only by its own tests. The four questions of `change-discipline.md`
+ * § Removing something removes its declaration:
+ *
+ *   1. it arrived with the redactor, when amqplib's two target shapes were both
+ *      accepted here;
+ *   2. the concept that carried it — "a connection target must be safe to log,
+ *      whatever shape it has" — was narrowed by d.292 to one shape, on purpose:
+ *      the second one silently discarded the caller's value;
+ *   3. nothing reads it because that shape cannot arrive, not because anybody
+ *      stopped caring;
+ *   4. what stands in its place is more conceptual — one declared shape, refused
+ *      loudly if it is anything else — so the answer is "delete", and a branch
+ *      that can never run is the silence `automation-gates.md` §5 calls a defect.
+ *
+ * It throws where `redactUrl` returns a placeholder, and that difference is
+ * deliberate: this function guards a DECLARED config key, where a wrong type is
+ * a boot-time defect the service must die on (§4 fail-fast), while `redactUrl`
+ * serves log lines and error messages, where a throw would replace the report
+ * with a second incident.
+ *
+ * @param {string} target - AMQP URL string.
+ * @returns {string} The same URL without its userinfo.
+ * @throws {TypeError} If the target is not a string. The message names the key to
+ *   write and NEVER the rejected value, which carries the broker password.
+ */
+function redactConnectionTarget(target) {
+  if (typeof target === 'string') return redactUrl(target);
+
+  throw new TypeError(
+    `[redactCredentials] Unsupported connection target - expected an AMQP URL string, got ` +
+      `"${target === null ? 'null' : typeof target}". ` +
+      `Fix: set config.host to the broker URL.`
+  );
+}
+
+module.exports = { redactConnectionTarget, redactUrl, UNPARSEABLE_PLACEHOLDER };

package/src/utils/serializer.js

@@ -19,7 +19,12 @@ function serialize(obj) {
   try {
     return JSON.stringify(obj);
   } catch (err) {
-    throw new SerializationError('Failed to serialize object', obj, err);
+    throw new SerializationError(
+      '[serializer] Failed to serialize object - Expected: a value JSON.stringify accepts. '
+        + 'Fix: read error.cause for the reason (circular reference, BigInt, …) and error.payload for the value that was rejected.',
+      obj,
+      err
+    );
   }
 }
 
@@ -34,7 +39,12 @@ function deserialize(buffer) {
     const str = Buffer.isBuffer(buffer) ? buffer.toString('utf8') : buffer;
     return JSON.parse(str);
   } catch (err) {
-    throw new SerializationError('Failed to deserialize payload', buffer, err);
+    throw new SerializationError(
+      '[serializer] Failed to deserialize payload - Expected: a Buffer or string holding valid JSON. '
+        + 'Fix: read error.cause for the parse reason and error.payload for the bytes that were rejected.',
+      buffer,
+      err
+    );
   }
 }