@devopsplaybook.io/common-utils 1.2.3 → 1.3.0

package/README.md

@@ -33,6 +33,7 @@ npm install @devopsplaybook.io/common-utils
 | `pg`                            | PostgreSQL client (`Pool`)                          |
 | `fs-extra`                      | File system helpers                                 |
 | `uuid`                          | UUID generation for JWT keys                        |
+| `axios`                         | HTTP client for the notifications integration        |
 
 ### Modules
 
@@ -290,6 +291,48 @@ DbUtilsNoTelemetryBatchInsert(
 
 ---
 
+#### `Notifications` -- Central Notifications Client
+
+Fail-safe client for sending notifications to the central notifications service (the `notifications` project). The client never throws when misconfigured: it is simply disabled, the integration status is logged exactly once at construction time, and follow-up `send` calls on a disabled client are silent and resolve to `null`.
+
+```ts
+import { NotificationsClient } from "@devopsplaybook.io/common-utils";
+
+const client = new NotificationsClient({
+  apiEndpoint: config.NOTIFICATIONS_API,
+  apiToken: config.NOTIFICATIONS_TOKEN,
+  logger: OTelLogger().createModuleLogger("notifications"),
+});
+
+// Optional helpers per severity
+await client.info("Job started", "Nightly sync running", "my-app");
+await client.success("Job finished", "Nightly sync done", "my-app");
+await client.warning("Disk usage high", "85% on /data", "my-app");
+await client.error("Job failed", "Nightly sync crashed", "my-app");
+
+// Or a full payload
+await client.send({
+  title: "Deployment finished",
+  body: "Version 1.2.3 deployed to production",
+  source: "my-app",
+  severity: "success",
+  data: JSON.stringify({ version: "1.2.3" }),
+});
+```
+
+| Export                 | Description                                                       |
+| ---------------------- | ----------------------------------------------------------------- |
+| `NotificationsClient`  | HTTP client with `send` plus `info`/`success`/`warning`/`error` helpers |
+| `NotificationsConfig`  | `{ apiEndpoint, apiToken, logger? }` constructor configuration      |
+| `NotificationPayload`  | `{ title, body?, source?, severity?, data? }` request payload      |
+| `NotificationResponse` | Shape returned by the notifications API                            |
+| `NotificationSeverity` | `"info" \| "warning" \| "error" \| "success"`                    |
+| `NotificationsLogger` | Minimal logger interface (`info`/`warn`/`error`), console by default |
+
+**Behaviour when not configured**: when `apiEndpoint` or `apiToken` is empty the client logs `"Notifications integration disabled (...)"` once at construction and every `send`/helper call resolves to `null` without logging, so the parent application never fails.
+
+---
+
 #### `SystemCommand` -- Shell Command Execution
 
 ```ts

package/dist/index.d.ts

@@ -4,5 +4,6 @@ export * from "./src/DbUtils";
 export * from "./src/DbUtilsNoTelemetry";
 export * from "./src/SqlDbUtils";
 export * from "./src/PostgresDbUtils";
+export * from "./src/Notifications";
 export * from "./src/SystemCommand";
 export * from "./src/Timeout";

package/dist/index.js

@@ -20,5 +20,6 @@ __exportStar(require("./src/DbUtils"), exports);
 __exportStar(require("./src/DbUtilsNoTelemetry"), exports);
 __exportStar(require("./src/SqlDbUtils"), exports);
 __exportStar(require("./src/PostgresDbUtils"), exports);
+__exportStar(require("./src/Notifications"), exports);
 __exportStar(require("./src/SystemCommand"), exports);
 __exportStar(require("./src/Timeout"), exports);

package/dist/src/Notifications.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Severity levels for notifications.
+ */
+export type NotificationSeverity = "info" | "warning" | "error" | "success";
+/**
+ * Minimal logger interface expected by the notifications client.
+ * Matches the subset of the OTel logger used by devopsplaybook.io projects.
+ */
+export interface NotificationsLogger {
+    info(message: string): void;
+    warn(message: string): void;
+    error(message: string, err?: unknown): void;
+}
+/**
+ * Configuration for {@link NotificationsClient}.
+ */
+export interface NotificationsConfig {
+    /** API endpoint URL (e.g., "https://notifications.example.com/api/notifications") */
+    apiEndpoint: string;
+    /** API token used for Bearer authentication */
+    apiToken: string;
+    /** Optional logger; falls back to console when omitted */
+    logger?: NotificationsLogger;
+}
+/**
+ * Payload for creating a notification.
+ */
+export interface NotificationPayload {
+    /** Notification title */
+    title: string;
+    /** Notification body/content */
+    body?: string;
+    /** Source identifier (defaults to "api") */
+    source?: string;
+    /** Severity level (defaults to "info") */
+    severity?: NotificationSeverity;
+    /** Additional data as a JSON string */
+    data?: string;
+}
+/**
+ * Response from the notifications API.
+ */
+export interface NotificationResponse {
+    id: string;
+    title: string;
+    body: string;
+    source: string;
+    severity: string;
+    data: string;
+    createdAt: string;
+}
+/**
+ * Client for sending notifications to the central notifications service.
+ *
+ * The client is fail-safe by design:
+ *
+ * - It is disabled (and never throws) when `apiEndpoint` or `apiToken` is
+ *   missing, so a partially configured parent application still starts.
+ * - The integration status is logged exactly once, at construction time.
+ * - Follow-up `send` calls on a disabled client are silent and resolve to
+ *   `null`.
+ * - Sending errors are logged and resolve to `null` instead of rejecting.
+ *
+ * @example
+ * ```ts
+ * const client = new NotificationsClient({
+ *   apiEndpoint: config.NOTIFICATIONS_API,
+ *   apiToken: config.NOTIFICATIONS_TOKEN,
+ *   logger: OTelLogger().createModuleLogger("notifications"),
+ * });
+ *
+ * await client.send({
+ *   title: "Deployment finished",
+ *   body: "Version 1.2.3 deployed to production",
+ *   source: "my-app",
+ *   severity: "success",
+ * });
+ * ```
+ */
+export declare class NotificationsClient {
+    private client;
+    private readonly enabled;
+    private readonly logger;
+    constructor(config: NotificationsConfig);
+    /**
+     * Check whether the client is properly configured.
+     */
+    isEnabled(): boolean;
+    /**
+     * Send a notification.
+     *
+     * @param payload  The notification payload.
+     * @returns The created notification, or `null` when disabled or on failure.
+     */
+    send(payload: NotificationPayload): Promise<NotificationResponse | null>;
+    /**
+     * Send an info notification.
+     */
+    info(title: string, body?: string, source?: string): Promise<NotificationResponse | null>;
+    /**
+     * Send a success notification.
+     */
+    success(title: string, body?: string, source?: string): Promise<NotificationResponse | null>;
+    /**
+     * Send a warning notification.
+     */
+    warning(title: string, body?: string, source?: string): Promise<NotificationResponse | null>;
+    /**
+     * Send an error notification.
+     */
+    error(title: string, body?: string, source?: string): Promise<NotificationResponse | null>;
+}

package/dist/src/Notifications.js

@@ -0,0 +1,118 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationsClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+/** Console fallback used when no logger is injected. */
+const consoleLogger = {
+    info: (message) => console.log(message),
+    warn: (message) => console.warn(message),
+    error: (message, err) => console.error(message, err),
+};
+/**
+ * Client for sending notifications to the central notifications service.
+ *
+ * The client is fail-safe by design:
+ *
+ * - It is disabled (and never throws) when `apiEndpoint` or `apiToken` is
+ *   missing, so a partially configured parent application still starts.
+ * - The integration status is logged exactly once, at construction time.
+ * - Follow-up `send` calls on a disabled client are silent and resolve to
+ *   `null`.
+ * - Sending errors are logged and resolve to `null` instead of rejecting.
+ *
+ * @example
+ * ```ts
+ * const client = new NotificationsClient({
+ *   apiEndpoint: config.NOTIFICATIONS_API,
+ *   apiToken: config.NOTIFICATIONS_TOKEN,
+ *   logger: OTelLogger().createModuleLogger("notifications"),
+ * });
+ *
+ * await client.send({
+ *   title: "Deployment finished",
+ *   body: "Version 1.2.3 deployed to production",
+ *   source: "my-app",
+ *   severity: "success",
+ * });
+ * ```
+ */
+class NotificationsClient {
+    constructor(config) {
+        this.client = null;
+        this.enabled = !!(config.apiEndpoint && config.apiToken);
+        this.logger = config.logger || consoleLogger;
+        if (this.enabled) {
+            this.client = axios_1.default.create({
+                baseURL: config.apiEndpoint,
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${config.apiToken}`,
+                },
+                timeout: 10000,
+            });
+            this.logger.info("Notifications integration enabled");
+        }
+        else {
+            this.logger.info("Notifications integration disabled (apiEndpoint or apiToken not set)");
+        }
+    }
+    /**
+     * Check whether the client is properly configured.
+     */
+    isEnabled() {
+        return this.enabled;
+    }
+    /**
+     * Send a notification.
+     *
+     * @param payload  The notification payload.
+     * @returns The created notification, or `null` when disabled or on failure.
+     */
+    async send(payload) {
+        if (!this.enabled || !this.client) {
+            return null;
+        }
+        try {
+            const response = await this.client.post("/", {
+                title: payload.title,
+                body: payload.body || "",
+                source: payload.source || "api",
+                severity: payload.severity || "info",
+                data: payload.data || "{}",
+            });
+            return response.data;
+        }
+        catch (err) {
+            this.logger.error("NotificationsClient: failed to send notification", err);
+            return null;
+        }
+    }
+    /**
+     * Send an info notification.
+     */
+    async info(title, body, source) {
+        return this.send({ title, body, source, severity: "info" });
+    }
+    /**
+     * Send a success notification.
+     */
+    async success(title, body, source) {
+        return this.send({ title, body, source, severity: "success" });
+    }
+    /**
+     * Send a warning notification.
+     */
+    async warning(title, body, source) {
+        return this.send({ title, body, source, severity: "warning" });
+    }
+    /**
+     * Send an error notification.
+     */
+    async error(title, body, source) {
+        return this.send({ title, body, source, severity: "error" });
+    }
+}
+exports.NotificationsClient = NotificationsClient;

