@syncbridge/builtins 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 Builtin Components

package/classes/transmit-logger.d.ts

@@ -0,0 +1,34 @@
+import { EventEmitter } from 'node:events';
+import { getStream } from 'file-stream-rotator';
+export declare class TransmitLogger extends EventEmitter {
+    protected _stream?: ReturnType<typeof getStream>;
+    readonly name: string;
+    useBase64: boolean;
+    constructor(options: TransmitLogger.Options);
+    received(content: Buffer | string, peer?: string): void;
+    transmitted(content: Buffer | string, peer?: string): void;
+    info(content: string, peer?: string): void;
+    protected _write(direction: string, content: Buffer | string, peer?: string): void;
+    protected _getHeader(direction: string, contentSize: number, peer?: string): string;
+}
+/**
+ * Variables
+ */
+declare class TransmitLogVariables {
+    constructor(init?: Partial<TransmitLogVariables>);
+    maxFileSize: string;
+    maxFiles: string;
+}
+export declare namespace TransmitLogger {
+    interface Options {
+        logDirectory?: string;
+        name: string;
+        frequency?: string;
+        maxFileSize?: string;
+        maxFiles?: string;
+        useBase64?: boolean;
+    }
+    const Variables: typeof TransmitLogVariables;
+    type Variables = TransmitLogVariables;
+}
+export {};

package/classes/transmit-logger.js

@@ -0,0 +1,90 @@
+import { __decorate, __metadata } from "tslib";
+import { EventEmitter } from 'node:events';
+import * as path from 'node:path';
+import { DefineVariable } from '@syncbridge/common';
+import { format } from 'date-fns';
+import { getStream } from 'file-stream-rotator';
+export class TransmitLogger extends EventEmitter {
+    _stream;
+    name;
+    useBase64 = false;
+    constructor(options) {
+        super();
+        this.name = options.name;
+        if (options.logDirectory) {
+            this._stream = getStream({
+                filename: path.join(options.logDirectory, `%DATE%-${options.name || ''}`),
+                extension: '.log',
+                audit_file: path.join(options.logDirectory, `.audit.json`),
+                date_format: 'YYYY-MM-DD',
+                size: options?.maxFileSize || '10m',
+                max_logs: options?.maxFiles || '14d',
+            });
+            this._stream.on('rotate', () => {
+                this.emit('rotate');
+            });
+            this._stream.on('new', () => {
+                this.emit('new');
+            });
+        }
+        this.useBase64 = options.useBase64 || false;
+    }
+    received(content, peer) {
+        this._write('R', content, peer);
+    }
+    transmitted(content, peer) {
+        this._write('T', content, peer);
+    }
+    info(content, peer) {
+        this._write('I', content, peer);
+    }
+    _write(direction, content, peer) {
+        if (!this._stream)
+            return;
+        const buffer = Buffer.isBuffer(content) ? content : Buffer.from(content);
+        this._stream.write(this._getHeader(direction, buffer.length, peer));
+        if (this.useBase64)
+            this._stream.write(buffer.toString('base64'));
+        else
+            this._stream.write(buffer, 'binary');
+        this._stream.write(`\n\n`);
+    }
+    _getHeader(direction, contentSize, peer) {
+        const t = new Date();
+        const timestamp = format(t, 'yyyyMMdd|HHmmss.S');
+        return `<<${direction}|${timestamp}|${contentSize}|${this.useBase64 ? 'b64' : ''}|${peer || ''}>>\n`;
+    }
+}
+/**
+ * Variables
+ */
+class TransmitLogVariables {
+    constructor(init) {
+        if (init)
+            Object.assign(this, init);
+    }
+}
+__decorate([
+    DefineVariable({
+        label: 'Max file size',
+        description: 'Maximum size of the file after which it will rotate. This can be a number of bytes, ' +
+            'or units of kb, mb, and gb. If using the units, add "k", "m", or "g" as the suffix. ' +
+            'The units need to directly follow the number.',
+        pattern: '^\\d+[k|m|g]?$',
+        default: '10m',
+    }),
+    __metadata("design:type", String)
+], TransmitLogVariables.prototype, "maxFileSize", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Max Files',
+        description: 'Maximum number of logs to keep. If not set, no logs will be removed. ' +
+            'This can be a number of files or number of days. If using days, add "d" as the suffix',
+        pattern: '^\\d+[d]?$',
+        default: '14d',
+    }),
+    __metadata("design:type", String)
+], TransmitLogVariables.prototype, "maxFiles", void 0);
+(function (TransmitLogger) {
+    TransmitLogger.Variables = TransmitLogVariables;
+})(TransmitLogger || (TransmitLogger = {}));

