@syncbridge/kafka 0.4.1

package/LICENSE

@@ -0,0 +1,15 @@
+Copyright (c) 2025 Panates (Panates Teknoloji Yatirim A.S.). All rights reserved.
+
+This software and associated documentation files (the "Software") are
+the proprietary property of Panates and are protected by copyright laws
+and international copyright treaties.
+
+Unauthorized copying, distribution, modification, reverse engineering,
+or use of this software, in whole or in part, is strictly prohibited
+without the express written permission of Panates.
+
+This Software is provided solely for use in accordance with the terms
+of a valid license agreement. Any unauthorized use may result in
+civil and/or criminal penalties.
+
+For licensing inquiries, please contact: info@panates.com

package/README.md

@@ -0,0 +1 @@
+# SyncBridge ICU Connectors

package/components/kafka-base.component.d.ts

@@ -0,0 +1,28 @@
+import { ComponentBase } from '@syncbridge/common';
+import { TcpClientComponent } from '@syncbridge/net';
+import { Kafka } from 'kafkajs';
+import { KafkaRetryVariables, KafkaSaslVariables, KafkaVariables } from './kafka.variables.js';
+/**
+ * Kafka component
+ */
+export declare class KafkaBaseComponent<TEvents extends KafkaBaseComponent.Events = KafkaBaseComponent.Events> extends ComponentBase<TEvents> {
+    kafka: Kafka;
+    values: KafkaVariables;
+    protected _init(): Promise<void>;
+}
+/**
+ * @namespace
+ */
+export declare namespace KafkaBaseComponent {
+    interface Events extends ComponentBase.Events {
+        message: [msg: any];
+    }
+    const Variables: typeof KafkaVariables;
+    type Variables = KafkaVariables;
+    const SaslVariables: typeof KafkaSaslVariables;
+    type SaslVariables = KafkaSaslVariables;
+    const RetryVariables: typeof KafkaRetryVariables;
+    type RetryVariables = KafkaRetryVariables;
+    const TlsVariables: typeof import("packages-ext/net/build/components/tcp-client.variables.js").TcpClientTlsVariables;
+    type TlsVariables = TcpClientComponent.TlsVariables;
+}

package/components/kafka-base.component.js

@@ -0,0 +1,54 @@
+import { __decorate, __metadata } from "tslib";
+import { Component, ComponentBase } from '@syncbridge/common';
+import { TcpClientComponent } from '@syncbridge/net';
+import { Kafka } from 'kafkajs';
+import { panatesAuthor } from '../constants.js';
+import { KafkaRetryVariables, KafkaSaslVariables, KafkaVariables, } from './kafka.variables.js';
+/**
+ * Kafka component
+ */
+let KafkaBaseComponent = class KafkaBaseComponent extends ComponentBase {
+    async _init() {
+        this.kafka = new Kafka({
+            brokers: this.values.brokers,
+            clientId: this.values.clientId,
+            connectionTimeout: this.values.connectTimeout,
+            authenticationTimeout: this.values.authenticationTimeout,
+            reauthenticationThreshold: this.values.reauthenticationThreshold,
+            requestTimeout: this.values.requestTimeout,
+            enforceRequestTimeout: this.values.enforceRequestTimeout,
+            retry: this.values.retry,
+            ssl: this.values.tsl,
+            sasl: {
+                mechanism: this.values.sasl?.mechanism,
+                username: this.values.sasl?.username,
+                password: this.values.sasl?.password,
+                authorizationIdentity: this.values.sasl?.awsAuthorizationIdentity,
+                accessKeyId: this.values.sasl?.awsAccessKeyId,
+                secretAccessKey: this.values.sasl?.awsSecretAccessKey,
+                sessionToken: this.values.sasl?.awsSessionToken,
+            },
+        });
+    }
+};
+__decorate([
+    Component.UseVariables(),
+    __metadata("design:type", KafkaVariables)
+], KafkaBaseComponent.prototype, "values", void 0);
+KafkaBaseComponent = __decorate([
+    Component({
+        abstract: true,
+        tags: ['consumer'],
+        author: panatesAuthor,
+    })
+], KafkaBaseComponent);
+export { KafkaBaseComponent };
+/**
+ * @namespace
+ */
+(function (KafkaBaseComponent) {
+    KafkaBaseComponent.Variables = KafkaVariables;
+    KafkaBaseComponent.SaslVariables = KafkaSaslVariables;
+    KafkaBaseComponent.RetryVariables = KafkaRetryVariables;
+    KafkaBaseComponent.TlsVariables = TcpClientComponent.TlsVariables;
+})(KafkaBaseComponent || (KafkaBaseComponent = {}));

