@zdavison/matador-nest 2.0.1

package/dist/constants.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Metadata key for storing event handler metadata on methods.
+ */
+export declare const MATADOR_EVENT_HANDLER: unique symbol;
+/**
+ * Metadata key for storing a list of all event handlers on a class.
+ */
+export declare const MATADOR_EVENT_HANDLERS: unique symbol;
+/**
+ * Injection token for module options.
+ */
+export declare const MATADOR_OPTIONS: unique symbol;
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,qBAAqB,eAAkC,CAAC;AAErE;;GAEG;AACH,eAAO,MAAM,sBAAsB,eAAmC,CAAC;AAEvE;;GAEG;AACH,eAAO,MAAM,eAAe,eAA4B,CAAC"}

package/dist/constants.js

@@ -0,0 +1,12 @@
+/**
+ * Metadata key for storing event handler metadata on methods.
+ */
+export const MATADOR_EVENT_HANDLER = Symbol('MATADOR_EVENT_HANDLER');
+/**
+ * Metadata key for storing a list of all event handlers on a class.
+ */
+export const MATADOR_EVENT_HANDLERS = Symbol('MATADOR_EVENT_HANDLERS');
+/**
+ * Injection token for module options.
+ */
+export const MATADOR_OPTIONS = Symbol('MATADOR_OPTIONS');

package/dist/decorators/index.d.ts

@@ -0,0 +1,3 @@
+export { OnMatadorEvent } from './on-matador-event.decorator.js';
+export { MatadorSubscriber } from './matador-subscriber.decorator.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/decorators/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/decorators/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC"}

package/dist/decorators/index.js

@@ -0,0 +1,2 @@
+export { OnMatadorEvent } from './on-matador-event.decorator.js';
+export { MatadorSubscriber } from './matador-subscriber.decorator.js';

package/dist/decorators/matador-subscriber.decorator.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Optional class decorator that marks a class as a Matador subscriber.
+ * Classes with @OnMatadorEvent methods are auto-discovered, so this decorator
+ * is optional. Use it for explicit documentation or when you want to ensure
+ * a class is treated as a subscriber even if it has no decorated methods yet.
+ *
+ * @example
+ * ```typescript
+ * @MatadorSubscriber()
+ * @Injectable()
+ * export class NotificationService {
+ *   @OnMatadorEvent(UserCreatedEvent, { description: '...' })
+ *   async onUserCreated(envelope: Envelope<...>) {
+ *     // ...
+ *   }
+ * }
+ * ```
+ */
+export declare function MatadorSubscriber(): ClassDecorator;
+//# sourceMappingURL=matador-subscriber.decorator.d.ts.map

package/dist/decorators/matador-subscriber.decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matador-subscriber.decorator.d.ts","sourceRoot":"","sources":["../../src/decorators/matador-subscriber.decorator.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,IAAI,cAAc,CAMlD"}

package/dist/decorators/matador-subscriber.decorator.js

@@ -0,0 +1,26 @@
+import { Injectable } from '@nestjs/common';
+/**
+ * Optional class decorator that marks a class as a Matador subscriber.
+ * Classes with @OnMatadorEvent methods are auto-discovered, so this decorator
+ * is optional. Use it for explicit documentation or when you want to ensure
+ * a class is treated as a subscriber even if it has no decorated methods yet.
+ *
+ * @example
+ * ```typescript
+ * @MatadorSubscriber()
+ * @Injectable()
+ * export class NotificationService {
+ *   @OnMatadorEvent(UserCreatedEvent, { description: '...' })
+ *   async onUserCreated(envelope: Envelope<...>) {
+ *     // ...
+ *   }
+ * }
+ * ```
+ */
+export function MatadorSubscriber() {
+    return (target) => {
+        // Ensure the class is injectable (apply @Injectable if not already)
+        // This is a no-op if @Injectable was already applied
+        Injectable()(target);
+    };
+}

package/dist/decorators/on-matador-event.decorator.d.ts

@@ -0,0 +1,24 @@
+import type { EventClass } from '@zdavison/matador';
+import type { OnMatadorEventOptions } from '../types.js';
+/**
+ * Method decorator that marks a method as a Matador event subscriber.
+ *
+ * @param eventClass - The event class to subscribe to
+ * @param options - Subscriber options (description is required)
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * export class NotificationService {
+ *   @OnMatadorEvent(UserCreatedEvent, {
+ *     description: 'Sends welcome email to new users',
+ *     idempotent: 'yes',
+ *   })
+ *   async onUserCreated(envelope: Envelope<UserCreatedEvent['data']>) {
+ *     await this.emailService.sendWelcome(envelope.data.email);
+ *   }
+ * }
+ * ```
+ */
+export declare function OnMatadorEvent<T>(eventClass: EventClass<T>, options: OnMatadorEventOptions): (target: object, propertyKey: string | symbol, descriptor: PropertyDescriptor) => PropertyDescriptor;
+//# sourceMappingURL=on-matador-event.decorator.d.ts.map

