@pinelab/vendure-plugin-alerting 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,6 @@
+# 1.0.0 (2026-05-27)
+
+- Initial release.
+- Event-based and log-based alerting.
+- `WebhookNotifier` out of the box.
+- Deduplication and JobQueue-backed delivery.

package/README.md

@@ -0,0 +1,126 @@
+# Vendure Alerting Plugin
+
+[Official documentation here](https://plugins.pinelab.studio/plugin/vendure-plugin-alerting)
+
+Send notifications based on Vendure events and log messages via configurable notifiers like webhooks, slack or N8N.
+
+## Getting started
+
+```ts
+import {
+  AlertingPlugin,
+  EventAlert,
+  LogAlert,
+  WebhookNotifier,
+} from '@pinelab/vendure-plugin-alerting';
+import { PaymentStateTransitionEvent } from '@vendure/core';
+
+// Slack example. Get the webhook URL from your slack account: https://docs.slack.dev/messaging/sending-messages-using-incoming-webhooks/
+const slack = new WebhookNotifier({
+  name: 'slack',
+  url: process.env.SLACK_WEBHOOK!,
+});
+
+const n8n = new WebhookNotifier({
+  name: 'n8n',
+  url: 'https://n8n.example.com/webhook/alert',
+});
+
+const plugins: VendurePlugin[] = [
+  AlertingPlugin.init({
+    alerts: [
+      // Alert on order payment failure
+      new EventAlert([slack, n8n])
+        .on(PaymentStateTransitionEvent)
+        .filter((e) => e.toState === 'Error') // Use this to decide when to alert
+        .notify((e) => `Payment error for order "${e.order.code}"`), // Notifies via Slack and n8n
+
+      // Alert on any error log from PaymentService
+      new LogAlert([slack])
+        .onLog('error', 'warn')
+        .filter((log) => log.loggerCtx === 'PaymentService')
+        .notify((log) => ({
+          subject: `[${log.level}] ${log.loggerCtx}`,
+          text: log.message,
+        })),
+    ],
+    // Deduplicate identical notifications to prevent alert storms: Only notify every once per X ms
+    deduplicationWindowMs: 60_000, // default
+  }),
+];
+```
+
+## Email notifier
+
+Send alerts as plain-text emails via Vendure's built-in `NodemailerEmailSender`. No templates are required — the alert subject and text are sent directly.
+
+```ts
+import { EmailNotifier } from '@pinelab/vendure-plugin-alerting';
+
+const email = new EmailNotifier({
+  name: 'email',
+  from: 'alerts@example.com',
+  to: 'admin@example.com',
+  transport: {
+    type: 'smtp',
+    host: 'smtp.example.com',
+    port: 587,
+    auth: {
+      user: 'username',
+      pass: 'password',
+    },
+  },
+});
+
+new LogAlert([email]).onLog('error').notify((log) => ({
+  subject: `[${log.level}] ${log.loggerCtx}`,
+  text: log.message,
+}));
+```
+
+You can use any transport supported by the EmailPlugin, such as `ses`, `sendmail`, or `file`. You can also pass a custom `EmailSender` via the `emailSender` option.
+
+## Custom Notifiers
+
+Implement the `Notifier` interface to create custom channels (e.g. SMS) and use custom metadata.
+
+```ts
+import { AlertMessage, Notifier } from '@pinelab/vendure-plugin-alerting';
+
+// Example notifier that uses custom metadata
+export class CustomNotifier implements Notifier {
+  name = 'my-custom-notifier';
+
+  notify({subject, text, metadata}: AlertMessage): Promise<void> {
+    // This is where you would implement the logic to send the alert message to your desired destination.
+    // With the given metadata you could send custom body or headers for example.
+    const authorization = metadata.myHeaders.bearerToken
+  }
+}
+
+// You would use this Notifier like this:
+const customNotifier = new CustomNotifier();
+new EventAlert([customNotifier])
+  .on(PaymentStateTransitionEvent)
+  .filter((e) => e.toState === 'Error')
+  .notify((log) => ({
+    subject: `My subject`,
+    text: `my custom message`,
+    metadata: {
+      key: "you can pass anything you want to your custom notifier here"
+      key2: "It is up to your notifier to use the metadata object"
+    }
+  })),
+```
+
+## Deduplication
+
+Identical alerts (same notifier + subject + text) fired within `deduplicationWindowMs` are dropped. This prevents alert storms when many events fire in rapid succession.
+
+## Retry
+
+Alert delivery is backed by the Vendure JobQueue. If a notifier throws, the job is retried with the configured retry strategy.
+
+## License
+
+MIT

package/dist/alerting.plugin.d.ts

@@ -0,0 +1,6 @@
+import { Type } from '@vendure/core';
+import { AlertingPluginOptions } from './types';
+export declare class AlertingPlugin {
+    static options: AlertingPluginOptions;
+    static init(options: AlertingPluginOptions): Type<AlertingPlugin>;
+}

package/dist/alerting.plugin.js

@@ -0,0 +1,43 @@
+"use strict";
+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 AlertingPlugin_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlertingPlugin = void 0;
+const core_1 = require("@vendure/core");
+const constants_1 = require("./constants");
+const alerting_service_1 = require("./services/alerting.service");
+let AlertingPlugin = AlertingPlugin_1 = class AlertingPlugin {
+    static init(options) {
+        this.options = {
+            ...this.options,
+            ...options,
+        };
+        return AlertingPlugin_1;
+    }
+};
+exports.AlertingPlugin = AlertingPlugin;
+AlertingPlugin.options = {
+    alerts: [],
+};
+exports.AlertingPlugin = AlertingPlugin = AlertingPlugin_1 = __decorate([
+    (0, core_1.VendurePlugin)({
+        imports: [core_1.PluginCommonModule],
+        providers: [
+            alerting_service_1.AlertingService,
+            {
+                provide: constants_1.PLUGIN_INIT_OPTIONS,
+                useFactory: () => AlertingPlugin.options,
+            },
+        ],
+        configuration: (config) => {
+            config.logger = alerting_service_1.AlertingService.wrapLogger(config.logger);
+            return config;
+        },
+        compatibility: '>=3.2.0',
+    })
+], AlertingPlugin);

package/dist/config/alert.d.ts

@@ -0,0 +1,82 @@
+import { Type, VendureEvent } from '@vendure/core';
+import { Notifier } from './notifier';
+import { AlertMessage, AlertLogLevel, LogAlertContext } from '../types';
+/**
+ * Abstract base for alert definitions consumed by {@link AlertingService}.
+ * Holds the shared notifier list, optional filter, and message builder.
+ *
+ * @typeParam T - The type of trigger this alert receives (a Vendure event or
+ *   a {@link LogAlertContext}).
+ */
+export declare abstract class BaseAlert<T> {
+    readonly notifiers: Notifier[];
+    /** Optional predicate that decides whether the alert should fire. */
+    filterFn?: (trigger: T) => boolean | Promise<boolean>;
+    /** Function that converts the trigger into an {@link AlertMessage}
+     *  (or a plain string, which is auto-wrapped as `{ subject: 'Alert', text: <string> }`). */
+    notifyFn: (trigger: T) => string | AlertMessage | Promise<string | AlertMessage>;
+    /**
+     * @param notifiers - The channels that will receive the alert when it fires.
+     */
+    constructor(notifiers: Notifier[]);
+    /**
+     * Only fire the alert when the predicate returns true for the trigger.
+     */
+    filter(fn: (trigger: T) => boolean | Promise<boolean>): this;
+    /**
+     * Define how the {@link AlertMessage} is built from the trigger.
+     * Returning a string is shorthand for `{ subject: 'Alert', text: <string> }`.
+     */
+    notify(fn: (trigger: T) => string | AlertMessage | Promise<string | AlertMessage>): this;
+}
+/**
+ * Builder for an alert rule that reacts to Vendure {@linkcode EventBus} events.
+ *
+ * The generic parameter {@linkcode E} is automatically inferred from the events
+ * passed to {@linkcode on()}. It starts as `never` so the alert only fires when
+ * explicitly subscribed to event types.
+ *
+ * @example
+ * ```ts
+ * new EventAlert([webhookNotifier])
+ *   .on(ProductEvent, OrderPlacedEvent)
+ *   .filter(e => e.type === 'created')
+ *   .notify(e => `Product ${e.type}`);
+ * ```
+ */
+export declare class EventAlert<E extends VendureEvent = never> extends BaseAlert<E> {
+    /** Vendure event types this alert subscribes to. */
+    events: Type<VendureEvent>[];
+    /**
+     * Trigger this alert when any of the given Vendure events are published.
+     *
+     * @returns A new {@linkcode EventAlert} whose event union now includes all
+     *   the events passed in.
+     */
+    on<T extends VendureEvent[]>(...events: {
+        [I in keyof T]: Type<T[I]>;
+    }): EventAlert<E | T[number]>;
+}
+/**
+ * Builder for an alert rule that reacts to log messages emitted through
+ * Vendure's {@linkcode VendureLogger}.
+ *
+ * @example
+ * ```ts
+ * new LogAlert([webhookNotifier])
+ *   .onLog('error', 'warn')
+ *   .filter(log => log.loggerCtx === 'PaymentGateway')
+ *   .notify(log => ({
+ *     subject: `[${log.level}] Payment issue`,
+ *     text: log.message,
+ *   }));
+ * ```
+ */
+export declare class LogAlert extends BaseAlert<LogAlertContext> {
+    /** Log levels this alert subscribes to. */
+    logLevels: AlertLogLevel[];
+    /**
+     * Trigger this alert when a log message is emitted at any of the given levels.
+     */
+    onLog(...levels: AlertLogLevel[]): this;
+}

package/dist/config/alert.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogAlert = exports.EventAlert = exports.BaseAlert = void 0;
+/**
+ * Abstract base for alert definitions consumed by {@link AlertingService}.
+ * Holds the shared notifier list, optional filter, and message builder.
+ *
+ * @typeParam T - The type of trigger this alert receives (a Vendure event or
+ *   a {@link LogAlertContext}).
+ */
+class BaseAlert {
+    /**
+     * @param notifiers - The channels that will receive the alert when it fires.
+     */
+    constructor(notifiers) {
+        this.notifiers = notifiers;
+    }
+    /**
+     * Only fire the alert when the predicate returns true for the trigger.
+     */
+    filter(fn) {
+        this.filterFn = fn;
+        return this;
+    }
+    /**
+     * Define how the {@link AlertMessage} is built from the trigger.
+     * Returning a string is shorthand for `{ subject: 'Alert', text: <string> }`.
+     */
+    notify(fn) {
+        this.notifyFn = fn;
+        return this;
+    }
+}
+exports.BaseAlert = BaseAlert;
+/**
+ * Builder for an alert rule that reacts to Vendure {@linkcode EventBus} events.
+ *
+ * The generic parameter {@linkcode E} is automatically inferred from the events
+ * passed to {@linkcode on()}. It starts as `never` so the alert only fires when
+ * explicitly subscribed to event types.
+ *
+ * @example
+ * ```ts
+ * new EventAlert([webhookNotifier])
+ *   .on(ProductEvent, OrderPlacedEvent)
+ *   .filter(e => e.type === 'created')
+ *   .notify(e => `Product ${e.type}`);
+ * ```
+ */
+class EventAlert extends BaseAlert {
+    constructor() {
+        super(...arguments);
+        /** Vendure event types this alert subscribes to. */
+        this.events = [];
+    }
+    /**
+     * Trigger this alert when any of the given Vendure events are published.
+     *
+     * @returns A new {@linkcode EventAlert} whose event union now includes all
+     *   the events passed in.
+     */
+    on(...events) {
+        this.events.push(...events);
+        return this;
+    }
+}
+exports.EventAlert = EventAlert;
+/**
+ * Builder for an alert rule that reacts to log messages emitted through
+ * Vendure's {@linkcode VendureLogger}.
+ *
+ * @example
+ * ```ts
+ * new LogAlert([webhookNotifier])
+ *   .onLog('error', 'warn')
+ *   .filter(log => log.loggerCtx === 'PaymentGateway')
+ *   .notify(log => ({
+ *     subject: `[${log.level}] Payment issue`,
+ *     text: log.message,
+ *   }));
+ * ```
+ */
+class LogAlert extends BaseAlert {
+    constructor() {
+        super(...arguments);
+        /** Log levels this alert subscribes to. */
+        this.logLevels = [];
+    }
+    /**
+     * Trigger this alert when a log message is emitted at any of the given levels.
+     */
+    onLog(...levels) {
+        this.logLevels.push(...levels);
+        return this;
+    }
+}
+exports.LogAlert = LogAlert;

package/dist/config/notifier.d.ts

@@ -0,0 +1,14 @@
+import { AlertMessage } from '../types';
+/**
+ * Defines an outgoing notification channel (e.g. webhook, email, SMS).
+ * Each notifier has a unique name and knows how to deliver an {@link AlertMessage}.
+ */
+export interface Notifier {
+    /** Unique name; used as job-data discriminator and in logs */
+    readonly name: string;
+    /**
+     * Deliver the alert message.
+     * Throwing causes the JobQueue to retry the delivery.
+     */
+    notify(message: AlertMessage): Promise<void>;
+}

package/dist/config/notifier.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/config/notifiers/email-notifier.d.ts

@@ -0,0 +1,26 @@
+import { AlertMessage } from '../../types';
+import { Notifier } from '../notifier';
+import { EmailSender, EmailTransportOptions } from '@vendure/email-plugin';
+export interface EmailNotifierConfig {
+    /** Unique name; used as job-data discriminator and in logs */
+    name: string;
+    /** Sender address */
+    from: string;
+    /** Recipient address */
+    to: string;
+    /** Vendure email transport options (e.g. SMTP, SES, file) */
+    transport: EmailTransportOptions;
+    /** Optional custom EmailSender; defaults to NodemailerEmailSender */
+    emailSender?: EmailSender;
+}
+/**
+ * Notifier that sends alert messages as plain-text emails via Vendure's
+ * built-in {@link NodemailerEmailSender}. No templates are required —
+ * the alert subject and text are sent directly as the email subject and body.
+ */
+export declare class EmailNotifier implements Notifier {
+    private config;
+    readonly name: string;
+    constructor(config: EmailNotifierConfig);
+    notify(message: AlertMessage): Promise<void>;
+}

package/dist/config/notifiers/email-notifier.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailNotifier = void 0;
+const email_plugin_1 = require("@vendure/email-plugin");
+/**
+ * Notifier that sends alert messages as plain-text emails via Vendure's
+ * built-in {@link NodemailerEmailSender}. No templates are required —
+ * the alert subject and text are sent directly as the email subject and body.
+ */
+class EmailNotifier {
+    constructor(config) {
+        this.config = config;
+        this.name = config.name;
+    }
+    async notify(message) {
+        const emailDetails = {
+            from: this.config.from,
+            recipient: this.config.to,
+            subject: message.subject,
+            body: message.text,
+            attachments: [],
+        };
+        const sender = this.config.emailSender ?? new email_plugin_1.NodemailerEmailSender();
+        await sender.send(emailDetails, this.config.transport);
+    }
+}
+exports.EmailNotifier = EmailNotifier;

package/dist/config/notifiers/webhook-notifier.d.ts

@@ -0,0 +1,15 @@
+import { AlertMessage } from '../../types';
+import { Notifier } from '../notifier';
+interface WebhookNotifierConfig {
+    name: string;
+    url: string;
+    method?: 'POST' | 'GET';
+    headers?: Record<string, string>;
+}
+export declare class WebhookNotifier implements Notifier {
+    private config;
+    readonly name: string;
+    constructor(config: WebhookNotifierConfig);
+    notify(message: AlertMessage): Promise<void>;
+}
+export {};

package/dist/config/notifiers/webhook-notifier.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhookNotifier = void 0;
+const node_fetch_1 = __importDefault(require("node-fetch"));
+class WebhookNotifier {
+    constructor(config) {
+        this.config = config;
+        this.name = config.name;
+    }
+    async notify(message) {
+        const headers = {
+            'content-type': 'application/json',
+            ...(this.config.headers || {}),
+            ...(message.metadata?.headers || {}),
+        };
+        const body = this.config.method === 'GET'
+            ? undefined
+            : JSON.stringify(message.metadata?.body ?? message);
+        const res = await (0, node_fetch_1.default)(this.config.url, {
+            method: this.config.method || 'POST',
+            headers,
+            body,
+        });
+        if (!res.ok) {
+            throw new Error(`Webhook ${this.name} returned ${res.status}: ${await res.text()}`);
+        }
+    }
+}
+exports.WebhookNotifier = WebhookNotifier;

package/dist/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const PLUGIN_INIT_OPTIONS: unique symbol;
+export declare const loggerCtx = "AlertingPlugin";

package/dist/constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loggerCtx = exports.PLUGIN_INIT_OPTIONS = void 0;
+exports.PLUGIN_INIT_OPTIONS = Symbol('PLUGIN_INIT_OPTIONS');
+exports.loggerCtx = 'AlertingPlugin';

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from './alerting.plugin';
+export * from './types';
+export * from './config/alert';
+export * from './config/notifier';
+export * from './config/notifiers/webhook-notifier';
+export * from './config/notifiers/email-notifier';
+export * from './services/alerting.service';

package/dist/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./alerting.plugin"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./config/alert"), exports);
+__exportStar(require("./config/notifier"), exports);
+__exportStar(require("./config/notifiers/webhook-notifier"), exports);
+__exportStar(require("./config/notifiers/email-notifier"), exports);
+__exportStar(require("./services/alerting.service"), exports);