package/components/kafka-consumer.component.d.ts

@@ -0,0 +1,33 @@
+import { TcpClientComponent } from '@syncbridge/net';
+import { Consumer } from 'kafkajs';
+import { KafkaRetryVariables, KafkaSaslVariables } from './kafka.variables.js';
+import { KafkaBaseComponent } from './kafka-base.component.js';
+import { KafkaConsumerVariables } from './kafka-consumer.variables.js';
+/**
+ * KafkaConsumer component
+ */
+export declare class KafkaConsumerComponent<TEvents extends KafkaConsumerComponent.Events = KafkaConsumerComponent.Events> extends KafkaBaseComponent<TEvents> {
+    protected _stopping?: boolean;
+    consumer: Consumer;
+    values: KafkaConsumerVariables;
+    protected _init(): Promise<void>;
+    protected _start(abortSignal: AbortSignal): Promise<void>;
+    protected _stop(): Promise<void>;
+    protected _onMessage(payload: any): Promise<void>;
+}
+/**
+ * @namespace
+ */
+export declare namespace KafkaConsumerComponent {
+    interface Events extends KafkaBaseComponent.Events {
+        message: [msg: any];
+    }
+    const Variables: typeof KafkaConsumerVariables;
+    type Variables = KafkaConsumerVariables;
+    const SaslVariables: typeof KafkaSaslVariables;
+    type SaslVariables = KafkaSaslVariables;
+    const RetryVariables: typeof KafkaRetryVariables;
+    type RetryVariables = KafkaRetryVariables;
+    const TlsVariables: typeof import("packages-ext/net/build/components/tcp-client.variables.js").TcpClientTlsVariables;
+    type TlsVariables = TcpClientComponent.TlsVariables;
+}

package/components/kafka-consumer.component.js

