@syncbridge/net 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/classes/tcp-client.d.ts

@@ -0,0 +1,48 @@
+import { Buffer } from 'node:buffer';
+import net from 'node:net';
+import tls from 'node:tls';
+import { Backoff } from 'backoff';
+import { AsyncEventEmitter, EventMap } from 'node-events-async';
+import reconnectCore from 'reconnect-core';
+export declare class TcpClient<T extends TcpClient.Events = TcpClient.Events> extends AsyncEventEmitter<EventMap<T>> {
+    protected _connectionManager?: ReturnType<typeof socketReconnect>;
+    protected _socket?: net.Socket;
+    host: string;
+    port: number;
+    connectTimeout?: number;
+    reconnectOptions: TcpClient.ReconnectOptions;
+    constructor(args?: TcpClient.Options);
+    get connected(): boolean;
+    get socket(): net.Socket | undefined;
+    connect(): void;
+    disconnect(): Promise<void>;
+    write(data: string | Buffer): void;
+}
+export declare namespace TcpClient {
+    interface Options {
+        host: string;
+        port: number;
+        connectTimeout?: number;
+        keepAlive?: boolean;
+        reconnect?: ReconnectOptions;
+        tls?: tls.TlsOptions;
+    }
+    interface ReconnectOptions {
+        strategy?: 'fibonacci' | 'exponential' | Backoff;
+        immediate?: boolean | undefined;
+        failAfter?: number | undefined;
+        randomisationFactor?: number | undefined;
+        initialDelay?: number | undefined;
+        maxDelay?: number | undefined;
+    }
+    interface Events {
+        connect: [socket: net.Socket];
+        disconnect: [error: Error | undefined];
+        reconnecting: [n: number, delay: number];
+        reconnect: [socket: net.Socket];
+        data: [data: Buffer];
+        error: [error: Error];
+    }
+}
+declare const socketReconnect: reconnectCore.CustomModule<net.NetConnectOpts, net.Socket>;
+export {};

package/classes/tcp-client.js

@@ -0,0 +1,131 @@
+import net from 'node:net';
+import { AsyncEventEmitter } from 'node-events-async';
+import reconnectCore from 'reconnect-core';
+export class TcpClient extends AsyncEventEmitter {
+    _connectionManager;
+    _socket;
+    host;
+    port;
+    connectTimeout;
+    reconnectOptions;
+    constructor(args) {
+        super();
+        this.reconnectOptions = args?.reconnect || {};
+        this.reconnectOptions.initialDelay =
+            this.reconnectOptions.initialDelay ?? 2000;
+        this.reconnectOptions.maxDelay = this.reconnectOptions.maxDelay ?? 10000;
+        this.reconnectOptions.strategy =
+            this.reconnectOptions.strategy ?? 'fibonacci';
+        this.host = args?.host || 'localhost';
+        this.port = args?.port || 0;
+        this.connectTimeout = args?.connectTimeout;
+    }
+    get connected() {
+        return !!this._connectionManager?.connected;
+    }
+    get socket() {
+        return this._socket;
+    }
+    connect() {
+        if (this.connected)
+            return;
+        let reconnecting = false;
+        const connectionManager = (this._connectionManager = socketReconnect({
+            ...this.reconnectOptions,
+            timeout: this.connectTimeout,
+        })
+            .on('error', (error) => {
+            if (!connectionManager.reconnect)
+                return;
+            error = error instanceof AggregateError ? error.errors[0] : error;
+            if (error.code === 'ECONNREFUSED')
+                error.message = `Connection refused to ${error.address}:${error.port}`;
+            this.emit('error', error);
+        })
+            .on('connect', (socket) => {
+            if (this._socket !== socket) {
+                this._socket = socket;
+                socket.on('data', (chunk) => this.emit('data', chunk));
+            }
+            if (reconnecting)
+                this.emit('reconnect', socket);
+            reconnecting = false;
+            this.emit('connect', socket);
+        })
+            .on('reconnect', (n, delay) => {
+            if (n === 0 && delay === 0)
+                return;
+            reconnecting = true;
+            this.emit('reconnecting', n, delay);
+        })
+            .on('disconnect', err => {
+            this._socket = undefined;
+            if (connectionManager.reconnect) {
+                if (err)
+                    err.message = `TCP socket connection lost: ${err.message}`;
+                else
+                    err = new Error('TCP socket connection lost');
+                this.emit('disconnect', err);
+            }
+            else
+                this.emit('disconnect');
+        }));
+        connectionManager.connect({
+            host: this.host,
+            port: this.port,
+            timeout: this.connectTimeout,
+            // keepAlive: this.
+        });
+    }
+    async disconnect() {
+        if (!this._connectionManager)
+            return;
+        const connectionManager = this._connectionManager;
+        this._connectionManager = undefined;
+        /** istanbul ignore else */
+        if (connectionManager.connected) {
+            connectionManager.reconnect = false;
+            return new Promise(resolve => {
+                connectionManager.once('disconnect', async () => {
+                    connectionManager.reset();
+                    this._connectionManager = undefined;
+                    resolve();
+                });
+                connectionManager.disconnect();
+                connectionManager.reset();
+            });
+        }
+        else {
+            connectionManager.disconnect();
+            connectionManager.reset();
+        }
+    }
+    write(data) {
+        if (!this._socket)
+            throw new Error(`Can't write while TCP socket is not connected`);
+        this._socket.write(data);
+    }
+}
+const socketReconnect = reconnectCore(args => {
+    // implement tls
+    const socket = net.connect({
+        ...args,
+        timeout: undefined,
+    });
+    if (args.timeout) {
+        const timer = setTimeout(() => {
+            socket.destroy(new Error('Connection timed out'));
+        }, args.timeout).unref();
+        const onConnect = () => {
+            clearTimeout(timer);
+            socket.removeListener('error', onError);
+        };
+        const onError = () => {
+            socket.removeListener('connect', onConnect);
+            clearTimeout(timer);
+        };
+        socket.once('connect', onConnect);
+        socket.once('error', onError);
+    }
+    return socket;
+});

