@adatechnology/rabbitmq-provider 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,82 @@
+import { Options } from 'amqplib';
+
+/**
+ * Copyright (c) 2026 Ada Technology. MIT License.
+ */
+
+type RabbitMqConnectionConfig = string | Options.Connect;
+type RabbitMqRoute = {
+    readonly exchange: string;
+    readonly queue: string;
+    readonly routingKey: string;
+};
+type RabbitMqRetryRoute = RabbitMqRoute & {
+    readonly delayMs: number;
+    readonly maxRetries: number;
+};
+type RabbitMqTopology = RabbitMqRoute & {
+    readonly retry: RabbitMqRetryRoute;
+    readonly deadLetter: RabbitMqRoute;
+};
+type RabbitMqProviderConfig = {
+    readonly connection: RabbitMqConnectionConfig;
+    readonly topology: RabbitMqTopology;
+};
+type RabbitMqDisposition = {
+    readonly type: 'ack';
+} | {
+    readonly type: 'retry';
+} | {
+    readonly type: 'dead-letter';
+};
+type RabbitMqConsumerMessage<TPayload> = {
+    readonly payload: TPayload;
+    readonly headers: Readonly<Record<string, unknown>>;
+    readonly messageId?: string;
+    readonly correlationId?: string;
+    readonly redelivered: boolean;
+    readonly retryCount: number;
+};
+type RabbitMqMessageHandler<TPayload> = (message: RabbitMqConsumerMessage<TPayload>) => RabbitMqDisposition | Promise<RabbitMqDisposition>;
+type RabbitMqMessageDecoder<TPayload> = (value: unknown) => TPayload;
+type RabbitMqConsumeParams<TPayload> = {
+    readonly decode: RabbitMqMessageDecoder<TPayload>;
+    readonly handler: RabbitMqMessageHandler<TPayload>;
+    readonly prefetch: number;
+    readonly consumerTag?: string;
+};
+type RabbitMqConsumer = {
+    readonly consumerTag: string;
+    cancel(): Promise<void>;
+};
+type RabbitMqPublishOptions = {
+    readonly headers?: Readonly<Record<string, unknown>>;
+    readonly messageId?: string;
+    readonly correlationId?: string;
+    readonly type?: string;
+};
+type RabbitMqProviderHealth = {
+    readonly healthy: true;
+};
+type RabbitMqProvider = {
+    publish<TPayload>(payload: TPayload, options?: RabbitMqPublishOptions): Promise<void>;
+    consume<TPayload>(params: RabbitMqConsumeParams<TPayload>): Promise<RabbitMqConsumer>;
+    healthCheck(): Promise<RabbitMqProviderHealth>;
+    close(): Promise<void>;
+};
+
+declare function createRabbitMqProvider(config: RabbitMqProviderConfig): Promise<RabbitMqProvider>;
+
+/**
+ * Copyright (c) 2026 Ada Technology. MIT License.
+ */
+declare class RabbitMqProviderClosedError extends Error {
+    readonly name = "RabbitMqProviderClosedError";
+    constructor();
+}
+declare class RabbitMqConfigurationError extends Error {
+    readonly name = "RabbitMqConfigurationError";
+    constructor(message: string);
+}
+
+export { RabbitMqConfigurationError, type RabbitMqConnectionConfig, type RabbitMqConsumeParams, type RabbitMqConsumer, type RabbitMqConsumerMessage, type RabbitMqDisposition, type RabbitMqMessageDecoder, type RabbitMqMessageHandler, type RabbitMqProvider, RabbitMqProviderClosedError, type RabbitMqProviderConfig, type RabbitMqProviderHealth, type RabbitMqPublishOptions, type RabbitMqRetryRoute, type RabbitMqRoute, type RabbitMqTopology, createRabbitMqProvider };

package/dist/index.js