@@ -0,0 +1,92 @@
+import { __decorate, __metadata } from "tslib";
+import { Component, ServiceStatus } from '@syncbridge/common';
+import { TcpClientComponent } from '@syncbridge/net';
+import { noOp, panatesAuthor } from '../constants.js';
+import { KafkaRetryVariables, KafkaSaslVariables } from './kafka.variables.js';
+import { KafkaBaseComponent } from './kafka-base.component.js';
+import { KafkaConsumerVariables } from './kafka-consumer.variables.js';
+/**
+ * KafkaConsumer component
+ */
+let KafkaConsumerComponent = class KafkaConsumerComponent extends KafkaBaseComponent {
+    _stopping;
+    async _init() {
+        await super._init();
+        this.consumer = this.kafka.consumer({
+            groupId: this.values.groupId,
+        });
+        this.consumer.on(this.consumer.events.CONNECT, () => {
+            this.emit('status-change', ServiceStatus.started);
+            this.emit('connect');
+        });
+        this.consumer.on(this.consumer.events.CRASH, event => {
+            this.emit('status-change', ServiceStatus.unhealthy, event.payload?.error);
+        });
+        this.consumer.on(this.consumer.events.DISCONNECT, () => {
+            if (!this._stopping) {
+                this.emit('status-change', ServiceStatus.unhealthy, new Error('Kafka consumer disconnected'));
+            }
+            this.emit('disconnect');
+        });
+    }
+    async _start(abortSignal) {
+        await super._start(abortSignal);
+        this.consumer
+            .connect()
+            .then(async () => {
+            await this.consumer
+                .subscribe({
+                topics: this.values.topics,
+                fromBeginning: this.values.fromBeginning,
+            })
+                .catch(async (e) => {
+                this.emit('error', e);
+                await this.consumer.disconnect().catch(noOp);
+                this.emit('status-change', ServiceStatus.unhealthy, e);
+            });
+            await this.consumer
+                .run({
+                eachMessage: async (payload) => {
+                    return this._onMessage(payload);
+                },
+            })
+                .catch(async (e) => {
+                this.emit('error', e);
+                await this.consumer.disconnect().catch(noOp);
+                this.emit('status-change', ServiceStatus.unhealthy, e);
+            });
+        })
+            .catch(noOp);
+    }
+    async _stop() {
+        this._stopping = true;
+        await this.consumer.disconnect();
+        return super._stop();
+    }
+    async _onMessage(payload) {
+        this.emit('message', payload);
+    }
+};
+__decorate([
+    Component.UseVariables(),
+    __metadata("design:type", KafkaConsumerVariables)
+], KafkaConsumerComponent.prototype, "values", void 0);
+KafkaConsumerComponent = __decorate([
+    Component({
+        className: 'KafkaConsumer',
+        displayName: 'Kafka Consumer',
+        description: 'Kafka consumer component',
+        author: panatesAuthor,
+        tags: ['consumer'],
+    })
+], KafkaConsumerComponent);
+export { KafkaConsumerComponent };
+/**
+ * @namespace
+ */
+(function (KafkaConsumerComponent) {
+    KafkaConsumerComponent.Variables = KafkaConsumerVariables;
+    KafkaConsumerComponent.SaslVariables = KafkaSaslVariables;
+    KafkaConsumerComponent.RetryVariables = KafkaRetryVariables;
+    KafkaConsumerComponent.TlsVariables = TcpClientComponent.TlsVariables;
+})(KafkaConsumerComponent || (KafkaConsumerComponent = {}));

package/components/kafka-consumer.variables.d.ts

@@ -0,0 +1,9 @@
+import { KafkaBaseComponent } from './kafka-base.component.js';
+/**
+ * Variables
+ */
+export declare class KafkaConsumerVariables extends KafkaBaseComponent.Variables {
+    groupId: string;
+    topics: string[];
+    fromBeginning: boolean;
+}

package/components/kafka-consumer.variables.js

@@ -0,0 +1,33 @@
+import { __decorate, __metadata } from "tslib";
+import { DefineVariable, VariableType } from '@syncbridge/common';
+import { KafkaBaseComponent } from './kafka-base.component.js';
+/**
+ * Variables
+ */
+export class KafkaConsumerVariables extends KafkaBaseComponent.Variables {
+}
+__decorate([
+    DefineVariable({
+        label: 'Group id',
+        description: 'A unique string that identifies the consumer group this consumer belongs to',
+        required: true,
+    }),
+    __metadata("design:type", String)
+], KafkaConsumerVariables.prototype, "groupId", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Topics',
+        description: 'Topics to subscribe to',
+        type: VariableType.String,
+        required: true,
+    }),
+    __metadata("design:type", Array)
+], KafkaConsumerVariables.prototype, "topics", void 0);
+__decorate([
+    DefineVariable({
+        label: 'From beginning',
+        description: 'Start consuming from the beginning of the topic',
+        default: false,
+    }),
+    __metadata("design:type", Boolean)
+], KafkaConsumerVariables.prototype, "fromBeginning", void 0);

package/components/kafka-producer.component.d.ts