package/classes.d.ts

@@ -0,0 +1 @@
+export * from './classes/transmit-logger.js';

package/classes.js

@@ -0,0 +1 @@
+export * from './classes/transmit-logger.js';

package/components/io-client-base.component.d.ts

@@ -0,0 +1,25 @@
+import { Buffer } from 'node:buffer';
+import { ComponentBase } from '@syncbridge/common';
+import { TransmitLogger } from '../classes/transmit-logger.js';
+import { IoClientComponentVariables } from './io-client-base.variables.js';
+/**
+ *
+ */
+export declare class IoClientBaseComponent<TEvents extends IoClientBaseComponent.Events = IoClientBaseComponent.Events> extends ComponentBase<TEvents> {
+    readonly protocol: string;
+    transmitLogger?: TransmitLogger;
+    values: IoClientComponentVariables;
+    protected _init(): Promise<void>;
+    write(data: string | Buffer): void;
+}
+/**
+ * @namespace
+ */
+export declare namespace IoClientBaseComponent {
+    interface Events extends ComponentBase.Events {
+        data: [data: Buffer, ...any];
+        transmit: [data: Buffer, ...any];
+    }
+    const Variables: typeof IoClientComponentVariables;
+    type Variables = IoClientComponentVariables;
+}

package/components/io-client-base.component.js

