@backstage/plugin-events-backend-module-kafka 0.0.0-nightly-20250612024034

package/CHANGELOG.md

@@ -0,0 +1,33 @@
+# @backstage/plugin-events-backend-module-kafka
+
+## 0.0.0-nightly-20250612024034
+
+### Minor Changes
+
+- b034b9d: Adds a new module `kafka` for plugin-events-backend
+
+  The module introduces the `KafkaConsumerClient` which creates a Kafka client used to establish consumer connections. It also provides the `KafkaConsumingEventPublisher`, a consumer that subscribes to configured Kafka topics and publishes received messages to the Event Service.
+
+### Patch Changes
+
+- Updated dependencies
+  - @backstage/backend-plugin-api@0.0.0-nightly-20250612024034
+  - @backstage/config@1.3.2
+  - @backstage/types@1.2.1
+  - @backstage/plugin-events-node@0.0.0-nightly-20250612024034
+
+## 0.1.0-next.0
+
+### Minor Changes
+
+- b034b9d: Adds a new module `kafka` for plugin-events-backend
+
+  The module introduces the `KafkaConsumerClient` which creates a Kafka client used to establish consumer connections. It also provides the `KafkaConsumingEventPublisher`, a consumer that subscribes to configured Kafka topics and publishes received messages to the Event Service.
+
+### Patch Changes
+
+- Updated dependencies
+  - @backstage/backend-plugin-api@1.4.0-next.1
+  - @backstage/config@1.3.2
+  - @backstage/types@1.2.1
+  - @backstage/plugin-events-node@0.4.12-next.1

package/README.md

@@ -0,0 +1,78 @@
+# @backstage/backstage-plugin-events-backend-module-kafka
+
+Welcome to the `events-backend-module-kafka` backend module!
+
+This package is a module for the `events-backend` backend plugin and extends the events system with an `KafkaConsumingEventPublisher.`
+
+This event publisher will allow you to receive events from an Kafka queue and will publish these to the used `EventsService` implementation.
+
+## Configuration
+
+To set up Kafka queues, you need to configure the following values:
+
+```yaml
+events:
+  modules:
+    kafka:
+      kafkaConsumingEventPublisher:
+        clientId: your-client-id # (Required) Client ID used by Backstage to identify when connecting to the Kafka cluster.
+        brokers: # (Required) List of brokers in the Kafka cluster to connect to.
+          - broker1
+          - broker2
+        topics:
+          - topic: 'backstage.topic' # (Required) Replace with actual topic name as expected by subscribers
+            kafka:
+              topics: # (Required) The Kafka topics to subscribe to.
+                - topic1
+              groupId: your-group-id # (Required) The GroupId to be used by the topic consumers.
+```
+
+For a complete list of all available fields that can be configured, refer to the [config.d.ts file](./config.d.ts).
+
+### Optional SSL Configuration
+
+If your Kafka cluster requires SSL, you can configure it as follows:
+
+```yaml
+events:
+  modules:
+    kafka:
+      kafkaConsumingEventPublisher:
+        ssl:
+          rejectUnauthorized: true # (Optional) If true, the server certificate is verified against the list of supplied CAs.
+          ca: [path/to/ca-cert] # (Optional) Array of trusted certificates in PEM format.
+          key: path/to/client-key # (Optional) Private key in PEM format.
+          cert: path/to/client-cert # (Optional) Public x509 certificate in PEM format.
+```
+
+### Optional SASL Authentication Configuration
+
+If your Kafka cluster requires `SASL` authentication, you can configure it as follows:
+
+```yaml
+events:
+  modules:
+    kafka:
+      kafkaConsumingEventPublisher:
+        sasl:
+          mechanism: 'plain' # SASL mechanism ('plain', 'scram-sha-256' or 'scram-sha-512')
+          username: your-username # SASL username
+          password: your-password # SASL password
+```
+
+This section includes optional `SSL` and `SASL` authentication configuration for enhanced security.
+
+## Installation
+
+1. Install this module
+2. Add your configuration.
+
+```bash
+# From your Backstage root directory
+yarn --cwd packages/backend add @backstage/plugin-events-backend-module-kafka
+```
+
+```typescript
+// packages/backend/src/index.ts
+backend.add(import('@backstage/plugin-events-backend-module-kafka'));
+```

package/config.d.ts