@@ -0,0 +1,34 @@
+import { TcpClientComponent } from '@syncbridge/net';
+import { Producer, ProducerBatch, ProducerRecord, RecordMetadata } from 'kafkajs';
+import { KafkaRetryVariables, KafkaSaslVariables } from './kafka.variables.js';
+import { KafkaBaseComponent } from './kafka-base.component.js';
+import { KafkaProducerVariables } from './kafka-producer.variables.js';
+/**
+ * KafkaProducer component
+ */
+export declare class KafkaProducerComponent<TEvents extends KafkaProducerComponent.Events = KafkaProducerComponent.Events> extends KafkaBaseComponent<TEvents> {
+    protected _stopping?: boolean;
+    producer: Producer;
+    values: KafkaProducerVariables;
+    protected _init(): Promise<void>;
+    protected _start(abortSignal: AbortSignal): Promise<void>;
+    protected _stop(): Promise<void>;
+    send(record: ProducerRecord): Promise<RecordMetadata[]>;
+    sendBatch(batch: ProducerBatch): Promise<RecordMetadata[]>;
+}
+/**
+ * @namespace
+ */
+export declare namespace KafkaProducerComponent {
+    interface Events extends KafkaBaseComponent.Events {
+        message: [msg: any];
+    }
+    const Variables: typeof KafkaProducerVariables;
+    type Variables = KafkaProducerVariables;
+    const SaslVariables: typeof KafkaSaslVariables;
+    type SaslVariables = KafkaSaslVariables;
+    const RetryVariables: typeof KafkaRetryVariables;
+    type RetryVariables = KafkaRetryVariables;
+    const TlsVariables: typeof import("packages-ext/net/build/components/tcp-client.variables.js").TcpClientTlsVariables;
+    type TlsVariables = TcpClientComponent.TlsVariables;
+}

package/components/kafka-producer.component.js

@@ -0,0 +1,67 @@
+import { __decorate, __metadata } from "tslib";
+import { Component, ServiceStatus } from '@syncbridge/common';
+import { TcpClientComponent } from '@syncbridge/net';
+import { noOp, panatesAuthor } from '../constants.js';
+import { KafkaRetryVariables, KafkaSaslVariables } from './kafka.variables.js';
+import { KafkaBaseComponent } from './kafka-base.component.js';
+import { KafkaProducerVariables } from './kafka-producer.variables.js';
+/**
+ * KafkaProducer component
+ */
+let KafkaProducerComponent = class KafkaProducerComponent extends KafkaBaseComponent {
+    _stopping;
+    async _init() {
+        await super._init();
+        this.producer = this.kafka.producer({
+            allowAutoTopicCreation: this.values.allowAutoTopicCreation,
+        });
+        this.producer.on(this.producer.events.CONNECT, () => {
+            this.emit('status-change', ServiceStatus.started);
+            this.emit('connect');
+        });
+        this.producer.on(this.producer.events.DISCONNECT, () => {
+            if (!this._stopping) {
+                this.emit('status-change', ServiceStatus.unhealthy, new Error('Kafka producer disconnected'));
+            }
+            this.emit('disconnect');
+        });
+    }
+    async _start(abortSignal) {
+        await super._start(abortSignal);
+        this.producer.connect().catch(noOp);
+    }
+    async _stop() {
+        this._stopping = true;
+        await this.producer.disconnect();
+        return super._stop();
+    }
+    async send(record) {
+        return this.producer.send(record);
+    }
+    async sendBatch(batch) {
+        return this.producer.sendBatch(batch);
+    }
+};
+__decorate([
+    Component.UseVariables(),
+    __metadata("design:type", KafkaProducerVariables)
+], KafkaProducerComponent.prototype, "values", void 0);
+KafkaProducerComponent = __decorate([
+    Component({
+        className: 'KafkaProducer',
+        displayName: 'Kafka Producer',
+        description: 'Kafka producer component',
+        author: panatesAuthor,
+        tags: ['producer'],
+    })
+], KafkaProducerComponent);
+export { KafkaProducerComponent };
+/**
+ * @namespace
+ */
+(function (KafkaProducerComponent) {
+    KafkaProducerComponent.Variables = KafkaProducerVariables;
+    KafkaProducerComponent.SaslVariables = KafkaSaslVariables;
+    KafkaProducerComponent.RetryVariables = KafkaRetryVariables;
+    KafkaProducerComponent.TlsVariables = TcpClientComponent.TlsVariables;
+})(KafkaProducerComponent || (KafkaProducerComponent = {}));