package/dist/services/alert-logger.d.ts

@@ -0,0 +1,20 @@
+import { VendureLogger } from '@vendure/core';
+import { AlertLogLevel, LogAlertContext } from '../types';
+/**
+ * VendureLogger wrapper that forwards log calls to the original logger
+ * and buffers entries so the AlertingService can process them.
+ */
+export declare class AlertingLogger implements VendureLogger {
+    private readonly wrapped;
+    private static logBuffer;
+    private static isReady;
+    private static onLogHandler?;
+    static setHandler(handler: (log: LogAlertContext) => void): void;
+    static pushLog(level: AlertLogLevel, message: string, ctx?: string): void;
+    constructor(wrapped: VendureLogger);
+    info(message: string, ctx?: string): void;
+    warn(message: string, ctx?: string): void;
+    error(message: string, ctx?: string, trace?: string): void;
+    debug(message: string, ctx?: string): void;
+    verbose(message: string, ctx?: string): void;
+}

package/dist/services/alert-logger.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlertingLogger = void 0;
+/**
+ * VendureLogger wrapper that forwards log calls to the original logger
+ * and buffers entries so the AlertingService can process them.
+ */
+class AlertingLogger {
+    static setHandler(handler) {
+        this.onLogHandler = handler;
+        this.isReady = true;
+        // Flush buffered logs
+        while (this.logBuffer.length > 0) {
+            const log = this.logBuffer.shift();
+            handler(log);
+        }
+    }
+    static pushLog(level, message, ctx) {
+        const log = { level, message, loggerCtx: ctx };
+        if (this.isReady && this.onLogHandler) {
+            this.onLogHandler(log);
+        }
+        else {
+            this.logBuffer.push(log);
+        }
+    }
+    constructor(wrapped) {
+        this.wrapped = wrapped;
+    }
+    info(message, ctx) {
+        this.wrapped.info(message, ctx);
+        AlertingLogger.pushLog('info', message, ctx);
+    }
+    warn(message, ctx) {
+        this.wrapped.warn(message, ctx);
+        AlertingLogger.pushLog('warn', message, ctx);
+    }
+    error(message, ctx, trace) {
+        this.wrapped.error(message, ctx, trace);
+        AlertingLogger.pushLog('error', message, ctx);
+    }
+    debug(message, ctx) {
+        this.wrapped.debug(message, ctx);
+    }
+    verbose(message, ctx) {
+        this.wrapped.verbose(message, ctx);
+    }
+}
+exports.AlertingLogger = AlertingLogger;
+AlertingLogger.logBuffer = [];
+AlertingLogger.isReady = false;