@@ -0,0 +1,205 @@
+/*
+ * Copyright 2025 The Backstage Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { HumanDuration } from '@backstage/types';
+
+export interface Config {
+  events?: {
+    modules?: {
+      /**
+       * events-backend-module-kafka plugin configuration.
+       */
+      kafka?: {
+        /**
+         * Configuration for KafkaConsumingEventPublisher
+         */
+        kafkaConsumingEventPublisher?: {
+          /**
+           * (Required) Client ID used by Backstage to identify when connecting to the Kafka cluster.
+           */
+          clientId: string;
+          /**
+           * (Required) List of brokers in the Kafka cluster to connect to.
+           */
+          brokers: string[];
+          /**
+           * Optional SSL connection parameters to connect to the cluster. Passed directly to Node tls.connect.
+           * See https://nodejs.org/dist/latest-v8.x/docs/api/tls.html#tls_tls_createsecurecontext_options
+           */
+          ssl?:
+            | {
+                ca?: string[];
+                /** @visibility secret */
+                key?: string;
+                cert?: string;
+                rejectUnauthorized?: boolean;
+              }
+            | boolean;
+          /**
+           * Optional SASL connection parameters.
+           */
+          sasl?: {
+            mechanism: 'plain' | 'scram-sha-256' | 'scram-sha-512';
+            username: string;
+            /** @visibility secret */
+            password: string;
+          };
+
+          /**
+           * Optional retry connection parameters.
+           */
+          retry: {
+            /**
+             * (Optional) Maximum wait time for a retry
+             * Default: 30000 ms.
+             */
+            maxRetryTime: HumanDuration | string;
+
+            /**
+             * (Optional) Initial value used to calculate the retry (This is still randomized following the randomization factor)
+             * Default: 300 ms.
+             */
+            initialRetryTime: HumanDuration | string;
+
+            /**
+             * (Optional) Randomization factor
+             * Default: 0.2.
+             */
+            factor: number;
+
+            /**
+             * (Optional) Exponential factor
+             * Default: 2.
+             */
+            multiplier: number;
+
+            /**
+             * (Optional) Max number of retries per call
+             * Default: 5.
+             */
+            retries: number;
+          };
+
+          /**
+           * (Optional) Timeout for authentication requests.
+           * Default: 10000 ms.
+           */
+          authenticationTimeout: HumanDuration | string;
+
+          /**
+           * (Optional) Time to wait for a successful connection.
+           * Default: 1000 ms.
+           */
+          connectionTimeout: HumanDuration | string;
+
+          /**
+           * (Optional) Time to wait for a successful request.
+           * Default: 30000 ms.
+           */
+          requestTimeout: HumanDuration | string;
+
+          /**
+           * (Optional) The request timeout can be disabled by setting enforceRequestTimeout to false.
+           * Default: true
+           */
+          enforceRequestTimeout: boolean;
+
+          /**
+           * Contains a object per topic for which an Kafka queue
+           * should be used as source of events.
+           */
+          topics: Array<{
+            /**
+             * (Required) The Backstage topic to publish to
+             */
+            topic: string;
+            /**
+             * (Required) KafkaConsumer-related configuration.
+             */
+            kafka: {
+              /**
+               * (Required) The Kafka topics to subscribe to
+               */
+              topics: string[];
+              /**
+               * (Required) The GroupId to be used by the topic consumers
+               */
+              groupId: string;
+
+              /**
+               * (Optional) Timeout used to detect failures.
+               * The consumer sends periodic heartbeats to indicate its liveness to the broker.
+               * If no heartbeats are received by the broker before the expiration of this session timeout,
+               * then the broker will remove this consumer from the group and initiate a rebalance
+               * Default: 30000 ms.
+               */
+              sessionTimeout: HumanDuration | string;
+
+              /**
+               * (Optional) The maximum time that the coordinator will wait for each member to rejoin when rebalancing the group
+               * Default: 60000 ms.
+               */
+              rebalanceTimeout: HumanDuration | string;
+
+              /**
+               * (Optional) The expected time between heartbeats to the consumer coordinator.
+               * Heartbeats are used to ensure that the consumer's session stays active.
+               * The value must be set lower than session timeout
+               * Default: 3000 ms.
+               */
+              heartbeatInterval: HumanDuration | string;
+
+              /**
+               * (Optional) The period of time after which we force a refresh of metadata
+               * even if we haven't seen any partition leadership changes to proactively discover any new brokers or partitions
+               * Default: 300000 ms (5 minutes).
+               */
+              metadataMaxAge: HumanDuration | string;
+
+              /**
+               * (Optional) The maximum amount of data per-partition the server will return.
+               * This size must be at least as large as the maximum message size the server allows
+               * or else it is possible for the producer to send messages larger than the consumer can fetch.
+               * If that happens, the consumer can get stuck trying to fetch a large message on a certain partition
+               * Default: 1048576 (1MB)
+               */
+              maxBytesPerPartition: number;
+
+              /**
+               * (Optional) Minimum amount of data the server should return for a fetch request, otherwise wait up to maxWaitTime for more data to accumulate.
+               * Default: 1
+               */
+              minBytes: number;
+
+              /**
+               * (Optional) Maximum amount of bytes to accumulate in the response. Supported by Kafka >= 0.10.1.0
+               * Default: 10485760 (10MB)
+               */
+              maxBytes: number;
+
+              /**
+               * (Optional) The maximum amount of time the server will block before answering the fetch request
+               * if there isn’t sufficient data to immediately satisfy the requirement given by minBytes
+               * Default: 5000
+               */
+              maxWaitTime: HumanDuration | string;
+            };
+          }>;
+        };
+      };
+    };
+  };
+}

package/dist/index.cjs.js

@@ -0,0 +1,10 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var eventsModuleKafkaConsumingEventPublisher = require('./service/eventsModuleKafkaConsumingEventPublisher.cjs.js');
+
+
+
+exports.default = eventsModuleKafkaConsumingEventPublisher.eventsModuleKafkaConsumingEventPublisher;
+//# sourceMappingURL=index.cjs.js.map

package/dist/index.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;"}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import * as _backstage_backend_plugin_api from '@backstage/backend-plugin-api';
+
+/**
+ * Kafka module for the Events plugin.
+ *
+ * @public
+ */
+declare const eventsModuleKafkaConsumingEventPublisher: _backstage_backend_plugin_api.BackendFeature;
+
+export { eventsModuleKafkaConsumingEventPublisher as default };

package/dist/publisher/KafkaConsumerClient.cjs.js

@@ -0,0 +1,44 @@
+'use strict';
+
+var kafkajs = require('kafkajs');
+var config = require('./config.cjs.js');
+var KafkaConsumingEventPublisher = require('./KafkaConsumingEventPublisher.cjs.js');
+var LoggerServiceAdapter = require('./LoggerServiceAdapter.cjs.js');
+
+class KafkaConsumerClient {
+  kafka;
+  consumers;
+  static fromConfig(options) {
+    const kafkaConfig = config.readConfig(options.config);
+    if (!kafkaConfig) {
+      options.logger.info(
+        "Kafka consumer not configured, skipping initialization"
+      );
+      return void 0;
+    }
+    return new KafkaConsumerClient(options.logger, options.events, kafkaConfig);
+  }
+  constructor(logger, events, config) {
+    this.kafka = new kafkajs.Kafka({
+      ...config.kafkaConfig,
+      logCreator: LoggerServiceAdapter.loggerServiceAdapter(logger)
+    });
+    this.consumers = config.kafkaConsumerConfigs.map(
+      (consumerConfig) => KafkaConsumingEventPublisher.KafkaConsumingEventPublisher.fromConfig({
+        kafkaClient: this.kafka,
+        config: consumerConfig,
+        logger,
+        events
+      })
+    );
+  }
+  async start() {
+    this.consumers.map(async (consumer) => await consumer.start());
+  }
+  async shutdown() {
+    this.consumers.map(async (consumer) => await consumer.shutdown());
+  }
+}
+
+exports.KafkaConsumerClient = KafkaConsumerClient;
+//# sourceMappingURL=KafkaConsumerClient.cjs.js.map