package/components/tcp-client.component.d.ts

@@ -0,0 +1,35 @@
+import { Buffer } from 'node:buffer';
+import { IoClientBaseComponent } from '@syncbridge/builtins';
+import { TcpClient } from '../classes/tcp-client.js';
+import { TcpClientReconnectVariables, TcpClientTlsVariables, TcpClientVariables } from './tcp-client.variables.js';
+/**
+ * TcpClient component
+ */
+export declare class TcpClientComponent<TEvents extends TcpClientComponent.Events = TcpClientComponent.Events> extends IoClientBaseComponent<TEvents> {
+    readonly protocol: string;
+    protected _client: TcpClient;
+    protected _stopping?: boolean;
+    protected _address?: any;
+    values: TcpClientVariables;
+    get connected(): boolean;
+    protected _init(): Promise<void>;
+    protected _start(abortSignal: AbortSignal): Promise<void>;
+    protected _stop(): Promise<void>;
+    write(data: string | Buffer): void;
+}
+/**
+ * @namespace
+ */
+export declare namespace TcpClientComponent {
+    interface Events extends IoClientBaseComponent.Events {
+        connect: [];
+        disconnect: [error: Error | undefined];
+        reconnecting: [n: number, delay: number];
+    }
+    const Variables: typeof TcpClientVariables;
+    type Variables = TcpClientVariables;
+    const ReconnectVariables: typeof TcpClientReconnectVariables;
+    type ReconnectVariables = TcpClientReconnectVariables;
+    const TlsVariables: typeof TcpClientTlsVariables;
+    type TlsVariables = TcpClientTlsVariables;
+}

package/components/tcp-client.component.js