package/index.ts

@@ -4,5 +4,6 @@ export * from "./src/DbUtils";
 export * from "./src/DbUtilsNoTelemetry";
 export * from "./src/SqlDbUtils";
 export * from "./src/PostgresDbUtils";
+export * from "./src/Notifications";
 export * from "./src/SystemCommand";
 export * from "./src/Timeout";

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@devopsplaybook.io/common-utils",
-  "version": "1.2.3",
-  "description": "Shared utility modules for devopsplaybook.io projects (DB, Config, OTel context, system helpers)",
+  "version": "1.3.0",
+  "description": "Shared utility modules for devopsplaybook.io projects (DB, Config, OTel context, notifications, system helpers)",
   "keywords": [
     "Open Telemetry",
     "OTel",
     "SQLite",
     "Postgres",
     "Config",
+    "Notifications",
     "Utilities"
   ],
   "license": "ISC",
@@ -24,6 +25,7 @@
     "@devopsplaybook.io/otel-utils": "^1.1.2",
     "@opentelemetry/api": "^1.9.1",
     "@opentelemetry/sdk-trace-base": "^2.10.0",
+    "axios": "^1.19.0",
     "better-sqlite3": "^13.0.3",
     "fs-extra": "^11.4.0",
     "pg": "^8.23.0",