package/dist/publisher/KafkaConsumerClient.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"KafkaConsumerClient.cjs.js","sources":["../../src/publisher/KafkaConsumerClient.ts"],"sourcesContent":["/*\n * Copyright 2025 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 */\nimport { LoggerService } from '@backstage/backend-plugin-api';\nimport { Config } from '@backstage/config';\nimport { EventsService } from '@backstage/plugin-events-node';\nimport { Kafka } from 'kafkajs';\nimport { KafkaEventSourceConfig, readConfig } from './config';\nimport { KafkaConsumingEventPublisher } from './KafkaConsumingEventPublisher';\nimport { loggerServiceAdapter } from './LoggerServiceAdapter';\n\n/**\n * KafkaConsumerClient\n *\n * This class creates the Kafka client that will be used to create the KafkaConsumingEventPublisher\n *\n * @public\n */\nexport class KafkaConsumerClient {\n  private readonly kafka: Kafka;\n  private readonly consumers: KafkaConsumingEventPublisher[];\n\n  static fromConfig(options: {\n    config: Config;\n    events: EventsService;\n    logger: LoggerService;\n  }): KafkaConsumerClient | undefined {\n    const kafkaConfig = readConfig(options.config);\n\n    if (!kafkaConfig) {\n      options.logger.info(\n        'Kafka consumer not configured, skipping initialization',\n      );\n      return undefined;\n    }\n\n    return new KafkaConsumerClient(options.logger, options.events, kafkaConfig);\n  }\n\n  private constructor(\n    logger: LoggerService,\n    events: EventsService,\n    config: KafkaEventSourceConfig,\n  ) {\n    this.kafka = new Kafka({\n      ...config.kafkaConfig,\n      logCreator: loggerServiceAdapter(logger),\n    });\n\n    this.consumers = config.kafkaConsumerConfigs.map(consumerConfig =>\n      KafkaConsumingEventPublisher.fromConfig({\n        kafkaClient: this.kafka,\n        config: consumerConfig,\n        logger,\n        events,\n      }),\n    );\n  }\n\n  async start(): Promise<void> {\n    this.consumers.map(async consumer => await consumer.start());\n  }\n\n  async shutdown(): Promise<void> {\n    this.consumers.map(async consumer => await consumer.shutdown());\n  }\n}\n"],"names":["readConfig","Kafka","loggerServiceAdapter","KafkaConsumingEventPublisher"],"mappings":";;;;;;;AA8BO,MAAM,mBAAoB,CAAA;AAAA,EACd,KAAA;AAAA,EACA,SAAA;AAAA,EAEjB,OAAO,WAAW,OAIkB,EAAA;AAClC,IAAM,MAAA,WAAA,GAAcA,iBAAW,CAAA,OAAA,CAAQ,MAAM,CAAA;AAE7C,IAAA,IAAI,CAAC,WAAa,EAAA;AAChB,MAAA,OAAA,CAAQ,MAAO,CAAA,IAAA;AAAA,QACb;AAAA,OACF;AACA,MAAO,OAAA,KAAA,CAAA;AAAA;AAGT,IAAA,OAAO,IAAI,mBAAoB,CAAA,OAAA,CAAQ,MAAQ,EAAA,OAAA,CAAQ,QAAQ,WAAW,CAAA;AAAA;AAC5E,EAEQ,WAAA,CACN,MACA,EAAA,MAAA,EACA,MACA,EAAA;AACA,IAAK,IAAA,CAAA,KAAA,GAAQ,IAAIC,aAAM,CAAA;AAAA,MACrB,GAAG,MAAO,CAAA,WAAA;AAAA,MACV,UAAA,EAAYC,0CAAqB,MAAM;AAAA,KACxC,CAAA;AAED,IAAK,IAAA,CAAA,SAAA,GAAY,OAAO,oBAAqB,CAAA,GAAA;AAAA,MAAI,CAAA,cAAA,KAC/CC,0DAA6B,UAAW,CAAA;AAAA,QACtC,aAAa,IAAK,CAAA,KAAA;AAAA,QAClB,MAAQ,EAAA,cAAA;AAAA,QACR,MAAA;AAAA,QACA;AAAA,OACD;AAAA,KACH;AAAA;AACF,EAEA,MAAM,KAAuB,GAAA;AAC3B,IAAA,IAAA,CAAK,UAAU,GAAI,CAAA,OAAM,aAAY,MAAM,QAAA,CAAS,OAAO,CAAA;AAAA;AAC7D,EAEA,MAAM,QAA0B,GAAA;AAC9B,IAAA,IAAA,CAAK,UAAU,GAAI,CAAA,OAAM,aAAY,MAAM,QAAA,CAAS,UAAU,CAAA;AAAA;AAElE;;;;"}

package/dist/publisher/KafkaConsumingEventPublisher.cjs.js