@@ -0,0 +1,102 @@
+import { __decorate, __metadata } from "tslib";
+import { IoClientBaseComponent } from '@syncbridge/builtins';
+import { Component, ServiceStatus } from '@syncbridge/common';
+import colors from 'ansi-colors';
+import { TcpClient } from '../classes/tcp-client.js';
+import { TcpClientReconnectVariables, TcpClientTlsVariables, TcpClientVariables, } from './tcp-client.variables.js';
+/**
+ * TcpClient component
+ */
+let TcpClientComponent = class TcpClientComponent extends IoClientBaseComponent {
+    protocol = 'tcp';
+    _stopping;
+    _address;
+    get connected() {
+        return this._client.connected;
+    }
+    async _init() {
+        await super._init();
+        this._client = new TcpClient({
+            host: this.values.host || 'localhost',
+            port: this.values.port || 0,
+            connectTimeout: this.values.connectTimeout,
+            keepAlive: this.values.keepAlive,
+            reconnect: this.values.reconnect,
+            tls: this.values.tls,
+        });
+        /* On connect */
+        this._client.on('connect', (socket) => {
+            this._address = { ...socket.address() };
+            this._address.toString = function () {
+                return `${this.address}:${this.port}`;
+            }.bind(this._address);
+            setImmediate(() => {
+                this.logger?.info(`TCP socket connected to ${colors.cyan(this._client.host + ':' + this._client.port)}`);
+                this.setStatus(ServiceStatus.started);
+                this.emit('connect');
+            });
+        });
+        /* On disconnect */
+        this._client.on('disconnect', (err) => {
+            if (this._stopping)
+                this.emit('disconnect');
+            else {
+                err = err || new Error('TCP socket disconnected');
+                this.logger?.error(err);
+                this.setStatus(ServiceStatus.unhealthy, err.message);
+                this.emit('disconnect');
+            }
+        });
+        /* On data */
+        this._client.on('data', (chunk) => {
+            this.emit('data', chunk, this._address);
+        });
+        /* On error */
+        this._client.on('error', (err) => {
+            this.emit('error', err);
+        });
+        /* On reconnecting */
+        this._client.on('reconnecting', (n, delay) => {
+            this.logger?.error(`Connection failed (${colors.cyan(String(n + 1))}). Will be retried after ${colors.cyan(delay + 'ms')}`);
+            this.emit('reconnecting', n, delay);
+        });
+    }
+    async _start(abortSignal) {
+        await super._start(abortSignal);
+        this._stopping = false;
+        this.logger?.info(`TCP socket connecting to ${colors.cyan(this._client.host + ':' + this._client.port)}`);
+        this._client.connect();
+    }
+    async _stop() {
+        this._stopping = true;
+        await this._client.disconnect();
+    }
+    write(data) {
+        if (!this.connected) {
+            throw new Error(`Can't write while TCP socket is not connected`);
+        }
+        this.emit('transmit', data, this._address);
+        this._client.write(data);
+    }
+};
+__decorate([
+    Component.UseVariables(),
+    __metadata("design:type", TcpClientVariables)
+], TcpClientComponent.prototype, "values", void 0);
+TcpClientComponent = __decorate([
+    Component({
+        className: 'TcpClient',
+        displayName: 'TCP Client',
+        description: 'TCP client component',
+        tags: ['tcp', 'client', 'socket', 'connection'],
+    })
+], TcpClientComponent);
+export { TcpClientComponent };
+/**
+ * @namespace
+ */
+(function (TcpClientComponent) {
+    TcpClientComponent.Variables = TcpClientVariables;
+    TcpClientComponent.ReconnectVariables = TcpClientReconnectVariables;
+    TcpClientComponent.TlsVariables = TcpClientTlsVariables;
+})(TcpClientComponent || (TcpClientComponent = {}));

package/components/tcp-client.variables.d.ts

@@ -0,0 +1,31 @@
+import { IoClientBaseComponent } from '@syncbridge/builtins';
+/**
+ * TLS variables
+ */
+export declare class TcpClientTlsVariables {
+    servername?: string;
+    key: string;
+    cert: string;
+    ca?: string;
+    passphrase?: string;
+    rejectUnauthorized: boolean;
+}
+/**
+ * Reconnect variables
+ */
+export declare class TcpClientReconnectVariables {
+    strategy: 'exponential' | 'fibonacci';
+    initialDelay: number;
+    maxDelay: number;
+}
+/**
+ * Variables
+ */
+export declare class TcpClientVariables extends IoClientBaseComponent.Variables {
+    host: string;
+    port: number;
+    keepAlive: boolean;
+    connectTimeout: number;
+    reconnect: TcpClientReconnectVariables;
+    tls: TcpClientTlsVariables;
+}

package/components/tcp-client.variables.js

