@backstage/plugin-events-backend 0.3.13-next.0 → 0.3.13-next.1

package/dist/alpha.cjs.js

@@ -2,992 +2,9 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var backendPluginApi = require('@backstage/backend-plugin-api');
-var alpha = require('@backstage/plugin-events-node/alpha');
-var pluginEventsNode = require('@backstage/plugin-events-node');
-var Router = require('express-promise-router');
-var HttpPostIngressEventPublisher = require('./cjs/HttpPostIngressEventPublisher-D6pQ6awS.cjs.js');
-var backendOpenapiUtils = require('@backstage/backend-openapi-utils');
-var errors = require('@backstage/errors');
-var types = require('@backstage/types');
-require('@backstage/backend-common');
-require('express');
+var EventsPlugin = require('./service/EventsPlugin.cjs.js');
 
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
-var Router__default = /*#__PURE__*/_interopDefaultCompat(Router);
 
-const spec = {
-  openapi: "3.0.3",
-  info: {
-    title: "events",
-    version: "1",
-    description: "The Backstage backend plugin that powers the events system.",
-    license: {
-      name: "Apache-2.0",
-      url: "http://www.apache.org/licenses/LICENSE-2.0.html"
-    },
-    contact: {}
-  },
-  servers: [
-    {
-      url: "/"
-    }
-  ],
-  components: {
-    examples: {},
-    headers: {},
-    parameters: {
-      subscriptionId: {
-        name: "subscriptionId",
-        in: "path",
-        required: true,
-        allowReserved: true,
-        schema: {
-          type: "string"
-        }
-      }
-    },
-    requestBodies: {},
-    responses: {
-      ErrorResponse: {
-        description: "An error response from the backend.",
-        content: {
-          "application/json; charset=utf-8": {
-            schema: {
-              $ref: "#/components/schemas/Error"
-            }
-          }
-        }
-      }
-    },
-    schemas: {
-      Event: {
-        type: "object",
-        required: ["topic", "payload"],
-        properties: {
-          topic: {
-            type: "string",
-            description: "The topic that the event is published on"
-          },
-          payload: {
-            description: "The event payload"
-          }
-        }
-      },
-      Error: {
-        type: "object",
-        properties: {
-          error: {
-            type: "object",
-            properties: {
-              name: {
-                type: "string"
-              },
-              message: {
-                type: "string"
-              }
-            },
-            required: ["name", "message"]
-          },
-          request: {
-            type: "object",
-            properties: {
-              method: {
-                type: "string"
-              },
-              url: {
-                type: "string"
-              }
-            },
-            required: ["method", "url"]
-          },
-          response: {
-            type: "object",
-            properties: {
-              statusCode: {
-                type: "number"
-              }
-            },
-            required: ["statusCode"]
-          }
-        },
-        required: ["error", "request", "response"]
-      }
-    },
-    securitySchemes: {
-      JWT: {
-        type: "http",
-        scheme: "bearer",
-        bearerFormat: "JWT"
-      }
-    }
-  },
-  paths: {
-    "/bus/v1/events": {
-      post: {
-        operationId: "PostEvent",
-        description: "Publish a new event",
-        responses: {
-          "201": {
-            description: "The event was published successfully"
-          },
-          "204": {
-            description: "The event did not need to be published as all subscribers have already been notified"
-          },
-          default: {
-            $ref: "#/components/responses/ErrorResponse"
-          }
-        },
-        security: [
-          {},
-          {
-            JWT: []
-          }
-        ],
-        requestBody: {
-          required: true,
-          content: {
-            "application/json": {
-              schema: {
-                type: "object",
-                required: ["event"],
-                properties: {
-                  event: {
-                    $ref: "#/components/schemas/Event"
-                  },
-                  notifiedSubscribers: {
-                    type: "array",
-                    description: "The IDs of subscriptions that have already received this event",
-                    items: {
-                      type: "string"
-                    }
-                  }
-                }
-              },
-              examples: {
-                "Publishing a simple Event": {
-                  value: {
-                    event: {
-                      topic: "test-topic",
-                      payload: {
-                        myData: "foo"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/bus/v1/subscriptions/{subscriptionId}": {
-      put: {
-        operationId: "PutSubscription",
-        description: "Ensures that the subscription exists with the provided configuration",
-        responses: {
-          "201": {
-            description: "The subscription exists or was created successfully"
-          },
-          default: {
-            $ref: "#/components/responses/ErrorResponse"
-          }
-        },
-        security: [
-          {},
-          {
-            JWT: []
-          }
-        ],
-        parameters: [
-          {
-            $ref: "#/components/parameters/subscriptionId"
-          }
-        ],
-        requestBody: {
-          required: true,
-          content: {
-            "application/json": {
-              schema: {
-                type: "object",
-                required: ["topics"],
-                properties: {
-                  topics: {
-                    type: "array",
-                    description: "The topics to subscribe to",
-                    items: {
-                      type: "string"
-                    }
-                  }
-                }
-              },
-              examples: {
-                "Subscribing to a single topic": {
-                  value: {
-                    topics: ["test-topic"]
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/bus/v1/subscriptions/{subscriptionId}/events": {
-      get: {
-        operationId: "GetSubscriptionEvents",
-        description: "Get new events for the provided subscription",
-        responses: {
-          "200": {
-            description: "New events",
-            content: {
-              "application/json": {
-                schema: {
-                  type: "object",
-                  required: ["events"],
-                  properties: {
-                    events: {
-                      type: "array",
-                      items: {
-                        $ref: "#/components/schemas/Event"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          },
-          "202": {
-            description: "No new events are available. Response will block until the client should try again."
-          },
-          default: {
-            $ref: "#/components/responses/ErrorResponse"
-          }
-        },
-        security: [
-          {},
-          {
-            JWT: []
-          }
-        ],
-        parameters: [
-          {
-            $ref: "#/components/parameters/subscriptionId"
-          }
-        ]
-      }
-    }
-  }
-};
-const createOpenApiRouter = async (options) => backendOpenapiUtils.createValidatedOpenApiRouter(spec, options);
-
-const MAX_BATCH_SIZE$1 = 10;
-const MAX_EVENTS_DEFAULT = 1e3;
-class MemoryEventBusStore {
-  #maxEvents;
-  #events = new Array();
-  #subscribers = /* @__PURE__ */ new Map();
-  #listeners = /* @__PURE__ */ new Set();
-  constructor(options = {}) {
-    this.#maxEvents = options.maxEvents ?? MAX_EVENTS_DEFAULT;
-  }
-  async publish(options) {
-    const topic = options.event.topic;
-    const notifiedSubscribers = new Set(options.notifiedSubscribers);
-    let hasOtherSubscribers = false;
-    for (const sub of this.#subscribers.values()) {
-      if (sub.topics.has(topic) && !notifiedSubscribers.has(sub.id)) {
-        hasOtherSubscribers = true;
-        break;
-      }
-    }
-    if (!hasOtherSubscribers) {
-      return void 0;
-    }
-    const nextSeq = this.#getMaxSeq() + 1;
-    this.#events.push({ ...options.event, notifiedSubscribers, seq: nextSeq });
-    for (const listener of this.#listeners) {
-      if (listener.topics.has(topic)) {
-        listener.resolve({ topic });
-        this.#listeners.delete(listener);
-      }
-    }
-    if (this.#events.length > this.#maxEvents) {
-      this.#events.shift();
-    }
-    return { eventId: String(nextSeq) };
-  }
-  #getMaxSeq() {
-    return this.#events[this.#events.length - 1]?.seq ?? 0;
-  }
-  async upsertSubscription(id, topics) {
-    const existing = this.#subscribers.get(id);
-    if (existing) {
-      existing.topics = new Set(topics);
-      return;
-    }
-    const sub = {
-      id,
-      seq: this.#getMaxSeq(),
-      topics: new Set(topics)
-    };
-    this.#subscribers.set(id, sub);
-  }
-  async readSubscription(id) {
-    const sub = this.#subscribers.get(id);
-    if (!sub) {
-      throw new errors.NotFoundError(`Subscription not found`);
-    }
-    const events = this.#events.filter(
-      (event) => event.seq > sub.seq && sub.topics.has(event.topic) && !event.notifiedSubscribers.has(id)
-    ).slice(0, MAX_BATCH_SIZE$1);
-    sub.seq = events[events.length - 1]?.seq ?? sub.seq;
-    return {
-      events: events.map(({ topic, eventPayload }) => ({
-        topic,
-        eventPayload
-      }))
-    };
-  }
-  async setupListener(subscriptionId, options) {
-    return {
-      waitForUpdate: async () => {
-        options.signal.throwIfAborted();
-        const sub = this.#subscribers.get(subscriptionId);
-        if (!sub) {
-          throw new errors.NotFoundError(`Subscription not found`);
-        }
-        return new Promise((resolve, reject) => {
-          const listener = {
-            topics: sub.topics,
-            resolve(result) {
-              resolve(result);
-              cleanup();
-            }
-          };
-          this.#listeners.add(listener);
-          const onAbort = () => {
-            this.#listeners.delete(listener);
-            reject(options.signal.reason);
-            cleanup();
-          };
-          function cleanup() {
-            options.signal.removeEventListener("abort", onAbort);
-          }
-          options.signal.addEventListener("abort", onAbort);
-        });
-      }
-    };
-  }
-}
-
-const WINDOW_MAX_COUNT_DEFAULT = 1e4;
-const WINDOW_MIN_AGE_DEFAULT = { minutes: 10 };
-const WINDOW_MAX_AGE_DEFAULT = { days: 1 };
-const MAX_BATCH_SIZE = 10;
-const LISTENER_CONNECTION_TIMEOUT_MS = 6e4;
-const KEEPALIVE_INTERVAL_MS = 6e4;
-const TABLE_EVENTS = "event_bus_events";
-const TABLE_SUBSCRIPTIONS = "event_bus_subscriptions";
-const TOPIC_PUBLISH = "event_bus_publish";
-function creatorId(credentials) {
-  return `service=${credentials.principal.subject}`;
-}
-const migrationsDir = backendPluginApi.resolvePackagePath(
-  "@backstage/plugin-events-backend",
-  "migrations"
-);
-class DatabaseEventBusListener {
-  #client;
-  #logger;
-  #listeners = /* @__PURE__ */ new Set();
-  #isShuttingDown = false;
-  #connPromise;
-  #connTimeout;
-  #keepaliveInterval;
-  constructor(client, logger) {
-    this.#client = client;
-    this.#logger = logger.child({ type: "DatabaseEventBusListener" });
-  }
-  async setupListener(topics, signal) {
-    if (this.#connTimeout) {
-      clearTimeout(this.#connTimeout);
-      this.#connTimeout = void 0;
-    }
-    await this.#ensureConnection();
-    const updatePromise = new Promise((resolve, reject) => {
-      const listener = {
-        topics,
-        resolve(result) {
-          resolve(result);
-          cleanup();
-        },
-        reject(err) {
-          reject(err);
-          cleanup();
-        }
-      };
-      this.#listeners.add(listener);
-      const onAbort = () => {
-        this.#listeners.delete(listener);
-        this.#maybeTimeoutConnection();
-        reject(signal.reason);
-        cleanup();
-      };
-      function cleanup() {
-        signal.removeEventListener("abort", onAbort);
-      }
-      signal.addEventListener("abort", onAbort);
-    });
-    updatePromise.catch(() => {
-    });
-    return { waitForUpdate: () => updatePromise };
-  }
-  async shutdown() {
-    if (this.#isShuttingDown) {
-      return;
-    }
-    this.#isShuttingDown = true;
-    const conn = await this.#connPromise?.catch(() => void 0);
-    if (conn) {
-      this.#destroyConnection(conn);
-    }
-  }
-  #handleNotify(topic) {
-    this.#logger.debug(`Listener received notification for topic '${topic}'`);
-    for (const l of this.#listeners) {
-      if (l.topics.has(topic)) {
-        l.resolve({ topic });
-        this.#listeners.delete(l);
-      }
-    }
-    this.#maybeTimeoutConnection();
-  }
-  // We don't try to reconnect on error, instead we notify all listeners and let
-  // them try to establish a new connection
-  #handleError(error) {
-    this.#logger.error(
-      `Listener connection failed, notifying all listeners`,
-      error
-    );
-    for (const l of this.#listeners) {
-      l.reject(new Error("Listener connection failed"));
-    }
-    this.#listeners.clear();
-    this.#maybeTimeoutConnection();
-  }
-  #maybeTimeoutConnection() {
-    if (this.#listeners.size === 0 && !this.#connTimeout) {
-      this.#connTimeout = setTimeout(() => {
-        this.#connTimeout = void 0;
-        this.#connPromise?.then((conn) => {
-          this.#logger.info("Listener connection timed out, destroying");
-          this.#connPromise = void 0;
-          this.#destroyConnection(conn);
-        });
-      }, LISTENER_CONNECTION_TIMEOUT_MS);
-    }
-  }
-  #destroyConnection(conn) {
-    if (this.#keepaliveInterval) {
-      clearInterval(this.#keepaliveInterval);
-      this.#keepaliveInterval = void 0;
-    }
-    this.#client.destroyRawConnection(conn).catch((error) => {
-      this.#logger.error(`Listener failed to destroy connection`, error);
-    });
-    conn.removeAllListeners();
-  }
-  async #ensureConnection() {
-    if (this.#isShuttingDown) {
-      throw new Error("Listener is shutting down");
-    }
-    if (this.#connPromise) {
-      await this.#connPromise;
-      return;
-    }
-    this.#connPromise = Promise.resolve().then(async () => {
-      const conn = await this.#client.acquireRawConnection();
-      try {
-        await conn.query(`LISTEN ${TOPIC_PUBLISH}`);
-        if (this.#keepaliveInterval) {
-          clearInterval(this.#keepaliveInterval);
-        }
-        this.#keepaliveInterval = setInterval(() => {
-          conn.query("select 1").catch((error) => {
-            this.#connPromise = void 0;
-            this.#destroyConnection(conn);
-            this.#handleError(new errors.ForwardedError("Keepalive failed", error));
-          });
-        }, KEEPALIVE_INTERVAL_MS);
-        conn.on("notification", (event) => {
-          this.#handleNotify(event.payload);
-        });
-        conn.on("error", (error) => {
-          this.#connPromise = void 0;
-          this.#destroyConnection(conn);
-          this.#handleError(error);
-        });
-        conn.on("end", (error) => {
-          this.#connPromise = void 0;
-          this.#destroyConnection(conn);
-          this.#handleError(
-            error ?? new Error("Connection ended unexpectedly")
-          );
-        });
-        return conn;
-      } catch (error) {
-        this.#destroyConnection(conn);
-        throw error;
-      }
-    });
-    try {
-      await this.#connPromise;
-    } catch (error) {
-      this.#connPromise = void 0;
-      throw error;
-    }
-  }
-}
-class DatabaseEventBusStore {
-  static async create(options) {
-    const db = await options.database.getClient();
-    if (db.client.config.client !== "pg") {
-      throw new Error(
-        `DatabaseEventBusStore only supports PostgreSQL, got '${db.client.config.client}'`
-      );
-    }
-    if (!options.database.migrations?.skip) {
-      await db.migrate.latest({
-        directory: migrationsDir
-      });
-    }
-    const listener = new DatabaseEventBusListener(db.client, options.logger);
-    const store = new DatabaseEventBusStore(
-      db,
-      options.logger,
-      listener,
-      options.window?.maxCount ?? WINDOW_MAX_COUNT_DEFAULT,
-      types.durationToMilliseconds(options.window?.minAge ?? WINDOW_MIN_AGE_DEFAULT),
-      types.durationToMilliseconds(options.window?.maxAge ?? WINDOW_MAX_AGE_DEFAULT)
-    );
-    await options.scheduler.scheduleTask({
-      id: "event-bus-cleanup",
-      frequency: { seconds: 10 },
-      timeout: { minutes: 1 },
-      initialDelay: { seconds: 10 },
-      fn: () => store.#cleanup()
-    });
-    options.lifecycle.addShutdownHook(async () => {
-      await listener.shutdown();
-    });
-    return store;
-  }
-  /** @internal */
-  static async forTest({
-    db,
-    logger,
-    minAge = 0,
-    maxAge = 1e4
-  }) {
-    await db.migrate.latest({ directory: migrationsDir });
-    const store = new DatabaseEventBusStore(
-      db,
-      logger,
-      new DatabaseEventBusListener(db.client, logger),
-      5,
-      minAge,
-      maxAge
-    );
-    return Object.assign(store, { clean: () => store.#cleanup() });
-  }
-  #db;
-  #logger;
-  #listener;
-  #windowMaxCount;
-  #windowMinAge;
-  #windowMaxAge;
-  constructor(db, logger, listener, windowMaxCount, windowMinAge, windowMaxAge) {
-    this.#db = db;
-    this.#logger = logger;
-    this.#listener = listener;
-    this.#windowMaxCount = windowMaxCount;
-    this.#windowMinAge = windowMinAge;
-    this.#windowMaxAge = windowMaxAge;
-  }
-  async publish(options) {
-    const topic = options.event.topic;
-    const notifiedSubscribers = options.notifiedSubscribers ?? [];
-    const result = await this.#db.into(
-      this.#db.raw("?? (??, ??, ??, ??)", [
-        TABLE_EVENTS,
-        // These are the rows that we insert, and should match the SELECT below
-        "created_by",
-        "topic",
-        "data_json",
-        "notified_subscribers"
-      ])
-    ).insert(
-      (q) => q.select(
-        this.#db.raw("?", [creatorId(options.credentials)]),
-        this.#db.raw("?", [topic]),
-        this.#db.raw("?", [
-          JSON.stringify({
-            payload: options.event.eventPayload,
-            metadata: options.event.metadata
-          })
-        ]),
-        this.#db.raw("?", [notifiedSubscribers])
-      ).from(TABLE_SUBSCRIPTIONS).whereNotIn("id", notifiedSubscribers).andWhere(this.#db.raw("? = ANY(topics)", [topic])).having(this.#db.raw("count(*)"), ">", 0)
-      // Check if there are any results
-    ).returning("id");
-    if (result.length === 0) {
-      return void 0;
-    }
-    if (result.length > 1) {
-      throw new Error(
-        `Failed to insert event, unexpectedly updated ${result.length} rows`
-      );
-    }
-    const [{ id }] = result;
-    const notifyResult = await this.#db.select(
-      this.#db.raw(`pg_notify(?, ?)`, [TOPIC_PUBLISH, topic])
-    );
-    if (notifyResult?.length !== 1) {
-      this.#logger.warn(
-        `Failed to notify subscribers of event with ID '${id}' on topic '${topic}'`
-      );
-    }
-    return { eventId: id };
-  }
-  async upsertSubscription(id, topics, credentials) {
-    const [{ max: maxId }] = await this.#db(TABLE_EVENTS).max("id");
-    const result = await this.#db(TABLE_SUBSCRIPTIONS).insert({
-      id,
-      created_by: creatorId(credentials),
-      updated_at: this.#db.fn.now(),
-      topics,
-      read_until: maxId || 0
-    }).onConflict("id").merge(["created_by", "topics", "updated_at"]).returning("*");
-    if (result.length !== 1) {
-      throw new Error(
-        `Failed to upsert subscription, updated ${result.length} rows`
-      );
-    }
-  }
-  async readSubscription(id) {
-    const { rows: result } = await this.#db.raw(
-      `
-      WITH subscription AS (
-        SELECT topics, read_until
-        FROM event_bus_subscriptions
-        WHERE id = :id
-        FOR UPDATE
-      ),
-      selected_events AS (
-        SELECT event_bus_events.*
-        FROM event_bus_events
-        INNER JOIN subscription
-        ON event_bus_events.topic = ANY(subscription.topics)
-        WHERE event_bus_events.id > subscription.read_until
-        AND NOT :id = ANY(event_bus_events.notified_subscribers)
-        ORDER BY event_bus_events.id ASC LIMIT :limit
-      ),
-      last_event_id AS (
-        SELECT max(id) AS last_event_id
-        FROM selected_events
-      ),
-      events_array AS (
-        SELECT json_agg(row_to_json(selected_events)) AS events
-        FROM selected_events
-      )
-      UPDATE event_bus_subscriptions
-      SET read_until = COALESCE(last_event_id, (SELECT MAX(id) FROM event_bus_events), 0)
-      FROM events_array, last_event_id
-      WHERE event_bus_subscriptions.id = :id
-      RETURNING events_array.events
-    `,
-      { id, limit: MAX_BATCH_SIZE }
-    );
-    if (result.length === 0) {
-      throw new errors.NotFoundError(`Subscription with ID '${id}' not found`);
-    } else if (result.length > 1) {
-      throw new Error(
-        `Failed to read subscription, unexpectedly updated ${result.length} rows`
-      );
-    }
-    const rows = result[0].events;
-    if (!rows || rows.length === 0) {
-      return { events: [] };
-    }
-    return {
-      events: rows.map((row) => {
-        const { payload, metadata } = JSON.parse(row.data_json);
-        return {
-          topic: row.topic,
-          eventPayload: payload,
-          metadata
-        };
-      })
-    };
-  }
-  async setupListener(subscriptionId, options) {
-    const result = await this.#db(TABLE_SUBSCRIPTIONS).select("topics").where({ id: subscriptionId }).first();
-    if (!result) {
-      throw new errors.NotFoundError(
-        `Subscription with ID '${subscriptionId}' not found`
-      );
-    }
-    options.signal.throwIfAborted();
-    return this.#listener.setupListener(
-      new Set(result.topics ?? []),
-      options.signal
-    );
-  }
-  async #cleanup() {
-    try {
-      const eventCount = await this.#db(TABLE_EVENTS).delete().orWhere(
-        (inner) => inner.whereIn(
-          "id",
-          this.#db.select("id").from(TABLE_EVENTS).orderBy("id", "desc").offset(this.#windowMaxCount)
-        ).andWhere(
-          "created_at",
-          "<",
-          new Date(Date.now() - this.#windowMinAge)
-        )
-      ).orWhere("created_at", "<", new Date(Date.now() - this.#windowMaxAge));
-      if (eventCount > 0) {
-        this.#logger.info(
-          `Event cleanup resulted in ${eventCount} old events being deleted`
-        );
-      }
-    } catch (error) {
-      this.#logger.error("Event cleanup failed", error);
-    }
-    try {
-      const [{ min: minId }] = await this.#db(TABLE_EVENTS).min("id");
-      let subscriberCount;
-      if (minId === null) {
-        subscriberCount = await this.#db(TABLE_SUBSCRIPTIONS).delete();
-      } else {
-        subscriberCount = await this.#db(TABLE_SUBSCRIPTIONS).delete().where("read_until", "<", minId - 1);
-      }
-      if (subscriberCount > 0) {
-        this.#logger.info(
-          `Subscription cleanup resulted in ${subscriberCount} stale subscribers being deleted`
-        );
-      }
-    } catch (error) {
-      this.#logger.error("Subscription cleanup failed", error);
-    }
-  }
-}
-
-const DEFAULT_NOTIFY_TIMEOUT_MS = 55e3;
-async function createEventBusStore(deps) {
-  const db = await deps.database.getClient();
-  if (db.client.config.client === "pg") {
-    deps.logger.info("Database is PostgreSQL, using database store");
-    return await DatabaseEventBusStore.create(deps);
-  }
-  deps.logger.info("Database is not PostgreSQL, using memory store");
-  return new MemoryEventBusStore();
-}
-async function createEventBusRouter(options) {
-  const { httpAuth, notifyTimeoutMs = DEFAULT_NOTIFY_TIMEOUT_MS } = options;
-  const logger = options.logger.child({ type: "EventBus" });
-  const store = await createEventBusStore(options);
-  const apiRouter = await createOpenApiRouter();
-  apiRouter.post("/bus/v1/events", async (req, res) => {
-    const credentials = await httpAuth.credentials(req, {
-      allow: ["service"]
-    });
-    const topic = req.body.event.topic;
-    const notifiedSubscribers = req.body.notifiedSubscribers;
-    const result = await store.publish({
-      event: {
-        topic,
-        eventPayload: req.body.event.payload
-      },
-      notifiedSubscribers,
-      credentials
-    });
-    if (result) {
-      logger.debug(
-        `Published event to '${topic}' with ID '${result.eventId}'`,
-        {
-          subject: credentials.principal.subject
-        }
-      );
-      res.status(201).end();
-    } else {
-      if (notifiedSubscribers) {
-        const notified = `'${notifiedSubscribers.join("', '")}'`;
-        logger.debug(
-          `Skipped publishing of event to '${topic}', subscribers have already been notified: ${notified}`,
-          { subject: credentials.principal.subject }
-        );
-      } else {
-        logger.debug(
-          `Skipped publishing of event to '${topic}', no subscribers present`,
-          { subject: credentials.principal.subject }
-        );
-      }
-      res.status(204).end();
-    }
-  });
-  apiRouter.get(
-    "/bus/v1/subscriptions/:subscriptionId/events",
-    async (req, res) => {
-      const credentials = await httpAuth.credentials(req, {
-        allow: ["service"]
-      });
-      const id = req.params.subscriptionId;
-      const controller = new AbortController();
-      req.on("end", () => controller.abort());
-      const listener = await store.setupListener(id, {
-        signal: controller.signal
-      });
-      const timeout = setTimeout(() => {
-        controller.abort();
-      }, notifyTimeoutMs);
-      try {
-        const { events } = await store.readSubscription(id);
-        logger.debug(
-          `Reading subscription '${id}' resulted in ${events.length} events`,
-          { subject: credentials.principal.subject }
-        );
-        if (events.length > 0) {
-          res.json({
-            events: events.map((event) => ({
-              topic: event.topic,
-              payload: event.eventPayload
-            }))
-          });
-        } else {
-          res.status(202);
-          res.flushHeaders();
-          try {
-            const { topic } = await listener.waitForUpdate();
-            logger.debug(
-              `Received notification for subscription '${id}' for topic '${topic}'`,
-              { subject: credentials.principal.subject }
-            );
-          } catch (error) {
-            if (error !== controller.signal.reason) {
-              logger.error(`Error listening for subscription '${id}'`, error);
-            }
-          } finally {
-            await new Promise(
-              (resolve) => setTimeout(resolve, 1 + Math.random() * 9)
-            );
-            res.end();
-          }
-        }
-      } finally {
-        controller.abort();
-        clearTimeout(timeout);
-      }
-    }
-  );
-  apiRouter.put("/bus/v1/subscriptions/:subscriptionId", async (req, res) => {
-    const credentials = await httpAuth.credentials(req, {
-      allow: ["service"]
-    });
-    const id = req.params.subscriptionId;
-    await store.upsertSubscription(id, req.body.topics, credentials);
-    logger.debug(
-      `New subscription '${id}' for topics '${req.body.topics.join("', '")}'`,
-      { subject: credentials.principal.subject }
-    );
-    res.status(201).end();
-  });
-  return apiRouter;
-}
-
-class EventsExtensionPointImpl {
-  #httpPostIngresses = [];
-  setEventBroker(_) {
-    throw new Error(
-      "setEventBroker is not supported anymore; use eventsServiceRef instead"
-    );
-  }
-  addPublishers(_) {
-    throw new Error(
-      "addPublishers is not supported anymore; use EventsService instead"
-    );
-  }
-  addSubscribers(_) {
-    throw new Error(
-      "addSubscribers is not supported anymore; use EventsService instead"
-    );
-  }
-  addHttpPostIngress(options) {
-    this.#httpPostIngresses.push(options);
-  }
-  get httpPostIngresses() {
-    return this.#httpPostIngresses;
-  }
-}
-const eventsPlugin = backendPluginApi.createBackendPlugin({
-  pluginId: "events",
-  register(env) {
-    const extensionPoint = new EventsExtensionPointImpl();
-    env.registerExtensionPoint(alpha.eventsExtensionPoint, extensionPoint);
-    env.registerInit({
-      deps: {
-        config: backendPluginApi.coreServices.rootConfig,
-        events: pluginEventsNode.eventsServiceRef,
-        database: backendPluginApi.coreServices.database,
-        logger: backendPluginApi.coreServices.logger,
-        scheduler: backendPluginApi.coreServices.scheduler,
-        lifecycle: backendPluginApi.coreServices.lifecycle,
-        httpAuth: backendPluginApi.coreServices.httpAuth,
-        router: backendPluginApi.coreServices.httpRouter
-      },
-      async init({
-        config,
-        events,
-        database,
-        logger,
-        scheduler,
-        lifecycle,
-        httpAuth,
-        router
-      }) {
-        const ingresses = Object.fromEntries(
-          extensionPoint.httpPostIngresses.map((ingress) => [
-            ingress.topic,
-            ingress
-          ])
-        );
-        const http = HttpPostIngressEventPublisher.HttpPostIngressEventPublisher.fromConfig({
-          config,
-          events,
-          ingresses,
-          logger
-        });
-        const eventsRouter = Router__default.default();
-        http.bind(eventsRouter);
-        router.use(
-          await createEventBusRouter({
-            database,
-            logger,
-            httpAuth,
-            scheduler,
-            lifecycle
-          })
-        );
-        router.use(eventsRouter);
-        router.addAuthPolicy({
-          allow: "unauthenticated",
-          path: "/http"
-        });
-      }
-    });
-  }
-});
-
-exports.default = eventsPlugin;
+exports.default = EventsPlugin.eventsPlugin;
 //# sourceMappingURL=alpha.cjs.js.map