@hahnpro/flow-sdk 2025.10.4 → 2025.11.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hahnpro/flow-sdk",
-  "version": "2025.10.4",
+  "version": "2025.11.1",
   "description": "SDK for building Flow Modules",
   "license": "MIT",
   "author": {
@@ -17,12 +17,10 @@
     "access": "public"
   },
   "dependencies": {
-    "@hahnpro/hpc-api": "2025.10.4",
+    "@hahnpro/hpc-api": "2025.11.1",
     "@nats-io/jetstream": "3.2.0",
     "@nats-io/nats-core": "3.2.0",
     "@nats-io/transport-node": "3.2.0",
-    "amqp-connection-manager": "4.1.15",
-    "amqplib": "0.10.9",
     "class-transformer": "0.5.1",
     "class-validator": "0.14.2",
     "cloudevents": "10.0.0",
@@ -34,7 +32,6 @@
     "string-interp": "0.3.6"
   },
   "devDependencies": {
-    "@types/amqplib": "0.10.8",
     "@types/jest": "30.0.0",
     "@types/lodash": "4.17.20",
     "@types/node": "22.18.13",
@@ -46,8 +43,7 @@
     "axios": "1.13.1",
     "class-transformer": "0.5.1",
     "class-validator": "0.14.2",
-    "lodash": "4.17.21",
-    "python-shell": "5.x"
+    "lodash": "4.17.21"
   },
   "engines": {
     "node": ">=v22"

package/src/lib/FlowApplication.d.ts

@@ -1,19 +1,14 @@
 import 'reflect-metadata';
 import { API, HttpClientService, MockAPI } from '@hahnpro/hpc-api';
 import { NatsConnection, ConnectionOptions as NatsConnectionOptions } from '@nats-io/nats-core';
-import { AmqpConnectionManager } from 'amqp-connection-manager';
 import { CloudEvent } from 'cloudevents';
 import { PartialObserver } from 'rxjs';
-import { AmqpConnection, AmqpConnectionConfig } from './amqp';
 import { ContextManager } from './ContextManager';
 import { ClassType, Flow, FlowElementContext } from './flow.interface';
 import { FlowEvent } from './FlowEvent';
 import { Logger } from './FlowLogger';
-import { RpcClient } from './RpcClient';
 interface FlowAppConfig {
     logger?: Logger;
-    amqpConfig?: AmqpConnectionConfig;
-    amqpConnection?: AmqpConnectionManager;
     natsConfig?: NatsConnectionOptions;
     natsConnection?: NatsConnection;
     apiClient?: HttpClientService;
@@ -25,9 +20,6 @@ export declare class FlowApplication {
     private modules;
     private flow;
     private _api;
-    private _rpcClient;
-    private amqpChannel;
-    private readonly amqpConnection;
     private readonly natsConnectionConfig?;
     private _natsConnection?;
     private readonly baseLogger;
@@ -44,8 +36,7 @@ export declare class FlowApplication {
     private readonly contextManager;
     private natsMessageIterator;
     constructor(modules: ClassType<any>[], flow: Flow, config?: FlowAppConfig);
-    constructor(modules: ClassType<any>[], flow: Flow, baseLogger?: Logger, amqpConnection?: AmqpConnection, natsConnection?: NatsConnection, skipApi?: boolean, explicitInit?: boolean);
-    get rpcClient(): RpcClient;
+    constructor(modules: ClassType<any>[], flow: Flow, baseLogger?: Logger, natsConnection?: NatsConnection, skipApi?: boolean, explicitInit?: boolean);
     get api(): API;
     get natsConnection(): NatsConnection;
     getContextManager(): ContextManager;
@@ -60,7 +51,7 @@ export declare class FlowApplication {
     emitPartial: (completeEvent: FlowEvent, partialEvent: FlowEvent) => void;
     onMessage: (cloudEvent: CloudEvent) => Promise<void>;
     /**
-     * Publish a flow event to the amqp flowlogs exchange.
+     * Publish a flow event to NATS
      * If the event size exceeds the limit it will be truncated
      *
      * TODO warum darf hier nicht false zurückgegeben werden? -> erzeugt loop
@@ -68,7 +59,7 @@ export declare class FlowApplication {
     publishNatsEventFlowlogs: (event: FlowEvent) => Promise<boolean>;
     /**
      * Calls onDestroy lifecycle method on all flow elements,
-     * closes amqp connection after allowing logs to be processed and published
+     * closes NATS connection after allowing logs to be processed and published
      * then exits process
      */
     destroy(exitCode?: number): Promise<void>;

package/src/lib/FlowApplication.js

@@ -11,18 +11,16 @@ const lodash_1 = require("lodash");
 const object_sizeof_1 = tslib_1.__importDefault(require("object-sizeof"));
 const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
-const amqp_1 = require("./amqp");
 const ContextManager_1 = require("./ContextManager");
 const flow_interface_1 = require("./flow.interface");
 const FlowLogger_1 = require("./FlowLogger");
 const nats_1 = require("./nats");
-const RpcClient_1 = require("./RpcClient");
 const utils_1 = require("./utils");
 const MAX_EVENT_SIZE_BYTES = +process.env.MAX_EVENT_SIZE_BYTES || 512 * 1024; // 512kb
 const WARN_EVENT_PROCESSING_SEC = +process.env.WARN_EVENT_PROCESSING_SEC || 60;
 const WARN_EVENT_QUEUE_SIZE = +process.env.WARN_EVENT_QUEUE_SIZE || 100;
 class FlowApplication {
-    constructor(modules, flow, baseLoggerOrConfig, amqpConnection, natsConnection, skipApi, explicitInit, mockApi) {
+    constructor(modules, flow, baseLoggerOrConfig, natsConnection, skipApi, explicitInit, mockApi) {
         this.modules = modules;
         this.flow = flow;
         this.declarations = {};
@@ -167,13 +165,9 @@ class FlowApplication {
                     }
                 }
             }
-            else if (cloudEvent.subject.endsWith('.destroy')) {
-                // TODO war com.flowstudio.deployment.destroy in RabbitMq: wo wird das jetzt wieder gesendet?
-                this.destroy();
-            }
         };
         /**
-         * Publish a flow event to the amqp flowlogs exchange.
+         * Publish a flow event to NATS
          * If the event size exceeds the limit it will be truncated
          *
          * TODO warum darf hier nicht false zurückgegeben werden? -> erzeugt loop
@@ -204,7 +198,6 @@ class FlowApplication {
         if (baseLoggerOrConfig && !baseLoggerOrConfig.log) {
             const config = baseLoggerOrConfig;
             this.baseLogger = config.logger;
-            this.amqpConnection = config.amqpConnection || (0, amqp_1.createAmqpConnection)(config.amqpConfig);
             this.natsConnectionConfig = config.natsConfig;
             this._natsConnection = config.natsConnection;
             this.skipApi = config.skipApi || false;
@@ -214,7 +207,6 @@ class FlowApplication {
         }
         else {
             this.baseLogger = baseLoggerOrConfig;
-            this.amqpConnection = amqpConnection?.managedConnection;
             this._natsConnection = natsConnection;
             this.skipApi = skipApi || false;
             explicitInit = explicitInit || false;
@@ -239,12 +231,6 @@ class FlowApplication {
             this.init();
         }
     }
-    get rpcClient() {
-        if (!this._rpcClient && this.amqpConnection) {
-            this._rpcClient = new RpcClient_1.RpcClient(this.amqpConnection, this.logger);
-        }
-        return this._rpcClient;
-    }
     get api() {
         return this._api;
     }
@@ -343,20 +329,6 @@ class FlowApplication {
                 await logErrorAndExit(`Could not set up consumer for deployment messages exchanges: ${e}`);
             }
         }
-        this.amqpChannel = this.amqpConnection?.createChannel({
-            json: true,
-            setup: async (channel) => {
-                try {
-                    await channel.assertExchange('flow', 'direct', { durable: true }); // TODO wieso weshalb warum: wo wird das gebraucht?
-                }
-                catch (e) {
-                    await logErrorAndExit(`Could not assert exchanges: ${e}`);
-                }
-            },
-        });
-        if (this.amqpChannel) {
-            await this.amqpChannel.waitForConnect();
-        }
         for (const module of this.modules) {
             const moduleName = Reflect.getMetadata('module:name', module);
             const moduleDeclarations = Reflect.getMetadata('module:declarations', module);
@@ -447,7 +419,7 @@ class FlowApplication {
     }
     /**
      * Calls onDestroy lifecycle method on all flow elements,
-     * closes amqp connection after allowing logs to be processed and published
+     * closes NATS connection after allowing logs to be processed and published
      * then exits process
      */
     async destroy(exitCode = 0) {
@@ -456,18 +428,12 @@ class FlowApplication {
                 for (const element of Object.values(this.elements)) {
                     element?.onDestroy?.();
                 }
-                if (this._rpcClient) {
-                    await this._rpcClient.close();
-                }
             }
             catch (err) {
                 this.logger.error(err);
             }
             // allow time for logs to be processed
             await (0, utils_1.delay)(250);
-            if (this.amqpConnection) {
-                await this.amqpConnection.close();
-            }
             // Close all output streams
             for (const [id, stream] of this.outputStreamMap.entries()) {
                 try {

package/src/lib/FlowElement.d.ts

@@ -1,5 +1,4 @@
 import { API } from '@hahnpro/hpc-api';
-import { PythonShell } from 'python-shell';
 import { ClassType, DeploymentMessage, FlowContext, FlowElementContext } from './flow.interface';
 import { Context } from './FlowApplication';
 import { FlowEvent } from './FlowEvent';
@@ -14,7 +13,6 @@ export declare abstract class FlowElement<T = any> {
     protected properties: T;
     private propertiesWithPlaceholders;
     private readonly app?;
-    private readonly rpcRoutingKey;
     private stopPropagateStream;
     constructor({ app, logger, ...metadata }: Context, properties?: unknown, propertiesClassType?: ClassType<T>, whitelist?: boolean);
     /**
@@ -49,8 +47,6 @@ export declare abstract class FlowElement<T = any> {
     protected logValidationErrors(error: any, parent?: string): void;
     protected validateEventData<E>(classType: ClassType<E>, event: FlowEvent, whitelist?: boolean): E;
     protected interpolate: (value: any, ...templateVariables: any) => any;
-    protected callRpcFunction(functionName: string, ...args: any[]): Promise<unknown>;
-    protected runPyRpcScript(scriptPath: string, ...args: (string | boolean | number)[]): PythonShell;
 }
 export declare function InputStream(id?: string, options?: {
     concurrent?: number;

package/src/lib/FlowElement.js

@@ -5,7 +5,6 @@ exports.InputStream = InputStream;
 exports.FlowFunction = FlowFunction;
 const class_transformer_1 = require("class-transformer");
 const class_validator_1 = require("class-validator");
-const python_shell_1 = require("python-shell");
 const FlowEvent_1 = require("./FlowEvent");
 const FlowLogger_1 = require("./FlowLogger");
 const utils_1 = require("./utils");
@@ -35,7 +34,6 @@ class FlowElement {
         this.api = this.app?.api;
         this.metadata = { ...metadata, functionFqn: this.functionFqn };
         this.logger = new FlowLogger_1.FlowLogger(this.metadata, logger || undefined, this.app?.publishNatsEventFlowlogs);
-        this.rpcRoutingKey = (this.metadata.flowId || '') + (this.metadata.deploymentId || '') + this.metadata.id;
         if (properties) {
             this.setProperties(properties);
         }
@@ -115,26 +113,6 @@ class FlowElement {
     validateEventData(classType, event, whitelist = false) {
         return this.validateProperties(classType, event.getData(), whitelist);
     }
-    async callRpcFunction(functionName, ...args) {
-        return this.app?.rpcClient.callFunction(this.rpcRoutingKey, functionName, ...args);
-    }
-    runPyRpcScript(scriptPath, ...args) {
-        const options = {
-            mode: 'text',
-            pythonOptions: ['-u'],
-            args: [__dirname, this.rpcRoutingKey, ...args.map((v) => v.toString())],
-        };
-        const pyshell = new python_shell_1.PythonShell(scriptPath, options);
-        pyshell.on('message', (message) => {
-            this.logger.debug(message);
-        });
-        pyshell.end((err) => {
-            if (err) {
-                this.logger.error(err);
-            }
-        });
-        return pyshell;
-    }
 }
 exports.FlowElement = FlowElement;
 function InputStream(id = 'default', options) {

package/src/lib/RpcClient.d.ts

@@ -1,13 +0,0 @@
-import type { AmqpConnectionManager } from 'amqp-connection-manager';
-import { FlowLogger } from './FlowLogger';
-export declare class RpcClient {
-    private readonly logger?;
-    private readonly channel;
-    private openRequests;
-    constructor(amqpConnection: AmqpConnectionManager, logger?: FlowLogger);
-    private onMessage;
-    callFunction: (routingKey: string, functionName: string, ...args: any[]) => Promise<unknown>;
-    declareFunction: (routingKey: string, name: string) => (...args: any[]) => Promise<unknown>;
-    close(): Promise<void>;
-    static formatTrace(stack?: string): string;
-}

package/src/lib/RpcClient.js

@@ -1,88 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RpcClient = void 0;
-const tslib_1 = require("tslib");
-const crypto_1 = require("crypto");
-const object_sizeof_1 = tslib_1.__importDefault(require("object-sizeof"));
-const MAX_MSG_SIZE = +process.env.MAX_RPC_MSG_SIZE_BYTES;
-const WARN_MSG_SIZE = +process.env.WARN_RPC_MSG_SIZE_BYTES;
-class RpcClient {
-    constructor(amqpConnection, logger) {
-        this.logger = logger;
-        this.openRequests = new Map();
-        this.onMessage = (msg) => {
-            if (this.openRequests.has(msg.properties.correlationId)) {
-                const { resolve, reject, trace } = this.openRequests.get(msg.properties.correlationId);
-                const response = JSON.parse(msg.content.toString());
-                switch (response.type) {
-                    case 'reply':
-                        resolve(response.value);
-                        break;
-                    case 'error': {
-                        const err = new Error(response.message);
-                        if (response.stack) {
-                            const stack = RpcClient.formatTrace(response.stack);
-                            err.stack = 'Remote Stack\n'.concat(stack, '\nLocal Stack\n', trace);
-                        }
-                        else {
-                            err.stack = trace;
-                        }
-                        reject(err);
-                        break;
-                    }
-                    default:
-                        reject(response);
-                        break;
-                }
-            }
-            else {
-                const message = `received unexpected response correlationID: ${msg.properties.correlationId}`;
-                /* eslint-disable-next-line no-console */
-                console.warn(message);
-            }
-        };
-        this.callFunction = (routingKey, functionName, ...args) => {
-            // in case remote returns error add this to the trace
-            const stack = new Error('test').stack;
-            return new Promise((resolve, reject) => {
-                // save to correlationId-> resolve/reject map
-                // on return resolve or reject promise
-                if (MAX_MSG_SIZE || WARN_MSG_SIZE) {
-                    const messageSize = (0, object_sizeof_1.default)(args);
-                    if (messageSize > MAX_MSG_SIZE) {
-                        throw new Error(`Max RPC message size exceeded: ${messageSize} bytes / ${MAX_MSG_SIZE} bytes`);
-                    }
-                    if (messageSize > WARN_MSG_SIZE) {
-                        this.logger?.warn(`Large RPC message size detected: ${messageSize} bytes`);
-                    }
-                }
-                const call = { functionName, arguments: args };
-                const correlationId = (0, crypto_1.randomUUID)();
-                this.openRequests.set(correlationId, { resolve, reject, trace: RpcClient.formatTrace(stack) });
-                this.channel
-                    .publish('rpc_direct_exchange', routingKey, call, { correlationId, replyTo: 'amq.rabbitmq.reply-to' })
-                    .catch((err) => reject(err));
-            });
-        };
-        this.declareFunction = (routingKey, name) => {
-            return (...args) => this.callFunction(routingKey, name, ...args);
-        };
-        if (!amqpConnection) {
-            throw new Error('currently no amqp connection available');
-        }
-        this.channel = amqpConnection.createChannel({
-            json: true,
-            setup: async (channel) => {
-                await channel.assertExchange('rpc_direct_exchange', 'direct', { durable: false });
-                await channel.consume('amq.rabbitmq.reply-to', this.onMessage, { noAck: true });
-            },
-        });
-    }
-    close() {
-        return this.channel.close();
-    }
-    static formatTrace(stack = '') {
-        return stack.split('\n').splice(1).join('\n');
-    }
-}
-exports.RpcClient = RpcClient;

package/src/lib/amqp.d.ts

@@ -1,14 +0,0 @@
-import { AmqpConnectionManager, ChannelWrapper } from 'amqp-connection-manager';
-export interface AmqpConnection {
-    managedChannel: ChannelWrapper;
-    managedConnection: AmqpConnectionManager;
-}
-export interface AmqpConnectionConfig {
-    protocol?: string;
-    hostname?: string;
-    vhost?: string;
-    user?: string;
-    password?: string;
-    port?: number;
-}
-export declare function createAmqpConnection(config: AmqpConnectionConfig): AmqpConnectionManager;

package/src/lib/amqp.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createAmqpConnection = createAmqpConnection;
-const amqp_connection_manager_1 = require("amqp-connection-manager");
-function createAmqpConnection(config) {
-    if (!config) {
-        return null;
-    }
-    const { protocol = process.env.RABBIT_PROTOCOL || 'amqp', hostname = process.env.RABBIT_HOST || 'localhost', port = +process.env.RABBIT_PORT || 5672, user = process.env.RABBIT_USER || 'guest', password = process.env.RABBIT_PASSWORD || 'guest', vhost = process.env.RABBIT_VHOST || '', } = config;
-    const uri = `${protocol}://${user}:${password}@${hostname}:${port}${vhost ? '/' + vhost : ''}`;
-    return (0, amqp_connection_manager_1.connect)(uri);
-}

package/src/lib/rpc_server.py

@@ -1,116 +0,0 @@
-import asyncio
-import json
-from asyncio import Future
-from functools import partial, wraps
-from aio_pika import IncomingMessage, Exchange, Message, connect_robust, ExchangeType
-from aio_pika.abc import AbstractRobustExchange
-import os
-
-user = os.getenv("RABBIT_USER", "guest")
-password = os.getenv("RABBIT_PASSWORD", "guest")
-host = os.getenv("RABBIT_HOST", "localhost")
-port = os.getenv("RABBIT_PORT", "5672")
-vhost = os.getenv("RABBIT_VHOST", "")
-routingKey = os.getenv("RPC_ROUTING_KEY", "rpc")
-max_msg_size = int(os.getenv("MAX_RPC_MSG_SIZE_BYTES", "0"))
-
-remote_procedures = {}
-flow_logs_exchange: AbstractRobustExchange
-
-
-def RemoteProcedure(func):
-    global remote_procedures
-
-    @wraps(func)
-    def function_wrapper(*args, **kwargs):
-        return func(*args, **kwargs)
-
-    remote_procedures[func.__name__] = func
-
-    return function_wrapper
-
-
-loop = asyncio.new_event_loop()
-asyncio.set_event_loop(loop)
-
-
-async def on_message(exchange: Exchange, message: IncomingMessage):
-    def callback(future: Future):
-        try:
-            res = future.result()
-            if type(res) is tuple and type(res[1]) is type and issubclass(res[1], json.JSONEncoder):
-                res = json.dumps(res[0], cls=res[1])
-            reply1 = {"type": "reply", "value": res}
-        except Exception as err:
-            # print(traceback.format_list(traceback.extract_stack(err)))
-            reply1 = {"type": "error", "message": str(err), "stack": "failed"}
-
-        asyncio.ensure_future(send_reply(exchange, reply1, message), loop=loop)
-
-
-    request = json.loads(message.body.decode())
-
-    # call function
-    if remote_procedures.keys().__contains__(request["functionName"]):
-        func = remote_procedures.get(request["functionName"])
-        future = loop.run_in_executor(None, func, *request["arguments"])
-        future.add_done_callback(callback)
-
-    else:
-        reply = {
-            "type": "error",
-            "message": request["functionName"] + " is not a function",
-        }
-        await send_reply(exchange, reply, original_message=message)
-
-
-async def send_reply(exchange: Exchange, reply, original_message: Message):
-    body = json.dumps(reply).encode("utf-8")
-
-    if max_msg_size > 0 and len(body) > max_msg_size:
-        body = json.dumps(
-            {
-                "type": "error",
-                "message": "Max RPC message size exceeded: " + str(len(body)) + " bytes / " + max_msg_size + " bytes",
-            }
-        ).encode("utf-8")
-
-    await exchange.publish(
-        Message(body=body, correlation_id=original_message.correlation_id),
-        routing_key=original_message.reply_to,
-    )
-
-
-async def main(loop, routing_key):
-    global flow_logs_exchange
-
-    url = "amqp://%s:%s@%s:%s/%s" % (user, password, host, port, vhost)
-    connection = await connect_robust(
-        url, loop=loop
-    )
-
-    channel = await connection.channel()
-
-    dest_exchange = await channel.declare_exchange(name="rpc_direct_exchange", type=ExchangeType.DIRECT)
-    flow_logs_exchange = await channel.declare_exchange(name='flowlogs', type=ExchangeType.FANOUT, durable=True)
-
-    queue = await channel.declare_queue("", exclusive=True)
-
-    await queue.bind(dest_exchange, routing_key)
-
-    await queue.consume(partial(
-        on_message, channel.default_exchange)
-    )
-
-
-def start_consumer(routing_key=routingKey):
-    loop.create_task(main(loop, routing_key))
-    loop.run_forever()
-
-def log(message):
-    global flow_logs_exchange
-
-    if flow_logs_exchange is not None:
-        flow_logs_exchange.publish(Message(body=json.dumps(message).encode("utf-8")), "")
-    else:
-        print("Connection not established. Call start_consumer first.")