@@ -0,0 +1,140 @@
+import { __decorate, __metadata } from "tslib";
+import { IoClientBaseComponent } from '@syncbridge/builtins';
+import { DefineVariable, VariableType } from '@syncbridge/common';
+/**
+ * TLS variables
+ */
+export class TcpClientTlsVariables {
+}
+__decorate([
+    DefineVariable({
+        label: 'SNI',
+        description: 'SNI (Server Name Indication)',
+    }),
+    __metadata("design:type", String)
+], TcpClientTlsVariables.prototype, "servername", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Key',
+        description: 'Private keys in PEM format',
+        required: true,
+    }),
+    __metadata("design:type", String)
+], TcpClientTlsVariables.prototype, "key", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Cert',
+        description: 'Cert chains in PEM format',
+        required: true,
+    }),
+    __metadata("design:type", String)
+], TcpClientTlsVariables.prototype, "cert", void 0);
+__decorate([
+    DefineVariable({
+        label: 'CA certificates',
+        description: 'Optionally override the trusted CA certificates. Default is to trust the well-known CAs ' +
+            "curated by Mozilla. Mozilla's CAs are completely replaced when CAs are explicitly specified " +
+            'using this option.',
+        required: true,
+    }),
+    __metadata("design:type", String)
+], TcpClientTlsVariables.prototype, "ca", void 0);
+__decorate([
+    DefineVariable({
+        type: VariableType.Secret,
+        label: 'Passphrase',
+        description: 'Passphrase to decrypt the private key',
+    }),
+    __metadata("design:type", String)
+], TcpClientTlsVariables.prototype, "passphrase", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Reject unauthorized',
+        description: 'If true will reject any connection which is not authorized with the list of supplied CAs',
+        default: true,
+    }),
+    __metadata("design:type", Boolean)
+], TcpClientTlsVariables.prototype, "rejectUnauthorized", void 0);
+/**
+ * Reconnect variables
+ */
+export class TcpClientReconnectVariables {
+}
+__decorate([
+    DefineVariable({
+        type: VariableType.Enum,
+        label: 'Reconnection strategy',
+        enumValues: ['exponential', 'fibonacci'],
+        default: 'exponential',
+    }),
+    __metadata("design:type", String)
+], TcpClientReconnectVariables.prototype, "strategy", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Initial delay',
+        description: 'Initial delay in milliseconds',
+        default: 2000,
+    }),
+    __metadata("design:type", Number)
+], TcpClientReconnectVariables.prototype, "initialDelay", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Maximum delay',
+        description: 'Maximum delay in milliseconds',
+        default: 10000,
+    }),
+    __metadata("design:type", Number)
+], TcpClientReconnectVariables.prototype, "maxDelay", void 0);
+/**
+ * Variables
+ */
+export class TcpClientVariables extends IoClientBaseComponent.Variables {
+}
+__decorate([
+    DefineVariable({
+        label: 'Host',
+        description: 'Hostname or IP address to be connected to',
+        required: true,
+    }),
+    __metadata("design:type", String)
+], TcpClientVariables.prototype, "host", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Port',
+        description: 'Port number of target listener',
+        required: true,
+        minValue: 1,
+        maxValue: 65535,
+    }),
+    __metadata("design:type", Number)
+], TcpClientVariables.prototype, "port", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Keep alive',
+        description: 'Enables keep-alive on the TCP socket',
+        default: false,
+    }),
+    __metadata("design:type", Boolean)
+], TcpClientVariables.prototype, "keepAlive", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Connect timeout',
+        description: 'Connection timeout in milliseconds',
+        default: 10000,
+    }),
+    __metadata("design:type", Number)
+], TcpClientVariables.prototype, "connectTimeout", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Reconnect',
+        description: 'Reconnect options',
+    }),
+    __metadata("design:type", TcpClientReconnectVariables)
+], TcpClientVariables.prototype, "reconnect", void 0);
+__decorate([
+    DefineVariable({
+        label: 'TLS',
+        description: 'TLS options',
+    }),
+    __metadata("design:type", TcpClientTlsVariables)
+], TcpClientVariables.prototype, "tls", void 0);

package/components/tcp-server.component.d.ts

@@ -0,0 +1,23 @@
+import { IoClientBaseComponent } from '@syncbridge/builtins';
+import { ComponentBase } from '@syncbridge/common';
+import { TcpServerTlsVariables, TcpServerVariables } from './tcp-server.variables.js';
+/**
+ * TcpServer component
+ * todo
+ */
+export declare class TcpServerComponent<TEvents extends TcpServerComponent.Events = TcpServerComponent.Events> extends ComponentBase<TEvents> {
+    values: TcpServerVariables;
+    protected _start(abortSignal: AbortSignal): Promise<void>;
+    protected _stop(): Promise<void>;
+}
+/**
+ * @namespace
+ */
+export declare namespace TcpServerComponent {
+    interface Events extends IoClientBaseComponent.Events {
+    }
+    const Variables: typeof TcpServerVariables;
+    type Variables = TcpServerVariables;
+    const TlsVariables: typeof TcpServerTlsVariables;
+    type TlsVariables = TcpServerTlsVariables;
+}

package/components/tcp-server.component.js

@@ -0,0 +1,32 @@
+import { __decorate, __metadata } from "tslib";
+import { Component, ComponentBase } from '@syncbridge/common';
+import { TcpServerTlsVariables, TcpServerVariables, } from './tcp-server.variables.js';
+/**
+ * TcpServer component
+ * todo
+ */
+let TcpServerComponent = class TcpServerComponent extends ComponentBase {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _start(abortSignal) { }
+    async _stop() { }
+};
+__decorate([
+    Component.UseVariables(),
+    __metadata("design:type", TcpServerVariables)
+], TcpServerComponent.prototype, "values", void 0);
+TcpServerComponent = __decorate([
+    Component({
+        className: 'TcpServer',
+        displayName: 'TCP Server',
+        description: 'TCP server component',
+        tags: ['tcp', 'server', 'socket'],
+    })
+], TcpServerComponent);
+export { TcpServerComponent };
+/**
+ * @namespace
+ */
+(function (TcpServerComponent) {
+    TcpServerComponent.Variables = TcpServerVariables;
+    TcpServerComponent.TlsVariables = TcpServerTlsVariables;
+})(TcpServerComponent || (TcpServerComponent = {}));

package/components/tcp-server.variables.d.ts

