@backstage/plugin-notifications-backend 0.4.1-next.0 → 0.4.1

package/dist/index.cjs.js

@@ -2,848 +2,9 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var backendPluginApi = require('@backstage/backend-plugin-api');
-var backendCommon = require('@backstage/backend-common');
-var express = require('express');
-var Router = require('express-promise-router');
-var pluginNotificationsCommon = require('@backstage/plugin-notifications-common');
-var uuid = require('uuid');
-var errors = require('@backstage/errors');
-var catalogModel = require('@backstage/catalog-model');
-var pluginSignalsNode = require('@backstage/plugin-signals-node');
-var pluginNotificationsNode = require('@backstage/plugin-notifications-node');
-var alpha = require('@backstage/plugin-catalog-node/alpha');
+var plugin = require('./plugin.cjs.js');
 
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
-var express__default = /*#__PURE__*/_interopDefaultCompat(express);
-var Router__default = /*#__PURE__*/_interopDefaultCompat(Router);
 
-const migrationsDir = backendPluginApi.resolvePackagePath(
-  "@backstage/plugin-notifications-backend",
-  "migrations"
-);
-const NOTIFICATION_COLUMNS = [
-  "id",
-  "title",
-  "description",
-  "severity",
-  "link",
-  "origin",
-  "scope",
-  "topic",
-  "icon",
-  "created",
-  "updated",
-  "user",
-  "read",
-  "saved"
-];
-const normalizeSeverity = (input) => {
-  let lower = (input ?? "normal").toLowerCase();
-  if (pluginNotificationsCommon.notificationSeverities.indexOf(lower) < 0) {
-    lower = "normal";
-  }
-  return lower;
-};
-class DatabaseNotificationsStore {
-  constructor(db) {
-    this.db = db;
-    this.isSQLite = this.db.client.config.client.includes("sqlite3");
-  }
-  isSQLite = false;
-  static async create({
-    database,
-    skipMigrations
-  }) {
-    const client = await database.getClient();
-    if (!database.migrations?.skip && !skipMigrations) {
-      await client.migrate.latest({
-        directory: migrationsDir
-      });
-    }
-    return new DatabaseNotificationsStore(client);
-  }
-  mapToInteger = (val) => {
-    return typeof val === "string" ? Number.parseInt(val, 10) : val ?? 0;
-  };
-  mapToNotifications = (rows) => {
-    return rows.map((row) => ({
-      id: row.id,
-      user: row.user,
-      created: new Date(row.created),
-      saved: row.saved,
-      read: row.read,
-      updated: row.updated,
-      origin: row.origin,
-      payload: {
-        title: row.title,
-        description: row.description,
-        link: row.link,
-        topic: row.topic,
-        severity: row.severity,
-        scope: row.scope,
-        icon: row.icon
-      }
-    }));
-  };
-  mapNotificationToDbRow = (notification) => {
-    return {
-      id: notification.id,
-      user: notification.user,
-      origin: notification.origin,
-      created: notification.created,
-      topic: notification.payload?.topic,
-      link: notification.payload?.link,
-      title: notification.payload?.title,
-      description: notification.payload?.description,
-      severity: normalizeSeverity(notification.payload?.severity),
-      scope: notification.payload?.scope,
-      icon: notification.payload.icon,
-      saved: notification.saved,
-      read: notification.read
-    };
-  };
-  mapBroadcastToDbRow = (notification) => {
-    return {
-      id: notification.id,
-      origin: notification.origin,
-      created: notification.created,
-      topic: notification.payload?.topic,
-      link: notification.payload?.link,
-      title: notification.payload?.title,
-      description: notification.payload?.description,
-      severity: normalizeSeverity(notification.payload?.severity),
-      icon: notification.payload.icon,
-      scope: notification.payload?.scope
-    };
-  };
-  getBroadcastUnion = (user) => {
-    return this.db("broadcast").leftJoin("broadcast_user_status", function clause() {
-      const join = this.on("id", "=", "broadcast_user_status.broadcast_id");
-      if (user !== null && user !== void 0) {
-        join.andOnVal("user", "=", user);
-      }
-    }).select(NOTIFICATION_COLUMNS);
-  };
-  getNotificationsBaseQuery = (options) => {
-    const { user, orderField } = options;
-    const subQuery = this.db("notification").select(NOTIFICATION_COLUMNS).unionAll([this.getBroadcastUnion(user)]).as("notifications");
-    const query = this.db.from(subQuery).where((q) => {
-      q.where("user", user).orWhereNull("user");
-    });
-    if (orderField && orderField.length > 0) {
-      orderField.forEach((orderBy) => {
-        query.orderBy(orderBy.field, orderBy.order);
-      });
-    } else if (!orderField) {
-      query.orderBy("created", "desc");
-    }
-    if (options.createdAfter) {
-      if (this.isSQLite) {
-        query.where("created", ">=", options.createdAfter.valueOf());
-      } else {
-        query.where("created", ">=", options.createdAfter.toISOString());
-      }
-    }
-    if (options.limit) {
-      query.limit(options.limit);
-    }
-    if (options.offset) {
-      query.offset(options.offset);
-    }
-    if (options.search) {
-      query.whereRaw(
-        `(LOWER(title) LIKE LOWER(?) OR LOWER(description) LIKE LOWER(?))`,
-        [`%${options.search}%`, `%${options.search}%`]
-      );
-    }
-    if (options.ids) {
-      query.whereIn("id", options.ids);
-    }
-    if (options.read) {
-      query.whereNotNull("read");
-    } else if (options.read === false) {
-      query.whereNull("read");
-    }
-    if (options.topic) {
-      query.where("topic", "=", options.topic);
-    }
-    if (options.saved) {
-      query.whereNotNull("saved");
-    } else if (options.saved === false) {
-      query.whereNull("saved");
-    }
-    if (options.minimumSeverity !== void 0) {
-      const idx = pluginNotificationsCommon.notificationSeverities.indexOf(options.minimumSeverity);
-      const equalOrHigher = pluginNotificationsCommon.notificationSeverities.slice(0, idx + 1);
-      query.whereIn("severity", equalOrHigher);
-    }
-    return query;
-  };
-  async getNotifications(options) {
-    const notificationQuery = this.getNotificationsBaseQuery(options);
-    const notifications = await notificationQuery.select(NOTIFICATION_COLUMNS);
-    return this.mapToNotifications(notifications);
-  }
-  async getNotificationsCount(options) {
-    const countOptions = { ...options };
-    countOptions.limit = void 0;
-    countOptions.offset = void 0;
-    countOptions.orderField = [];
-    const notificationQuery = this.getNotificationsBaseQuery(countOptions);
-    const response = await notificationQuery.count("id as CNT");
-    return Number(response[0].CNT);
-  }
-  async saveNotification(notification) {
-    await this.db.insert(this.mapNotificationToDbRow(notification)).into("notification");
-  }
-  async saveBroadcast(notification) {
-    await this.db.insert(this.mapBroadcastToDbRow(notification)).into("broadcast");
-    if (notification.saved || notification.read) {
-      await this.db.insert({
-        user: notification.user,
-        broadcast_id: notification.id,
-        saved: notification.saved,
-        read: notification.read
-      }).into("broadcast_user_status");
-    }
-  }
-  async getStatus(options) {
-    const notificationQuery = this.getNotificationsBaseQuery({
-      ...options,
-      orderField: []
-    });
-    const readSubQuery = notificationQuery.clone().count("id").whereNotNull("read").as("READ");
-    const unreadSubQuery = notificationQuery.clone().count("id").whereNull("read").as("UNREAD");
-    const query = await notificationQuery.select(readSubQuery, unreadSubQuery).first();
-    return {
-      unread: this.mapToInteger(query?.UNREAD),
-      read: this.mapToInteger(query?.READ)
-    };
-  }
-  async getExistingScopeNotification(options) {
-    const query = this.db("notification").where("user", options.user).where("scope", options.scope).where("origin", options.origin).limit(1);
-    const rows = await query;
-    if (!rows || rows.length === 0) {
-      return null;
-    }
-    return rows[0];
-  }
-  async getExistingScopeBroadcast(options) {
-    const query = this.db("broadcast").where("scope", options.scope).where("origin", options.origin).limit(1);
-    const rows = await query;
-    if (!rows || rows.length === 0) {
-      return null;
-    }
-    return rows[0];
-  }
-  async restoreExistingNotification({
-    id,
-    notification
-  }) {
-    const updateColumns = {
-      title: notification.payload.title,
-      description: notification.payload.description,
-      link: notification.payload.link,
-      topic: notification.payload.topic,
-      updated: /* @__PURE__ */ new Date(),
-      severity: normalizeSeverity(notification.payload?.severity),
-      read: null
-    };
-    const notificationQuery = this.db("notification").where("id", id).where("user", notification.user);
-    const broadcastQuery = this.db("broadcast").where("id", id);
-    await Promise.all([
-      notificationQuery.update(updateColumns),
-      broadcastQuery.update({ ...updateColumns, read: void 0 })
-    ]);
-    return await this.getNotification({ id, user: notification.user });
-  }
-  async getNotification(options) {
-    const rows = await this.db.select("*").from(
-      this.db("notification").select(NOTIFICATION_COLUMNS).unionAll([this.getBroadcastUnion(options.user)]).as("notifications")
-    ).where("id", options.id).limit(1);
-    if (!rows || rows.length === 0) {
-      return null;
-    }
-    return this.mapToNotifications(rows)[0];
-  }
-  markReadSaved = async (ids, user, read, saved) => {
-    await this.db("notification").whereIn("id", ids).where("user", user).update({ read, saved });
-    const broadcasts = this.mapToNotifications(
-      await this.db("broadcast").whereIn("id", ids).select()
-    );
-    if (broadcasts.length > 0)
-      if (!this.isSQLite) {
-        await this.db("broadcast_user_status").insert(
-          broadcasts.map((b) => ({
-            broadcast_id: b.id,
-            user,
-            read,
-            saved
-          }))
-        ).onConflict(["broadcast_id", "user"]).merge(["read", "saved"]);
-      } else {
-        for (const b of broadcasts) {
-          const baseQuery = this.db("broadcast_user_status").where("broadcast_id", b.id).where("user", user);
-          const exists = await baseQuery.clone().limit(1).select().first();
-          if (exists) {
-            await baseQuery.clone().update({ read, saved });
-          } else {
-            await baseQuery.clone().insert({ broadcast_id: b.id, user, read, saved });
-          }
-        }
-      }
-  };
-  async markRead(options) {
-    await this.markReadSaved(options.ids, options.user, /* @__PURE__ */ new Date(), void 0);
-  }
-  async markUnread(options) {
-    await this.markReadSaved(options.ids, options.user, null, void 0);
-  }
-  async markSaved(options) {
-    await this.markReadSaved(options.ids, options.user, void 0, /* @__PURE__ */ new Date());
-  }
-  async markUnsaved(options) {
-    await this.markReadSaved(options.ids, options.user, void 0, null);
-  }
-}
-
-function parseStringsParam(param, ctx) {
-  if (param === void 0) {
-    return void 0;
-  }
-  const array = [param].flat();
-  if (array.some((p) => typeof p !== "string")) {
-    throw new errors.InputError(`Invalid ${ctx}, not a string`);
-  }
-  return array;
-}
-function parseEntityOrderFieldParams(params) {
-  const orderFieldStrings = parseStringsParam(params.orderField, "orderField");
-  if (!orderFieldStrings) {
-    return void 0;
-  }
-  return orderFieldStrings.map((orderFieldString) => {
-    const [field, order] = orderFieldString.split(",");
-    if (order !== void 0 && !isOrder(order)) {
-      throw new errors.InputError("Invalid order field order, must be asc or desc");
-    }
-    return { field, order };
-  });
-}
-function isOrder(order) {
-  return ["asc", "desc"].includes(order);
-}
-
-const isUserEntityRef = (ref) => catalogModel.parseEntityRef(ref).kind.toLocaleLowerCase() === "user";
-const partitionEntityRefs = (refs) => refs.reduce(
-  ([userEntityRefs, otherEntityRefs], ref) => {
-    return isUserEntityRef(ref) ? [[...userEntityRefs, ref], otherEntityRefs] : [userEntityRefs, [...otherEntityRefs, ref]];
-  },
-  [[], []]
-);
-const getUsersForEntityRef = async (entityRef, excludeEntityRefs, options) => {
-  const { auth, catalogClient } = options;
-  if (entityRef === null) {
-    return [];
-  }
-  const { token } = await auth.getPluginRequestToken({
-    onBehalfOf: await auth.getOwnServiceCredentials(),
-    targetPluginId: "catalog"
-  });
-  const excluded = Array.isArray(excludeEntityRefs) ? excludeEntityRefs : [excludeEntityRefs];
-  const refsArr = Array.isArray(entityRef) ? entityRef : [entityRef];
-  const [userEntityRefs, otherEntityRefs] = partitionEntityRefs(refsArr);
-  const users = userEntityRefs.filter((ref) => !excluded.includes(ref));
-  const entityRefs = otherEntityRefs.filter((ref) => !excluded.includes(ref));
-  const fields = ["kind", "metadata.name", "metadata.namespace", "relations"];
-  let entities = [];
-  if (entityRefs.length > 0) {
-    const fetchedEntities = await catalogClient.getEntitiesByRefs(
-      {
-        entityRefs,
-        fields
-      },
-      { token }
-    );
-    entities = fetchedEntities.items;
-  }
-  const mapEntity = async (entity) => {
-    if (!entity) {
-      return [];
-    }
-    const currentEntityRef = catalogModel.stringifyEntityRef(entity);
-    if (excluded.includes(currentEntityRef)) {
-      return [];
-    }
-    if (catalogModel.isUserEntity(entity)) {
-      return [currentEntityRef];
-    }
-    if (catalogModel.isGroupEntity(entity)) {
-      if (!entity.relations?.length) {
-        return [];
-      }
-      const groupUsers = entity.relations.filter(
-        (relation) => relation.type === catalogModel.RELATION_HAS_MEMBER && isUserEntityRef(relation.targetRef)
-      ).map((r) => r.targetRef);
-      const childGroupRefs = entity.relations.filter((relation) => relation.type === catalogModel.RELATION_PARENT_OF).map((r) => r.targetRef);
-      let childGroupUsers = [];
-      if (childGroupRefs.length > 0) {
-        const childGroups = await catalogClient.getEntitiesByRefs(
-          {
-            entityRefs: childGroupRefs,
-            fields
-          },
-          { token }
-        );
-        childGroupUsers = await Promise.all(childGroups.items.map(mapEntity));
-      }
-      return [...groupUsers, ...childGroupUsers.flat(2)].filter(
-        (ref) => !excluded.includes(ref)
-      );
-    }
-    if (entity.relations?.length) {
-      const ownerRef = entity.relations.find(
-        (relation) => relation.type === catalogModel.RELATION_OWNED_BY
-      )?.targetRef;
-      if (!ownerRef) {
-        return [];
-      }
-      if (isUserEntityRef(ownerRef)) {
-        if (excluded.includes(ownerRef)) {
-          return [];
-        }
-        return [ownerRef];
-      }
-      const owner = await catalogClient.getEntityByRef(ownerRef, { token });
-      return mapEntity(owner);
-    }
-    return [];
-  };
-  for (const entity of entities) {
-    const u = await mapEntity(entity);
-    users.push(...u);
-  }
-  return [...new Set(users)].filter(Boolean);
-};
-
-async function createRouter(options) {
-  const {
-    config,
-    logger,
-    database,
-    auth,
-    httpAuth,
-    userInfo,
-    catalog,
-    processors = [],
-    signals
-  } = options;
-  const store = await DatabaseNotificationsStore.create({ database });
-  const frontendBaseUrl = config.getString("app.baseUrl");
-  const getUser = async (req) => {
-    const credentials = await httpAuth.credentials(req, { allow: ["user"] });
-    const info = await userInfo.getUserInfo(credentials);
-    return info.userEntityRef;
-  };
-  const filterProcessors = (payload) => {
-    const result = [];
-    for (const processor of processors) {
-      if (processor.getNotificationFilters) {
-        const filters = processor.getNotificationFilters();
-        if (filters.minSeverity) {
-          if (pluginNotificationsCommon.notificationSeverities.indexOf(payload.severity ?? "normal") > pluginNotificationsCommon.notificationSeverities.indexOf(filters.minSeverity)) {
-            continue;
-          }
-        }
-        if (filters.maxSeverity) {
-          if (pluginNotificationsCommon.notificationSeverities.indexOf(payload.severity ?? "normal") < pluginNotificationsCommon.notificationSeverities.indexOf(filters.maxSeverity)) {
-            continue;
-          }
-        }
-        if (filters.excludedTopics && payload.topic) {
-          if (filters.excludedTopics.includes(payload.topic)) {
-            continue;
-          }
-        }
-      }
-      result.push(processor);
-    }
-    return result;
-  };
-  const processOptions = async (opts) => {
-    const filtered = filterProcessors(opts.payload);
-    let ret = opts;
-    for (const processor of filtered) {
-      try {
-        ret = processor.processOptions ? await processor.processOptions(ret) : ret;
-      } catch (e) {
-        logger.error(
-          `Error while processing notification options with ${processor.getName()}: ${e}`
-        );
-      }
-    }
-    return ret;
-  };
-  const preProcessNotification = async (notification, opts) => {
-    const filtered = filterProcessors(notification.payload);
-    let ret = notification;
-    for (const processor of filtered) {
-      try {
-        ret = processor.preProcess ? await processor.preProcess(ret, opts) : ret;
-      } catch (e) {
-        logger.error(
-          `Error while pre processing notification with ${processor.getName()}: ${e}`
-        );
-      }
-    }
-    return ret;
-  };
-  const postProcessNotification = async (notification, opts) => {
-    const filtered = filterProcessors(notification.payload);
-    for (const processor of filtered) {
-      if (processor.postProcess) {
-        try {
-          await processor.postProcess(notification, opts);
-        } catch (e) {
-          logger.error(
-            `Error while post processing notification with ${processor.getName()}: ${e}`
-          );
-        }
-      }
-    }
-  };
-  const validateLink = (link) => {
-    const stripLeadingSlash = (s) => s.replace(/^\//, "");
-    const ensureTrailingSlash = (s) => s.replace(/\/?$/, "/");
-    const url = new URL(
-      stripLeadingSlash(link),
-      ensureTrailingSlash(frontendBaseUrl)
-    );
-    if (url.protocol !== "https:" && url.protocol !== "http:") {
-      throw new Error("Only HTTP/HTTPS links are allowed");
-    }
-  };
-  const router = Router__default.default();
-  router.use(express__default.default.json());
-  router.get("/health", (_, response) => {
-    logger.info("PONG!");
-    response.json({ status: "ok" });
-  });
-  router.get("/", async (req, res) => {
-    const user = await getUser(req);
-    const opts = {
-      user
-    };
-    if (req.query.offset) {
-      opts.offset = Number.parseInt(req.query.offset.toString(), 10);
-    }
-    if (req.query.limit) {
-      opts.limit = Number.parseInt(req.query.limit.toString(), 10);
-    }
-    if (req.query.orderField) {
-      opts.orderField = parseEntityOrderFieldParams(req.query);
-    }
-    if (req.query.search) {
-      opts.search = req.query.search.toString();
-    }
-    if (req.query.read === "true") {
-      opts.read = true;
-    } else if (req.query.read === "false") {
-      opts.read = false;
-    }
-    if (req.query.topic) {
-      opts.topic = req.query.topic.toString();
-    }
-    if (req.query.saved === "true") {
-      opts.saved = true;
-    } else if (req.query.saved === "false") {
-      opts.saved = false;
-    }
-    if (req.query.createdAfter) {
-      const sinceEpoch = Date.parse(String(req.query.createdAfter));
-      if (isNaN(sinceEpoch)) {
-        throw new errors.InputError("Unexpected date format");
-      }
-      opts.createdAfter = new Date(sinceEpoch);
-    }
-    if (req.query.minimumSeverity) {
-      opts.minimumSeverity = normalizeSeverity(
-        req.query.minimumSeverity.toString()
-      );
-    }
-    const [notifications, totalCount] = await Promise.all([
-      store.getNotifications(opts),
-      store.getNotificationsCount(opts)
-    ]);
-    res.json({
-      totalCount,
-      notifications
-    });
-  });
-  router.get("/status", async (req, res) => {
-    const user = await getUser(req);
-    const status = await store.getStatus({ user });
-    res.json(status);
-  });
-  router.get("/:id", async (req, res) => {
-    const user = await getUser(req);
-    const opts = {
-      user,
-      limit: 1,
-      ids: [req.params.id]
-    };
-    const notifications = await store.getNotifications(opts);
-    if (notifications.length !== 1) {
-      throw new errors.NotFoundError("Not found");
-    }
-    res.json(notifications[0]);
-  });
-  router.post("/update", async (req, res) => {
-    const user = await getUser(req);
-    const { ids, read, saved } = req.body;
-    if (!ids || !Array.isArray(ids)) {
-      throw new errors.InputError();
-    }
-    if (read === true) {
-      await store.markRead({ user, ids });
-      if (signals) {
-        await signals.publish({
-          recipients: { type: "user", entityRef: [user] },
-          message: { action: "notification_read", notification_ids: ids },
-          channel: "notifications"
-        });
-      }
-    } else if (read === false) {
-      await store.markUnread({ user, ids });
-      if (signals) {
-        await signals.publish({
-          recipients: { type: "user", entityRef: [user] },
-          message: { action: "notification_unread", notification_ids: ids },
-          channel: "notifications"
-        });
-      }
-    }
-    if (saved === true) {
-      await store.markSaved({ user, ids });
-    } else if (saved === false) {
-      await store.markUnsaved({ user, ids });
-    }
-    const notifications = await store.getNotifications({ ids, user });
-    res.json(notifications);
-  });
-  const sendBroadcastNotification = async (baseNotification, opts, origin) => {
-    const { scope } = opts.payload;
-    const broadcastNotification = {
-      ...baseNotification,
-      user: null,
-      id: uuid.v4()
-    };
-    const notification = await preProcessNotification(
-      broadcastNotification,
-      opts
-    );
-    let existingNotification;
-    if (scope) {
-      existingNotification = await store.getExistingScopeBroadcast({
-        scope,
-        origin
-      });
-    }
-    let ret = notification;
-    if (existingNotification) {
-      const restored = await store.restoreExistingNotification({
-        id: existingNotification.id,
-        notification: { ...notification, user: "" }
-      });
-      ret = restored ?? notification;
-    } else {
-      await store.saveBroadcast(notification);
-    }
-    if (signals) {
-      await signals.publish({
-        recipients: { type: "broadcast" },
-        message: {
-          action: "new_notification",
-          notification_id: ret.id
-        },
-        channel: "notifications"
-      });
-      postProcessNotification(ret, opts);
-    }
-    return notification;
-  };
-  const sendUserNotifications = async (baseNotification, users, opts, origin) => {
-    const notifications = [];
-    const { scope } = opts.payload;
-    const uniqueUsers = [...new Set(users)];
-    for (const user of uniqueUsers) {
-      const userNotification = {
-        ...baseNotification,
-        id: uuid.v4(),
-        user
-      };
-      const notification = await preProcessNotification(userNotification, opts);
-      let existingNotification;
-      if (scope) {
-        existingNotification = await store.getExistingScopeNotification({
-          user,
-          scope,
-          origin
-        });
-      }
-      let ret = notification;
-      if (existingNotification) {
-        const restored = await store.restoreExistingNotification({
-          id: existingNotification.id,
-          notification
-        });
-        ret = restored ?? notification;
-      } else {
-        await store.saveNotification(notification);
-      }
-      notifications.push(ret);
-      if (signals) {
-        await signals.publish({
-          recipients: { type: "user", entityRef: [user] },
-          message: {
-            action: "new_notification",
-            notification_id: ret.id
-          },
-          channel: "notifications"
-        });
-      }
-      postProcessNotification(ret, opts);
-    }
-    return notifications;
-  };
-  router.post(
-    "/",
-    async (req, res) => {
-      const opts = await processOptions(req.body);
-      const { recipients, payload } = opts;
-      const notifications = [];
-      let users = [];
-      const credentials = await httpAuth.credentials(req, {
-        allow: ["service"]
-      });
-      const { title, link } = payload;
-      if (!recipients || !title) {
-        logger.error(`Invalid notification request received`);
-        throw new errors.InputError(`Invalid notification request received`);
-      }
-      if (link) {
-        try {
-          validateLink(link);
-        } catch (e) {
-          throw new errors.InputError("Invalid link provided", e);
-        }
-      }
-      const origin = credentials.principal.subject;
-      const baseNotification = {
-        payload: {
-          ...payload,
-          severity: payload.severity ?? "normal"
-        },
-        origin,
-        created: /* @__PURE__ */ new Date()
-      };
-      if (recipients.type === "broadcast") {
-        const broadcast = await sendBroadcastNotification(
-          baseNotification,
-          opts,
-          origin
-        );
-        notifications.push(broadcast);
-      } else {
-        const entityRef = recipients.entityRef;
-        try {
-          users = await getUsersForEntityRef(
-            entityRef,
-            recipients.excludeEntityRef ?? [],
-            { auth, catalogClient: catalog }
-          );
-        } catch (e) {
-          logger.error(`Failed to resolve notification receivers: ${e}`);
-          throw new errors.InputError("Failed to resolve notification receivers", e);
-        }
-        const userNotifications = await sendUserNotifications(
-          baseNotification,
-          users,
-          opts,
-          origin
-        );
-        notifications.push(...userNotifications);
-      }
-      res.json(notifications);
-    }
-  );
-  router.use(backendCommon.errorHandler());
-  return router;
-}
-
-class NotificationsProcessingExtensionPointImpl {
-  #processors = new Array();
-  addProcessor(...processors) {
-    this.#processors.push(...processors.flat());
-  }
-  get processors() {
-    return this.#processors;
-  }
-}
-const notificationsPlugin = backendPluginApi.createBackendPlugin({
-  pluginId: "notifications",
-  register(env) {
-    const processingExtensions = new NotificationsProcessingExtensionPointImpl();
-    env.registerExtensionPoint(
-      pluginNotificationsNode.notificationsProcessingExtensionPoint,
-      processingExtensions
-    );
-    env.registerInit({
-      deps: {
-        auth: backendPluginApi.coreServices.auth,
-        httpAuth: backendPluginApi.coreServices.httpAuth,
-        userInfo: backendPluginApi.coreServices.userInfo,
-        httpRouter: backendPluginApi.coreServices.httpRouter,
-        logger: backendPluginApi.coreServices.logger,
-        database: backendPluginApi.coreServices.database,
-        signals: pluginSignalsNode.signalsServiceRef,
-        config: backendPluginApi.coreServices.rootConfig,
-        catalog: alpha.catalogServiceRef
-      },
-      async init({
-        auth,
-        httpAuth,
-        userInfo,
-        httpRouter,
-        logger,
-        database,
-        signals,
-        config,
-        catalog
-      }) {
-        httpRouter.use(
-          await createRouter({
-            auth,
-            httpAuth,
-            userInfo,
-            logger,
-            config,
-            database,
-            catalog,
-            signals,
-            processors: processingExtensions.processors
-          })
-        );
-        httpRouter.addAuthPolicy({
-          path: "/health",
-          allow: "unauthenticated"
-        });
-      }
-    });
-  }
-});
-
-exports.default = notificationsPlugin;
+exports.default = plugin.notificationsPlugin;
 //# sourceMappingURL=index.cjs.js.map