nestjs-runmq 1.0.0

package/README.md

@@ -0,0 +1,342 @@
+# nestjs-runmq
+
+NestJS module for [RunMQ](https://github.com/runmq/queue) — decorator-based message processors, an injectable publisher service, and automatic lifecycle management.
+
+## Installation
+
+```bash
+npm install nestjs-runmq runmq
+```
+
+---
+
+## Quick Start
+
+### 1. Register the Module
+
+```typescript
+// app.module.ts
+import { Module } from '@nestjs/common';
+import { RunMQModule } from 'nestjs-runmq';
+
+@Module({
+  imports: [
+    RunMQModule.forRoot({
+      url: 'amqp://localhost:5672',
+      reconnectDelay: 3000,
+      maxReconnectAttempts: 5,
+      management: {
+        url: 'http://localhost:15672',
+        username: 'guest',
+        password: 'guest',
+      },
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+RunMQ connects automatically when the app starts and disconnects cleanly on shutdown.
+
+---
+
+### 2. Create a Processor
+
+Decorate a class with `@Processor()` and mark the handler method with `@ProcessMessage()`:
+
+```typescript
+// email.processor.ts
+import { Injectable } from '@nestjs/common';
+import { Processor, ProcessMessage, RunMQMessageContent } from 'nestjs-runmq';
+
+@Processor({
+  topic: 'user.created',
+  name: 'emailService',
+  consumersCount: 2,
+  attempts: 3,
+  attemptsDelay: 2000,
+})
+@Injectable()
+export class EmailProcessor {
+  @ProcessMessage()
+  async handle(message: RunMQMessageContent<{ email: string; name: string }>) {
+    console.log(`Sending welcome email to ${message.message.email}`);
+  }
+}
+```
+
+Register it as a provider in any module:
+
+```typescript
+@Module({
+  providers: [EmailProcessor],
+})
+export class EmailModule {}
+```
+
+The processor is discovered and registered automatically on startup — no manual wiring needed.
+
+---
+
+### 3. Publish Messages
+
+Inject `RunMQPublisherService` anywhere in your app:
+
+```typescript
+// user.service.ts
+import { Injectable } from '@nestjs/common';
+import { RunMQPublisherService } from 'nestjs-runmq';
+
+@Injectable()
+export class UserService {
+  constructor(private readonly publisher: RunMQPublisherService) {}
+
+  async createUser(email: string, name: string) {
+    // ... save user
+    this.publisher.publish('user.created', { email, name });
+  }
+}
+```
+
+---
+
+## Configuration
+
+### Static (`forRoot`)
+
+```typescript
+RunMQModule.forRoot({
+  url: 'amqp://localhost:5672',
+  reconnectDelay: 5000,        // Optional, default: 5000ms
+  maxReconnectAttempts: 5,     // Optional, default: 5
+  management: {                // Optional, enables policy-based TTL
+    url: 'http://localhost:15672',
+    username: 'guest',
+    password: 'guest',
+  },
+})
+```
+
+### Async (`forRootAsync`)
+
+Load configuration at runtime — e.g., from environment variables via `@nestjs/config`:
+
+```typescript
+// app.module.ts
+import { ConfigModule, ConfigService } from '@nestjs/config';
+
+RunMQModule.forRootAsync({
+  imports: [ConfigModule],
+  inject: [ConfigService],
+  useFactory: (config: ConfigService) => ({
+    url: config.get('RABBITMQ_URL'),
+    reconnectDelay: config.get('RABBITMQ_RECONNECT_DELAY', 5000),
+    maxReconnectAttempts: config.get('RABBITMQ_MAX_RECONNECT_ATTEMPTS', 5),
+    management: {
+      url: config.get('RABBITMQ_MANAGEMENT_URL'),
+      username: config.get('RABBITMQ_MANAGEMENT_USER', 'guest'),
+      password: config.get('RABBITMQ_MANAGEMENT_PASS', 'guest'),
+    },
+  }),
+})
+```
+
+#### `useClass`
+
+```typescript
+import { Injectable } from '@nestjs/common';
+import { RunMQOptionsFactory, RunMQModuleOptions } from 'nestjs-runmq';
+
+@Injectable()
+export class RabbitMQConfig implements RunMQOptionsFactory {
+  createRunMQOptions(): RunMQModuleOptions {
+    return {
+      url: process.env.RABBITMQ_URL ?? 'amqp://localhost:5672',
+      reconnectDelay: 5000,
+      maxReconnectAttempts: 5,
+      management: {
+        url: process.env.RABBITMQ_MANAGEMENT_URL ?? 'http://localhost:15672',
+        username: process.env.RABBITMQ_MANAGEMENT_USER ?? 'guest',
+        password: process.env.RABBITMQ_MANAGEMENT_PASS ?? 'guest',
+      },
+    };
+  }
+}
+
+RunMQModule.forRootAsync({ useClass: RabbitMQConfig })
+```
+
+#### `useExisting`
+
+```typescript
+RunMQModule.forRootAsync({ useExisting: RabbitMQConfig })
+```
+
+---
+
+## Decorators
+
+### `@Processor(options)`
+
+Class-level decorator. Marks a class as a RunMQ message processor.
+
+| Option | Type | Required | Default | Description |
+|--------|------|----------|---------|-------------|
+| `topic` | `string` | Yes | — | Topic to subscribe to |
+| `name` | `string` | Yes | — | Unique processor name (creates an isolated queue) |
+| `consumersCount` | `number` | No | `1` | Concurrent consumers |
+| `attempts` | `number` | No | `1` | Max retry attempts |
+| `attemptsDelay` | `number` | No | `1000` | Milliseconds between retries |
+| `messageSchema` | `MessageSchema` | No | — | Optional JSON schema validation |
+| `usePoliciesForDelay` | `boolean` | No | `false` | Use RabbitMQ policies for delay queues (recommended) |
+
+### `@ProcessMessage()`
+
+Method-level decorator. Marks which method handles incoming messages. Exactly **one** method per `@Processor` class must be decorated.
+
+**Method signature**: `(message: RunMQMessageContent<T>) => Promise<void>`
+
+### `@InjectRunMQ()`
+
+Parameter decorator. Injects the raw `RunMQ` instance for advanced use cases:
+
+```typescript
+import { Injectable } from '@nestjs/common';
+import { InjectRunMQ } from 'nestjs-runmq';
+import { RunMQ } from 'runmq';
+
+@Injectable()
+export class HealthService {
+  constructor(@InjectRunMQ() private readonly runmq: RunMQ) {}
+
+  check() {
+    return { rabbitmq: this.runmq.isActive() };
+  }
+}
+```
+
+---
+
+## Injectable Services
+
+### `RunMQPublisherService`
+
+| Method | Signature | Description |
+|--------|-----------|-------------|
+| `publish` | `(topic: string, message: Record<string, any>, correlationId?: string) => void` | Publishes a message to the given topic |
+
+Throws `'RunMQ is not connected'` if called before the connection is established.
+
+---
+
+## Error Handling
+
+| Scenario | Behavior |
+|----------|----------|
+| RabbitMQ unreachable at startup | Logged via NestJS Logger, error is re-thrown |
+| `publish()` before connection | Throws `Error('RunMQ is not connected')` |
+| Duplicate `@Processor` name | Throws at startup: `Duplicate processor name: {name}` |
+| No `@ProcessMessage` in a `@Processor` class | Throws at startup: `No @ProcessMessage handler found in {ClassName}` |
+| Multiple `@ProcessMessage` in one class | Throws at startup: `Multiple @ProcessMessage handlers in {ClassName}` |
+
+---
+
+## Re-exported Types
+
+The following types from `runmq` are re-exported for convenience:
+
+```typescript
+import {
+  RunMQMessageContent,
+  RunMQMessageMetaContent,
+  RunMQConnectionConfig,
+  RunMQProcessorConfiguration,
+  MessageSchema,
+  SchemaType,
+  SchemaFailureStrategy,
+  RabbitMQManagementConfig,
+  RunMQLogger,
+  RunMQ,
+} from 'nestjs-runmq';
+```
+
+---
+
+## Full Example
+
+```typescript
+// app.module.ts
+import { Module } from '@nestjs/common';
+import { RunMQModule } from 'nestjs-runmq';
+import { EmailModule } from './email/email.module';
+import { UserModule } from './user/user.module';
+
+@Module({
+  imports: [
+    RunMQModule.forRoot({
+      url: 'amqp://localhost:5672',
+      reconnectDelay: 5000,
+      maxReconnectAttempts: 5,
+      management: {
+        url: 'http://localhost:15672',
+        username: 'guest',
+        password: 'guest',
+      },
+    }),
+    EmailModule,
+    UserModule,
+  ],
+})
+export class AppModule {}
+```
+
+```typescript
+// email/email.processor.ts
+import { Injectable } from '@nestjs/common';
+import { Processor, ProcessMessage, RunMQMessageContent } from 'nestjs-runmq';
+
+@Processor({ topic: 'user.created', name: 'emailService', consumersCount: 2, attempts: 3 })
+@Injectable()
+export class EmailProcessor {
+  @ProcessMessage()
+  async handle(message: RunMQMessageContent<{ email: string; name: string }>) {
+    console.log(`Sending welcome email to ${message.message.email}`);
+  }
+}
+```
+
+```typescript
+// email/email.module.ts
+import { Module } from '@nestjs/common';
+import { EmailProcessor } from './email.processor';
+
+@Module({ providers: [EmailProcessor] })
+export class EmailModule {}
+```
+
+```typescript
+// user/user.service.ts
+import { Injectable } from '@nestjs/common';
+import { RunMQPublisherService } from 'nestjs-runmq';
+
+@Injectable()
+export class UserService {
+  constructor(private readonly publisher: RunMQPublisherService) {}
+
+  async createUser(email: string, name: string) {
+    this.publisher.publish('user.created', { email, name });
+  }
+}
+```
+
+---
+
+## Dashboard
+
+Monitor your queues, processors, and messages in real time with [RunMQ Pulse](https://github.com/runmq/pulse).
+
+---
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,313 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  InjectRunMQ: () => InjectRunMQ,
+  ProcessMessage: () => ProcessMessage,
+  Processor: () => Processor,
+  RunMQ: () => import_runmq5.RunMQ,
+  RunMQModule: () => RunMQModule,
+  RunMQPublisherService: () => RunMQPublisherService,
+  RunMQService: () => RunMQService
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/runmq.module.ts
+var import_common5 = require("@nestjs/common");
+var import_core2 = require("@nestjs/core");
+var import_runmq = require("runmq");
+
+// src/constants.ts
+var RUNMQ_INSTANCE = /* @__PURE__ */ Symbol("RUNMQ_INSTANCE");
+var RUNMQ_MODULE_OPTIONS = /* @__PURE__ */ Symbol("RUNMQ_MODULE_OPTIONS");
+var RUNMQ_PROCESSOR_METADATA = "RUNMQ_PROCESSOR";
+var RUNMQ_HANDLER_METADATA = "RUNMQ_HANDLER";
+
+// src/runmq.service.ts
+var import_common = require("@nestjs/common");
+var RunMQService = class {
+  constructor(_instance) {
+    this._instance = _instance;
+    this.logger = new import_common.Logger(RunMQService.name);
+  }
+  async onModuleDestroy() {
+    try {
+      await this._instance.disconnect();
+    } catch (error) {
+      this.logger.error(
+        `RunMQ disconnect error: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  get instance() {
+    return this._instance;
+  }
+};
+RunMQService = __decorateClass([
+  (0, import_common.Injectable)(),
+  __decorateParam(0, (0, import_common.Inject)(RUNMQ_INSTANCE))
+], RunMQService);
+
+// src/runmq-explorer.service.ts
+var import_common2 = require("@nestjs/common");
+var import_core = require("@nestjs/core");
+var RunMQExplorerService = class {
+  constructor(discoveryService, runmq) {
+    this.discoveryService = discoveryService;
+    this.runmq = runmq;
+  }
+  async onModuleInit() {
+    var _b;
+    const providers = this.discoveryService.getProviders();
+    const registeredNames = /* @__PURE__ */ new Set();
+    for (const wrapper of providers) {
+      const { instance, metatype } = wrapper;
+      if (!instance || !metatype) continue;
+      const processorOptions = Reflect.getMetadata(RUNMQ_PROCESSOR_METADATA, metatype);
+      if (!processorOptions) continue;
+      const className = metatype.name;
+      if (registeredNames.has(processorOptions.name)) {
+        throw new Error(`Duplicate processor name: ${processorOptions.name}`);
+      }
+      const prototype = Object.getPrototypeOf(instance);
+      const methodNames = Object.getOwnPropertyNames(prototype).filter(
+        (key) => key !== "constructor"
+      );
+      const handlerMethods = methodNames.filter(
+        (key) => Reflect.getMetadata(RUNMQ_HANDLER_METADATA, prototype, key)
+      );
+      if (handlerMethods.length === 0) {
+        throw new Error(
+          `No @ProcessMessage handler found in ${className}`
+        );
+      }
+      if (handlerMethods.length > 1) {
+        throw new Error(
+          `Multiple @ProcessMessage handlers in ${className}`
+        );
+      }
+      registeredNames.add(processorOptions.name);
+      const handlerName = handlerMethods[0];
+      const handler = instance[handlerName].bind(instance);
+      const _a = processorOptions, { topic } = _a, config = __objRest(_a, ["topic"]);
+      await this.runmq.process(
+        topic,
+        __spreadProps(__spreadValues({}, config), { consumersCount: (_b = config.consumersCount) != null ? _b : 1 }),
+        handler
+      );
+    }
+  }
+};
+RunMQExplorerService = __decorateClass([
+  (0, import_common2.Injectable)(),
+  __decorateParam(0, (0, import_common2.Inject)(import_core.DiscoveryService)),
+  __decorateParam(1, (0, import_common2.Inject)(RUNMQ_INSTANCE))
+], RunMQExplorerService);
+
+// src/runmq-publisher.service.ts
+var import_common3 = require("@nestjs/common");
+var RunMQPublisherService = class {
+  constructor(runmq) {
+    this.runmq = runmq;
+  }
+  publish(topic, message, correlationId) {
+    if (!this.runmq.isActive()) {
+      throw new Error("RunMQ is not connected");
+    }
+    this.runmq.publish(topic, message, correlationId);
+  }
+};
+RunMQPublisherService = __decorateClass([
+  (0, import_common3.Injectable)(),
+  __decorateParam(0, (0, import_common3.Inject)(RUNMQ_INSTANCE))
+], RunMQPublisherService);
+
+// src/logger-adapter.ts
+var import_common4 = require("@nestjs/common");
+var NestJSRunMQLogger = class {
+  constructor() {
+    this.logger = new import_common4.Logger("RunMQ");
+  }
+  log(message, ...optionalParams) {
+    this.logger.log(message, ...optionalParams);
+  }
+  error(message, ...optionalParams) {
+    this.logger.error(message, ...optionalParams);
+  }
+  warn(message, ...optionalParams) {
+    this.logger.warn(message, ...optionalParams);
+  }
+  info(message, ...optionalParams) {
+    this.logger.log(message, ...optionalParams);
+  }
+  debug(message, ...optionalParams) {
+    this.logger.debug(message, ...optionalParams);
+  }
+  verbose(message, ...optionalParams) {
+    this.logger.verbose(message, ...optionalParams);
+  }
+};
+
+// src/runmq.module.ts
+var RunMQModule = class {
+  static forRoot(options) {
+    return RunMQModule.buildDynamicModule(
+      [{ provide: RUNMQ_MODULE_OPTIONS, useValue: options }]
+    );
+  }
+  static forRootAsync(options) {
+    return RunMQModule.buildDynamicModule(
+      RunMQModule.createAsyncProviders(options),
+      options.imports
+    );
+  }
+  static buildDynamicModule(optionsProviders, extraImports = []) {
+    return {
+      global: true,
+      module: RunMQModule,
+      imports: [import_core2.DiscoveryModule, ...extraImports],
+      providers: [
+        ...optionsProviders,
+        {
+          provide: RUNMQ_INSTANCE,
+          useFactory: async (options) => import_runmq.RunMQ.start(options, new NestJSRunMQLogger()),
+          inject: [RUNMQ_MODULE_OPTIONS]
+        },
+        RunMQService,
+        RunMQExplorerService,
+        RunMQPublisherService
+      ],
+      exports: [RunMQService, RUNMQ_INSTANCE, RunMQPublisherService]
+    };
+  }
+  static createAsyncProviders(options) {
+    var _a;
+    if (options.useFactory) {
+      return [
+        {
+          provide: RUNMQ_MODULE_OPTIONS,
+          useFactory: options.useFactory,
+          inject: (_a = options.inject) != null ? _a : []
+        }
+      ];
+    }
+    if (options.useClass) {
+      return [
+        {
+          provide: RUNMQ_MODULE_OPTIONS,
+          useFactory: async (factory) => factory.createRunMQOptions(),
+          inject: [options.useClass]
+        },
+        {
+          provide: options.useClass,
+          useClass: options.useClass
+        }
+      ];
+    }
+    if (options.useExisting) {
+      return [
+        {
+          provide: RUNMQ_MODULE_OPTIONS,
+          useFactory: async (factory) => factory.createRunMQOptions(),
+          inject: [options.useExisting]
+        }
+      ];
+    }
+    throw new Error(
+      "RunMQModule.forRootAsync() requires useFactory, useClass, or useExisting"
+    );
+  }
+};
+RunMQModule = __decorateClass([
+  (0, import_common5.Module)({})
+], RunMQModule);
+
+// src/decorators/processor.decorator.ts
+var import_reflect_metadata = require("reflect-metadata");
+function Processor(options) {
+  return (target) => {
+    Reflect.defineMetadata(RUNMQ_PROCESSOR_METADATA, options, target);
+  };
+}
+
+// src/decorators/process-message.decorator.ts
+var import_reflect_metadata2 = require("reflect-metadata");
+function ProcessMessage() {
+  return (target, propertyKey) => {
+    Reflect.defineMetadata(RUNMQ_HANDLER_METADATA, propertyKey, target, propertyKey);
+  };
+}
+
+// src/decorators/inject-runmq.decorator.ts
+var import_common6 = require("@nestjs/common");
+var InjectRunMQ = () => (0, import_common6.Inject)(RUNMQ_INSTANCE);
+
+// src/index.ts
+var import_runmq5 = require("runmq");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InjectRunMQ,
+  ProcessMessage,
+  Processor,
+  RunMQ,
+  RunMQModule,
+  RunMQPublisherService,
+  RunMQService
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/runmq.module.ts","../src/constants.ts","../src/runmq.service.ts","../src/runmq-explorer.service.ts","../src/runmq-publisher.service.ts","../src/logger-adapter.ts","../src/decorators/processor.decorator.ts","../src/decorators/process-message.decorator.ts","../src/decorators/inject-runmq.decorator.ts"],"sourcesContent":["export { RunMQModule } from './runmq.module';\n\nexport { RunMQService } from './runmq.service';\nexport { RunMQPublisherService } from './runmq-publisher.service';\n\nexport { Processor } from './decorators/processor.decorator';\nexport { ProcessMessage } from './decorators/process-message.decorator';\nexport { InjectRunMQ } from './decorators/inject-runmq.decorator';\n\nexport type { RunMQModuleOptions, RunMQOptionsFactory } from './interfaces/runmq-module-options.interface';\nexport type { RunMQAsyncModuleOptions } from './interfaces/runmq-async-options.interface';\nexport type { ProcessorDecoratorOptions } from './decorators/processor.decorator';\n\nexport type {\n  RunMQMessageContent,\n  RunMQMessageMetaContent,\n  RunMQConnectionConfig,\n  RunMQProcessorConfiguration,\n  MessageSchema,\n  SchemaType,\n  SchemaFailureStrategy,\n  RabbitMQManagementConfig,\n  RunMQLogger,\n  RunMQQueueMetadata,\n} from 'runmq';\nexport { RunMQ } from 'runmq';\n","import { DynamicModule, Module, Provider } from '@nestjs/common';\nimport { DiscoveryModule } from '@nestjs/core';\nimport { RunMQ } from 'runmq';\nimport { RUNMQ_INSTANCE, RUNMQ_MODULE_OPTIONS } from './constants';\nimport { RunMQModuleOptions, RunMQOptionsFactory } from './interfaces/runmq-module-options.interface';\nimport { RunMQAsyncModuleOptions } from './interfaces/runmq-async-options.interface';\nimport { RunMQService } from './runmq.service';\nimport { RunMQExplorerService } from './runmq-explorer.service';\nimport { RunMQPublisherService } from './runmq-publisher.service';\nimport { NestJSRunMQLogger } from './logger-adapter';\n\n@Module({})\nexport class RunMQModule {\n  static forRoot(options: RunMQModuleOptions): DynamicModule {\n    return RunMQModule.buildDynamicModule(\n      [{ provide: RUNMQ_MODULE_OPTIONS, useValue: options }],\n    );\n  }\n\n  static forRootAsync(options: RunMQAsyncModuleOptions): DynamicModule {\n    return RunMQModule.buildDynamicModule(\n      RunMQModule.createAsyncProviders(options),\n      options.imports,\n    );\n  }\n\n  private static buildDynamicModule(\n    optionsProviders: Provider[],\n    extraImports: any[] = [],\n  ): DynamicModule {\n    return {\n      global: true,\n      module: RunMQModule,\n      imports: [DiscoveryModule, ...extraImports],\n      providers: [\n        ...optionsProviders,\n        {\n          provide: RUNMQ_INSTANCE,\n          useFactory: async (options: RunMQModuleOptions) =>\n            RunMQ.start(options, new NestJSRunMQLogger()),\n          inject: [RUNMQ_MODULE_OPTIONS],\n        },\n        RunMQService,\n        RunMQExplorerService,\n        RunMQPublisherService,\n      ],\n      exports: [RunMQService, RUNMQ_INSTANCE, RunMQPublisherService],\n    };\n  }\n\n  private static createAsyncProviders(options: RunMQAsyncModuleOptions): Provider[] {\n    if (options.useFactory) {\n      return [\n        {\n          provide: RUNMQ_MODULE_OPTIONS,\n          useFactory: options.useFactory,\n          inject: options.inject ?? [],\n        },\n      ];\n    }\n\n    if (options.useClass) {\n      return [\n        {\n          provide: RUNMQ_MODULE_OPTIONS,\n          useFactory: async (factory: RunMQOptionsFactory) =>\n            factory.createRunMQOptions(),\n          inject: [options.useClass],\n        },\n        {\n          provide: options.useClass,\n          useClass: options.useClass,\n        },\n      ];\n    }\n\n    if (options.useExisting) {\n      return [\n        {\n          provide: RUNMQ_MODULE_OPTIONS,\n          useFactory: async (factory: RunMQOptionsFactory) =>\n            factory.createRunMQOptions(),\n          inject: [options.useExisting],\n        },\n      ];\n    }\n\n    throw new Error(\n      'RunMQModule.forRootAsync() requires useFactory, useClass, or useExisting',\n    );\n  }\n}\n","export const RUNMQ_INSTANCE = Symbol('RUNMQ_INSTANCE');\nexport const RUNMQ_MODULE_OPTIONS = Symbol('RUNMQ_MODULE_OPTIONS');\n\nexport const RUNMQ_PROCESSOR_METADATA = 'RUNMQ_PROCESSOR';\nexport const RUNMQ_HANDLER_METADATA = 'RUNMQ_HANDLER';\n","import { Injectable, Inject, OnModuleDestroy, Logger } from '@nestjs/common';\nimport { RunMQ } from 'runmq';\nimport { RUNMQ_INSTANCE } from './constants';\n\n@Injectable()\nexport class RunMQService implements OnModuleDestroy {\n  private readonly logger = new Logger(RunMQService.name);\n\n  constructor(\n    @Inject(RUNMQ_INSTANCE) private readonly _instance: RunMQ,\n  ) {}\n\n  async onModuleDestroy(): Promise<void> {\n    try {\n      await this._instance.disconnect();\n    } catch (error) {\n      this.logger.error(\n        `RunMQ disconnect error: ${error instanceof Error ? error.message : String(error)}`,\n      );\n    }\n  }\n\n  get instance(): RunMQ {\n    return this._instance;\n  }\n}\n","import { Injectable, Inject, OnModuleInit } from '@nestjs/common';\nimport { DiscoveryService } from '@nestjs/core';\nimport { RunMQ } from 'runmq';\nimport { RUNMQ_PROCESSOR_METADATA, RUNMQ_HANDLER_METADATA, RUNMQ_INSTANCE } from './constants';\nimport type { ProcessorDecoratorOptions } from './decorators/processor.decorator';\n\n@Injectable()\nexport class RunMQExplorerService implements OnModuleInit {\n  constructor(\n    @Inject(DiscoveryService) private readonly discoveryService: DiscoveryService,\n    @Inject(RUNMQ_INSTANCE) private readonly runmq: RunMQ,\n  ) {}\n\n  async onModuleInit(): Promise<void> {\n    const providers = this.discoveryService.getProviders();\n    const registeredNames = new Set<string>();\n\n    for (const wrapper of providers) {\n      const { instance, metatype } = wrapper;\n\n      if (!instance || !metatype) continue;\n\n      const processorOptions: ProcessorDecoratorOptions | undefined =\n        Reflect.getMetadata(RUNMQ_PROCESSOR_METADATA, metatype);\n\n      if (!processorOptions) continue;\n\n      const className = metatype.name;\n\n      // Check for duplicate processor names\n      if (registeredNames.has(processorOptions.name)) {\n        throw new Error(`Duplicate processor name: ${processorOptions.name}`);\n      }\n\n      // Find method decorated with @ProcessMessage()\n      const prototype = Object.getPrototypeOf(instance);\n      const methodNames = Object.getOwnPropertyNames(prototype).filter(\n        (key) => key !== 'constructor',\n      );\n\n      const handlerMethods = methodNames.filter((key) =>\n        Reflect.getMetadata(RUNMQ_HANDLER_METADATA, prototype, key),\n      );\n\n      if (handlerMethods.length === 0) {\n        throw new Error(\n          `No @ProcessMessage handler found in ${className}`,\n        );\n      }\n\n      if (handlerMethods.length > 1) {\n        throw new Error(\n          `Multiple @ProcessMessage handlers in ${className}`,\n        );\n      }\n\n      registeredNames.add(processorOptions.name);\n\n      const handlerName = handlerMethods[0];\n      const handler = instance[handlerName].bind(instance);\n\n      const { topic, ...config } = processorOptions;\n      await this.runmq.process(\n        topic,\n        { ...config, consumersCount: config.consumersCount ?? 1 },\n        handler,\n      );\n    }\n  }\n}\n","import { Injectable, Inject } from '@nestjs/common';\nimport { RunMQ } from 'runmq';\nimport { RUNMQ_INSTANCE } from './constants';\n\n@Injectable()\nexport class RunMQPublisherService {\n  constructor(\n    @Inject(RUNMQ_INSTANCE) private readonly runmq: RunMQ,\n  ) {}\n\n  publish(topic: string, message: Record<string, any>, correlationId?: string): void {\n    if (!this.runmq.isActive()) {\n      throw new Error('RunMQ is not connected');\n    }\n    this.runmq.publish(topic, message, correlationId);\n  }\n}\n","import { Logger } from '@nestjs/common';\nimport type { RunMQLogger } from 'runmq';\n\nexport class NestJSRunMQLogger implements RunMQLogger {\n  private readonly logger = new Logger('RunMQ');\n\n  log(message: string, ...optionalParams: any[]): void {\n    this.logger.log(message, ...optionalParams);\n  }\n\n  error(message: string, ...optionalParams: any[]): void {\n    this.logger.error(message, ...optionalParams);\n  }\n\n  warn(message: string, ...optionalParams: any[]): void {\n    this.logger.warn(message, ...optionalParams);\n  }\n\n  info(message: string, ...optionalParams: any[]): void {\n    this.logger.log(message, ...optionalParams);\n  }\n\n  debug(message: string, ...optionalParams: any[]): void {\n    this.logger.debug(message, ...optionalParams);\n  }\n\n  verbose(message: string, ...optionalParams: any[]): void {\n    this.logger.verbose(message, ...optionalParams);\n  }\n}\n","import 'reflect-metadata';\nimport { RUNMQ_PROCESSOR_METADATA } from '../constants';\nimport type { MessageSchema } from 'runmq';\n\nexport interface ProcessorDecoratorOptions {\n  topic: string;\n  name: string;\n  consumersCount?: number;\n  attempts?: number;\n  attemptsDelay?: number;\n  messageSchema?: MessageSchema;\n  usePoliciesForDelay?: boolean;\n}\n\nexport function Processor(options: ProcessorDecoratorOptions): ClassDecorator {\n  return (target) => {\n    Reflect.defineMetadata(RUNMQ_PROCESSOR_METADATA, options, target);\n  };\n}\n","import 'reflect-metadata';\nimport { RUNMQ_HANDLER_METADATA } from '../constants';\n\nexport function ProcessMessage(): MethodDecorator {\n  return (target, propertyKey) => {\n    Reflect.defineMetadata(RUNMQ_HANDLER_METADATA, propertyKey, target, propertyKey);\n  };\n}\n","import { Inject } from '@nestjs/common';\nimport { RUNMQ_INSTANCE } from '../constants';\n\nexport const InjectRunMQ = (): ParameterDecorator => Inject(RUNMQ_INSTANCE);\n"],"mappings":"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","names":["import_common","import_core","import_common","import_common","import_common","import_reflect_metadata","import_common","import_runmq"]}

package/dist/index.d.cts

@@ -0,0 +1,58 @@
+import { ModuleMetadata, Type, DynamicModule, OnModuleDestroy } from '@nestjs/common';
+import { RabbitMQManagementConfig, RunMQ, MessageSchema } from 'runmq';
+export { MessageSchema, RabbitMQManagementConfig, RunMQ, RunMQConnectionConfig, RunMQLogger, RunMQMessageContent, RunMQMessageMetaContent, RunMQProcessorConfiguration, RunMQQueueMetadata, SchemaFailureStrategy, SchemaType } from 'runmq';
+
+interface RunMQModuleOptions {
+    url: string;
+    reconnectDelay?: number;
+    maxReconnectAttempts?: number;
+    management?: RabbitMQManagementConfig;
+}
+interface RunMQOptionsFactory {
+    createRunMQOptions(): RunMQModuleOptions | Promise<RunMQModuleOptions>;
+}
+
+interface RunMQAsyncModuleOptions extends Pick<ModuleMetadata, 'imports'> {
+    useFactory?: (...args: any[]) => RunMQModuleOptions | Promise<RunMQModuleOptions>;
+    inject?: any[];
+    useClass?: Type<RunMQOptionsFactory>;
+    useExisting?: Type<RunMQOptionsFactory>;
+}
+
+declare class RunMQModule {
+    static forRoot(options: RunMQModuleOptions): DynamicModule;
+    static forRootAsync(options: RunMQAsyncModuleOptions): DynamicModule;
+    private static buildDynamicModule;
+    private static createAsyncProviders;
+}
+
+declare class RunMQService implements OnModuleDestroy {
+    private readonly _instance;
+    private readonly logger;
+    constructor(_instance: RunMQ);
+    onModuleDestroy(): Promise<void>;
+    get instance(): RunMQ;
+}
+
+declare class RunMQPublisherService {
+    private readonly runmq;
+    constructor(runmq: RunMQ);
+    publish(topic: string, message: Record<string, any>, correlationId?: string): void;
+}
+
+interface ProcessorDecoratorOptions {
+    topic: string;
+    name: string;
+    consumersCount?: number;
+    attempts?: number;
+    attemptsDelay?: number;
+    messageSchema?: MessageSchema;
+    usePoliciesForDelay?: boolean;
+}
+declare function Processor(options: ProcessorDecoratorOptions): ClassDecorator;
+
+declare function ProcessMessage(): MethodDecorator;
+
+declare const InjectRunMQ: () => ParameterDecorator;
+
+export { InjectRunMQ, ProcessMessage, Processor, type ProcessorDecoratorOptions, type RunMQAsyncModuleOptions, RunMQModule, type RunMQModuleOptions, type RunMQOptionsFactory, RunMQPublisherService, RunMQService };

package/dist/index.d.ts

@@ -0,0 +1,58 @@
+import { ModuleMetadata, Type, DynamicModule, OnModuleDestroy } from '@nestjs/common';
+import { RabbitMQManagementConfig, RunMQ, MessageSchema } from 'runmq';
+export { MessageSchema, RabbitMQManagementConfig, RunMQ, RunMQConnectionConfig, RunMQLogger, RunMQMessageContent, RunMQMessageMetaContent, RunMQProcessorConfiguration, RunMQQueueMetadata, SchemaFailureStrategy, SchemaType } from 'runmq';
+
+interface RunMQModuleOptions {
+    url: string;
+    reconnectDelay?: number;
+    maxReconnectAttempts?: number;
+    management?: RabbitMQManagementConfig;
+}
+interface RunMQOptionsFactory {
+    createRunMQOptions(): RunMQModuleOptions | Promise<RunMQModuleOptions>;
+}
+
+interface RunMQAsyncModuleOptions extends Pick<ModuleMetadata, 'imports'> {
+    useFactory?: (...args: any[]) => RunMQModuleOptions | Promise<RunMQModuleOptions>;
+    inject?: any[];
+    useClass?: Type<RunMQOptionsFactory>;
+    useExisting?: Type<RunMQOptionsFactory>;
+}
+
+declare class RunMQModule {
+    static forRoot(options: RunMQModuleOptions): DynamicModule;
+    static forRootAsync(options: RunMQAsyncModuleOptions): DynamicModule;
+    private static buildDynamicModule;
+    private static createAsyncProviders;
+}
+
+declare class RunMQService implements OnModuleDestroy {
+    private readonly _instance;
+    private readonly logger;
+    constructor(_instance: RunMQ);
+    onModuleDestroy(): Promise<void>;
+    get instance(): RunMQ;
+}
+
+declare class RunMQPublisherService {
+    private readonly runmq;
+    constructor(runmq: RunMQ);
+    publish(topic: string, message: Record<string, any>, correlationId?: string): void;
+}
+
+interface ProcessorDecoratorOptions {
+    topic: string;
+    name: string;
+    consumersCount?: number;
+    attempts?: number;
+    attemptsDelay?: number;
+    messageSchema?: MessageSchema;
+    usePoliciesForDelay?: boolean;
+}
+declare function Processor(options: ProcessorDecoratorOptions): ClassDecorator;
+
+declare function ProcessMessage(): MethodDecorator;
+
+declare const InjectRunMQ: () => ParameterDecorator;
+
+export { InjectRunMQ, ProcessMessage, Processor, type ProcessorDecoratorOptions, type RunMQAsyncModuleOptions, RunMQModule, type RunMQModuleOptions, type RunMQOptionsFactory, RunMQPublisherService, RunMQService };

package/dist/index.js

@@ -0,0 +1,284 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+
+// src/runmq.module.ts
+import { Module } from "@nestjs/common";
+import { DiscoveryModule } from "@nestjs/core";
+import { RunMQ } from "runmq";
+
+// src/constants.ts
+var RUNMQ_INSTANCE = /* @__PURE__ */ Symbol("RUNMQ_INSTANCE");
+var RUNMQ_MODULE_OPTIONS = /* @__PURE__ */ Symbol("RUNMQ_MODULE_OPTIONS");
+var RUNMQ_PROCESSOR_METADATA = "RUNMQ_PROCESSOR";
+var RUNMQ_HANDLER_METADATA = "RUNMQ_HANDLER";
+
+// src/runmq.service.ts
+import { Injectable, Inject, Logger } from "@nestjs/common";
+var RunMQService = class {
+  constructor(_instance) {
+    this._instance = _instance;
+    this.logger = new Logger(RunMQService.name);
+  }
+  async onModuleDestroy() {
+    try {
+      await this._instance.disconnect();
+    } catch (error) {
+      this.logger.error(
+        `RunMQ disconnect error: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  get instance() {
+    return this._instance;
+  }
+};
+RunMQService = __decorateClass([
+  Injectable(),
+  __decorateParam(0, Inject(RUNMQ_INSTANCE))
+], RunMQService);
+
+// src/runmq-explorer.service.ts
+import { Injectable as Injectable2, Inject as Inject2 } from "@nestjs/common";
+import { DiscoveryService } from "@nestjs/core";
+var RunMQExplorerService = class {
+  constructor(discoveryService, runmq) {
+    this.discoveryService = discoveryService;
+    this.runmq = runmq;
+  }
+  async onModuleInit() {
+    var _b;
+    const providers = this.discoveryService.getProviders();
+    const registeredNames = /* @__PURE__ */ new Set();
+    for (const wrapper of providers) {
+      const { instance, metatype } = wrapper;
+      if (!instance || !metatype) continue;
+      const processorOptions = Reflect.getMetadata(RUNMQ_PROCESSOR_METADATA, metatype);
+      if (!processorOptions) continue;
+      const className = metatype.name;
+      if (registeredNames.has(processorOptions.name)) {
+        throw new Error(`Duplicate processor name: ${processorOptions.name}`);
+      }
+      const prototype = Object.getPrototypeOf(instance);
+      const methodNames = Object.getOwnPropertyNames(prototype).filter(
+        (key) => key !== "constructor"
+      );
+      const handlerMethods = methodNames.filter(
+        (key) => Reflect.getMetadata(RUNMQ_HANDLER_METADATA, prototype, key)
+      );
+      if (handlerMethods.length === 0) {
+        throw new Error(
+          `No @ProcessMessage handler found in ${className}`
+        );
+      }
+      if (handlerMethods.length > 1) {
+        throw new Error(
+          `Multiple @ProcessMessage handlers in ${className}`
+        );
+      }
+      registeredNames.add(processorOptions.name);
+      const handlerName = handlerMethods[0];
+      const handler = instance[handlerName].bind(instance);
+      const _a = processorOptions, { topic } = _a, config = __objRest(_a, ["topic"]);
+      await this.runmq.process(
+        topic,
+        __spreadProps(__spreadValues({}, config), { consumersCount: (_b = config.consumersCount) != null ? _b : 1 }),
+        handler
+      );
+    }
+  }
+};
+RunMQExplorerService = __decorateClass([
+  Injectable2(),
+  __decorateParam(0, Inject2(DiscoveryService)),
+  __decorateParam(1, Inject2(RUNMQ_INSTANCE))
+], RunMQExplorerService);
+
+// src/runmq-publisher.service.ts
+import { Injectable as Injectable3, Inject as Inject3 } from "@nestjs/common";
+var RunMQPublisherService = class {
+  constructor(runmq) {
+    this.runmq = runmq;
+  }
+  publish(topic, message, correlationId) {
+    if (!this.runmq.isActive()) {
+      throw new Error("RunMQ is not connected");
+    }
+    this.runmq.publish(topic, message, correlationId);
+  }
+};
+RunMQPublisherService = __decorateClass([
+  Injectable3(),
+  __decorateParam(0, Inject3(RUNMQ_INSTANCE))
+], RunMQPublisherService);
+
+// src/logger-adapter.ts
+import { Logger as Logger2 } from "@nestjs/common";
+var NestJSRunMQLogger = class {
+  constructor() {
+    this.logger = new Logger2("RunMQ");
+  }
+  log(message, ...optionalParams) {
+    this.logger.log(message, ...optionalParams);
+  }
+  error(message, ...optionalParams) {
+    this.logger.error(message, ...optionalParams);
+  }
+  warn(message, ...optionalParams) {
+    this.logger.warn(message, ...optionalParams);
+  }
+  info(message, ...optionalParams) {
+    this.logger.log(message, ...optionalParams);
+  }
+  debug(message, ...optionalParams) {
+    this.logger.debug(message, ...optionalParams);
+  }
+  verbose(message, ...optionalParams) {
+    this.logger.verbose(message, ...optionalParams);
+  }
+};
+
+// src/runmq.module.ts
+var RunMQModule = class {
+  static forRoot(options) {
+    return RunMQModule.buildDynamicModule(
+      [{ provide: RUNMQ_MODULE_OPTIONS, useValue: options }]
+    );
+  }
+  static forRootAsync(options) {
+    return RunMQModule.buildDynamicModule(
+      RunMQModule.createAsyncProviders(options),
+      options.imports
+    );
+  }
+  static buildDynamicModule(optionsProviders, extraImports = []) {
+    return {
+      global: true,
+      module: RunMQModule,
+      imports: [DiscoveryModule, ...extraImports],
+      providers: [
+        ...optionsProviders,
+        {
+          provide: RUNMQ_INSTANCE,
+          useFactory: async (options) => RunMQ.start(options, new NestJSRunMQLogger()),
+          inject: [RUNMQ_MODULE_OPTIONS]
+        },
+        RunMQService,
+        RunMQExplorerService,
+        RunMQPublisherService
+      ],
+      exports: [RunMQService, RUNMQ_INSTANCE, RunMQPublisherService]
+    };
+  }
+  static createAsyncProviders(options) {
+    var _a;
+    if (options.useFactory) {
+      return [
+        {
+          provide: RUNMQ_MODULE_OPTIONS,
+          useFactory: options.useFactory,
+          inject: (_a = options.inject) != null ? _a : []
+        }
+      ];
+    }
+    if (options.useClass) {
+      return [
+        {
+          provide: RUNMQ_MODULE_OPTIONS,
+          useFactory: async (factory) => factory.createRunMQOptions(),
+          inject: [options.useClass]
+        },
+        {
+          provide: options.useClass,
+          useClass: options.useClass
+        }
+      ];
+    }
+    if (options.useExisting) {
+      return [
+        {
+          provide: RUNMQ_MODULE_OPTIONS,
+          useFactory: async (factory) => factory.createRunMQOptions(),
+          inject: [options.useExisting]
+        }
+      ];
+    }
+    throw new Error(
+      "RunMQModule.forRootAsync() requires useFactory, useClass, or useExisting"
+    );
+  }
+};
+RunMQModule = __decorateClass([
+  Module({})
+], RunMQModule);
+
+// src/decorators/processor.decorator.ts
+import "reflect-metadata";
+function Processor(options) {
+  return (target) => {
+    Reflect.defineMetadata(RUNMQ_PROCESSOR_METADATA, options, target);
+  };
+}
+
+// src/decorators/process-message.decorator.ts
+import "reflect-metadata";
+function ProcessMessage() {
+  return (target, propertyKey) => {
+    Reflect.defineMetadata(RUNMQ_HANDLER_METADATA, propertyKey, target, propertyKey);
+  };
+}
+
+// src/decorators/inject-runmq.decorator.ts
+import { Inject as Inject4 } from "@nestjs/common";
+var InjectRunMQ = () => Inject4(RUNMQ_INSTANCE);
+
+// src/index.ts
+import { RunMQ as RunMQ2 } from "runmq";
+export {
+  InjectRunMQ,
+  ProcessMessage,
+  Processor,
+  RunMQ2 as RunMQ,
+  RunMQModule,
+  RunMQPublisherService,
+  RunMQService
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/runmq.module.ts","../src/constants.ts","../src/runmq.service.ts","../src/runmq-explorer.service.ts","../src/runmq-publisher.service.ts","../src/logger-adapter.ts","../src/decorators/processor.decorator.ts","../src/decorators/process-message.decorator.ts","../src/decorators/inject-runmq.decorator.ts","../src/index.ts"],"sourcesContent":["import { DynamicModule, Module, Provider } from '@nestjs/common';\nimport { DiscoveryModule } from '@nestjs/core';\nimport { RunMQ } from 'runmq';\nimport { RUNMQ_INSTANCE, RUNMQ_MODULE_OPTIONS } from './constants';\nimport { RunMQModuleOptions, RunMQOptionsFactory } from './interfaces/runmq-module-options.interface';\nimport { RunMQAsyncModuleOptions } from './interfaces/runmq-async-options.interface';\nimport { RunMQService } from './runmq.service';\nimport { RunMQExplorerService } from './runmq-explorer.service';\nimport { RunMQPublisherService } from './runmq-publisher.service';\nimport { NestJSRunMQLogger } from './logger-adapter';\n\n@Module({})\nexport class RunMQModule {\n  static forRoot(options: RunMQModuleOptions): DynamicModule {\n    return RunMQModule.buildDynamicModule(\n      [{ provide: RUNMQ_MODULE_OPTIONS, useValue: options }],\n    );\n  }\n\n  static forRootAsync(options: RunMQAsyncModuleOptions): DynamicModule {\n    return RunMQModule.buildDynamicModule(\n      RunMQModule.createAsyncProviders(options),\n      options.imports,\n    );\n  }\n\n  private static buildDynamicModule(\n    optionsProviders: Provider[],\n    extraImports: any[] = [],\n  ): DynamicModule {\n    return {\n      global: true,\n      module: RunMQModule,\n      imports: [DiscoveryModule, ...extraImports],\n      providers: [\n        ...optionsProviders,\n        {\n          provide: RUNMQ_INSTANCE,\n          useFactory: async (options: RunMQModuleOptions) =>\n            RunMQ.start(options, new NestJSRunMQLogger()),\n          inject: [RUNMQ_MODULE_OPTIONS],\n        },\n        RunMQService,\n        RunMQExplorerService,\n        RunMQPublisherService,\n      ],\n      exports: [RunMQService, RUNMQ_INSTANCE, RunMQPublisherService],\n    };\n  }\n\n  private static createAsyncProviders(options: RunMQAsyncModuleOptions): Provider[] {\n    if (options.useFactory) {\n      return [\n        {\n          provide: RUNMQ_MODULE_OPTIONS,\n          useFactory: options.useFactory,\n          inject: options.inject ?? [],\n        },\n      ];\n    }\n\n    if (options.useClass) {\n      return [\n        {\n          provide: RUNMQ_MODULE_OPTIONS,\n          useFactory: async (factory: RunMQOptionsFactory) =>\n            factory.createRunMQOptions(),\n          inject: [options.useClass],\n        },\n        {\n          provide: options.useClass,\n          useClass: options.useClass,\n        },\n      ];\n    }\n\n    if (options.useExisting) {\n      return [\n        {\n          provide: RUNMQ_MODULE_OPTIONS,\n          useFactory: async (factory: RunMQOptionsFactory) =>\n            factory.createRunMQOptions(),\n          inject: [options.useExisting],\n        },\n      ];\n    }\n\n    throw new Error(\n      'RunMQModule.forRootAsync() requires useFactory, useClass, or useExisting',\n    );\n  }\n}\n","export const RUNMQ_INSTANCE = Symbol('RUNMQ_INSTANCE');\nexport const RUNMQ_MODULE_OPTIONS = Symbol('RUNMQ_MODULE_OPTIONS');\n\nexport const RUNMQ_PROCESSOR_METADATA = 'RUNMQ_PROCESSOR';\nexport const RUNMQ_HANDLER_METADATA = 'RUNMQ_HANDLER';\n","import { Injectable, Inject, OnModuleDestroy, Logger } from '@nestjs/common';\nimport { RunMQ } from 'runmq';\nimport { RUNMQ_INSTANCE } from './constants';\n\n@Injectable()\nexport class RunMQService implements OnModuleDestroy {\n  private readonly logger = new Logger(RunMQService.name);\n\n  constructor(\n    @Inject(RUNMQ_INSTANCE) private readonly _instance: RunMQ,\n  ) {}\n\n  async onModuleDestroy(): Promise<void> {\n    try {\n      await this._instance.disconnect();\n    } catch (error) {\n      this.logger.error(\n        `RunMQ disconnect error: ${error instanceof Error ? error.message : String(error)}`,\n      );\n    }\n  }\n\n  get instance(): RunMQ {\n    return this._instance;\n  }\n}\n","import { Injectable, Inject, OnModuleInit } from '@nestjs/common';\nimport { DiscoveryService } from '@nestjs/core';\nimport { RunMQ } from 'runmq';\nimport { RUNMQ_PROCESSOR_METADATA, RUNMQ_HANDLER_METADATA, RUNMQ_INSTANCE } from './constants';\nimport type { ProcessorDecoratorOptions } from './decorators/processor.decorator';\n\n@Injectable()\nexport class RunMQExplorerService implements OnModuleInit {\n  constructor(\n    @Inject(DiscoveryService) private readonly discoveryService: DiscoveryService,\n    @Inject(RUNMQ_INSTANCE) private readonly runmq: RunMQ,\n  ) {}\n\n  async onModuleInit(): Promise<void> {\n    const providers = this.discoveryService.getProviders();\n    const registeredNames = new Set<string>();\n\n    for (const wrapper of providers) {\n      const { instance, metatype } = wrapper;\n\n      if (!instance || !metatype) continue;\n\n      const processorOptions: ProcessorDecoratorOptions | undefined =\n        Reflect.getMetadata(RUNMQ_PROCESSOR_METADATA, metatype);\n\n      if (!processorOptions) continue;\n\n      const className = metatype.name;\n\n      // Check for duplicate processor names\n      if (registeredNames.has(processorOptions.name)) {\n        throw new Error(`Duplicate processor name: ${processorOptions.name}`);\n      }\n\n      // Find method decorated with @ProcessMessage()\n      const prototype = Object.getPrototypeOf(instance);\n      const methodNames = Object.getOwnPropertyNames(prototype).filter(\n        (key) => key !== 'constructor',\n      );\n\n      const handlerMethods = methodNames.filter((key) =>\n        Reflect.getMetadata(RUNMQ_HANDLER_METADATA, prototype, key),\n      );\n\n      if (handlerMethods.length === 0) {\n        throw new Error(\n          `No @ProcessMessage handler found in ${className}`,\n        );\n      }\n\n      if (handlerMethods.length > 1) {\n        throw new Error(\n          `Multiple @ProcessMessage handlers in ${className}`,\n        );\n      }\n\n      registeredNames.add(processorOptions.name);\n\n      const handlerName = handlerMethods[0];\n      const handler = instance[handlerName].bind(instance);\n\n      const { topic, ...config } = processorOptions;\n      await this.runmq.process(\n        topic,\n        { ...config, consumersCount: config.consumersCount ?? 1 },\n        handler,\n      );\n    }\n  }\n}\n","import { Injectable, Inject } from '@nestjs/common';\nimport { RunMQ } from 'runmq';\nimport { RUNMQ_INSTANCE } from './constants';\n\n@Injectable()\nexport class RunMQPublisherService {\n  constructor(\n    @Inject(RUNMQ_INSTANCE) private readonly runmq: RunMQ,\n  ) {}\n\n  publish(topic: string, message: Record<string, any>, correlationId?: string): void {\n    if (!this.runmq.isActive()) {\n      throw new Error('RunMQ is not connected');\n    }\n    this.runmq.publish(topic, message, correlationId);\n  }\n}\n","import { Logger } from '@nestjs/common';\nimport type { RunMQLogger } from 'runmq';\n\nexport class NestJSRunMQLogger implements RunMQLogger {\n  private readonly logger = new Logger('RunMQ');\n\n  log(message: string, ...optionalParams: any[]): void {\n    this.logger.log(message, ...optionalParams);\n  }\n\n  error(message: string, ...optionalParams: any[]): void {\n    this.logger.error(message, ...optionalParams);\n  }\n\n  warn(message: string, ...optionalParams: any[]): void {\n    this.logger.warn(message, ...optionalParams);\n  }\n\n  info(message: string, ...optionalParams: any[]): void {\n    this.logger.log(message, ...optionalParams);\n  }\n\n  debug(message: string, ...optionalParams: any[]): void {\n    this.logger.debug(message, ...optionalParams);\n  }\n\n  verbose(message: string, ...optionalParams: any[]): void {\n    this.logger.verbose(message, ...optionalParams);\n  }\n}\n","import 'reflect-metadata';\nimport { RUNMQ_PROCESSOR_METADATA } from '../constants';\nimport type { MessageSchema } from 'runmq';\n\nexport interface ProcessorDecoratorOptions {\n  topic: string;\n  name: string;\n  consumersCount?: number;\n  attempts?: number;\n  attemptsDelay?: number;\n  messageSchema?: MessageSchema;\n  usePoliciesForDelay?: boolean;\n}\n\nexport function Processor(options: ProcessorDecoratorOptions): ClassDecorator {\n  return (target) => {\n    Reflect.defineMetadata(RUNMQ_PROCESSOR_METADATA, options, target);\n  };\n}\n","import 'reflect-metadata';\nimport { RUNMQ_HANDLER_METADATA } from '../constants';\n\nexport function ProcessMessage(): MethodDecorator {\n  return (target, propertyKey) => {\n    Reflect.defineMetadata(RUNMQ_HANDLER_METADATA, propertyKey, target, propertyKey);\n  };\n}\n","import { Inject } from '@nestjs/common';\nimport { RUNMQ_INSTANCE } from '../constants';\n\nexport const InjectRunMQ = (): ParameterDecorator => Inject(RUNMQ_INSTANCE);\n","export { RunMQModule } from './runmq.module';\n\nexport { RunMQService } from './runmq.service';\nexport { RunMQPublisherService } from './runmq-publisher.service';\n\nexport { Processor } from './decorators/processor.decorator';\nexport { ProcessMessage } from './decorators/process-message.decorator';\nexport { InjectRunMQ } from './decorators/inject-runmq.decorator';\n\nexport type { RunMQModuleOptions, RunMQOptionsFactory } from './interfaces/runmq-module-options.interface';\nexport type { RunMQAsyncModuleOptions } from './interfaces/runmq-async-options.interface';\nexport type { ProcessorDecoratorOptions } from './decorators/processor.decorator';\n\nexport type {\n  RunMQMessageContent,\n  RunMQMessageMetaContent,\n  RunMQConnectionConfig,\n  RunMQProcessorConfiguration,\n  MessageSchema,\n  SchemaType,\n  SchemaFailureStrategy,\n  RabbitMQManagementConfig,\n  RunMQLogger,\n  RunMQQueueMetadata,\n} from 'runmq';\nexport { RunMQ } from 'runmq';\n"],"mappings":"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","names":["Injectable","Inject","Injectable","Inject","Injectable","Inject","Injectable","Inject","Logger","Inject","Inject","RunMQ"]}

package/package.json

@@ -0,0 +1,115 @@
+{
+  "name": "nestjs-runmq",
+  "type": "module",
+  "version": "1.0.0",
+  "description": "NestJS module for RunMQ - a reliable, high-performance message queue library for Node.js, built on top of RabbitMQ",
+  "keywords": [
+    "nestjs",
+    "runmq",
+    "rabbitmq",
+    "message-queue",
+    "processors",
+    "microservices",
+    "decorator"
+  ],
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts",
+    "lint": "eslint .",
+    "lint:fix": "eslint --fix .",
+    "test": "jest",
+    "test:unit": "jest tests/unit",
+    "test:integration": "jest tests/integration",
+    "test:coverage": "jest --coverage"
+  },
+  "peerDependencies": {
+    "@nestjs/common": ">=10.0.0",
+    "@nestjs/core": ">=10.0.0",
+    "reflect-metadata": ">=0.1.0",
+    "runmq": ">=1.4.0",
+    "rxjs": ">=7.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/runmq/nestjs.git"
+  },
+  "author": "https://github.com/iifawzi",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bugs": {
+    "url": "https://github.com/runmq/nestjs/issues"
+  },
+  "homepage": "https://github.com/runmq/nestjs#readme",
+  "devDependencies": {
+    "@nestjs/common": "^10.0.0",
+    "@nestjs/core": "^10.0.0",
+    "@nestjs/testing": "^10.0.0",
+    "@eslint/js": "^9.29.0",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/commit-analyzer": "^10.0.4",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^11.0.1",
+    "@semantic-release/release-notes-generator": "^11.0.7",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^22.0.0",
+    "@types/supertest": "^6.0.0",
+    "eslint": "^9.29.0",
+    "globals": "^16.0.0",
+    "jest": "^30.0.3",
+    "reflect-metadata": "^0.2.2",
+    "runmq": "^1.4.0",
+    "rxjs": "^7.8.0",
+    "semantic-release": "^24.2.0",
+    "supertest": "^7.0.0",
+    "ts-jest": "^29.4.0",
+    "ts-node": "^10.9.2",
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.35.0"
+  },
+  "release": {
+    "branches": [
+      "main"
+    ],
+    "plugins": [
+      "@semantic-release/commit-analyzer",
+      "@semantic-release/release-notes-generator",
+      "@semantic-release/changelog",
+      [
+        "@semantic-release/github",
+        {
+          "assets": [
+            {
+              "path": "dist.zip",
+              "label": "Distribution"
+            }
+          ]
+        }
+      ],
+      [
+        "@semantic-release/git",
+        {
+          "assets": [
+            "package.json",
+            "CHANGELOG.md"
+          ],
+          "message": "chore(release): ${nextRelease.version} [skip ci]\n\n${nextRelease.notes}"
+        }
+      ]
+    ]
+  }
+}