@@ -0,0 +1,16 @@
+import { TransmitLogger } from '@syncbridge/builtins';
+import { TcpClientTlsVariables } from './tcp-client.variables.js';
+/**
+ * TLS variables
+ */
+export declare class TcpServerTlsVariables extends TcpClientTlsVariables {
+    requestCert: boolean;
+}
+/**
+ * Variables
+ */
+export declare class TcpServerVariables {
+    port: number;
+    tls: TcpServerTlsVariables;
+    communicationLogs?: TransmitLogger.Variables;
+}

package/components/tcp-server.variables.js

@@ -0,0 +1,46 @@
+import { __decorate, __metadata } from "tslib";
+import { TransmitLogger } from '@syncbridge/builtins';
+import { DefineVariable } from '@syncbridge/common';
+import { TcpClientTlsVariables } from './tcp-client.variables.js';
+/**
+ * TLS variables
+ */
+export class TcpServerTlsVariables extends TcpClientTlsVariables {
+}
+__decorate([
+    DefineVariable({
+        label: 'Request cert',
+        description: 'If true the server will request a certificate from clients that connect and attempt to verify that certificate',
+        default: false,
+    }),
+    __metadata("design:type", Boolean)
+], TcpServerTlsVariables.prototype, "requestCert", void 0);
+/**
+ * Variables
+ */
+export class TcpServerVariables {
+}
+__decorate([
+    DefineVariable({
+        label: 'Port',
+        description: 'Port number to be listen',
+        required: true,
+        minValue: 1,
+        maxValue: 65535,
+    }),
+    __metadata("design:type", Number)
+], TcpServerVariables.prototype, "port", void 0);
+__decorate([
+    DefineVariable({
+        label: 'TLS',
+        description: 'TLS options',
+    }),
+    __metadata("design:type", TcpServerTlsVariables)
+], TcpServerVariables.prototype, "tls", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Communication Logs',
+        description: 'Stores communication logs if enabled',
+    }),
+    __metadata("design:type", TransmitLogger.Variables)
+], TcpServerVariables.prototype, "communicationLogs", void 0);

package/components/udp-client.component.d.ts

@@ -0,0 +1,29 @@
+import { Buffer } from 'node:buffer';
+import dgram from 'node:dgram';
+import { IoClientBaseComponent } from '@syncbridge/builtins';
+import { UdpClientVariables } from './udp-client.variables.js';
+/**
+ * UdpClient component
+ */
+export declare class UdpClientComponent<TEvents extends UdpClientComponent.Events = UdpClientComponent.Events> extends IoClientBaseComponent<TEvents> {
+    readonly protocol: string;
+    socket: dgram.Socket & {
+        readonly isBroadcastEnabled: boolean;
+    };
+    protected _stopping?: boolean;
+    values: UdpClientVariables;
+    protected _start(abortSignal: AbortSignal): Promise<void>;
+    protected _stop(): Promise<void>;
+    write(data: string | Buffer, port?: number, host?: string): void;
+}
+/**
+ * @namespace
+ */
+export declare namespace UdpClientComponent {
+    interface Events extends IoClientBaseComponent.Events {
+        data: [data: Buffer, info: dgram.RemoteInfo];
+        write: [data: Buffer | string];
+    }
+    const Variables: typeof UdpClientVariables;
+    type Variables = UdpClientVariables;
+}

package/components/udp-client.component.js