package/dist/decorators/on-matador-event.decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"on-matador-event.decorator.d.ts","sourceRoot":"","sources":["../../src/decorators/on-matador-event.decorator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD,OAAO,KAAK,EAEV,qBAAqB,EACtB,MAAM,aAAa,CAAC;AAErB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAC9B,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,EACzB,OAAO,EAAE,qBAAqB,GAC7B,CACD,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,GAAG,MAAM,EAC5B,UAAU,EAAE,kBAAkB,KAC3B,kBAAkB,CAiCtB"}

package/dist/decorators/on-matador-event.decorator.js

@@ -0,0 +1,38 @@
+import { MATADOR_EVENT_HANDLER, MATADOR_EVENT_HANDLERS } from '../constants.js';
+/**
+ * Method decorator that marks a method as a Matador event subscriber.
+ *
+ * @param eventClass - The event class to subscribe to
+ * @param options - Subscriber options (description is required)
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * export class NotificationService {
+ *   @OnMatadorEvent(UserCreatedEvent, {
+ *     description: 'Sends welcome email to new users',
+ *     idempotent: 'yes',
+ *   })
+ *   async onUserCreated(envelope: Envelope<UserCreatedEvent['data']>) {
+ *     await this.emailService.sendWelcome(envelope.data.email);
+ *   }
+ * }
+ * ```
+ */
+export function OnMatadorEvent(eventClass, options) {
+    return (target, propertyKey, descriptor) => {
+        const metadata = {
+            eventClass: eventClass,
+            options,
+            methodName: String(propertyKey),
+        };
+        // Store metadata on the method itself
+        if (descriptor.value != null) {
+            Reflect.defineMetadata(MATADOR_EVENT_HANDLER, metadata, descriptor.value);
+        }
+        // Maintain a list of all handlers on the class for discovery
+        const existingHandlers = Reflect.getMetadata(MATADOR_EVENT_HANDLERS, target.constructor) ?? [];
+        Reflect.defineMetadata(MATADOR_EVENT_HANDLERS, [...existingHandlers, metadata], target.constructor);
+        return descriptor;
+    };
+}

package/dist/discovery/index.d.ts

@@ -0,0 +1,2 @@
+export { SubscriberDiscoveryService } from './subscriber-discovery.service.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/discovery/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/discovery/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,0BAA0B,EAAE,MAAM,mCAAmC,CAAC"}

package/dist/discovery/index.js

@@ -0,0 +1 @@
+export { SubscriberDiscoveryService } from './subscriber-discovery.service.js';

package/dist/discovery/subscriber-discovery.service.d.ts

@@ -0,0 +1,37 @@
+import { type OnModuleInit } from '@nestjs/common';
+import { DiscoveryService } from '@nestjs/core';
+import { type MatadorSchema } from '@zdavison/matador';
+import type { MatadorModuleOptions } from '../types.js';
+/**
+ * Service that discovers all @OnMatadorEvent decorated methods in the application
+ * and builds a Matador schema from them.
+ */
+export declare class SubscriberDiscoveryService implements OnModuleInit {
+    private readonly discoveryService;
+    private schema;
+    private discovered;
+    constructor(discoveryService: DiscoveryService);
+    onModuleInit(): void;
+    /**
+     * Discovers all @OnMatadorEvent decorated methods and builds the schema.
+     */
+    private discoverSubscribers;
+    /**
+     * Registers a single handler method as a subscriber.
+     */
+    private registerHandler;
+    /**
+     * Adds a subscriber to the schema for an event.
+     */
+    private addToSchema;
+    /**
+     * Gets the discovered schema.
+     * Must be called after onModuleInit has run.
+     */
+    getSchema(): MatadorSchema;
+    /**
+     * Gets the schema merged with additional events from options.
+     */
+    getMergedSchema(options: MatadorModuleOptions): MatadorSchema;
+}
+//# sourceMappingURL=subscriber-discovery.service.d.ts.map

package/dist/discovery/subscriber-discovery.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscriber-discovery.service.d.ts","sourceRoot":"","sources":["../../src/discovery/subscriber-discovery.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC/D,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,EAIL,KAAK,aAAa,EAGnB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAEV,oBAAoB,EACrB,MAAM,aAAa,CAAC;AAYrB;;;GAGG;AACH,qBACa,0BAA2B,YAAW,YAAY;IAIjD,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IAH7C,OAAO,CAAC,MAAM,CAAqB;IACnC,OAAO,CAAC,UAAU,CAAS;gBAEE,gBAAgB,EAAE,gBAAgB;IAE/D,YAAY,IAAI,IAAI;IAIpB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IA4B3B;;OAEG;IACH,OAAO,CAAC,eAAe;IAmDvB;;OAEG;IACH,OAAO,CAAC,WAAW;IAoBnB;;;OAGG;IACH,SAAS,IAAI,aAAa;IAI1B;;OAEG;IACH,eAAe,CAAC,OAAO,EAAE,oBAAoB,GAAG,aAAa;CAoB9D"}