@@ -0,0 +1,62 @@
+'use strict';
+
+class KafkaConsumingEventPublisher {
+  constructor(kafkaClient, logger, events, config) {
+    this.events = events;
+    this.kafkaConsumer = kafkaClient.consumer(config.consumerConfig);
+    this.consumerSubscribeTopics = config.consumerSubscribeTopics;
+    this.backstageTopic = config.backstageTopic;
+    const id = `events.kafka.publisher:${this.backstageTopic}`;
+    this.logger = logger.child({
+      class: KafkaConsumingEventPublisher.prototype.constructor.name,
+      groupId: config.consumerConfig.groupId,
+      kafkaTopics: config.consumerSubscribeTopics.topics.toString(),
+      backstageTopic: config.backstageTopic,
+      taskId: id
+    });
+  }
+  kafkaConsumer;
+  consumerSubscribeTopics;
+  backstageTopic;
+  logger;
+  static fromConfig(env) {
+    return new KafkaConsumingEventPublisher(
+      env.kafkaClient,
+      env.logger,
+      env.events,
+      env.config
+    );
+  }
+  async start() {
+    try {
+      await this.kafkaConsumer.connect();
+      await this.kafkaConsumer.subscribe(this.consumerSubscribeTopics);
+      await this.kafkaConsumer.run({
+        eachMessage: async ({ message }) => {
+          this.events.publish({
+            topic: this.backstageTopic,
+            eventPayload: JSON.parse(message.value?.toString()),
+            metadata: this.convertHeadersToMetadata(message.headers)
+          });
+        }
+      });
+    } catch (error) {
+      this.logger.error("Kafka consumer connection failed ", error);
+    }
+  }
+  async shutdown() {
+    await this.kafkaConsumer.disconnect();
+  }
+  convertHeadersToMetadata = (headers) => {
+    if (!headers) return void 0;
+    const metadata = {};
+    Object.entries(headers).forEach(([key, value]) => {
+      if (Array.isArray(value)) metadata[key] = value.map((v) => v.toString());
+      else metadata[key] = value?.toString();
+    });
+    return metadata;
+  };
+}
+
+exports.KafkaConsumingEventPublisher = KafkaConsumingEventPublisher;
+//# sourceMappingURL=KafkaConsumingEventPublisher.cjs.js.map