@@ -0,0 +1,119 @@
+import { __decorate, __metadata } from "tslib";
+import dgram from 'node:dgram';
+import { IoClientBaseComponent } from '@syncbridge/builtins';
+import { Component, ServiceStatus } from '@syncbridge/common';
+import { UdpClientVariables } from './udp-client.variables.js';
+/**
+ * UdpClient component
+ */
+let UdpClientComponent = class UdpClientComponent extends IoClientBaseComponent {
+    protocol = 'udp';
+    _stopping;
+    async _start(abortSignal) {
+        await super._start(abortSignal);
+        this._stopping = false;
+        this.socket = dgram.createSocket('udp4');
+        let isBroadcastEnabled = false;
+        Object.defineProperty(this.socket, 'isBroadcastEnabled', {
+            get() {
+                return isBroadcastEnabled;
+            },
+        });
+        const oldSetBroadcast = this.socket.setBroadcast;
+        this.socket.setBroadcast = (value) => {
+            isBroadcastEnabled = value;
+            oldSetBroadcast.call(this.socket, value);
+        };
+        this.socket.on('connect', () => {
+            this.emit('connect');
+            this.setStatus(ServiceStatus.started);
+        });
+        this.socket.on('listening', () => {
+            const { bindInterface } = this.values;
+            const port = this.socket.address().port;
+            this.emit('listening', port);
+            this.logger?.info(`UDP socket listening on port ${port}` +
+                (bindInterface ? ` interface ${bindInterface}` : ''));
+            this.setStatus(ServiceStatus.started);
+        });
+        this.socket.on('message', (msg, info) => {
+            if (info.address === '127.0.0.1')
+                return;
+            // todo logger
+            // this.logger.debug(
+            //   `Data received from ${colors.cyan(info.address + ':' + info.port)} (${msg.length} bytes)`,
+            //   {
+            //     host: info.address,
+            //     port: info.port,
+            //     size: msg.length,
+            //   },
+            // );
+            const info2 = {
+                ...info,
+                toString() {
+                    return `${this.address}:${this.port}`;
+                },
+            };
+            this.emit('data', msg, info2);
+        });
+        if (this.values.bindInterface) {
+            this.socket.bind(this.values.port || 0, this.values.bindInterface);
+        }
+        if (this.values.port) {
+            this.socket.connect(this.values.port, this.values.host);
+        }
+        else
+            this.setStatus(ServiceStatus.started);
+    }
+    async _stop() {
+        this._stopping = true;
+        await new Promise(resolve => {
+            this.socket.close(resolve);
+            this._stopping = false;
+        });
+    }
+    write(data, port, host) {
+        host = host || this.values.host;
+        port = port || this.values.port;
+        if (!host)
+            throw new Error('You must provide "host" variable to send message over UDP socket');
+        this.socket.send(data, port, host);
+        const info2 = {
+            address: host,
+            port: port,
+            size: data.length,
+            toString() {
+                return `${this.address}:${this.port}`;
+            },
+        };
+        this.emit('transmit', data, info2);
+        // todo logger
+        // if (this.socket.isBroadcastEnabled)
+        //   this.logger.debug(
+        //     `Broadcast message sent ${colors.cyan(host + ':' + port)} (${data.length} bytes)`,
+        //   );
+        // else
+        //   this.logger.debug(
+        //     `Message sent to ${colors.cyan(host + ':' + port)} (${data.length} bytes)`,
+        //   );
+    }
+};
+__decorate([
+    Component.UseVariables(),
+    __metadata("design:type", UdpClientVariables)
+], UdpClientComponent.prototype, "values", void 0);
+UdpClientComponent = __decorate([
+    Component({
+        className: 'UdpClient',
+        displayName: 'UDP Client',
+        description: 'UDP client component',
+        tags: ['udp', 'client', 'socket', 'connection'],
+    })
+], UdpClientComponent);
+export { UdpClientComponent };
+/**
+ * @namespace
+ */
+(function (UdpClientComponent) {
+    UdpClientComponent.Variables = UdpClientVariables;
+})(UdpClientComponent || (UdpClientComponent = {}));

package/components/udp-client.variables.d.ts

@@ -0,0 +1,10 @@
+import { IoClientBaseComponent } from '@syncbridge/builtins';
+/**
+ * Variables
+ */
+export declare class UdpClientVariables extends IoClientBaseComponent.Variables {
+    port?: number;
+    host?: string;
+    bindInterface?: string;
+}
+export declare function getInterfaceAddresses(): string[];

package/components/udp-client.variables.js

@@ -0,0 +1,48 @@
+import { __decorate, __metadata } from "tslib";
+import os from 'node:os';
+import { IoClientBaseComponent } from '@syncbridge/builtins';
+import { DefineVariable, VariableType } from '@syncbridge/common';
+/**
+ * Variables
+ */
+export class UdpClientVariables extends IoClientBaseComponent.Variables {
+}
+__decorate([
+    DefineVariable({
+        label: 'Port',
+        description: 'Port number of target listener',
+        minValue: 1,
+        maxValue: 65535,
+    }),
+    __metadata("design:type", Number)
+], UdpClientVariables.prototype, "port", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Host',
+        description: 'Hostname or IP address which udp messages will send to',
+    }),
+    __metadata("design:type", String)
+], UdpClientVariables.prototype, "host", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Bind Interface',
+        description: 'Interface address to bind to. If not specified, will bind to all available addresses',
+        type: VariableType.Enum,
+        enumValues: getInterfaceAddresses(),
+    }),
+    __metadata("design:type", String)
+], UdpClientVariables.prototype, "bindInterface", void 0);
+export function getInterfaceAddresses() {
+    const interfaces = os.networkInterfaces();
+    const addresses = [];
+    for (const ifaces of Object.values(interfaces)) {
+        if (!ifaces)
+            continue;
+        for (const iface of ifaces) {
+            if (iface.family === 'IPv4' && !iface.internal) {
+                addresses.push(iface.address);
+            }
+        }
+    }
+    return addresses;
+}

package/components/udp-listener.component.d.ts

