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

package/dist/service/EventsPlugin.cjs.js

@@ -0,0 +1,98 @@
+'use strict';
+
+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('./http/HttpPostIngressEventPublisher.cjs.js');
+var createEventBusRouter = require('./hub/createEventBusRouter.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var Router__default = /*#__PURE__*/_interopDefaultCompat(Router);
+
+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.createEventBusRouter({
+            database,
+            logger,
+            httpAuth,
+            scheduler,
+            lifecycle
+          })
+        );
+        router.use(eventsRouter);
+        router.addAuthPolicy({
+          allow: "unauthenticated",
+          path: "/http"
+        });
+      }
+    });
+  }
+});
+
+exports.eventsPlugin = eventsPlugin;
+//# sourceMappingURL=EventsPlugin.cjs.js.map

package/dist/service/EventsPlugin.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventsPlugin.cjs.js","sources":["../../src/service/EventsPlugin.ts"],"sourcesContent":["/*\n * Copyright 2022 The Backstage Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  createBackendPlugin,\n  coreServices,\n} from '@backstage/backend-plugin-api';\nimport {\n  eventsExtensionPoint,\n  EventsExtensionPoint,\n} from '@backstage/plugin-events-node/alpha';\nimport {\n  eventsServiceRef,\n  HttpPostIngressOptions,\n} from '@backstage/plugin-events-node';\nimport Router from 'express-promise-router';\nimport { HttpPostIngressEventPublisher } from './http';\nimport { createEventBusRouter } from './hub';\n\nclass EventsExtensionPointImpl implements EventsExtensionPoint {\n  #httpPostIngresses: HttpPostIngressOptions[] = [];\n\n  setEventBroker(_: any): void {\n    throw new Error(\n      'setEventBroker is not supported anymore; use eventsServiceRef instead',\n    );\n  }\n\n  addPublishers(_: any): void {\n    throw new Error(\n      'addPublishers is not supported anymore; use EventsService instead',\n    );\n  }\n\n  addSubscribers(_: any): void {\n    throw new Error(\n      'addSubscribers is not supported anymore; use EventsService instead',\n    );\n  }\n\n  addHttpPostIngress(options: HttpPostIngressOptions) {\n    this.#httpPostIngresses.push(options);\n  }\n\n  get httpPostIngresses() {\n    return this.#httpPostIngresses;\n  }\n}\n\n/**\n * Events plugin\n *\n * @alpha\n */\nexport const eventsPlugin = createBackendPlugin({\n  pluginId: 'events',\n  register(env) {\n    const extensionPoint = new EventsExtensionPointImpl();\n    env.registerExtensionPoint(eventsExtensionPoint, extensionPoint);\n\n    env.registerInit({\n      deps: {\n        config: coreServices.rootConfig,\n        events: eventsServiceRef,\n        database: coreServices.database,\n        logger: coreServices.logger,\n        scheduler: coreServices.scheduler,\n        lifecycle: coreServices.lifecycle,\n        httpAuth: coreServices.httpAuth,\n        router: coreServices.httpRouter,\n      },\n      async init({\n        config,\n        events,\n        database,\n        logger,\n        scheduler,\n        lifecycle,\n        httpAuth,\n        router,\n      }) {\n        const ingresses = Object.fromEntries(\n          extensionPoint.httpPostIngresses.map(ingress => [\n            ingress.topic,\n            ingress as Omit<HttpPostIngressOptions, 'topic'>,\n          ]),\n        );\n\n        const http = HttpPostIngressEventPublisher.fromConfig({\n          config,\n          events,\n          ingresses,\n          logger,\n        });\n        const eventsRouter = Router();\n        http.bind(eventsRouter);\n\n        router.use(\n          await createEventBusRouter({\n            database,\n            logger,\n            httpAuth,\n            scheduler,\n            lifecycle,\n          }),\n        );\n\n        router.use(eventsRouter);\n        router.addAuthPolicy({\n          allow: 'unauthenticated',\n          path: '/http',\n        });\n      },\n    });\n  },\n});\n"],"names":["createBackendPlugin","eventsExtensionPoint","coreServices","eventsServiceRef","HttpPostIngressEventPublisher","Router","createEventBusRouter"],"mappings":";;;;;;;;;;;;;AAgCA,MAAM,wBAAyD,CAAA;AAAA,EAC7D,qBAA+C,EAAC,CAAA;AAAA,EAEhD,eAAe,CAAc,EAAA;AAC3B,IAAA,MAAM,IAAI,KAAA;AAAA,MACR,uEAAA;AAAA,KACF,CAAA;AAAA,GACF;AAAA,EAEA,cAAc,CAAc,EAAA;AAC1B,IAAA,MAAM,IAAI,KAAA;AAAA,MACR,mEAAA;AAAA,KACF,CAAA;AAAA,GACF;AAAA,EAEA,eAAe,CAAc,EAAA;AAC3B,IAAA,MAAM,IAAI,KAAA;AAAA,MACR,oEAAA;AAAA,KACF,CAAA;AAAA,GACF;AAAA,EAEA,mBAAmB,OAAiC,EAAA;AAClD,IAAK,IAAA,CAAA,kBAAA,CAAmB,KAAK,OAAO,CAAA,CAAA;AAAA,GACtC;AAAA,EAEA,IAAI,iBAAoB,GAAA;AACtB,IAAA,OAAO,IAAK,CAAA,kBAAA,CAAA;AAAA,GACd;AACF,CAAA;AAOO,MAAM,eAAeA,oCAAoB,CAAA;AAAA,EAC9C,QAAU,EAAA,QAAA;AAAA,EACV,SAAS,GAAK,EAAA;AACZ,IAAM,MAAA,cAAA,GAAiB,IAAI,wBAAyB,EAAA,CAAA;AACpD,IAAI,GAAA,CAAA,sBAAA,CAAuBC,4BAAsB,cAAc,CAAA,CAAA;AAE/D,IAAA,GAAA,CAAI,YAAa,CAAA;AAAA,MACf,IAAM,EAAA;AAAA,QACJ,QAAQC,6BAAa,CAAA,UAAA;AAAA,QACrB,MAAQ,EAAAC,iCAAA;AAAA,QACR,UAAUD,6BAAa,CAAA,QAAA;AAAA,QACvB,QAAQA,6BAAa,CAAA,MAAA;AAAA,QACrB,WAAWA,6BAAa,CAAA,SAAA;AAAA,QACxB,WAAWA,6BAAa,CAAA,SAAA;AAAA,QACxB,UAAUA,6BAAa,CAAA,QAAA;AAAA,QACvB,QAAQA,6BAAa,CAAA,UAAA;AAAA,OACvB;AAAA,MACA,MAAM,IAAK,CAAA;AAAA,QACT,MAAA;AAAA,QACA,MAAA;AAAA,QACA,QAAA;AAAA,QACA,MAAA;AAAA,QACA,SAAA;AAAA,QACA,SAAA;AAAA,QACA,QAAA;AAAA,QACA,MAAA;AAAA,OACC,EAAA;AACD,QAAA,MAAM,YAAY,MAAO,CAAA,WAAA;AAAA,UACvB,cAAA,CAAe,iBAAkB,CAAA,GAAA,CAAI,CAAW,OAAA,KAAA;AAAA,YAC9C,OAAQ,CAAA,KAAA;AAAA,YACR,OAAA;AAAA,WACD,CAAA;AAAA,SACH,CAAA;AAEA,QAAM,MAAA,IAAA,GAAOE,4DAA8B,UAAW,CAAA;AAAA,UACpD,MAAA;AAAA,UACA,MAAA;AAAA,UACA,SAAA;AAAA,UACA,MAAA;AAAA,SACD,CAAA,CAAA;AACD,QAAA,MAAM,eAAeC,uBAAO,EAAA,CAAA;AAC5B,QAAA,IAAA,CAAK,KAAK,YAAY,CAAA,CAAA;AAEtB,QAAO,MAAA,CAAA,GAAA;AAAA,UACL,MAAMC,yCAAqB,CAAA;AAAA,YACzB,QAAA;AAAA,YACA,MAAA;AAAA,YACA,QAAA;AAAA,YACA,SAAA;AAAA,YACA,SAAA;AAAA,WACD,CAAA;AAAA,SACH,CAAA;AAEA,QAAA,MAAA,CAAO,IAAI,YAAY,CAAA,CAAA;AACvB,QAAA,MAAA,CAAO,aAAc,CAAA;AAAA,UACnB,KAAO,EAAA,iBAAA;AAAA,UACP,IAAM,EAAA,OAAA;AAAA,SACP,CAAA,CAAA;AAAA,OACH;AAAA,KACD,CAAA,CAAA;AAAA,GACH;AACF,CAAC;;;;"}