package/dist/publisher/KafkaConsumingEventPublisher.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"KafkaConsumingEventPublisher.cjs.js","sources":["../../src/publisher/KafkaConsumingEventPublisher.ts"],"sourcesContent":["/*\n * Copyright 2025 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 */\nimport { LoggerService } from '@backstage/backend-plugin-api';\nimport { EventParams, EventsService } from '@backstage/plugin-events-node';\nimport { Consumer, ConsumerSubscribeTopics, IHeaders, Kafka } from 'kafkajs';\nimport { KafkaConsumerConfig } from './config';\n\ntype EventMetadata = EventParams['metadata'];\n\n/**\n *\n * This class subscribes to Kafka topics and publishes events received to the registered subscriber.\n * The message payload will be used as the event payload and passed to the subscribers.\n *\n * @public\n */\nexport class KafkaConsumingEventPublisher {\n  private readonly kafkaConsumer: Consumer;\n  private readonly consumerSubscribeTopics: ConsumerSubscribeTopics;\n  private readonly backstageTopic: string;\n  private readonly logger: LoggerService;\n\n  static fromConfig(env: {\n    kafkaClient: Kafka;\n    config: KafkaConsumerConfig;\n    events: EventsService;\n    logger: LoggerService;\n  }): KafkaConsumingEventPublisher {\n    return new KafkaConsumingEventPublisher(\n      env.kafkaClient,\n      env.logger,\n      env.events,\n      env.config,\n    );\n  }\n\n  private constructor(\n    kafkaClient: Kafka,\n    logger: LoggerService,\n    private readonly events: EventsService,\n    config: KafkaConsumerConfig,\n  ) {\n    this.kafkaConsumer = kafkaClient.consumer(config.consumerConfig);\n    this.consumerSubscribeTopics = config.consumerSubscribeTopics;\n    this.backstageTopic = config.backstageTopic;\n    const id = `events.kafka.publisher:${this.backstageTopic}`;\n    this.logger = logger.child({\n      class: KafkaConsumingEventPublisher.prototype.constructor.name,\n      groupId: config.consumerConfig.groupId,\n      kafkaTopics: config.consumerSubscribeTopics.topics.toString(),\n      backstageTopic: config.backstageTopic,\n      taskId: id,\n    });\n  }\n\n  async start(): Promise<void> {\n    try {\n      await this.kafkaConsumer.connect();\n\n      await this.kafkaConsumer.subscribe(this.consumerSubscribeTopics);\n\n      await this.kafkaConsumer.run({\n        eachMessage: async ({ message }) => {\n          this.events.publish({\n            topic: this.backstageTopic,\n            eventPayload: JSON.parse(message.value?.toString()!),\n            metadata: this.convertHeadersToMetadata(message.headers),\n          });\n        },\n      });\n    } catch (error: any) {\n      this.logger.error('Kafka consumer connection failed ', error);\n    }\n  }\n\n  async shutdown(): Promise<void> {\n    await this.kafkaConsumer.disconnect();\n  }\n\n  private convertHeadersToMetadata = (\n    headers: IHeaders | undefined,\n  ): EventParams['metadata'] => {\n    if (!headers) return undefined;\n\n    const metadata: EventMetadata = {};\n\n    Object.entries(headers).forEach(([key, value]) => {\n      // If value is an array use toString() on all values converting any Buffer types to valid strings\n      if (Array.isArray(value)) metadata[key] = value.map(v => v.toString());\n      // Always return the values using toString() to catch all Buffer types that should be converted to strings\n      else metadata[key] = value?.toString();\n    });\n\n    return metadata;\n  };\n}\n"],"names":[],"mappings":";;AA6BO,MAAM,4BAA6B,CAAA;AAAA,EAoBhC,WACN,CAAA,WAAA,EACA,MACiB,EAAA,MAAA,EACjB,MACA,EAAA;AAFiB,IAAA,IAAA,CAAA,MAAA,GAAA,MAAA;AAGjB,IAAA,IAAA,CAAK,aAAgB,GAAA,WAAA,CAAY,QAAS,CAAA,MAAA,CAAO,cAAc,CAAA;AAC/D,IAAA,IAAA,CAAK,0BAA0B,MAAO,CAAA,uBAAA;AACtC,IAAA,IAAA,CAAK,iBAAiB,MAAO,CAAA,cAAA;AAC7B,IAAM,MAAA,EAAA,GAAK,CAA0B,uBAAA,EAAA,IAAA,CAAK,cAAc,CAAA,CAAA;AACxD,IAAK,IAAA,CAAA,MAAA,GAAS,OAAO,KAAM,CAAA;AAAA,MACzB,KAAA,EAAO,4BAA6B,CAAA,SAAA,CAAU,WAAY,CAAA,IAAA;AAAA,MAC1D,OAAA,EAAS,OAAO,cAAe,CAAA,OAAA;AAAA,MAC/B,WAAa,EAAA,MAAA,CAAO,uBAAwB,CAAA,MAAA,CAAO,QAAS,EAAA;AAAA,MAC5D,gBAAgB,MAAO,CAAA,cAAA;AAAA,MACvB,MAAQ,EAAA;AAAA,KACT,CAAA;AAAA;AACH,EApCiB,aAAA;AAAA,EACA,uBAAA;AAAA,EACA,cAAA;AAAA,EACA,MAAA;AAAA,EAEjB,OAAO,WAAW,GAKe,EAAA;AAC/B,IAAA,OAAO,IAAI,4BAAA;AAAA,MACT,GAAI,CAAA,WAAA;AAAA,MACJ,GAAI,CAAA,MAAA;AAAA,MACJ,GAAI,CAAA,MAAA;AAAA,MACJ,GAAI,CAAA;AAAA,KACN;AAAA;AACF,EAqBA,MAAM,KAAuB,GAAA;AAC3B,IAAI,IAAA;AACF,MAAM,MAAA,IAAA,CAAK,cAAc,OAAQ,EAAA;AAEjC,MAAA,MAAM,IAAK,CAAA,aAAA,CAAc,SAAU,CAAA,IAAA,CAAK,uBAAuB,CAAA;AAE/D,MAAM,MAAA,IAAA,CAAK,cAAc,GAAI,CAAA;AAAA,QAC3B,WAAa,EAAA,OAAO,EAAE,OAAA,EAAc,KAAA;AAClC,UAAA,IAAA,CAAK,OAAO,OAAQ,CAAA;AAAA,YAClB,OAAO,IAAK,CAAA,cAAA;AAAA,YACZ,cAAc,IAAK,CAAA,KAAA,CAAM,OAAQ,CAAA,KAAA,EAAO,UAAW,CAAA;AAAA,YACnD,QAAU,EAAA,IAAA,CAAK,wBAAyB,CAAA,OAAA,CAAQ,OAAO;AAAA,WACxD,CAAA;AAAA;AACH,OACD,CAAA;AAAA,aACM,KAAY,EAAA;AACnB,MAAK,IAAA,CAAA,MAAA,CAAO,KAAM,CAAA,mCAAA,EAAqC,KAAK,CAAA;AAAA;AAC9D;AACF,EAEA,MAAM,QAA0B,GAAA;AAC9B,IAAM,MAAA,IAAA,CAAK,cAAc,UAAW,EAAA;AAAA;AACtC,EAEQ,wBAAA,GAA2B,CACjC,OAC4B,KAAA;AAC5B,IAAI,IAAA,CAAC,SAAgB,OAAA,KAAA,CAAA;AAErB,IAAA,MAAM,WAA0B,EAAC;AAEjC,IAAO,MAAA,CAAA,OAAA,CAAQ,OAAO,CAAE,CAAA,OAAA,CAAQ,CAAC,CAAC,GAAA,EAAK,KAAK,CAAM,KAAA;AAEhD,MAAA,IAAI,KAAM,CAAA,OAAA,CAAQ,KAAK,CAAA,EAAY,QAAA,CAAA,GAAG,CAAI,GAAA,KAAA,CAAM,GAAI,CAAA,CAAA,CAAA,KAAK,CAAE,CAAA,QAAA,EAAU,CAAA;AAAA,WAEvD,QAAA,CAAA,GAAG,CAAI,GAAA,KAAA,EAAO,QAAS,EAAA;AAAA,KACtC,CAAA;AAED,IAAO,OAAA,QAAA;AAAA,GACT;AACF;;;;"}

package/dist/publisher/LoggerServiceAdapter.cjs.js

@@ -0,0 +1,28 @@
+'use strict';
+
+var kafkajs = require('kafkajs');
+
+const loggerServiceAdapter = (loggerService) => (_level) => {
+  return (entry) => {
+    const { namespace, level, log } = entry;
+    const { message, ...extra } = log;
+    const logMethods = {
+      [kafkajs.logLevel.ERROR]: loggerService.error,
+      [kafkajs.logLevel.WARN]: loggerService.warn,
+      [kafkajs.logLevel.INFO]: loggerService.info,
+      [kafkajs.logLevel.DEBUG]: loggerService.debug,
+      [kafkajs.logLevel.NOTHING]: () => {
+      }
+    };
+    logMethods[level].call(
+      loggerService,
+      `Kafka ${namespace} ${log.message}`,
+      {
+        ...extra
+      }
+    );
+  };
+};
+
+exports.loggerServiceAdapter = loggerServiceAdapter;
+//# sourceMappingURL=LoggerServiceAdapter.cjs.js.map