@@ -0,0 +1,60 @@
+import { __decorate, __metadata } from "tslib";
+import path from 'node:path';
+import { Component, ComponentBase } from '@syncbridge/common';
+import { TransmitLogger } from '../classes/transmit-logger.js';
+import { panatesAuthor } from '../constants.js';
+import { IoClientComponentVariables } from './io-client-base.variables.js';
+/**
+ *
+ */
+let IoClientBaseComponent = class IoClientBaseComponent extends ComponentBase {
+    protocol = '';
+    transmitLogger;
+    async _init() {
+        await super._init();
+        const { communicationLogs } = this.values;
+        const { dataDirectory } = this.processor;
+        if (communicationLogs) {
+            const transmitLogger = (this.transmitLogger = new TransmitLogger({
+                ...communicationLogs,
+                logDirectory: dataDirectory
+                    ? path.join(dataDirectory, 'comm-logs')
+                    : undefined,
+                name: this.path.replace(/\//g, '-'),
+                maxFiles: communicationLogs?.maxFiles,
+                maxFileSize: communicationLogs?.maxFileSize,
+            }));
+            this.on('data', (data, info) => {
+                transmitLogger.received(data, info);
+            });
+            this.on('transmit', (data, info) => {
+                transmitLogger.transmitted(data, info);
+            });
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    write(data) {
+        throw new Error(`"${this.constructor.name}" component do not support write operations.`);
+    }
+};
+__decorate([
+    Component.UseVariables(),
+    __metadata("design:type", IoClientComponentVariables)
+], IoClientBaseComponent.prototype, "values", void 0);
+IoClientBaseComponent = __decorate([
+    Component({
+        abstract: true,
+        className: 'IoClient',
+        displayName: 'IO Client',
+        description: 'Abstract component for IO operations',
+        author: panatesAuthor,
+        tags: ['io', 'stream'],
+    })
+], IoClientBaseComponent);
+export { IoClientBaseComponent };
+/**
+ * @namespace
+ */
+(function (IoClientBaseComponent) {
+    IoClientBaseComponent.Variables = IoClientComponentVariables;
+})(IoClientBaseComponent || (IoClientBaseComponent = {}));

package/components/io-client-base.variables.d.ts

@@ -0,0 +1,7 @@
+import { TransmitLogger } from '../classes/transmit-logger.js';
+/**
+ *
+ */
+export declare class IoClientComponentVariables {
+    communicationLogs?: TransmitLogger.Variables;
+}

package/components/io-client-base.variables.js

@@ -0,0 +1,15 @@
+import { __decorate, __metadata } from "tslib";
+import { DefineVariable } from '@syncbridge/common';
+import { TransmitLogger } from '../classes/transmit-logger.js';
+/**
+ *
+ */
+export class IoClientComponentVariables {
+}
+__decorate([
+    DefineVariable({
+        label: 'Communication Logs',
+        description: 'Stores communication logs if enabled',
+    }),
+    __metadata("design:type", TransmitLogger.Variables)
+], IoClientComponentVariables.prototype, "communicationLogs", void 0);

package/components.d.ts

@@ -0,0 +1 @@
+export * from './components/io-client-base.component.js';

package/components.js

@@ -0,0 +1 @@
+export * from './components/io-client-base.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,9 @@
+import * as classes from './classes.js';
+import * as components from './components.js';
+import * as processors from './processors.js';
+export { classes, components, processors };
+export * from './classes.js';
+export * from './components.js';
+export * from './processors.js';
+declare const cfg: import("@syncbridge/common").IExtensionPackage;
+export default cfg;

package/index.js

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

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@syncbridge/builtins",
+  "version": "0.4.1",
+  "description": "SyncBridge builtin 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",
+    "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",
+    "@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"
+  }
+}

package/processors/io-bridge.processor.d.ts

@@ -0,0 +1,7 @@
+import { ProcessorBase } from '@syncbridge/common';
+import { IoClientBaseComponent } from '../components.js';
+export declare class IOBridgeProcessor extends ProcessorBase {
+    readonly peer1: IoClientBaseComponent;
+    readonly peer2: IoClientBaseComponent;
+    protected _init(): Promise<void>;
+}

package/processors/io-bridge.processor.js

@@ -0,0 +1,49 @@
+import { __decorate, __metadata } from "tslib";
+import { Processor, ProcessorBase } from '@syncbridge/common';
+import { IoClientBaseComponent } from '../components.js';
+import { panatesAuthor } from '../constants.js';
+let IOBridgeProcessor = class IOBridgeProcessor extends ProcessorBase {
+    async _init() {
+        await super._init();
+        this.peer1.on('data', (data) => {
+            try {
+                this.peer2.write(data);
+            }
+            catch (err) {
+                err.message = `Failed to write data to peer2: ${err.message}`;
+                this.emit('error', err);
+            }
+        });
+        this.peer2.on('data', (data) => {
+            try {
+                this.peer1.write(data);
+            }
+            catch (err) {
+                err.message = `Failed to write data to peer1: ${err.message}`;
+                this.emit('error', err);
+            }
+        });
+    }
+};
+__decorate([
+    Processor.UseComponent({
+        interfaces: IoClientBaseComponent.interfaces,
+        required: true,
+    }),
+    __metadata("design:type", IoClientBaseComponent)
+], IOBridgeProcessor.prototype, "peer1", void 0);
+__decorate([
+    Processor.UseComponent({
+        interfaces: IoClientBaseComponent.interfaces,
+        required: true,
+    }),
+    __metadata("design:type", IoClientBaseComponent)
+], IOBridgeProcessor.prototype, "peer2", void 0);
+IOBridgeProcessor = __decorate([
+    Processor({
+        description: 'Create a bridge between two IO peers',
+        author: panatesAuthor,
+        tags: ['io', 'bridge'],
+    })
+], IOBridgeProcessor);
+export { IOBridgeProcessor };

package/processors.d.ts

@@ -0,0 +1 @@
+export * from './processors/io-bridge.processor.js';

package/processors.js

@@ -0,0 +1 @@
+export * from './processors/io-bridge.processor.js';