package/dist/discovery/subscriber-discovery.service.js

@@ -0,0 +1,144 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Injectable } from '@nestjs/common';
+import { DiscoveryService } from '@nestjs/core';
+import { createSubscriber, } from '@zdavison/matador';
+import { MATADOR_EVENT_HANDLERS } from '../constants.js';
+/**
+ * Service that discovers all @OnMatadorEvent decorated methods in the application
+ * and builds a Matador schema from them.
+ */
+let SubscriberDiscoveryService = class SubscriberDiscoveryService {
+    discoveryService;
+    schema = {};
+    discovered = false;
+    constructor(discoveryService) {
+        this.discoveryService = discoveryService;
+    }
+    onModuleInit() {
+        this.discoverSubscribers();
+    }
+    /**
+     * Discovers all @OnMatadorEvent decorated methods and builds the schema.
+     */
+    discoverSubscribers() {
+        if (this.discovered) {
+            return;
+        }
+        const providers = this.discoveryService.getProviders();
+        for (const wrapper of providers) {
+            const { instance } = wrapper;
+            if (!instance || typeof instance !== 'object') {
+                continue;
+            }
+            const handlers = Reflect.getMetadata(MATADOR_EVENT_HANDLERS, instance.constructor);
+            if (!handlers || handlers.length === 0) {
+                continue;
+            }
+            for (const handler of handlers) {
+                this.registerHandler(instance, handler);
+            }
+        }
+        this.discovered = true;
+    }
+    /**
+     * Registers a single handler method as a subscriber.
+     */
+    registerHandler(instance, metadata) {
+        const { eventClass, options, methodName } = metadata;
+        const className = instance.constructor.name;
+        // Auto-generate name if not provided: ClassName.methodName
+        const subscriberName = options.name ?? `${className}.${methodName}`;
+        // Determine if this is a resumable subscriber
+        const isResumable = options.idempotent === 'resumable';
+        // Create the callback that calls the instance method
+        // biome-ignore lint/suspicious/noExplicitAny: Instance methods may have various signatures
+        const boundMethod = instance[methodName].bind(instance);
+        // Create a subscriber that calls the instance method
+        const subscriber = isResumable
+            ? createSubscriber({
+                name: subscriberName,
+                description: options.description,
+                idempotent: 'resumable',
+                importance: options.importance,
+                targetQueue: options.targetQueue,
+                enabled: options.enabled,
+                callback: async (envelope, context) => {
+                    await boundMethod(envelope, context);
+                },
+            })
+            : createSubscriber({
+                name: subscriberName,
+                description: options.description,
+                idempotent: options.idempotent,
+                importance: options.importance,
+                targetQueue: options.targetQueue,
+                enabled: options.enabled,
+                callback: async (envelope) => {
+                    await boundMethod(envelope);
+                },
+            });
+        // Add to schema
+        this.addToSchema(eventClass, subscriber);
+    }
+    /**
+     * Adds a subscriber to the schema for an event.
+     */
+    addToSchema(eventClass, subscriber) {
+        const eventKey = eventClass.key;
+        const existing = this.schema[eventKey];
+        if (existing) {
+            // Add subscriber to existing event entry
+            const [existingEventClass, existingSubscribers] = existing;
+            this.schema[eventKey] = [
+                existingEventClass,
+                [...existingSubscribers, subscriber],
+            ];
+        }
+        else {
+            // Create new entry
+            this.schema[eventKey] = [eventClass, [subscriber]];
+        }
+    }
+    /**
+     * Gets the discovered schema.
+     * Must be called after onModuleInit has run.
+     */
+    getSchema() {
+        return this.schema;
+    }
+    /**
+     * Gets the schema merged with additional events from options.
+     */
+    getMergedSchema(options) {
+        const mergedSchema = { ...this.schema };
+        if (options.additionalEvents) {
+            for (const [eventClass, subscribers] of options.additionalEvents) {
+                const existing = mergedSchema[eventClass.key];
+                if (existing) {
+                    const [existingEventClass, existingSubscribers] = existing;
+                    mergedSchema[eventClass.key] = [
+                        existingEventClass,
+                        [...existingSubscribers, ...subscribers],
+                    ];
+                }
+                else {
+                    mergedSchema[eventClass.key] = [eventClass, subscribers];
+                }
+            }
+        }
+        return mergedSchema;
+    }
+};
+SubscriberDiscoveryService = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [DiscoveryService])
+], SubscriberDiscoveryService);
+export { SubscriberDiscoveryService };