@@ -0,0 +1,410 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/rabbitmq-provider.factory.ts
+import { connect } from "amqplib";
+
+// src/rabbitmq-provider.error.ts
+var RabbitMqProviderClosedError = class extends Error {
+  static {
+    __name(this, "RabbitMqProviderClosedError");
+  }
+  name = "RabbitMqProviderClosedError";
+  constructor() {
+    super("RabbitMQ provider is closing or already closed");
+  }
+};
+var RabbitMqConfigurationError = class extends Error {
+  static {
+    __name(this, "RabbitMqConfigurationError");
+  }
+  name = "RabbitMqConfigurationError";
+  constructor(message) {
+    super(message);
+  }
+};
+
+// src/rabbitmq-provider.service.ts
+var RabbitMqProviderService = class {
+  static {
+    __name(this, "RabbitMqProviderService");
+  }
+  connection;
+  publisherChannel;
+  topology;
+  consumers = /* @__PURE__ */ new Map();
+  openingConsumerChannels = /* @__PURE__ */ new Set();
+  closePromise;
+  closing = false;
+  constructor({ connection, publisherChannel, topology }) {
+    this.connection = connection;
+    this.publisherChannel = publisherChannel;
+    this.topology = topology;
+  }
+  async publish(payload, options = {}) {
+    this.assertOpen();
+    await this.publishConfirmed({
+      content: Buffer.from(JSON.stringify(payload)),
+      exchange: this.topology.exchange,
+      options: {
+        ...options,
+        contentType: "application/json",
+        persistent: true
+      },
+      routingKey: this.topology.routingKey
+    });
+  }
+  async consume({ decode, handler, prefetch, consumerTag }) {
+    this.assertOpen();
+    assertValidPrefetch(prefetch);
+    const channel = await this.connection.createChannel();
+    const inFlight = /* @__PURE__ */ new Set();
+    this.openingConsumerChannels.add(channel);
+    try {
+      this.assertOpen();
+      await channel.prefetch(prefetch);
+      this.assertOpen();
+      const reply = await channel.consume(this.topology.queue, (message) => {
+        if (!message) {
+          return;
+        }
+        const processing = this.processDelivery({
+          channel,
+          decode,
+          handler,
+          message
+        });
+        inFlight.add(processing);
+        void processing.then(() => inFlight.delete(processing), () => inFlight.delete(processing));
+      }, {
+        consumerTag,
+        noAck: false
+      });
+      this.assertOpen();
+      this.openingConsumerChannels.delete(channel);
+      this.consumers.set(reply.consumerTag, {
+        channel,
+        inFlight
+      });
+      return {
+        consumerTag: reply.consumerTag,
+        cancel: /* @__PURE__ */ __name(() => this.cancelConsumer(reply.consumerTag), "cancel")
+      };
+    } catch (error) {
+      this.openingConsumerChannels.delete(channel);
+      await closeChannel(channel);
+      throw error;
+    }
+  }
+  async healthCheck() {
+    this.assertOpen();
+    await this.publisherChannel.checkQueue(this.topology.queue);
+    return {
+      healthy: true
+    };
+  }
+  close() {
+    this.closePromise ??= this.shutdown();
+    return this.closePromise;
+  }
+  async processDelivery({ channel, decode, handler, message }) {
+    const decoded = decodeDelivery({
+      decode,
+      message,
+      retryQueue: this.topology.retry.queue
+    });
+    if (!decoded) {
+      channel.reject(message, false);
+      return;
+    }
+    try {
+      const disposition = await handler(decoded);
+      await this.applyDisposition({
+        channel,
+        disposition,
+        message,
+        retryCount: decoded.retryCount
+      });
+    } catch {
+      await this.handleFailure({
+        channel,
+        message,
+        metadata: decoded
+      });
+    }
+  }
+  async applyDisposition({ channel, disposition, message, retryCount: retryCount2 }) {
+    if (disposition.type === "ack") {
+      channel.ack(message);
+      return;
+    }
+    if (disposition.type === "dead-letter") {
+      channel.reject(message, false);
+      return;
+    }
+    if (retryCount2 >= this.topology.retry.maxRetries) {
+      channel.reject(message, false);
+      return;
+    }
+    await this.publishRetry({
+      channel,
+      message,
+      retryCount: retryCount2
+    });
+  }
+  async handleFailure({ channel, message, metadata }) {
+    if (metadata.retryCount === 0 && !metadata.redelivered) {
+      channel.nack(message, false, true);
+      return;
+    }
+    if (metadata.retryCount >= this.topology.retry.maxRetries) {
+      channel.reject(message, false);
+      return;
+    }
+    await this.publishRetry({
+      channel,
+      message,
+      retryCount: metadata.retryCount
+    });
+  }
+  async publishRetry({ channel, message, retryCount: retryCount2 }) {
+    try {
+      await this.publishConfirmed({
+        content: message.content,
+        exchange: this.topology.retry.exchange,
+        options: retryPublishOptions({
+          message,
+          retryCount: retryCount2
+        }),
+        routingKey: this.topology.retry.routingKey
+      });
+      channel.ack(message);
+    } catch {
+      channel.nack(message, false, true);
+    }
+  }
+  async publishConfirmed({ content, exchange, options, routingKey }) {
+    const confirmation = createDeferred();
+    const canWrite = this.publisherChannel.publish(exchange, routingKey, content, options, (error) => {
+      if (error) {
+        confirmation.reject(toError(error));
+        return;
+      }
+      confirmation.resolve();
+    });
+    if (canWrite) {
+      await confirmation.promise;
+      return;
+    }
+    await Promise.all([
+      confirmation.promise,
+      waitForDrain(this.publisherChannel)
+    ]);
+  }
+  cancelConsumer(consumerTag) {
+    const consumer = this.consumers.get(consumerTag);
+    if (!consumer) {
+      return Promise.resolve();
+    }
+    consumer.cancellation ??= this.cancelAndDrain({
+      consumer,
+      consumerTag
+    });
+    return consumer.cancellation;
+  }
+  async cancelAndDrain({ consumer, consumerTag }) {
+    await consumer.channel.cancel(consumerTag);
+    await Promise.all([
+      ...consumer.inFlight
+    ]);
+    await consumer.channel.close();
+    this.consumers.delete(consumerTag);
+  }
+  async shutdown() {
+    this.closing = true;
+    await Promise.all([
+      ...this.consumers.keys()
+    ].map((consumerTag) => this.cancelConsumer(consumerTag)));
+    await Promise.all([
+      ...this.openingConsumerChannels
+    ].map(closeChannel));
+    await this.publisherChannel.waitForConfirms();
+    await this.publisherChannel.close();
+    await this.connection.close();
+  }
+  assertOpen() {
+    if (this.closing) {
+      throw new RabbitMqProviderClosedError();
+    }
+  }
+};
+function decodeDelivery({ decode, message, retryQueue }) {
+  try {
+    const headers = normalizeHeaders(message.properties.headers);
+    return {
+      payload: decode(JSON.parse(message.content.toString())),
+      headers,
+      messageId: stringProperty(message.properties.messageId),
+      correlationId: stringProperty(message.properties.correlationId),
+      redelivered: message.fields.redelivered,
+      retryCount: retryCount({
+        headers,
+        retryQueue
+      })
+    };
+  } catch {
+    return void 0;
+  }
+}
+__name(decodeDelivery, "decodeDelivery");
+function normalizeHeaders(headers) {
+  return headers ?? {};
+}
+__name(normalizeHeaders, "normalizeHeaders");
+function stringProperty(value) {
+  return typeof value === "string" ? value : void 0;
+}
+__name(stringProperty, "stringProperty");
+function retryCount({ headers, retryQueue }) {
+  const providerRetryCount = headers["x-ada-retry-count"];
+  if (typeof providerRetryCount === "number" && Number.isInteger(providerRetryCount) && providerRetryCount >= 0) {
+    return providerRetryCount;
+  }
+  const deaths = headers["x-death"];
+  if (!Array.isArray(deaths)) {
+    return 0;
+  }
+  return deaths.reduce((count, death) => {
+    if (!isRetryDeath(death, retryQueue)) {
+      return count;
+    }
+    return count + death.count;
+  }, 0);
+}
+__name(retryCount, "retryCount");
+function isRetryDeath(death, retryQueue) {
+  if (!death || typeof death !== "object") {
+    return false;
+  }
+  return "count" in death && typeof death.count === "number" && "queue" in death && death.queue === retryQueue;
+}
+__name(isRetryDeath, "isRetryDeath");
+function retryPublishOptions({ message, retryCount: retryCount2 }) {
+  return {
+    appId: stringProperty(message.properties.appId),
+    contentEncoding: stringProperty(message.properties.contentEncoding),
+    contentType: stringProperty(message.properties.contentType),
+    correlationId: stringProperty(message.properties.correlationId),
+    headers: {
+      ...message.properties.headers,
+      "x-ada-retry-count": retryCount2 + 1
+    },
+    messageId: stringProperty(message.properties.messageId),
+    persistent: true,
+    type: stringProperty(message.properties.type)
+  };
+}
+__name(retryPublishOptions, "retryPublishOptions");
+function createDeferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((promiseResolve, promiseReject) => {
+    resolve = promiseResolve;
+    reject = promiseReject;
+  });
+  return {
+    promise,
+    resolve,
+    reject
+  };
+}
+__name(createDeferred, "createDeferred");
+function waitForDrain(channel) {
+  return new Promise((resolve) => {
+    channel.once("drain", resolve);
+  });
+}
+__name(waitForDrain, "waitForDrain");
+function toError(error) {
+  return error instanceof Error ? error : new Error("RabbitMQ publish failed");
+}
+__name(toError, "toError");
+function assertValidPrefetch(prefetch) {
+  if (!Number.isInteger(prefetch) || prefetch <= 0) {
+    throw new RabbitMqConfigurationError("RabbitMQ consumer prefetch must be a positive integer");
+  }
+}
+__name(assertValidPrefetch, "assertValidPrefetch");
+async function closeChannel(channel) {
+  try {
+    await channel.close();
+  } catch {
+  }
+}
+__name(closeChannel, "closeChannel");
+
+// src/rabbitmq-provider.factory.ts
+async function createRabbitMqProvider(config) {
+  assertValidTopology(config.topology);
+  const connection = await connect(config.connection);
+  const publisherChannel = await connection.createConfirmChannel();
+  try {
+    await assertTopology({
+      channel: publisherChannel,
+      topology: config.topology
+    });
+  } catch (error) {
+    await publisherChannel.close();
+    await connection.close();
+    throw error;
+  }
+  return new RabbitMqProviderService({
+    connection,
+    publisherChannel,
+    topology: config.topology
+  });
+}
+__name(createRabbitMqProvider, "createRabbitMqProvider");
+async function assertTopology({ channel, topology }) {
+  await channel.assertExchange(topology.exchange, "direct", {
+    durable: true
+  });
+  await channel.assertExchange(topology.retry.exchange, "direct", {
+    durable: true
+  });
+  await channel.assertExchange(topology.deadLetter.exchange, "direct", {
+    durable: true
+  });
+  await channel.assertQueue(topology.queue, {
+    durable: true,
+    deadLetterExchange: topology.deadLetter.exchange,
+    deadLetterRoutingKey: topology.deadLetter.routingKey
+  });
+  await channel.bindQueue(topology.queue, topology.exchange, topology.routingKey);
+  await channel.assertQueue(topology.retry.queue, {
+    durable: true,
+    messageTtl: topology.retry.delayMs,
+    deadLetterExchange: topology.exchange,
+    deadLetterRoutingKey: topology.routingKey
+  });
+  await channel.bindQueue(topology.retry.queue, topology.retry.exchange, topology.retry.routingKey);
+  await channel.assertQueue(topology.deadLetter.queue, {
+    durable: true
+  });
+  await channel.bindQueue(topology.deadLetter.queue, topology.deadLetter.exchange, topology.deadLetter.routingKey);
+}
+__name(assertTopology, "assertTopology");
+function assertValidTopology(topology) {
+  if (!Number.isInteger(topology.retry.delayMs) || topology.retry.delayMs <= 0) {
+    throw new RabbitMqConfigurationError("RabbitMQ retry delayMs must be a positive integer");
+  }
+  if (!Number.isInteger(topology.retry.maxRetries) || topology.retry.maxRetries < 0) {
+    throw new RabbitMqConfigurationError("RabbitMQ retry maxRetries must be a non-negative integer");
+  }
+}
+__name(assertValidTopology, "assertValidTopology");
+export {
+  RabbitMqConfigurationError,
+  RabbitMqProviderClosedError,
+  createRabbitMqProvider
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@adatechnology/rabbitmq-provider",
+  "version": "0.1.1",
+  "description": "Typed RabbitMQ provider for Bun workers and APIs",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "bun": ">=1.3.0"
+  },
+  "keywords": [
+    "amqp",
+    "bun",
+    "rabbitmq",
+    "worker"
+  ],
+  "author": "Ada Technology",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "amqplib": "2.0.1"
+  },
+  "devDependencies": {
+    "@types/bun": "1.3.14",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
+  },
+  "scripts": {
+    "build": "tsup",
+    "check": "tsc --noEmit",
+    "test": "bun test",
+    "test:integration": "bun test --preload ./src/require-test-rabbitmq.ts",
+    "format": "prettier --write .",
+    "format:check": "prettier --check ."
+  }
+}