package/components/kafka-producer.variables.d.ts

@@ -0,0 +1,7 @@
+import { KafkaBaseComponent } from './kafka-base.component.js';
+/**
+ * Variables
+ */
+export declare class KafkaProducerVariables extends KafkaBaseComponent.Variables {
+    allowAutoTopicCreation: boolean;
+}

package/components/kafka-producer.variables.js

@@ -0,0 +1,15 @@
+import { __decorate, __metadata } from "tslib";
+import { DefineVariable } from '@syncbridge/common';
+import { KafkaBaseComponent } from './kafka-base.component.js';
+/**
+ * Variables
+ */
+export class KafkaProducerVariables extends KafkaBaseComponent.Variables {
+}
+__decorate([
+    DefineVariable({
+        label: 'AutoTopic Creation',
+        description: 'Allow topic creation when querying metadata for non-existent topics',
+    }),
+    __metadata("design:type", Boolean)
+], KafkaProducerVariables.prototype, "allowAutoTopicCreation", void 0);

package/components/kafka.variables.d.ts

@@ -0,0 +1,41 @@
+import { TcpClientComponent } from '@syncbridge/net';
+/**
+ * Retry variables
+ */
+export declare class KafkaRetryVariables {
+    strategy: 'fibonacci' | 'exponential';
+    initialDelay: number;
+    maxDelay: number;
+    maxRetryTime: number;
+    initialRetryTime: number;
+    factor: number;
+    multiplier: number;
+    retries: number;
+}
+/**
+ * SASL variables
+ */
+export declare class KafkaSaslVariables {
+    mechanism: string;
+    username?: string;
+    password?: string;
+    awsAuthorizationIdentity?: string;
+    awsAccessKeyId?: string;
+    awsSecretAccessKey?: string;
+    awsSessionToken?: string;
+}
+/**
+ * Variables
+ */
+export declare class KafkaVariables {
+    brokers: string[];
+    clientId?: string;
+    connectTimeout: number;
+    authenticationTimeout: number;
+    reauthenticationThreshold: number;
+    requestTimeout: number;
+    enforceRequestTimeout: boolean;
+    retry: KafkaRetryVariables;
+    sasl: KafkaSaslVariables;
+    tsl: TcpClientComponent.TlsVariables;
+}

package/components/kafka.variables.js

