@hahnpro/flow-sdk 5.0.0-0 → 5.0.1

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 Hahn PRO
+Copyright (c) 2021 Hahn PRO
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,3 +1,3 @@
 # `@hahnpro/flow-sdk`
 
-https://gitlab.com/hahnpro/flow
+https://github.com/hahnprojects/flow

package/dist/FlowApplication.d.ts

@@ -1,34 +1,73 @@
 import 'reflect-metadata';
-import { AmqpConnection, Nack } from '@golevelup/nestjs-rabbitmq';
-import { CloudEvent } from 'cloudevents';
+import { API, HttpClient, MockAPI } from '@hahnpro/hpc-api';
+import { ConsumeMessage } from 'amqplib';
+import { AmqpConnectionManager } from 'amqp-connection-manager';
 import { PartialObserver } from 'rxjs';
-import { API } from './api';
+import { AmqpConnection, AmqpConnectionConfig } from './amqp';
 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;
+    apiClient?: HttpClient;
+    skipApi?: boolean;
+    explicitInit?: boolean;
+    mockApi?: MockAPI;
+}
 export declare class FlowApplication {
-    private amqpConnection?;
-    api: API;
+    private modules;
+    private flow;
+    private _api;
+    private _rpcClient;
+    private amqpChannel;
+    private readonly amqpConnection;
+    private readonly baseLogger;
     private context;
     private declarations;
     private elements;
-    private logger;
-    private properties;
-    private _rpcClient;
+    private initialized;
+    private readonly logger;
     private outputStreamMap;
-    constructor(modules: Array<ClassType<any>>, flow: Flow, logger?: Logger, amqpConnection?: AmqpConnection, skipApi?: boolean);
+    private outputQueueMetrics;
+    private performanceMap;
+    private properties;
+    private readonly skipApi;
+    private readonly apiClient?;
+    constructor(modules: ClassType<any>[], flow: Flow, config?: FlowAppConfig);
+    constructor(modules: ClassType<any>[], flow: Flow, baseLogger?: Logger, amqpConnection?: AmqpConnection, skipApi?: boolean, explicitInit?: boolean);
+    get rpcClient(): RpcClient;
+    get api(): API;
+    init(): Promise<void>;
+    private publishLifecycleEvent;
+    private setQueueMetrics;
+    private updateMetrics;
     subscribe: (streamId: string, observer: PartialObserver<FlowEvent>) => import("rxjs").Subscription;
     emit: (event: FlowEvent) => void;
+    emitPartial: (completeEvent: FlowEvent, partialEvent: FlowEvent) => void;
     getProperties(): Record<string, any>;
-    onMessage: (event: CloudEvent) => Promise<Nack | undefined>;
-    publishEvent: (event: FlowEvent) => Promise<void>;
-    get rpcClient(): RpcClient;
-    destroy(): Promise<void>;
+    onMessage: (msg: ConsumeMessage) => Promise<void>;
+    /**
+     * Publish a flow event to the amqp flowlogs exchange.
+     * If the event size exceeds the limit it will be truncated
+     */
+    publishEvent: (event: FlowEvent) => Promise<boolean>;
+    /**
+     * Calls onDestroy lifecycle method on all flow elements,
+     * closes amqp connection after allowing logs to be processed and published
+     * then exits process
+     */
+    destroy(exitCode?: number): Promise<void>;
+    /**
+     * Returns rxjs subject for the specified stream id.
+     * A new subject will be created if one doesn't exist yet.
+     */
     private getOutputStream;
-    private truncate;
 }
 export interface Context extends FlowElementContext {
     app?: FlowApplication;
     logger?: Logger;
 }
+export {};

package/dist/FlowApplication.js

@@ -3,93 +3,181 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowApplication = void 0;
 const tslib_1 = require("tslib");
 require("reflect-metadata");
-const nestjs_rabbitmq_1 = require("@golevelup/nestjs-rabbitmq");
+const hpc_api_1 = require("@hahnpro/hpc-api");
+const cloudevents_1 = require("cloudevents");
+const crypto_1 = require("crypto");
 const object_sizeof_1 = tslib_1.__importDefault(require("object-sizeof"));
+const perf_hooks_1 = require("perf_hooks");
 const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
-const util_1 = require("util");
-const uuid_1 = require("uuid");
-const api_1 = require("./api");
+const amqp_1 = require("./amqp");
+const flow_interface_1 = require("./flow.interface");
 const FlowLogger_1 = require("./FlowLogger");
 const RpcClient_1 = require("./RpcClient");