@@ -0,0 +1,29 @@
+import { Buffer } from 'node:buffer';
+import dgram from 'node:dgram';
+import { IoClientBaseComponent } from '@syncbridge/builtins';
+import { UdpListenerVariables } from './udp-listener.variables.js';
+/**
+ * UdpClient component
+ */
+export declare class UdpListenerComponent<TEvents extends UdpListenerComponent.Events = UdpListenerComponent.Events> extends IoClientBaseComponent<TEvents> {
+    readonly protocol: string;
+    socket: dgram.Socket & {
+        readonly isBroadcastEnabled: boolean;
+    };
+    protected _stopping?: boolean;
+    values: UdpListenerVariables;
+    protected _start(abortSignal: AbortSignal): Promise<void>;
+    protected _stop(): Promise<void>;
+    write(data: string | Buffer, port?: number, host?: string): void;
+}
+/**
+ * @namespace
+ */
+export declare namespace UdpListenerComponent {
+    interface Events extends IoClientBaseComponent.Events {
+        data: [data: Buffer, info: dgram.RemoteInfo];
+        write: [data: Buffer | string];
+    }
+    const Variables: typeof UdpListenerVariables;
+    type Variables = UdpListenerVariables;
+}

package/components/udp-listener.component.js

@@ -0,0 +1,116 @@
+import { __decorate, __metadata } from "tslib";
+import dgram from 'node:dgram';
+import { IoClientBaseComponent } from '@syncbridge/builtins';
+import { Component, ServiceStatus } from '@syncbridge/common';
+import { UdpListenerVariables } from './udp-listener.variables.js';
+/**
+ * UdpClient component
+ */
+let UdpListenerComponent = class UdpListenerComponent extends IoClientBaseComponent {
+    protocol = 'udp';
+    _stopping;
+    async _start(abortSignal) {
+        await super._start(abortSignal);
+        this._stopping = false;
+        this.socket = dgram.createSocket('udp4');
+        let isBroadcastEnabled = false;
+        Object.defineProperty(this.socket, 'isBroadcastEnabled', {
+            get() {
+                return isBroadcastEnabled;
+            },
+        });
+        const oldSetBroadcast = this.socket.setBroadcast;
+        this.socket.setBroadcast = (value) => {
+            isBroadcastEnabled = value;
+            oldSetBroadcast.call(this.socket, value);
+        };
+        this.socket.on('listening', () => {
+            const { bindInterface, multicastInterface } = this.values;
+            if (this.values.broadcast) {
+                this.logger?.debug(`Broadcast mode enabled`);
+                this.socket.setBroadcast(true);
+            }
+            if (this.values.multicastGroups)
+                this.values.multicastGroups.forEach(group => {
+                    this.logger?.debug(`Joining multicast group ${group}`);
+                    this.socket.addMembership(group, multicastInterface);
+                });
+            const port = this.socket.address().port;
+            this.emit('listening', port);
+            this.logger?.info(`UDP socket listening on port ${port}` +
+                (bindInterface ? ` interface ${bindInterface}` : ''));
+            this.setStatus(ServiceStatus.started);
+        });
+        this.socket.on('message', (msg, info) => {
+            if (info.address === '127.0.0.1')
+                return;
+            // todo logger
+            // this.logger.debug(
+            //   `Data received from ${colors.cyan(info.address + ':' + info.port)} (${msg.length} bytes)`,
+            //   {
+            //     host: info.address,
+            //     port: info.port,
+            //     size: msg.length,
+            //   },
+            // );
+            const info2 = {
+                ...info,
+                toString() {
+                    return `${this.address}:${this.port}`;
+                },
+            };
+            this.emit('data', msg, info2);
+        });
+        this.socket.bind(this.values.port, this.values.bindInterface || '0.0.0.0');
+    }
+    async _stop() {
+        this._stopping = true;
+        await new Promise(resolve => {
+            this.socket.close(resolve);
+            this._stopping = false;
+        });
+    }
+    write(data, port, host) {
+        port = port || this.values.port;
+        if (!host)
+            throw new Error('You must provide "host" variable to send message over UDP socket');
+        this.socket.send(data, port, host);
+        const info2 = {
+            address: host,
+            port: port,
+            size: data.length,
+            toString() {
+                return `${this.address}:${this.port}`;
+            },
+        };
+        this.emit('transmit', data, info2);
+        // todo logger
+        // if (this.socket.isBroadcastEnabled)
+        //   this.logger.debug(
+        //     `Broadcast message sent ${colors.cyan(host + ':' + port)} (${data.length} bytes)`,
+        //   );
+        // else
+        //   this.logger.debug(
+        //     `Message sent to ${colors.cyan(host + ':' + port)} (${data.length} bytes)`,
+        //   );
+    }
+};
+__decorate([
+    Component.UseVariables(),
+    __metadata("design:type", UdpListenerVariables)
+], UdpListenerComponent.prototype, "values", void 0);
+UdpListenerComponent = __decorate([
+    Component({
+        className: 'UdpListener',
+        displayName: 'UDP Listener',
+        description: 'UDP listener component',
+        tags: ['udp', 'server', 'connection'],
+    })
+], UdpListenerComponent);
+export { UdpListenerComponent };
+/**
+ * @namespace
+ */
+(function (UdpListenerComponent) {
+    UdpListenerComponent.Variables = UdpListenerVariables;
+})(UdpListenerComponent || (UdpListenerComponent = {}));