@@ -0,0 +1,222 @@
+import { __decorate, __metadata } from "tslib";
+import { DefineVariable, VariableType } from '@syncbridge/common';
+import { TcpClientComponent } from '@syncbridge/net';
+/**
+ * Retry variables
+ */
+export class KafkaRetryVariables {
+}
+__decorate([
+    DefineVariable({
+        type: VariableType.Enum,
+        description: 'Reconnection strategy',
+        enumValues: ['fibonacci', 'exponential'],
+        default: 'fibonacci',
+    }),
+    __metadata("design:type", String)
+], KafkaRetryVariables.prototype, "strategy", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Initial delay',
+        description: 'Initial delay in milliseconds',
+        default: 2000,
+    }),
+    __metadata("design:type", Number)
+], KafkaRetryVariables.prototype, "initialDelay", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Maximum delay',
+        description: 'Maximum delay in milliseconds',
+        default: 10000,
+    }),
+    __metadata("design:type", Number)
+], KafkaRetryVariables.prototype, "maxDelay", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Max Retry Time',
+        description: 'Maximum wait time for a retry in milliseconds',
+        default: 30000,
+    }),
+    __metadata("design:type", Number)
+], KafkaRetryVariables.prototype, "maxRetryTime", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Initial Retry Time',
+        description: 'Initial value used to calculate the retry in milliseconds ' +
+            '(This is still randomized following the randomization factor)',
+        default: 300,
+    }),
+    __metadata("design:type", Number)
+], KafkaRetryVariables.prototype, "initialRetryTime", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Factor',
+        description: 'Randomization factor',
+        default: 0.2,
+    }),
+    __metadata("design:type", Number)
+], KafkaRetryVariables.prototype, "factor", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Multiplier',
+        description: 'Exponential factor',
+        default: 2,
+    }),
+    __metadata("design:type", Number)
+], KafkaRetryVariables.prototype, "multiplier", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Retries',
+        description: 'Max number of retries per call',
+        default: 5,
+    }),
+    __metadata("design:type", Number)
+], KafkaRetryVariables.prototype, "retries", void 0);
+/**
+ * SASL variables
+ */
+export class KafkaSaslVariables {
+}
+__decorate([
+    DefineVariable({
+        label: 'Mechanism',
+        description: 'SASL mechanism',
+        type: VariableType.Enum,
+        enumValues: ['plain', 'scram-sha-256', 'scram-sha-512', 'aws'],
+        required: true,
+        default: 'plain',
+    }),
+    __metadata("design:type", String)
+], KafkaSaslVariables.prototype, "mechanism", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Username',
+        description: 'Username. Available for "plain", "scram-sha-256" and "scram-sha-512" mechanisms"',
+    }),
+    __metadata("design:type", String)
+], KafkaSaslVariables.prototype, "username", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Password',
+        description: 'Username. Available for "plain", "scram-sha-256" and "scram-sha-512" mechanisms"',
+        type: VariableType.Secret,
+    }),
+    __metadata("design:type", String)
+], KafkaSaslVariables.prototype, "password", void 0);
+__decorate([
+    DefineVariable({
+        label: 'AWS Authorization Identity',
+        description: 'AWS Authorization Identity. Available for "aws" mechanism',
+        type: VariableType.Secret,
+    }),
+    __metadata("design:type", String)
+], KafkaSaslVariables.prototype, "awsAuthorizationIdentity", void 0);
+__decorate([
+    DefineVariable({
+        label: 'AWS Access Key Id',
+        description: 'AWS Access Key Id. Available for "aws" mechanism',
+        type: VariableType.Secret,
+    }),
+    __metadata("design:type", String)
+], KafkaSaslVariables.prototype, "awsAccessKeyId", void 0);
+__decorate([
+    DefineVariable({
+        label: 'AWS Secret Access Key',
+        description: 'AWS Secret Access Key. Available for "aws" mechanism',
+        type: VariableType.Secret,
+    }),
+    __metadata("design:type", String)
+], KafkaSaslVariables.prototype, "awsSecretAccessKey", void 0);
+__decorate([
+    DefineVariable({
+        label: 'AWS Session Token',
+        description: 'AWS Session Token. Available for "aws" mechanism',
+        type: VariableType.Secret,
+    }),
+    __metadata("design:type", String)
+], KafkaSaslVariables.prototype, "awsSessionToken", void 0);
+/**
+ * Variables
+ */
+export class KafkaVariables {
+}
+__decorate([
+    DefineVariable({
+        label: 'Brokers',
+        description: 'The client must be configured with at least one broker. ' +
+            'The brokers on the list are considered seed brokers and are only used to bootstrap the client and load initial metadata.',
+        type: VariableType.String,
+        isArray: true,
+        required: true,
+    }),
+    __metadata("design:type", Array)
+], KafkaVariables.prototype, "brokers", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Client id',
+        description: 'A logical identifier of an application. Can be used by brokers to apply ' +
+            'quotas or trace requests to a specific application',
+    }),
+    __metadata("design:type", String)
+], KafkaVariables.prototype, "clientId", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Connect timeout',
+        description: 'Time in milliseconds to wait for a successful connection',
+        default: 10000,
+    }),
+    __metadata("design:type", Number)
+], KafkaVariables.prototype, "connectTimeout", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Authentication timeout',
+        description: 'Timeout in ms for authentication requests',
+        default: 10000,
+    }),
+    __metadata("design:type", Number)
+], KafkaVariables.prototype, "authenticationTimeout", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Reauthentication threshold',
+        description: 'Threshold in milliseconds to reauthenticate',
+        default: 10000,
+    }),
+    __metadata("design:type", Number)
+], KafkaVariables.prototype, "reauthenticationThreshold", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Request timeout',
+        description: 'Time in milliseconds to wait for a successful request',
+        default: 30000,
+    }),
+    __metadata("design:type", Number)
+], KafkaVariables.prototype, "requestTimeout", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Enforce request timeout',
+        description: 'Determines if the request timeout should be enforced',
+        default: true,
+    }),
+    __metadata("design:type", Boolean)
+], KafkaVariables.prototype, "enforceRequestTimeout", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Retry',
+        description: 'Retry options',
+    }),
+    __metadata("design:type", KafkaRetryVariables)
+], KafkaVariables.prototype, "retry", void 0);
+__decorate([
+    DefineVariable({
+        label: 'SASL',
+        description: 'SASL authenticate options',
+    }),
+    __metadata("design:type", KafkaSaslVariables)
+], KafkaVariables.prototype, "sasl", void 0);
+__decorate([
+    DefineVariable({
+        label: 'TSL',
+        description: 'TSL options',
+    }),
+    __metadata("design:type", TcpClientComponent.TlsVariables)
+], KafkaVariables.prototype, "tsl", void 0);