package/dist/publisher/LoggerServiceAdapter.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LoggerServiceAdapter.cjs.js","sources":["../../src/publisher/LoggerServiceAdapter.ts"],"sourcesContent":["/*\n * Copyright 2025 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 */\nimport { LoggerService } from '@backstage/backend-plugin-api';\nimport { LogEntry, logLevel } from 'kafkajs';\n\nexport const loggerServiceAdapter =\n  (loggerService: LoggerService) => (_level: logLevel) => {\n    return (entry: LogEntry) => {\n      const { namespace, level, log } = entry;\n      const { message, ...extra } = log;\n\n      const logMethods: Record<\n        logLevel,\n        (message: string, meta?: object) => void\n      > = {\n        [logLevel.ERROR]: loggerService.error,\n        [logLevel.WARN]: loggerService.warn,\n        [logLevel.INFO]: loggerService.info,\n        [logLevel.DEBUG]: loggerService.debug,\n        [logLevel.NOTHING]: () => {},\n      };\n\n      // Use loggerService method that matches the level\n      logMethods[level].call(\n        loggerService,\n        `Kafka ${namespace} ${log.message}`,\n        {\n          ...extra,\n        },\n      );\n    };\n  };\n"],"names":["logLevel"],"mappings":";;;;AAkBO,MAAM,oBACX,GAAA,CAAC,aAAiC,KAAA,CAAC,MAAqB,KAAA;AACtD,EAAA,OAAO,CAAC,KAAoB,KAAA;AAC1B,IAAA,MAAM,EAAE,SAAA,EAAW,KAAO,EAAA,GAAA,EAAQ,GAAA,KAAA;AAClC,IAAA,MAAM,EAAE,OAAA,EAAS,GAAG,KAAA,EAAU,GAAA,GAAA;AAE9B,IAAA,MAAM,UAGF,GAAA;AAAA,MACF,CAACA,gBAAA,CAAS,KAAK,GAAG,aAAc,CAAA,KAAA;AAAA,MAChC,CAACA,gBAAA,CAAS,IAAI,GAAG,aAAc,CAAA,IAAA;AAAA,MAC/B,CAACA,gBAAA,CAAS,IAAI,GAAG,aAAc,CAAA,IAAA;AAAA,MAC/B,CAACA,gBAAA,CAAS,KAAK,GAAG,aAAc,CAAA,KAAA;AAAA,MAChC,CAACA,gBAAA,CAAS,OAAO,GAAG,MAAM;AAAA;AAAC,KAC7B;AAGA,IAAA,UAAA,CAAW,KAAK,CAAE,CAAA,IAAA;AAAA,MAChB,aAAA;AAAA,MACA,CAAS,MAAA,EAAA,SAAS,CAAI,CAAA,EAAA,GAAA,CAAI,OAAO,CAAA,CAAA;AAAA,MACjC;AAAA,QACE,GAAG;AAAA;AACL,KACF;AAAA,GACF;AACF;;;;"}

package/dist/publisher/config.cjs.js

@@ -0,0 +1,102 @@
+'use strict';
+
+var config = require('@backstage/config');
+var luxon = require('luxon');
+
+const CONFIG_PREFIX_PUBLISHER = "events.modules.kafka.kafkaConsumingEventPublisher";
+const readOptionalHumanDurationInMs = (config$1, key) => {
+  const humanDuration = config$1.has(key) ? config.readDurationFromConfig(config$1, { key }) : void 0;
+  if (!humanDuration) return void 0;
+  return luxon.Duration.fromObject(humanDuration).as("milliseconds");
+};
+const readConfig = (config) => {
+  const kafkaConfig = config.getOptionalConfig(CONFIG_PREFIX_PUBLISHER);
+  if (!kafkaConfig) {
+    return void 0;
+  }
+  const clientId = kafkaConfig.getString("clientId");
+  const brokers = kafkaConfig.getStringArray("brokers");
+  const authenticationTimeout = readOptionalHumanDurationInMs(
+    kafkaConfig,
+    "authenticationTimeout"
+  );
+  const connectionTimeout = readOptionalHumanDurationInMs(
+    kafkaConfig,
+    "connectionTimeout"
+  );
+  const requestTimeout = readOptionalHumanDurationInMs(
+    kafkaConfig,
+    "requestTimeout"
+  );
+  const enforceRequestTimeout = kafkaConfig.getOptionalBoolean(
+    "enforceRequestTimeout"
+  );
+  const ssl = kafkaConfig.getOptional("ssl");
+  const sasl = kafkaConfig.getOptional("sasl");
+  const retry = {
+    maxRetryTime: readOptionalHumanDurationInMs(
+      kafkaConfig,
+      "retry.maxRetryTime"
+    ),
+    initialRetryTime: readOptionalHumanDurationInMs(
+      kafkaConfig,
+      "retry.initialRetryTime"
+    ),
+    factor: kafkaConfig.getOptionalNumber("retry.factor"),
+    multiplier: kafkaConfig.getOptionalNumber("retry.multiplier"),
+    retries: kafkaConfig.getOptionalNumber("retry.retries")
+  };
+  const kafkaConsumerConfigs = kafkaConfig.getConfigArray("topics").map((topic) => {
+    return {
+      backstageTopic: topic.getString("topic"),
+      consumerConfig: {
+        groupId: topic.getString("kafka.groupId"),
+        sessionTimeout: readOptionalHumanDurationInMs(
+          topic,
+          "kafka.sessionTimeout"
+        ),
+        rebalanceTimeout: readOptionalHumanDurationInMs(
+          topic,
+          "kafka.rebalanceTimeout"
+        ),
+        heartbeatInterval: readOptionalHumanDurationInMs(
+          topic,
+          "kafka.heartbeatInterval"
+        ),
+        metadataMaxAge: readOptionalHumanDurationInMs(
+          topic,
+          "kafka.metadataMaxAge"
+        ),
+        maxBytesPerPartition: topic.getOptionalNumber(
+          "kafka.maxBytesPerPartition"
+        ),
+        minBytes: topic.getOptionalNumber("kafka.minBytes"),
+        maxBytes: topic.getOptionalNumber("kafka.maxBytes"),
+        maxWaitTimeInMs: readOptionalHumanDurationInMs(
+          topic,
+          "kafka.maxWaitTime"
+        )
+      },
+      consumerSubscribeTopics: {
+        topics: topic.getStringArray("kafka.topics")
+      }
+    };
+  });
+  return {
+    kafkaConfig: {
+      clientId,
+      brokers,
+      ssl,
+      sasl,
+      authenticationTimeout,
+      connectionTimeout,
+      requestTimeout,
+      enforceRequestTimeout,
+      retry
+    },
+    kafkaConsumerConfigs
+  };
+};
+
+exports.readConfig = readConfig;
+//# sourceMappingURL=config.cjs.js.map

package/dist/publisher/config.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.cjs.js","sources":["../../src/publisher/config.ts"],"sourcesContent":["/*\n * Copyright 2025 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 */\nimport { Config, readDurationFromConfig } from '@backstage/config';\nimport { ConsumerConfig, ConsumerSubscribeTopics, KafkaConfig } from 'kafkajs';\nimport { Duration } from 'luxon';\n\n/**\n * @public\n */\nexport interface KafkaConsumerConfig {\n  backstageTopic: string;\n  consumerConfig: ConsumerConfig;\n  consumerSubscribeTopics: ConsumerSubscribeTopics;\n}\n\n/**\n * @public\n */\nexport interface KafkaEventSourceConfig {\n  kafkaConfig: KafkaConfig;\n  kafkaConsumerConfigs: KafkaConsumerConfig[];\n}\n\nconst CONFIG_PREFIX_PUBLISHER =\n  'events.modules.kafka.kafkaConsumingEventPublisher';\n\n/**\n * Reads an optional HumanDuration from the config and returns the value in milliseconds if the key is defined.\n *\n * @param config - The configuration object to read from.\n * @param key - The key to look up in the configuration.\n * @returns The duration in milliseconds, or undefined if the key is not defined.\n */\nconst readOptionalHumanDurationInMs = (\n  config: Config,\n  key: string,\n): number | undefined => {\n  const humanDuration = config.has(key)\n    ? readDurationFromConfig(config, { key })\n    : undefined;\n\n  if (!humanDuration) return undefined;\n\n  return Duration.fromObject(humanDuration).as('milliseconds');\n};\n\nexport const readConfig = (\n  config: Config,\n): KafkaEventSourceConfig | undefined => {\n  const kafkaConfig = config.getOptionalConfig(CONFIG_PREFIX_PUBLISHER);\n\n  if (!kafkaConfig) {\n    return undefined;\n  }\n\n  const clientId = kafkaConfig.getString('clientId');\n  const brokers = kafkaConfig.getStringArray('brokers');\n\n  const authenticationTimeout = readOptionalHumanDurationInMs(\n    kafkaConfig,\n    'authenticationTimeout',\n  );\n\n  const connectionTimeout = readOptionalHumanDurationInMs(\n    kafkaConfig,\n    'connectionTimeout',\n  );\n  const requestTimeout = readOptionalHumanDurationInMs(\n    kafkaConfig,\n    'requestTimeout',\n  );\n  const enforceRequestTimeout = kafkaConfig.getOptionalBoolean(\n    'enforceRequestTimeout',\n  );\n\n  const ssl = kafkaConfig.getOptional('ssl') as KafkaConfig['ssl'];\n  const sasl = kafkaConfig.getOptional('sasl') as KafkaConfig['sasl'];\n\n  const retry: KafkaConfig['retry'] = {\n    maxRetryTime: readOptionalHumanDurationInMs(\n      kafkaConfig,\n      'retry.maxRetryTime',\n    ),\n    initialRetryTime: readOptionalHumanDurationInMs(\n      kafkaConfig,\n      'retry.initialRetryTime',\n    ),\n    factor: kafkaConfig.getOptionalNumber('retry.factor'),\n    multiplier: kafkaConfig.getOptionalNumber('retry.multiplier'),\n    retries: kafkaConfig.getOptionalNumber('retry.retries'),\n  };\n\n  const kafkaConsumerConfigs: KafkaConsumerConfig[] = kafkaConfig\n    .getConfigArray('topics')\n    .map(topic => {\n      return {\n        backstageTopic: topic.getString('topic'),\n        consumerConfig: {\n          groupId: topic.getString('kafka.groupId'),\n          sessionTimeout: readOptionalHumanDurationInMs(\n            topic,\n            'kafka.sessionTimeout',\n          ),\n          rebalanceTimeout: readOptionalHumanDurationInMs(\n            topic,\n            'kafka.rebalanceTimeout',\n          ),\n          heartbeatInterval: readOptionalHumanDurationInMs(\n            topic,\n            'kafka.heartbeatInterval',\n          ),\n          metadataMaxAge: readOptionalHumanDurationInMs(\n            topic,\n            'kafka.metadataMaxAge',\n          ),\n          maxBytesPerPartition: topic.getOptionalNumber(\n            'kafka.maxBytesPerPartition',\n          ),\n          minBytes: topic.getOptionalNumber('kafka.minBytes'),\n          maxBytes: topic.getOptionalNumber('kafka.maxBytes'),\n          maxWaitTimeInMs: readOptionalHumanDurationInMs(\n            topic,\n            'kafka.maxWaitTime',\n          ),\n        },\n        consumerSubscribeTopics: {\n          topics: topic.getStringArray('kafka.topics'),\n        },\n      };\n    });\n\n  return {\n    kafkaConfig: {\n      clientId,\n      brokers,\n      ssl,\n      sasl,\n      authenticationTimeout,\n      connectionTimeout,\n      requestTimeout,\n      enforceRequestTimeout,\n      retry,\n    },\n    kafkaConsumerConfigs,\n  };\n};\n"],"names":["config","readDurationFromConfig","Duration"],"mappings":"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"}

package/dist/service/eventsModuleKafkaConsumingEventPublisher.cjs.js

@@ -0,0 +1,35 @@
+'use strict';
+
+var backendPluginApi = require('@backstage/backend-plugin-api');
+var KafkaConsumerClient = require('../publisher/KafkaConsumerClient.cjs.js');
+var pluginEventsNode = require('@backstage/plugin-events-node');
+
+const eventsModuleKafkaConsumingEventPublisher = backendPluginApi.createBackendModule({
+  pluginId: "events",
+  moduleId: "kafka-consuming-event-publisher",
+  register(env) {
+    env.registerInit({
+      deps: {
+        config: backendPluginApi.coreServices.rootConfig,
+        events: pluginEventsNode.eventsServiceRef,
+        logger: backendPluginApi.coreServices.logger,
+        lifecycle: backendPluginApi.coreServices.lifecycle
+      },
+      async init({ config, logger, events, lifecycle }) {
+        const kafka = KafkaConsumerClient.KafkaConsumerClient.fromConfig({
+          config,
+          events,
+          logger
+        });
+        if (!kafka) {
+          return;
+        }
+        await kafka.start();
+        lifecycle.addShutdownHook(async () => await kafka.shutdown());
+      }
+    });
+  }
+});
+
+exports.eventsModuleKafkaConsumingEventPublisher = eventsModuleKafkaConsumingEventPublisher;
+//# sourceMappingURL=eventsModuleKafkaConsumingEventPublisher.cjs.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"eventsModuleKafkaConsumingEventPublisher.cjs.js","sources":["../../src/service/eventsModuleKafkaConsumingEventPublisher.ts"],"sourcesContent":["/*\n * Copyright 2025 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 */\nimport {\n  coreServices,\n  createBackendModule,\n} from '@backstage/backend-plugin-api';\nimport { KafkaConsumerClient } from '../publisher/KafkaConsumerClient';\nimport { eventsServiceRef } from '@backstage/plugin-events-node';\n\n/**\n * Kafka module for the Events plugin.\n *\n * @public\n */\nexport const eventsModuleKafkaConsumingEventPublisher = createBackendModule({\n  pluginId: 'events',\n  moduleId: 'kafka-consuming-event-publisher',\n  register(env) {\n    env.registerInit({\n      deps: {\n        config: coreServices.rootConfig,\n        events: eventsServiceRef,\n        logger: coreServices.logger,\n        lifecycle: coreServices.lifecycle,\n      },\n      async init({ config, logger, events, lifecycle }) {\n        const kafka = KafkaConsumerClient.fromConfig({\n          config,\n          events,\n          logger,\n        });\n\n        if (!kafka) {\n          return;\n        }\n\n        await kafka.start();\n\n        lifecycle.addShutdownHook(async () => await kafka.shutdown());\n      },\n    });\n  },\n});\n"],"names":["createBackendModule","coreServices","eventsServiceRef","KafkaConsumerClient"],"mappings":";;;;;;AA2BO,MAAM,2CAA2CA,oCAAoB,CAAA;AAAA,EAC1E,QAAU,EAAA,QAAA;AAAA,EACV,QAAU,EAAA,iCAAA;AAAA,EACV,SAAS,GAAK,EAAA;AACZ,IAAA,GAAA,CAAI,YAAa,CAAA;AAAA,MACf,IAAM,EAAA;AAAA,QACJ,QAAQC,6BAAa,CAAA,UAAA;AAAA,QACrB,MAAQ,EAAAC,iCAAA;AAAA,QACR,QAAQD,6BAAa,CAAA,MAAA;AAAA,QACrB,WAAWA,6BAAa,CAAA;AAAA,OAC1B;AAAA,MACA,MAAM,IAAK,CAAA,EAAE,QAAQ,MAAQ,EAAA,MAAA,EAAQ,WAAa,EAAA;AAChD,QAAM,MAAA,KAAA,GAAQE,wCAAoB,UAAW,CAAA;AAAA,UAC3C,MAAA;AAAA,UACA,MAAA;AAAA,UACA;AAAA,SACD,CAAA;AAED,QAAA,IAAI,CAAC,KAAO,EAAA;AACV,UAAA;AAAA;AAGF,QAAA,MAAM,MAAM,KAAM,EAAA;AAElB,QAAA,SAAA,CAAU,eAAgB,CAAA,YAAY,MAAM,KAAA,CAAM,UAAU,CAAA;AAAA;AAC9D,KACD,CAAA;AAAA;AAEL,CAAC;;;;"}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@backstage/plugin-events-backend-module-kafka",
+  "version": "0.0.0-nightly-20250612024034",
+  "description": "The kafka backend module for the events plugin.",
+  "backstage": {
+    "role": "backend-plugin-module",
+    "pluginId": "events",
+    "pluginPackage": "@backstage/plugin-events-backend",
+    "features": {
+      ".": "@backstage/BackendFeature"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "main": "dist/index.cjs.js",
+    "types": "dist/index.d.ts"
+  },
+  "homepage": "https://backstage.io",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/backstage/backstage",
+    "directory": "plugins/events-backend-module-kafka"
+  },
+  "license": "Apache-2.0",
+  "main": "dist/index.cjs.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "config.d.ts"
+  ],
+  "scripts": {
+    "build": "backstage-cli package build",
+    "clean": "backstage-cli package clean",
+    "lint": "backstage-cli package lint",
+    "prepack": "backstage-cli package prepack",
+    "postpack": "backstage-cli package postpack",
+    "start": "backstage-cli package start",
+    "test": "backstage-cli package test"
+  },
+  "dependencies": {
+    "@backstage/backend-plugin-api": "0.0.0-nightly-20250612024034",
+    "@backstage/config": "1.3.2",
+    "@backstage/plugin-events-node": "0.0.0-nightly-20250612024034",
+    "@backstage/types": "1.2.1",
+    "kafkajs": "^2.2.4",
+    "luxon": "^3.0.0"
+  },
+  "devDependencies": {
+    "@backstage/backend-test-utils": "0.0.0-nightly-20250612024034",
+    "@backstage/cli": "0.0.0-nightly-20250612024034",
+    "@backstage/plugin-events-backend-test-utils": "0.0.0-nightly-20250612024034"
+  },
+  "configSchema": "config.d.ts",
+  "typesVersions": {
+    "*": {
+      "package.json": [
+        "package.json"
+      ]
+    }
+  }
+}