package/components/udp-listener.variables.d.ts

@@ -0,0 +1,11 @@
+import { IoClientBaseComponent } from '@syncbridge/builtins';
+/**
+ * Variables
+ */
+export declare class UdpListenerVariables extends IoClientBaseComponent.Variables {
+    port: number;
+    broadcast?: boolean;
+    multicastGroups?: string[];
+    bindInterface?: string;
+    multicastInterface?: string;
+}

package/components/udp-listener.variables.js

@@ -0,0 +1,53 @@
+import { __decorate, __metadata } from "tslib";
+import { IoClientBaseComponent } from '@syncbridge/builtins';
+import { DefineVariable, VariableType } from '@syncbridge/common';
+import { getInterfaceAddresses } from './udp-client.variables.js';
+/**
+ * Variables
+ */
+export class UdpListenerVariables extends IoClientBaseComponent.Variables {
+}
+__decorate([
+    DefineVariable({
+        label: 'Port',
+        description: 'Port number of target listener',
+        required: true,
+        minValue: 1,
+        maxValue: 65535,
+    }),
+    __metadata("design:type", Number)
+], UdpListenerVariables.prototype, "port", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Broadcast',
+        description: "Sets the SO_BROADCAST socket option. When set to true, UDP packets may be sent to a local interface's broadcast address.",
+    }),
+    __metadata("design:type", Boolean)
+], UdpListenerVariables.prototype, "broadcast", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Multicast Groups',
+        description: 'Multicast groups to be joined',
+        type: VariableType.String,
+        isArray: true,
+    }),
+    __metadata("design:type", Array)
+], UdpListenerVariables.prototype, "multicastGroups", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Bind Interface',
+        description: 'Interface address to bind to. If not specified, will bind to all available addresses',
+        type: VariableType.Enum,
+        enumValues: getInterfaceAddresses(),
+    }),
+    __metadata("design:type", String)
+], UdpListenerVariables.prototype, "bindInterface", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Multicast Interface',
+        description: 'Interface address to bind for multicast packages',
+        type: VariableType.Enum,
+        enumValues: getInterfaceAddresses(),
+    }),
+    __metadata("design:type", String)
+], UdpListenerVariables.prototype, "multicastInterface", void 0);

package/components.d.ts

@@ -0,0 +1,4 @@
+export * from './components/tcp-client.component.js';
+export * from './components/tcp-server.component.js';
+export * from './components/udp-client.component.js';
+export * from './components/udp-listener.component.js';

package/components.js

@@ -0,0 +1,4 @@
+export * from './components/tcp-client.component.js';
+export * from './components/tcp-server.component.js';
+export * from './components/udp-client.component.js';
+export * from './components/udp-listener.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,51 @@
+{
+  "name": "@syncbridge/net",
+  "version": "0.4.1",
+  "description": "SyncBridge builtin net (socket) extensions",
+  "author": "Panates Inc",
+  "license": "UNLICENSED",
+  "dependencies": {
+    "@ngrok/ngrok": "^1.7.0",
+    "@pinggy/pinggy": "^0.3.2",
+    "@serialport/bindings-interface": "^1.2.2",
+    "@sqb/connect": "^4.19.6",
+    "@sqb/oracle": "^4.21.1",
+    "@sqb/postgres": "^4.21.1",
+    "ansi-colors": "^4.1.3",
+    "backoff": "^2.5.0",
+    "date-fns": "^4.1.0",
+    "fast-tokenizer": "^1.9.0",
+    "file-stream-rotator": "^1.0.0",
+    "hl7v2": "^1.7.0",
+    "hl7v2-net": "^1.7.0",
+    "kafkajs": "^2.2.4",
+    "lightning-pool": "^4.12.0",
+    "node-events-async": "^1.5.0",
+    "oracledb": "^6.10.0",
+    "putil-varhelpers": "^1.7.0",
+    "reconnect-core": "^1.3.0",
+    "serialport": "^13.0.0"
+  },
+  "peerDependencies": {
+    "@syncbridge/common": "^0.4.1",
+    "@syncbridge/builtins": "^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"
+  }
+}