package/src/Notifications.spec.ts

@@ -0,0 +1,265 @@
+jest.mock("axios", () => ({
+  create: jest.fn(),
+}));
+
+import axios from "axios";
+import {
+  NotificationsClient,
+  NotificationsLogger,
+} from "./Notifications";
+
+const mockedCreate = axios.create as jest.MockedFunction<
+  typeof axios.create
+>;
+
+/** Logger double that records every call. */
+function createMockLogger(): NotificationsLogger & {
+  info: jest.Mock;
+  warn: jest.Mock;
+  error: jest.Mock;
+} {
+  return {
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+  };
+}
+
+describe("NotificationsClient", () => {
+  let mockPost: jest.Mock;
+  let mockLogger: ReturnType<typeof createMockLogger>;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockPost = jest.fn();
+    mockedCreate.mockReturnValue({ post: mockPost } as never);
+    mockLogger = createMockLogger();
+  });
+
+  describe("constructor", () => {
+    it("should be enabled when apiEndpoint and apiToken are set", () => {
+      const client = new NotificationsClient({
+        apiEndpoint: "http://localhost/api/notifications",
+        apiToken: "token",
+        logger: mockLogger,
+      });
+
+      expect(client.isEnabled()).toBe(true);
+      expect(mockedCreate).toHaveBeenCalledTimes(1);
+    });
+
+    it("should be disabled when apiEndpoint is empty", () => {
+      const client = new NotificationsClient({
+        apiEndpoint: "",
+        apiToken: "token",
+        logger: mockLogger,
+      });
+
+      expect(client.isEnabled()).toBe(false);
+      expect(mockedCreate).not.toHaveBeenCalled();
+    });
+
+    it("should be disabled when apiToken is empty", () => {
+      const client = new NotificationsClient({
+        apiEndpoint: "http://localhost/api/notifications",
+        apiToken: "",
+        logger: mockLogger,
+      });
+
+      expect(client.isEnabled()).toBe(false);
+      expect(mockedCreate).not.toHaveBeenCalled();
+    });
+
+    it("should log the enabled status exactly once at construction", () => {
+      new NotificationsClient({
+        apiEndpoint: "http://localhost/api/notifications",
+        apiToken: "token",
+        logger: mockLogger,
+      });
+
+      expect(mockLogger.info).toHaveBeenCalledTimes(1);
+      expect(mockLogger.info).toHaveBeenCalledWith(
+        "Notifications integration enabled",
+      );
+    });
+
+    it("should log the disabled status exactly once at construction", () => {
+      new NotificationsClient({
+        apiEndpoint: "",
+        apiToken: "",
+        logger: mockLogger,
+      });
+
+      expect(mockLogger.info).toHaveBeenCalledTimes(1);
+      expect(mockLogger.info).toHaveBeenCalledWith(
+        "Notifications integration disabled (apiEndpoint or apiToken not set)",
+      );
+    });
+
+    it("should fall back to console logging when no logger is provided", () => {
+      const logSpy = jest.spyOn(console, "log").mockImplementation(jest.fn());
+
+      const client = new NotificationsClient({
+        apiEndpoint: "http://localhost/api/notifications",
+        apiToken: "token",
+      });
+
+      expect(client.isEnabled()).toBe(true);
+      expect(logSpy).toHaveBeenCalledWith(
+        "Notifications integration enabled",
+      );
+
+      logSpy.mockRestore();
+    });
+  });
+
+  describe("send", () => {
+    it("should return null silently when disabled", async () => {
+      const client = new NotificationsClient({
+        apiEndpoint: "",
+        apiToken: "",
+        logger: mockLogger,
+      });
+      jest.clearAllMocks(); // drop the startup log
+
+      const result = await client.send({ title: "Test" });
+
+      expect(result).toBeNull();
+      expect(mockPost).not.toHaveBeenCalled();
+      expect(mockLogger.info).not.toHaveBeenCalled();
+      expect(mockLogger.warn).not.toHaveBeenCalled();
+      expect(mockLogger.error).not.toHaveBeenCalled();
+    });
+
+    it("should post with default values when payload fields are omitted", async () => {
+      const client = new NotificationsClient({
+        apiEndpoint: "http://localhost/api/notifications",
+        apiToken: "token",
+        logger: mockLogger,
+      });
+      const response = {
+        id: "id-1",
+        title: "Test",
+        body: "",
+        source: "api",
+        severity: "info",
+        data: "{}",
+        createdAt: "2026-08-26T00:00:00.000Z",
+      };
+      mockPost.mockResolvedValue({ data: response });
+
+      const result = await client.send({ title: "Test" });
+
+      expect(mockPost).toHaveBeenCalledWith("/", {
+        title: "Test",
+        body: "",
+        source: "api",
+        severity: "info",
+        data: "{}",
+      });
+      expect(result).toEqual(response);
+    });
+
+    it("should pass through explicit payload values", async () => {
+      const client = new NotificationsClient({
+        apiEndpoint: "http://localhost/api/notifications",
+        apiToken: "token",
+        logger: mockLogger,
+      });
+      mockPost.mockResolvedValue({ data: {} });
+
+      await client.send({
+        title: "Alert",
+        body: "Something happened",
+        source: "my-app",
+        severity: "error",
+        data: '{"key":"value"}',
+      });
+
+      expect(mockPost).toHaveBeenCalledWith("/", {
+        title: "Alert",
+        body: "Something happened",
+        source: "my-app",
+        severity: "error",
+        data: '{"key":"value"}',
+      });
+    });
+
+    it("should return null and log an error when the request fails", async () => {
+      const client = new NotificationsClient({
+        apiEndpoint: "http://localhost/api/notifications",
+        apiToken: "token",
+        logger: mockLogger,
+      });
+      const failure = new Error("network down");
+      mockPost.mockRejectedValue(failure);
+
+      const result = await client.send({ title: "Test" });
+
+      expect(result).toBeNull();
+      expect(mockLogger.error).toHaveBeenCalledWith(
+        "NotificationsClient: failed to send notification",
+        failure,
+      );
+    });
+
+    it("should not reject when the request fails", async () => {
+      const client = new NotificationsClient({
+        apiEndpoint: "http://localhost/api/notifications",
+        apiToken: "token",
+        logger: mockLogger,
+      });
+      mockPost.mockRejectedValue(new Error("network down"));
+
+      await expect(client.send({ title: "Test" })).resolves.toBeNull();
+    });
+  });
+
+  describe("severity helpers", () => {
+    it.each([
+      ["info", "info"],
+      ["success", "success"],
+      ["warning", "warning"],
+      ["error", "error"],
+    ] as const)(
+      "should send a %s notification",
+      async (method, severity) => {
+        const client = new NotificationsClient({
+          apiEndpoint: "http://localhost/api/notifications",
+          apiToken: "token",
+          logger: mockLogger,
+        });
+        mockPost.mockResolvedValue({ data: {} });
+
+        await client[method]("Title", "Body", "my-app");
+
+        expect(mockPost).toHaveBeenCalledWith(
+          "/",
+          expect.objectContaining({
+            title: "Title",
+            body: "Body",
+            source: "my-app",
+            severity,
+          }),
+        );
+      },
+    );
+
+    it("should return null silently from helpers when disabled", async () => {
+      const client = new NotificationsClient({
+        apiEndpoint: "",
+        apiToken: "",
+        logger: mockLogger,
+      });
+      jest.clearAllMocks(); // drop the startup log
+
+      expect(await client.info("Title")).toBeNull();
+      expect(await client.success("Title")).toBeNull();
+      expect(await client.warning("Title")).toBeNull();
+      expect(await client.error("Title")).toBeNull();
+      expect(mockPost).not.toHaveBeenCalled();
+      expect(mockLogger.info).not.toHaveBeenCalled();
+      expect(mockLogger.error).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/Notifications.ts

@@ -0,0 +1,201 @@
+import axios, { AxiosInstance } from "axios";
+
+/**
+ * Severity levels for notifications.
+ */
+export type NotificationSeverity = "info" | "warning" | "error" | "success";
+
+/**
+ * Minimal logger interface expected by the notifications client.
+ * Matches the subset of the OTel logger used by devopsplaybook.io projects.
+ */
+export interface NotificationsLogger {
+  info(message: string): void;
+  warn(message: string): void;
+  error(message: string, err?: unknown): void;
+}
+
+/**
+ * Configuration for {@link NotificationsClient}.
+ */
+export interface NotificationsConfig {
+  /** API endpoint URL (e.g., "https://notifications.example.com/api/notifications") */
+  apiEndpoint: string;
+  /** API token used for Bearer authentication */
+  apiToken: string;
+  /** Optional logger; falls back to console when omitted */
+  logger?: NotificationsLogger;
+}
+
+/**
+ * Payload for creating a notification.
+ */
+export interface NotificationPayload {
+  /** Notification title */
+  title: string;
+  /** Notification body/content */
+  body?: string;
+  /** Source identifier (defaults to "api") */
+  source?: string;
+  /** Severity level (defaults to "info") */
+  severity?: NotificationSeverity;
+  /** Additional data as a JSON string */
+  data?: string;
+}
+
+/**
+ * Response from the notifications API.
+ */
+export interface NotificationResponse {
+  id: string;
+  title: string;
+  body: string;
+  source: string;
+  severity: string;
+  data: string;
+  createdAt: string;
+}
+
+/** Console fallback used when no logger is injected. */
+const consoleLogger: NotificationsLogger = {
+  info: (message: string) => console.log(message),
+  warn: (message: string) => console.warn(message),
+  error: (message: string, err?: unknown) => console.error(message, err),
+};
+
+/**
+ * Client for sending notifications to the central notifications service.
+ *
+ * The client is fail-safe by design:
+ *
+ * - It is disabled (and never throws) when `apiEndpoint` or `apiToken` is
+ *   missing, so a partially configured parent application still starts.
+ * - The integration status is logged exactly once, at construction time.
+ * - Follow-up `send` calls on a disabled client are silent and resolve to
+ *   `null`.
+ * - Sending errors are logged and resolve to `null` instead of rejecting.
+ *
+ * @example
+ * ```ts
+ * const client = new NotificationsClient({
+ *   apiEndpoint: config.NOTIFICATIONS_API,
+ *   apiToken: config.NOTIFICATIONS_TOKEN,
+ *   logger: OTelLogger().createModuleLogger("notifications"),
+ * });
+ *
+ * await client.send({
+ *   title: "Deployment finished",
+ *   body: "Version 1.2.3 deployed to production",
+ *   source: "my-app",
+ *   severity: "success",
+ * });
+ * ```
+ */
+export class NotificationsClient {
+  private client: AxiosInstance | null = null;
+  private readonly enabled: boolean;
+  private readonly logger: NotificationsLogger;
+
+  constructor(config: NotificationsConfig) {
+    this.enabled = !!(config.apiEndpoint && config.apiToken);
+    this.logger = config.logger || consoleLogger;
+
+    if (this.enabled) {
+      this.client = axios.create({
+        baseURL: config.apiEndpoint,
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${config.apiToken}`,
+        },
+        timeout: 10000,
+      });
+      this.logger.info("Notifications integration enabled");
+    } else {
+      this.logger.info(
+        "Notifications integration disabled (apiEndpoint or apiToken not set)",
+      );
+    }
+  }
+
+  /**
+   * Check whether the client is properly configured.
+   */
+  public isEnabled(): boolean {
+    return this.enabled;
+  }
+
+  /**
+   * Send a notification.
+   *
+   * @param payload  The notification payload.
+   * @returns The created notification, or `null` when disabled or on failure.
+   */
+  public async send(
+    payload: NotificationPayload,
+  ): Promise<NotificationResponse | null> {
+    if (!this.enabled || !this.client) {
+      return null;
+    }
+
+    try {
+      const response = await this.client.post<NotificationResponse>("/", {
+        title: payload.title,
+        body: payload.body || "",
+        source: payload.source || "api",
+        severity: payload.severity || "info",
+        data: payload.data || "{}",
+      });
+      return response.data;
+    } catch (err) {
+      this.logger.error(
+        "NotificationsClient: failed to send notification",
+        err,
+      );
+      return null;
+    }
+  }
+
+  /**
+   * Send an info notification.
+   */
+  public async info(
+    title: string,
+    body?: string,
+    source?: string,
+  ): Promise<NotificationResponse | null> {
+    return this.send({ title, body, source, severity: "info" });
+  }
+
+  /**
+   * Send a success notification.
+   */
+  public async success(
+    title: string,
+    body?: string,
+    source?: string,
+  ): Promise<NotificationResponse | null> {
+    return this.send({ title, body, source, severity: "success" });
+  }
+
+  /**
+   * Send a warning notification.
+   */
+  public async warning(
+    title: string,
+    body?: string,
+    source?: string,
+  ): Promise<NotificationResponse | null> {
+    return this.send({ title, body, source, severity: "warning" });
+  }
+
+  /**
+   * Send an error notification.
+   */
+  public async error(
+    title: string,
+    body?: string,
+    source?: string,
+  ): Promise<NotificationResponse | null> {
+    return this.send({ title, body, source, severity: "error" });
+  }
+}