package/dist/{cjs/HttpPostIngressEventPublisher-D6pQ6awS.cjs.js → service/http/HttpPostIngressEventPublisher.cjs.js}

@@ -3,28 +3,13 @@
 var backendCommon = require('@backstage/backend-common');
 var express = require('express');
 var Router = require('express-promise-router');
+var RequestValidationContextImpl = require('./validation/RequestValidationContextImpl.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);
 
-class RequestValidationContextImpl {
-  #rejectionDetails;
-  reject(details) {
-    this.#rejectionDetails = {
-      status: details?.status ?? 403,
-      payload: details?.payload ?? {}
-    };
-  }
-  wasRejected() {
-    return this.#rejectionDetails !== void 0;
-  }
-  get rejectionDetails() {
-    return this.#rejectionDetails;
-  }
-}
-
 class HttpPostIngressEventPublisher {
   constructor(events, logger, ingresses) {
     this.events = events;
@@ -60,7 +45,7 @@ class HttpPostIngressEventPublisher {
         body: request.body,
         headers: request.headers
       };
-      const context = new RequestValidationContextImpl();
+      const context = new RequestValidationContextImpl.RequestValidationContextImpl();
       await validator?.(requestDetails, context);
       if (context.wasRejected()) {
         response.status(context.rejectionDetails.status).json(context.rejectionDetails.payload);
@@ -79,4 +64,4 @@ class HttpPostIngressEventPublisher {
 }
 
 exports.HttpPostIngressEventPublisher = HttpPostIngressEventPublisher;
-//# sourceMappingURL=HttpPostIngressEventPublisher-D6pQ6awS.cjs.js.map
+//# sourceMappingURL=HttpPostIngressEventPublisher.cjs.js.map

package/dist/service/http/HttpPostIngressEventPublisher.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"HttpPostIngressEventPublisher.cjs.js","sources":["../../../src/service/http/HttpPostIngressEventPublisher.ts"],"sourcesContent":["/*\n * Copyright 2022 The Backstage Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { errorHandler } from '@backstage/backend-common';\nimport { LoggerService } from '@backstage/backend-plugin-api';\nimport { Config } from '@backstage/config';\nimport {\n  EventsService,\n  HttpPostIngressOptions,\n  RequestValidator,\n} from '@backstage/plugin-events-node';\nimport express from 'express';\nimport Router from 'express-promise-router';\nimport { RequestValidationContextImpl } from './validation';\n\n/**\n * Publishes events received from their origin (e.g., webhook events from an SCM system)\n * via HTTP POST endpoint and passes the request body as event payload to the registered subscribers.\n *\n * @public\n */\n// TODO(pjungermann): add prom metrics? (see plugins/catalog-backend/src/util/metrics.ts, etc.)\nexport class HttpPostIngressEventPublisher {\n  static fromConfig(env: {\n    config: Config;\n    events: EventsService;\n    ingresses?: { [topic: string]: Omit<HttpPostIngressOptions, 'topic'> };\n    logger: LoggerService;\n  }): HttpPostIngressEventPublisher {\n    const topics =\n      env.config.getOptionalStringArray('events.http.topics') ?? [];\n\n    const ingresses = env.ingresses ?? {};\n    topics.forEach(topic => {\n      // don't overwrite topic settings\n      // (e.g., added at the config as well as argument)\n      if (!ingresses[topic]) {\n        ingresses[topic] = {};\n      }\n    });\n\n    return new HttpPostIngressEventPublisher(env.events, env.logger, ingresses);\n  }\n\n  private constructor(\n    private readonly events: EventsService,\n    private readonly logger: LoggerService,\n    private readonly ingresses: {\n      [topic: string]: Omit<HttpPostIngressOptions, 'topic'>;\n    },\n  ) {}\n\n  bind(router: express.Router): void {\n    router.use('/http', this.createRouter(this.ingresses));\n  }\n\n  private createRouter(ingresses: {\n    [topic: string]: Omit<HttpPostIngressOptions, 'topic'>;\n  }): express.Router {\n    const router = Router();\n    router.use(express.json());\n\n    Object.keys(ingresses).forEach(topic =>\n      this.addRouteForTopic(router, topic, ingresses[topic].validator),\n    );\n\n    router.use(errorHandler());\n    return router;\n  }\n\n  private addRouteForTopic(\n    router: express.Router,\n    topic: string,\n    validator?: RequestValidator,\n  ): void {\n    const path = `/${topic}`;\n\n    router.post(path, async (request, response) => {\n      const requestDetails = {\n        body: request.body,\n        headers: request.headers,\n      };\n      const context = new RequestValidationContextImpl();\n      await validator?.(requestDetails, context);\n      if (context.wasRejected()) {\n        response\n          .status(context.rejectionDetails!.status)\n          .json(context.rejectionDetails!.payload);\n        return;\n      }\n\n      const eventPayload = request.body;\n      await this.events.publish({\n        topic,\n        eventPayload,\n        metadata: request.headers,\n      });\n\n      response.status(202).json({ status: 'accepted' });\n    });\n\n    // TODO(pjungermann): We don't really know the externally defined path prefix here,\n    //  however it is more useful for users to have it. Is there a better way?\n    this.logger.info(`Registered /api/events/http${path} to receive events`);\n  }\n}\n"],"names":["Router","express","errorHandler","RequestValidationContextImpl"],"mappings":"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"}

package/dist/service/http/validation/RequestValidationContextImpl.cjs.js

@@ -0,0 +1,20 @@
+'use strict';
+
+class RequestValidationContextImpl {
+  #rejectionDetails;
+  reject(details) {
+    this.#rejectionDetails = {
+      status: details?.status ?? 403,
+      payload: details?.payload ?? {}
+    };
+  }
+  wasRejected() {
+    return this.#rejectionDetails !== void 0;
+  }
+  get rejectionDetails() {
+    return this.#rejectionDetails;
+  }
+}
+
+exports.RequestValidationContextImpl = RequestValidationContextImpl;
+//# sourceMappingURL=RequestValidationContextImpl.cjs.js.map

package/dist/service/http/validation/RequestValidationContextImpl.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RequestValidationContextImpl.cjs.js","sources":["../../../../src/service/http/validation/RequestValidationContextImpl.ts"],"sourcesContent":["/*\n * Copyright 2022 The Backstage Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  RequestRejectionDetails,\n  RequestValidationContext,\n} from '@backstage/plugin-events-node';\n\nexport class RequestValidationContextImpl implements RequestValidationContext {\n  #rejectionDetails: RequestRejectionDetails | undefined;\n\n  reject(details?: Partial<RequestRejectionDetails>): void {\n    this.#rejectionDetails = {\n      status: details?.status ?? 403,\n      payload: details?.payload ?? {},\n    };\n  }\n\n  wasRejected(): boolean {\n    return this.#rejectionDetails !== undefined;\n  }\n\n  get rejectionDetails() {\n    return this.#rejectionDetails;\n  }\n}\n"],"names":[],"mappings":";;AAqBO,MAAM,4BAAiE,CAAA;AAAA,EAC5E,iBAAA,CAAA;AAAA,EAEA,OAAO,OAAkD,EAAA;AACvD,IAAA,IAAA,CAAK,iBAAoB,GAAA;AAAA,MACvB,MAAA,EAAQ,SAAS,MAAU,IAAA,GAAA;AAAA,MAC3B,OAAA,EAAS,OAAS,EAAA,OAAA,IAAW,EAAC;AAAA,KAChC,CAAA;AAAA,GACF;AAAA,EAEA,WAAuB,GAAA;AACrB,IAAA,OAAO,KAAK,iBAAsB,KAAA,KAAA,CAAA,CAAA;AAAA,GACpC;AAAA,EAEA,IAAI,gBAAmB,GAAA;AACrB,IAAA,OAAO,IAAK,CAAA,iBAAA,CAAA;AAAA,GACd;AACF;;;;"}

package/dist/service/hub/DatabaseEventBusStore.cjs.js

@@ -0,0 +1,410 @@
+'use strict';
+
+var backendPluginApi = require('@backstage/backend-plugin-api');
+var errors = require('@backstage/errors');
+var types = require('@backstage/types');
+
+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);
+    }
+  }
+}
+
+exports.DatabaseEventBusStore = DatabaseEventBusStore;
+//# sourceMappingURL=DatabaseEventBusStore.cjs.js.map