package/dist/services/alerting.service.d.ts

@@ -0,0 +1,20 @@
+import { OnApplicationBootstrap, OnModuleInit } from '@nestjs/common';
+import { EventBus, JobQueueService, VendureLogger } from '@vendure/core';
+import { AlertingPluginOptions } from '../types';
+export declare class AlertingService implements OnModuleInit, OnApplicationBootstrap {
+    private eventBus;
+    private jobQueueService;
+    private options;
+    private jobQueue;
+    private dedupMap;
+    private notifiersByName;
+    constructor(eventBus: EventBus, jobQueueService: JobQueueService, options: AlertingPluginOptions);
+    onModuleInit(): Promise<void>;
+    onApplicationBootstrap(): void;
+    static wrapLogger(logger: VendureLogger): VendureLogger;
+    private handleTrigger;
+    private processJob;
+    private dedupKey;
+    private hash;
+    private cleanupDedupMap;
+}

package/dist/services/alerting.service.js

@@ -0,0 +1,150 @@
+"use strict";
+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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlertingService = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@vendure/core");
+const constants_1 = require("../constants");
+const alert_1 = require("../config/alert");
+const alert_logger_1 = require("./alert-logger");
+let AlertingService = class AlertingService {
+    constructor(eventBus, jobQueueService, options) {
+        this.eventBus = eventBus;
+        this.jobQueueService = jobQueueService;
+        this.options = options;
+        this.dedupMap = new Map();
+        this.notifiersByName = new Map();
+    }
+    async onModuleInit() {
+        this.jobQueue = await this.jobQueueService.createQueue({
+            name: 'alerting-notify',
+            process: async (job) => {
+                try {
+                    await this.processJob(job.data.notifierName, job.data.alertMessage);
+                }
+                catch (e) {
+                    const err = e instanceof Error ? e : new Error(String(e));
+                    core_1.Logger.error(`Failed to process alert job for notifier "${job.data.notifierName}": ${err.message}`, constants_1.loggerCtx, err.stack);
+                    throw e;
+                }
+            },
+        });
+    }
+    onApplicationBootstrap() {
+        // Build notifier lookup from all alerts
+        for (const alert of this.options.alerts) {
+            for (const notifier of alert.notifiers) {
+                this.notifiersByName.set(notifier.name, notifier);
+            }
+        }
+        // Subscribe to configured events (EventAlert only)
+        for (const alert of this.options.alerts) {
+            if (alert instanceof alert_1.EventAlert) {
+                for (const EventType of alert.events) {
+                    this.eventBus.ofType(EventType).subscribe(async (event) => {
+                        try {
+                            await this.handleTrigger(alert, event);
+                        }
+                        catch (e) {
+                            core_1.Logger.error(`Failed to handle event ${event.constructor.name} for alert: ${e}`, constants_1.loggerCtx);
+                        }
+                    });
+                }
+            }
+        }
+        // Subscribe to log buffer (LogAlert only)
+        alert_logger_1.AlertingLogger.setHandler((log) => {
+            for (const alert of this.options.alerts) {
+                if (alert instanceof alert_1.LogAlert && alert.logLevels.includes(log.level)) {
+                    this.handleTrigger(alert, log).catch((e) => {
+                        core_1.Logger.error(`Failed to handle log alert: ${e}`, constants_1.loggerCtx);
+                    });
+                }
+            }
+        });
+    }
+    static wrapLogger(logger) {
+        return new alert_logger_1.AlertingLogger(logger);
+    }
+    async handleTrigger(alert, trigger) {
+        // Prevent infinite loops: skip logs emitted by this plugin
+        const logCtx = trigger.loggerCtx;
+        if (logCtx === constants_1.loggerCtx) {
+            return;
+        }
+        // Apply filter if configured
+        if (alert.filterFn) {
+            const passes = await alert.filterFn(trigger);
+            if (!passes) {
+                return;
+            }
+        }
+        // Build message
+        const raw = await alert.notifyFn(trigger);
+        const message = typeof raw === 'string' ? { subject: 'Alert', text: raw } : raw;
+        // Enqueue one job per notifier
+        for (const notifier of alert.notifiers) {
+            await this.jobQueue.add({
+                notifierName: notifier.name,
+                alertMessage: message,
+            });
+        }
+    }
+    async processJob(notifierName, message) {
+        const windowMs = this.options.deduplicationWindowMs ?? 60_000;
+        const key = this.dedupKey(notifierName, message);
+        const lastSent = this.dedupMap.get(key);
+        const now = Date.now();
+        if (lastSent && now - lastSent < windowMs) {
+            core_1.Logger.info(`Dropping duplicate alert for notifier "${notifierName}" with subject "${message.subject}"`, constants_1.loggerCtx);
+            return;
+        }
+        this.dedupMap.set(key, now);
+        this.cleanupDedupMap(windowMs);
+        const notifier = this.notifiersByName.get(notifierName);
+        if (!notifier) {
+            throw new Error(`Notifier "${notifierName}" not found`);
+        }
+        await notifier.notify(message);
+        core_1.Logger.info(`Sent alert to notifier "${notifierName}" with subject "${message.subject}"`, constants_1.loggerCtx);
+    }
+    dedupKey(notifierName, message) {
+        const str = `${notifierName}:${message.subject}:${message.text}`;
+        return this.hash(str);
+    }
+    hash(input) {
+        let hash = 0;
+        for (let i = 0; i < input.length; i++) {
+            const char = input.charCodeAt(i);
+            hash = (hash << 5) - hash + char;
+            hash |= 0;
+        }
+        return hash.toString(16);
+    }
+    cleanupDedupMap(windowMs) {
+        const cutoff = Date.now() - windowMs;
+        for (const [key, ts] of this.dedupMap.entries()) {
+            if (ts < cutoff) {
+                this.dedupMap.delete(key);
+            }
+        }
+    }
+};
+exports.AlertingService = AlertingService;
+exports.AlertingService = AlertingService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(2, (0, common_1.Inject)(constants_1.PLUGIN_INIT_OPTIONS)),
+    __metadata("design:paramtypes", [core_1.EventBus,
+        core_1.JobQueueService, Object])
+], AlertingService);