-const MAX_EVENT_SIZE_BYTES = 512 * 1024;
+const utils_1 = require("./utils");
+const MAX_EVENT_SIZE_BYTES = +process.env.MAX_EVENT_SIZE_BYTES || 512 * 1024;
+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, logger, amqpConnection, skipApi = false) {
-        this.amqpConnection = amqpConnection;
+    constructor(modules, flow, baseLoggerOrConfig, amqpConnection, skipApi, explicitInit, mockApi) {
+        this.modules = modules;
+        this.flow = flow;
         this.declarations = {};
         this.elements = {};
-        this.outputStreamMap = {};
+        this.initialized = false;
+        this.outputStreamMap = new Map();
+        this.outputQueueMetrics = new Map();
+        this.performanceMap = new Map();
+        this.publishLifecycleEvent = (element, flowEventId, eventType, data = {}) => {
+            if (!this.amqpChannel) {
+                return;
+            }
+            try {
+                const { flowId, deploymentId, id: elementId, functionFqn, inputStreamId } = element.getMetadata();
+                const event = new cloudevents_1.CloudEvent({
+                    source: `flows/${flowId}/deployments/${deploymentId}/elements/${elementId}`,
+                    type: eventType,
+                    data: {
+                        flowEventId,
+                        functionFqn,
+                        inputStreamId,
+                        ...data,
+                    },
+                    time: new Date().toISOString(),
+                });
+                const message = event.toJSON();
+                return this.amqpChannel.publish('flow', 'lifecycle', message);
+            }
+            catch (err) {
+                this.logger.error(err);
+            }
+        };
+        this.setQueueMetrics = (id) => {
+            const metrics = this.outputQueueMetrics.get(id) || { size: 0, lastAdd: 0, lastRemove: Date.now(), warnings: 0 };
+            const secsProcessing = Math.round((metrics.lastAdd - metrics.lastRemove) / 1000);
+            metrics.size++;
+            metrics.lastAdd = Date.now();
+            if (secsProcessing >= WARN_EVENT_PROCESSING_SEC * (metrics.warnings + 1)) {
+                this.logger.warn(`Input stream "${id}" has ${metrics.size} queued events and the last event has been processing for ${secsProcessing}s`);
+                metrics.warnings++;
+            }
+            else if (metrics.size % WARN_EVENT_QUEUE_SIZE === 0) {
+                this.logger.warn(`Input stream "${id}" has ${metrics.size} queued events`);
+            }
+            this.outputQueueMetrics.set(id, metrics);
+        };
+        this.updateMetrics = (id) => {
+            const metrics = this.outputQueueMetrics.get(id);
+            if (metrics) {
+                metrics.size = metrics.size > 0 ? metrics.size - 1 : 0;
+                metrics.lastRemove = Date.now();
+                metrics.warnings = 0;
+                this.outputQueueMetrics.set(id, metrics);
+            }
+        };
         this.subscribe = (streamId, observer) => this.getOutputStream(streamId).subscribe(observer);
         this.emit = (event) => {
-            var _a;
             if (event) {
                 try {
                     this.publishEvent(event);
-                    this.getOutputStream(event.getStreamId()).next(event);
+                    if (this.outputStreamMap.has(event.getStreamId())) {
+                        this.getOutputStream(event.getStreamId()).next(event);
+                    }
                 }
                 catch (err) {
-                    (_a = this.logger) === null || _a === void 0 ? void 0 : _a.error(err);
+                    this.logger.error(err);
+                }
+            }
+        };
+        this.emitPartial = (completeEvent, partialEvent) => {
+            try {
+                if (completeEvent && this.outputStreamMap.has(completeEvent.getStreamId())) {
+                    this.getOutputStream(completeEvent.getStreamId()).next(completeEvent);
+                }
+                if (partialEvent) {
+                    this.publishEvent(partialEvent);
                 }
             }
+            catch (err) {
+                this.logger.error(err);
+            }
         };
-        this.onMessage = async (event) => {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        this.onMessage = async (msg) => {
+            let event;
+            try {
+                event = JSON.parse(msg.content.toString());
+            }
+            catch (err) {
+                this.logger.error(err);
+                return;
+            }
             if (event.type === 'com.flowstudio.deployment.update') {
                 try {
                     const flow = event.data;
                     if (!flow) {
-                        return new nestjs_rabbitmq_1.Nack(false);
+                        this.amqpChannel.nack(msg, false, false);
+                        return;
                     }
                     let context = {};
                     if (flow.context) {
-                        this.context = Object.assign(Object.assign({}, this.context), flow.context);
+                        this.context = { ...this.context, ...flow.context };
                         context = this.context;
                     }
                     if (flow.properties) {
                         this.properties = flow.properties;
                         for (const element of Object.values(this.elements)) {
-                            (_a = element.onFlowPropertiesChanged) === null || _a === void 0 ? void 0 : _a.call(element, flow.properties);
+                            element.onFlowPropertiesChanged?.(flow.properties);
                         }
                     }
                     if (Object.keys(context).length > 0) {
                         for (const element of flow.elements || []) {
-                            context = Object.assign(Object.assign({}, context), { name: element.name });
-                            (_c = (_b = this.elements) === null || _b === void 0 ? void 0 : _b[element.id]) === null || _c === void 0 ? void 0 : _c.onContextChanged(context);
+                            context = { ...context, name: element.name };
+                            this.elements?.[element.id]?.onContextChanged(context);
                         }
                     }
                     for (const element of flow.elements || []) {
-                        (_e = (_d = this.elements) === null || _d === void 0 ? void 0 : _d[element.id]) === null || _e === void 0 ? void 0 : _e.onPropertiesChanged(element.properties);
+                        this.elements?.[element.id]?.onPropertiesChanged(element.properties);
                     }
                     const statusEvent = {
-                        eventId: uuid_1.v4(),
+                        eventId: (0, crypto_1.randomUUID)(),
                         eventTime: new Date().toISOString(),
                         eventType: 'com.hahnpro.event.health',
                         contentType: 'application/json',
                         data: { deploymentId: this.context.deploymentId, status: 'updated' },
                     };
-                    (_f = this.amqpConnection) === null || _f === void 0 ? void 0 : _f.publish('deployment', 'health', statusEvent).catch((err) => this.logger.error(err));
+                    try {
+                        this.amqpChannel?.publish('deployment', 'health', statusEvent);
+                    }
+                    catch (err) {
+                        this.logger.error(err);
+                    }
                 }
                 catch (err) {
                     this.logger.error(err);
                     const statusEvent = {
-                        eventId: uuid_1.v4(),
+                        eventId: (0, crypto_1.randomUUID)(),
                         eventTime: new Date().toISOString(),
                         eventType: 'com.hahnpro.event.health',
                         contentType: 'application/json',
                         data: { deploymentId: this.context.deploymentId, status: 'updating failed' },
                     };
-                    (_g = this.amqpConnection) === null || _g === void 0 ? void 0 : _g.publish('deployment', 'health', statusEvent).catch((err) => this.logger.error(err));
+                    try {
+                        this.amqpChannel?.publish('deployment', 'health', statusEvent);
+                    }
+                    catch (e) {
+                        this.logger.error(e);
+                    }
                 }
             }
             else if (event.type === 'com.flowstudio.deployment.message') {
                 const data = event.data;
-                const elementId = data === null || data === void 0 ? void 0 : data.elementId;
+                const elementId = data?.elementId;
                 if (elementId) {
-                    (_k = (_j = (_h = this.elements) === null || _h === void 0 ? void 0 : _h[elementId]) === null || _j === void 0 ? void 0 : _j.onMessage) === null || _k === void 0 ? void 0 : _k.call(_j, data);
+                    this.elements?.[elementId]?.onMessage?.(data);
                 }
                 else {
                     for (const element of Object.values(this.elements)) {
-                        (_l = element === null || element === void 0 ? void 0 : element.onMessage) === null || _l === void 0 ? void 0 : _l.call(element, data);
+                        element?.onMessage?.(data);
                     }
                 }
             }
@@ -97,131 +185,224 @@ class FlowApplication {
                 this.destroy();
             }
             else {
-                return new nestjs_rabbitmq_1.Nack(false);
+                this.amqpChannel.nack(msg, false, false);
             }
-            return undefined;
         };
         this.publishEvent = (event) => {
-            if (!this.amqpConnection) {
+            if (!this.amqpChannel) {
                 return;
             }
             try {
                 const message = event.format();
-                if (object_sizeof_1.default(message) > MAX_EVENT_SIZE_BYTES) {
-                    message.data = this.truncate(message.data);
+                if ((0, object_sizeof_1.default)(message) > MAX_EVENT_SIZE_BYTES) {
+                    message.data = (0, utils_1.truncate)(message.data);
                 }
-                return this.amqpConnection.publish('flowlogs', '', message);
+                return this.amqpChannel.publish('flowlogs', '', message);
             }
             catch (err) {
                 this.logger.error(err);
             }
         };
+        if (baseLoggerOrConfig && !baseLoggerOrConfig.log) {
+            const config = baseLoggerOrConfig;
+            this.baseLogger = config.logger;
+            this.amqpConnection = config.amqpConnection || (0, amqp_1.createAmqpConnection)(config.amqpConfig);
+            this.skipApi = config.skipApi || false;
+            explicitInit = config.explicitInit || false;
+            this._api = config.mockApi || null;
+            this.apiClient = config.apiClient;
+        }
+        else {
+            this.baseLogger = baseLoggerOrConfig;
+            this.amqpConnection = amqpConnection?.managedConnection;
+            this.skipApi = skipApi || false;
+            explicitInit = explicitInit || false;
+            this._api = mockApi || null;
+        }
+        this.logger = new FlowLogger_1.FlowLogger({ id: 'none', functionFqn: 'FlowApplication', ...flow?.context }, this.baseLogger || undefined, this.publishEvent);
+        process.once('uncaughtException', (err) => {
+            this.logger.error('Uncaught exception!');
+            this.logger.error(err);
+            this.destroy(1);
+        });
+        process.on('unhandledRejection', (reason) => {
+            this.logger.error('Unhandled promise rejection!');
+            this.logger.error(reason);
+        });
         process.on('SIGTERM', () => {
-            this.logger.log('Flow Application is terminating.');
-            this.destroy().finally(() => process.exit(0));
+            this.logger.log('Flow Deployment is terminating');
+            this.destroy(0);
         });
-        this.context = Object.assign({}, flow.context);
-        this.properties = flow.properties || {};
-        this.logger = logger || FlowLogger_1.defaultLogger;
+        if (explicitInit !== true) {
+            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;
+    }
+    async init() {
+        if (this.initialized)
+            return;
+        this.context = { ...this.flow.context };
+        this.properties = this.flow.properties || {};
         try {
-            if (!skipApi) {
-                this.api = new api_1.API();
+            if (!this.skipApi && !(this._api instanceof hpc_api_1.MockAPI)) {
+                this._api = new hpc_api_1.API(this.apiClient);
             }
         }
         catch (err) {
-            this.logger.error((err === null || err === void 0 ? void 0 : err.message) || err);
+            this.logger.error(err?.message || err);
         }
-        for (const module of modules) {
+        const logErrorAndExit = async (err) => {
+            this.logger.error(new Error(err));
+            await this.destroy(1);
+        };
+        this.amqpChannel = this.amqpConnection?.createChannel({
+            json: true,
+            setup: async (channel) => {
+                try {
+                    await channel.assertExchange('deployment', 'direct', { durable: true });
+                    await channel.assertExchange('flowlogs', 'fanout', { durable: true });
+                    await channel.assertExchange('flow', 'direct', { durable: true });
+                }
+                catch (e) {
+                    await logErrorAndExit(`Could not assert exchanges: ${e}`);
+                }
+                try {
+                    const queue = await channel.assertQueue(null, { durable: false, exclusive: true });
+                    await channel.bindQueue(queue.queue, 'deployment', this.context.deploymentId);
+                    await channel.consume(queue.queue, (msg) => this.onMessage(msg));
+                }
+                catch (err) {
+                    await logErrorAndExit(`Could not subscribe to deployment exchange: ${err}`);
+                }
+            },
+        });
+        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);
             if (!moduleName || !moduleDeclarations || !Array.isArray(moduleDeclarations)) {
-                throw new Error(`FlowModule (${module.name}) metadata is missing or invalid.`);
+                await logErrorAndExit(`FlowModule (${module.name}) metadata is missing or invalid`);
+                return;
             }
             for (const declaration of moduleDeclarations) {
                 const functionFqn = Reflect.getMetadata('element:functionFqn', declaration);
                 if (!functionFqn) {
-                    throw new Error(`FlowFunction (${declaration.name}) metadata is missing or invalid.`);
+                    await logErrorAndExit(`FlowFunction (${declaration.name}) metadata is missing or invalid`);
+                    return;
                 }
                 this.declarations[`${moduleName}.${functionFqn}`] = declaration;
             }
         }
-        for (const element of flow.elements) {
+        for (const element of this.flow.elements) {
             const { id, name, properties, module, functionFqn } = element;
             try {
-                const context = Object.assign(Object.assign({}, this.context), { id, name, logger, app: this });
+                const context = { ...this.context, id, name, logger: this.baseLogger, app: this };
                 this.elements[id] = new this.declarations[`${module}.${functionFqn}`](context, properties);
             }
             catch (err) {
-                console.error(err);
-                throw new Error(`Could not create FlowElement for ${module}.${functionFqn}`);
+                await logErrorAndExit(`Could not create FlowElement for ${module}.${functionFqn}`);
+                return;
             }
         }
-        for (const connection of flow.connections) {
+        for (const connection of this.flow.connections) {
             const { source, target, sourceStream = 'default', targetStream = 'default' } = connection;
             if (!source || !target) {
                 continue;
             }
-            const streamId = `${source}.${sourceStream}`;
+            const sourceStreamId = `${source}.${sourceStream}`;
+            const targetStreamId = `${target}.${targetStream}`;
             const element = this.elements[target];
             if (!element || !element.constructor) {
-                throw new Error(target + ' has not been initialized');
+                await logErrorAndExit(`${target} has not been initialized`);
+                return;
             }
             const streamHandler = Reflect.getMetadata(`stream:${targetStream}`, element.constructor);
             if (!streamHandler || !element[streamHandler]) {
-                throw new Error(`${target} does not implement a handler for ${targetStream}`);
+                await logErrorAndExit(`${target} does not implement a handler for ${targetStream}`);
+                return;
             }
             const streamOptions = Reflect.getMetadata(`stream:options:${targetStream}`, element.constructor) || {};
             const concurrent = streamOptions.concurrent || 1;
-            const outputStream = this.getOutputStream(streamId);
+            const outputStream = this.getOutputStream(sourceStreamId);
             outputStream
-                .pipe(operators_1.mergeMap((event) => element[streamHandler](event), concurrent), operators_1.catchError((err, observable) => {
-                element.handleApiError(err);
-                return observable;
+                .pipe((0, operators_1.tap)(() => this.setQueueMetrics(targetStreamId)), (0, operators_1.mergeMap)(async (event) => {
+                const eventId = event.getId();
+                this.publishLifecycleEvent(element, eventId, flow_interface_1.LifecycleEvent.ACTIVATED);
+                this.performanceMap.set(eventId, perf_hooks_1.performance.eventLoopUtilization());
+                const start = perf_hooks_1.performance.now();
+                try {
+                    await element[streamHandler](event);
+                    const duration = Math.ceil(perf_hooks_1.performance.now() - start);
+                    this.publishLifecycleEvent(element, eventId, flow_interface_1.LifecycleEvent.COMPLETED, { duration });
+                }
+                catch (err) {
+                    const duration = Math.ceil(perf_hooks_1.performance.now() - start);
+                    this.publishLifecycleEvent(element, eventId, flow_interface_1.LifecycleEvent.TERMINATED, { duration });
+                    try {
+                        element.handleApiError(err);
+                    }
+                    catch (e) {
+                        this.logger.error(err);
+                    }
+                }
+                return event;
+            }, concurrent), (0, operators_1.tap)((event) => {
+                this.updateMetrics(targetStreamId);
+                let elu = this.performanceMap.get(event.getId());
+                if (elu) {
+                    this.performanceMap.delete(event.getId());
+                    elu = perf_hooks_1.performance.eventLoopUtilization(elu);
+                    if (elu.utilization > 0.75 && elu.active > 2000) {
+                        this.logger.warn(`High event loop utilization detected for ${targetStreamId} with event ${event.getId()}! Handler was active for ${Number(elu.active).toFixed(2)}ms with a utilization of ${Number(elu.utilization * 100).toFixed(2)}%. Consider refactoring or move tasks to a worker thread.`);
+                    }
+                }
             }))
                 .subscribe();
         }
-        if (this.amqpConnection) {
-            this.amqpConnection.createSubscriber((msg) => this.onMessage(msg), {
-                exchange: 'deployment',
-                routingKey: this.context.deploymentId,
-                queueOptions: { durable: false, exclusive: true },
-            });
-        }
+        this.initialized = true;
+        this.logger.log('Flow Deployment is running');
     }
     getProperties() {
         return this.properties;
     }
-    get rpcClient() {
-        var _a;
-        if (!((_a = this.amqpConnection) === null || _a === void 0 ? void 0 : _a.managedConnection)) {
-            throw new Error('No AMQP connection available');
+    async destroy(exitCode = 0) {
+        try {
+            try {
+                for (const element of Object.values(this.elements)) {
+                    element?.onDestroy?.();
+                }
+                this._rpcClient && (await this._rpcClient.close());
+            }
+            catch (err) {
+                this.logger.error(err);
+            }
+            await (0, utils_1.delay)(250);
+            this.amqpConnection && (await this.amqpConnection.close());
         }
-        if (!this._rpcClient) {
-            this._rpcClient = new RpcClient_1.RpcClient(this.amqpConnection.managedConnection);
+        catch (err) {
+            console.error(err);
         }
-        return this._rpcClient;
-    }
-    async destroy() {
-        var _a, _b;
-        for (const element of Object.values(this.elements)) {
-            (_a = element === null || element === void 0 ? void 0 : element.onDestroy) === null || _a === void 0 ? void 0 : _a.call(element);
+        finally {
+            if (process.env.NODE_ENV !== 'test') {
+                process.exit(exitCode);
+            }
         }
-        await ((_b = this._rpcClient) === null || _b === void 0 ? void 0 : _b.close());
     }
     getOutputStream(id) {
-        const stream = this.outputStreamMap[id];
+        const stream = this.outputStreamMap.get(id);
         if (!stream) {
-            this.outputStreamMap[id] = new rxjs_1.Subject();
-            return this.outputStreamMap[id];
+            this.outputStreamMap.set(id, new rxjs_1.Subject());
+            return this.outputStreamMap.get(id);
         }
         return stream;
     }
-    truncate(msg) {
-        let truncated = util_1.inspect(msg, { depth: 4, maxStringLength: 1000 });
-        if (truncated.startsWith("'") && truncated.endsWith("'")) {
-            truncated = truncated.substring(1, truncated.length - 1);
-        }
-        return truncated;
-    }
 }
 exports.FlowApplication = FlowApplication;

package/dist/FlowElement.d.ts

@@ -1,6 +1,6 @@
 import { PythonShell } from 'python-shell';
-import { API } from './api';
-import { ClassType, FlowElementContext, DeploymentMessage, FlowContext } from './flow.interface';
+import { API } from '@hahnpro/hpc-api';
+import { ClassType, DeploymentMessage, FlowContext, FlowElementContext } from './flow.interface';
 import { Context } from './FlowApplication';
 import { FlowEvent } from './FlowEvent';
 import { FlowLogger } from './FlowLogger';
@@ -14,6 +14,7 @@ export declare abstract class FlowElement<T = any> {
     protected properties: T;
     private readonly app?;
     private readonly rpcRoutingKey;
+    private stopPropagateStream;
     constructor({ app, logger, ...metadata }: Context, properties?: unknown, propertiesClassType?: ClassType<T>, whitelist?: boolean);
     get flowProperties(): Record<string, any>;
     onDestroy?: () => void;
@@ -21,17 +22,24 @@ export declare abstract class FlowElement<T = any> {
     onFlowPropertiesChanged?: (properties: Record<string, any>) => void;
     onContextChanged: (context: Partial<FlowContext>) => void;
     onPropertiesChanged: (properties: T) => void;
+    getMetadata: () => FlowElementContext;
     protected setProperties: (properties: T) => void;
     handleApiError: (error: any) => void;
+    /**
+     * @deprecated since version 4.8.0, will be removed in 5.0.0, use emitEvent(...) instead
+     */
     protected emitOutput(data?: any, outputId?: string, time?: Date): FlowEvent;
+    protected emitEvent(data: Record<string, any>, inputEvent: FlowEvent, outputId?: string, time?: Date): FlowEvent;
     protected validateProperties<P>(classType: ClassType<P>, properties?: any, whitelist?: boolean): P;
+    protected logValidationErrors(error: any, parent?: string): void;
     protected validateEventData<E>(classType: ClassType<E>, event: FlowEvent, whitelist?: boolean): E;
-    protected interpolate(text: string, ...templateVariables: any): string;
+    protected interpolate: (value: any, ...templateVariables: any) => any;
     protected callRpcFunction(functionName: string, ...args: any[]): Promise<unknown>;
-    protected runPyRpcScript(scriptPath: string): PythonShell;
+    protected runPyRpcScript(scriptPath: string, ...args: (string | boolean | number)[]): PythonShell;
 }
 export declare function InputStream(id?: string, options?: {
     concurrent?: number;
+    stopPropagation?: boolean;
 }): MethodDecorator;
 export declare function FlowFunction(fqn: string): ClassDecorator;
 export declare abstract class FlowResource<T = any> extends FlowElement<T> {