package/components.d.ts

@@ -0,0 +1,3 @@
+export * from './components/kafka-base.component.js';
+export * from './components/kafka-consumer.component.js';
+export * from './components/kafka-producer.component.js';

package/components.js

@@ -0,0 +1,3 @@
+export * from './components/kafka-base.component.js';
+export * from './components/kafka-consumer.component.js';
+export * from './components/kafka-producer.component.js';

package/constants.d.ts

@@ -0,0 +1,4 @@
+import { AuthorMetadata } from '@syncbridge/common';
+export declare const version = "1";
+export declare const noOp: () => undefined;
+export declare const panatesAuthor: AuthorMetadata;

package/constants.js

@@ -0,0 +1,7 @@
+export const version = '0.4.1';
+export const noOp = () => undefined;
+export const panatesAuthor = {
+    name: 'Panates Technology AS',
+    email: 'info@panates.com',
+    url: 'https://www.panates.com',
+};

package/index.d.ts

@@ -0,0 +1,5 @@
+import * as components from './components.js';
+export { components };
+export * from './components.js';
+declare const cfg: import("@syncbridge/common").IExtensionPackage;
+export default cfg;

package/index.js

@@ -0,0 +1,9 @@
+import { makeExtensionPackage } from '@syncbridge/common';
+import * as components from './components.js';
+export { components };
+export * from './components.js';
+const cfg = makeExtensionPackage({
+    processors: [],
+    components: Object.values(components),
+});
+export default cfg;

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@syncbridge/kafka",
+  "version": "0.4.1",
+  "description": "SyncBridge Kafka connection components",
+  "author": "Panates Inc",
+  "license": "UNLICENSED",
+  "dependencies": {
+    "ansi-colors": "^4.1.3",
+    "kafkajs": "^2.2.4",
+    "node-events-async": "^1.5.0",
+    "oracledb": "^6.10.0"
+  },
+  "peerDependencies": {
+    "@syncbridge/common": "^0.4.1",
+    "@syncbridge/builtins": "^0.4.1",
+    "@syncbridge/net": "^0.4.1",
+    "@sqb/builder": ">=4.19.6 <5",
+    "@sqb/connect": ">=4.19.6 <5"
+  },
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "type": "module",
+  "module": "./index.js",
+  "types": "./index.d.ts",
+  "engines": {
+    "node": ">=20.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}