package/dist/types.d.ts

@@ -0,0 +1,22 @@
+import { EventAlert, LogAlert } from './config/alert';
+export interface AlertMessage {
+    subject: string;
+    text: string;
+    metadata?: Record<string, any>;
+}
+export type AlertLogLevel = 'info' | 'warn' | 'error';
+export interface LogAlertContext {
+    level: AlertLogLevel;
+    message: string;
+    loggerCtx?: string;
+}
+export type AlertTrigger<E = unknown> = E | LogAlertContext;
+export interface AlertingPluginOptions {
+    alerts: Array<EventAlert<any> | LogAlert>;
+    /**
+     * Time window for deduplication in ms. Identical AlertMessages
+     * (same notifier + subject + text hash) within this window are dropped.
+     * Default: 60_000
+     */
+    deduplicationWindowMs?: number;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@pinelab/vendure-plugin-alerting",
+  "version": "1.0.0",
+  "description": "Vendure plugin for sending alerts based on events and log to various notifiers like Slack, email or N8N",
+  "author": "Martijn van de Brug <martijn@pinelab.studio>",
+  "homepage": "https://plugins.pinelab.studio/",
+  "repository": "https://github.com/Pinelab-studio/pinelab-vendure-plugins",
+  "license": "MIT",
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "build": "rimraf dist && tsc",
+    "start": "yarn ts-node test/dev-server.ts",
+    "test": "vitest run",
+    "lint": "echo 'No linting configured'"
+  },
+  "dependencies": {
+    "node-fetch": "^2.6.7",
+    "catch-unknown": "^2.0.0"
+  }
+}