@hahnpro/flow-sdk 9.4.1 → 9.6.0

package/dist/FlowApplication.js

@@ -32,9 +32,6 @@ class FlowApplication {
         this.outputQueueMetrics = new Map();
         this.performanceMap = new Map();
         this.publishLifecycleEvent = async (element, flowEventId, eventType, data = {}) => {
-            if (!this.amqpChannel) {
-                return;
-            }
             try {
                 const { flowId, deploymentId, id: elementId, functionFqn, inputStreamId } = element.getMetadata();
                 const natsEvent = {
@@ -47,7 +44,7 @@ class FlowApplication {
                         ...data,
                     },
                 };
-                await (0, nats_1.publishNatsEvent)(this.logger, this.natsConnection, natsEvent, `${nats_1.natsFlowsPrefixFlowDeployment}.flowlifecycle.${deploymentId}`);
+                await (0, nats_1.publishNatsEvent)(this.logger, this._natsConnection, natsEvent, `${nats_1.natsFlowsPrefixFlowDeployment}.flowlifecycle.${deploymentId}`);
             }
             catch (err) {
                 this.logger.error(err);
@@ -141,7 +138,7 @@ class FlowApplication {
                             status: 'updated',
                         },
                     };
-                    await (0, nats_1.publishNatsEvent)(this.logger, this.natsConnection, natsEvent);
+                    await (0, nats_1.publishNatsEvent)(this.logger, this._natsConnection, natsEvent);
                 }
                 catch (err) {
                     this.logger.error(err);
@@ -154,7 +151,7 @@ class FlowApplication {
                             status: 'updating failed',
                         },
                     };
-                    await (0, nats_1.publishNatsEvent)(this.logger, this.natsConnection, natsEvent);
+                    await (0, nats_1.publishNatsEvent)(this.logger, this._natsConnection, natsEvent);
                 }
             }
             else if (cloudEvent.subject.endsWith('.message')) {
@@ -174,8 +171,8 @@ class FlowApplication {
             }
         };
         this.publishNatsEventFlowlogs = async (event) => {
-            if (!this.natsConnection || this.natsConnection.isClosed()) {
-                return;
+            if (!this._natsConnection || this._natsConnection.isClosed()) {
+                return true;
             }
             try {
                 const formatedEvent = event.format();
@@ -188,7 +185,7 @@ class FlowApplication {
                     subject: `${this.context.deploymentId}`,
                     data: formatedEvent,
                 };
-                await (0, nats_1.publishNatsEvent)(this.logger, this.natsConnection, natsEvent);
+                await (0, nats_1.publishNatsEvent)(this.logger, this._natsConnection, natsEvent);
                 return true;
             }
             catch (err) {
@@ -315,6 +312,7 @@ class FlowApplication {
                     name: `flow-deployment-${this.context.deploymentId}`,
                     filter_subject: `${nats_1.natsFlowsPrefixFlowDeployment}.${this.context.deploymentId}.*`,
                     inactive_threshold: 10 * 60 * 1_000_000_000,
+                    deliver_policy: jetstream_1.DeliverPolicy.New,
                 };
                 const consumer = await (0, nats_1.getOrCreateConsumer)(this.logger, this._natsConnection, nats_1.FLOWS_STREAM_NAME, consumerOptions.name, consumerOptions);
                 const handleNatsStatus = async () => {
@@ -453,21 +451,37 @@ class FlowApplication {
             if (this.amqpConnection) {
                 await this.amqpConnection.close();
             }
-            if (this._natsConnection && !this._natsConnection.isClosed()) {
-                await (0, jetstream_1.jetstreamManager)(this._natsConnection).then((jsm) => {
-                    jsm.consumers
-                        .delete(nats_1.FLOWS_STREAM_NAME, `flow-deployment-${this.context.deploymentId}`)
-                        .then(() => {
-                        this.logger.error(`Deleted consumer for flow deployment ${this.context.deploymentId}`);
-                    })
-                        .catch((err) => {
-                        this.logger.error(`Could not delete consumer for flow deployment ${this.context.deploymentId}: ${err.message}`);
+            for (const [id, stream] of this.outputStreamMap.entries()) {
+                try {
+                    stream?.complete();
+                }
+                catch (err) {
+                    this.logger.error(`Error completing output stream ${id}: ${err.message}`);
+                }
+            }
+            try {
+                await this.natsMessageIterator?.close();
+                await this._natsConnection?.drain();
+                await this._natsConnection?.close();
+                if (this._natsConnection && !this._natsConnection.isClosed()) {
+                    await (0, jetstream_1.jetstreamManager)(this._natsConnection).then((jsm) => {
+                        jsm.consumers
+                            .delete(nats_1.FLOWS_STREAM_NAME, `flow-deployment-${this.context?.deploymentId}`)
+                            .then(() => {
+                            this.logger.debug(`Deleted consumer for flow deployment ${this.context?.deploymentId}`);
+                        })
+                            .catch((err) => {
+                            this.logger.error(`Could not delete consumer for flow deployment ${this.context?.deploymentId}: ${err.message}`);
+                        });
                     });
-                });
-                await this._natsConnection.drain();
+                }
+            }
+            catch (err) {
+                this.logger.error(err);
             }
-            await this.natsMessageIterator?.close();
-            await this._natsConnection?.close();
+            process.removeAllListeners('SIGTERM');
+            process.removeAllListeners('uncaughtException');
+            process.removeAllListeners('unhandledRejection');
         }
         catch (err) {
             console.error(err);

package/dist/FlowLogger.d.ts

@@ -8,8 +8,13 @@ export interface Logger {
     verbose(message: any, metadata?: any): void;
 }
 export declare const defaultLogger: Logger;
+export declare enum STACK_TRACE {
+    FULL = "full",
+    ONLY_LOG_CALL = "only-log-call"
+}
 export interface LoggerOptions {
     truncate: boolean;
+    stackTrace?: STACK_TRACE;
 }
 export declare class FlowLogger implements Logger {
     private readonly metadata;
@@ -22,5 +27,18 @@ export declare class FlowLogger implements Logger {
     log: (message: any, options?: LoggerOptions) => void;
     warn: (message: any, options?: LoggerOptions) => void;
     verbose: (message: any, options?: LoggerOptions) => void;
+    /**
+     * Parses a message into a FlowLog object, including optional stack trace information.
+     *
+     * @details Requirements for the output format of messages:
+     * - Necessary for consistent logging and event publishing, because the OpenSearch index expects a specific structure: flat_object.
+     * - The current UI expects a `message` property to be present, so we ensure it is always set.
+     *
+     * @param {any} message - The message to be logged. Can be a string, an object with a `message` property, or any other type.
+     * @param {string} level - The log level (e.g., 'error', 'debug', 'warn', 'verbose').
+     * @param {LoggerOptions} options - Additional options for logging, such as whether to include a stack trace.
+     * @returns {FlowLog} - An object containing the parsed log message and optional stack trace.
+     */
+    private parseMessageToFlowLog;
     private publish;
 }

package/dist/FlowLogger.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FlowLogger = exports.defaultLogger = void 0;
+exports.FlowLogger = exports.STACK_TRACE = exports.defaultLogger = void 0;
 const FlowEvent_1 = require("./FlowEvent");
 exports.defaultLogger = {
     debug: (msg, metadata) => console.debug(msg),
@@ -9,8 +9,13 @@ exports.defaultLogger = {
     warn: (msg, metadata) => console.warn(msg),
     verbose: (msg, metadata) => console.log(msg, metadata),
 };
+var STACK_TRACE;
+(function (STACK_TRACE) {
+    STACK_TRACE["FULL"] = "full";
+    STACK_TRACE["ONLY_LOG_CALL"] = "only-log-call";
+})(STACK_TRACE || (exports.STACK_TRACE = STACK_TRACE = {}));
 class FlowLogger {
-    static getStackTrace() {
+    static getStackTrace(stacktrace = STACK_TRACE.FULL) {
         let stack;
         try {
             throw new Error('');
@@ -21,8 +26,14 @@ class FlowLogger {
         stack = stack
             .split('\n')
             .map((line) => line.trim())
-            .filter((value) => !value.includes('Logger'));
-        return stack.splice(1).join('\n');
+            .filter((value) => value.includes('at ') && !value.includes('Logger'));
+        if (stacktrace === STACK_TRACE.ONLY_LOG_CALL && stack.length > 0) {
+            stack = stack[0];
+        }
+        else {
+            stack = stack.splice(1).join('\n');
+        }
+        return stack;
     }
     constructor(metadata, logger = exports.defaultLogger, publishEvent) {
         this.metadata = metadata;
@@ -34,28 +45,49 @@ class FlowLogger {
         this.warn = (message, options) => this.publish(message, 'warn', options);
         this.verbose = (message, options) => this.publish(message, 'verbose', options);
     }
+    parseMessageToFlowLog(message, level, options) {
+        let flowLogMessage;
+        if (!message) {
+            flowLogMessage = 'No message provided!';
+        }
+        else if (typeof message.message === 'string') {
+            flowLogMessage = message.message;
+        }
+        else if (typeof message === 'string') {
+            flowLogMessage = message;
+        }
+        else {
+            try {
+                flowLogMessage = JSON.stringify(message.message ?? message);
+            }
+            catch (e) {
+                flowLogMessage = 'Error: Could not stringify the message.';
+            }
+        }
+        const flowLog = { message: flowLogMessage };
+        if (['error', 'debug', 'warn', 'verbose'].includes(level) || options?.stackTrace) {
+            flowLog.stackTrace = FlowLogger.getStackTrace(options?.stackTrace ?? STACK_TRACE.ONLY_LOG_CALL);
+        }
+        return flowLog;
+    }
     publish(message, level, options) {
+        const flowLogData = this.parseMessageToFlowLog(message, level, options);
         if (this.publishEvent) {
-            const data = message?.message
-                ? message
-                : {
-                    ...message,
-                    message: typeof message === 'string' ? message : JSON.stringify(message),
-                };
-            const event = new FlowEvent_1.FlowEvent(this.metadata, data, `flow.log.${level}`);
+            const event = new FlowEvent_1.FlowEvent(this.metadata, flowLogData, `flow.log.${level}`);
             this.publishEvent(event);
         }
+        const messageWithStackTrace = flowLogData.stackTrace ? `${flowLogData.message}\n${flowLogData.stackTrace}` : flowLogData.message;
         switch (level) {
             case 'debug':
-                return this.logger.debug(message, { ...this.metadata, ...options });
+                return this.logger.debug(messageWithStackTrace, { ...this.metadata, ...options });
             case 'error':
-                return this.logger.error(message, { ...this.metadata, ...options });
+                return this.logger.error(messageWithStackTrace, { ...this.metadata, ...options });
             case 'warn':
-                return this.logger.warn(message, { ...this.metadata, ...options });
+                return this.logger.warn(messageWithStackTrace, { ...this.metadata, ...options });
             case 'verbose':
-                return this.logger.verbose(message, { ...this.metadata, ...options });
+                return this.logger.verbose(messageWithStackTrace, { ...this.metadata, ...options });
             default:
-                this.logger.log(message, { ...this.metadata, ...options });
+                this.logger.log(messageWithStackTrace, { ...this.metadata, ...options });
         }
     }
 }

package/dist/nats.js

@@ -66,6 +66,7 @@ async function natsEventListener(nc, logger, reconnectHandler) {
 }
 async function publishNatsEvent(logger, nc, event, subject) {
     if (!nc || nc.isClosed()) {
+        logger.error('NATS connection is not available, cannot publish event');
         return;
     }
     const cloudEvent = new cloudevents_1.CloudEvent({ datacontenttype: 'application/json', ...event });

package/dist/utils.d.ts

@@ -3,6 +3,45 @@ export declare function fillTemplate(value: any, ...templateVariables: any): any
 export declare function getCircularReplacer(): (key: any, value: any) => any;
 export declare function toArray(value?: string | string[]): string[];
 export declare function delay(ms: number): Promise<void>;
+/**
+ * Creates a promise that resolves after a specified delay, with support for cancellation via an AbortSignal.
+ *
+ * @param {number} ms - The delay duration in milliseconds.
+ * @param {Object} [options] - Optional configuration.
+ * @param {AbortSignal} [options.signal] - An AbortSignal to allow cancellation of the delay.
+ *
+ * @returns {Promise<void>} A promise that resolves after the specified delay or rejects if aborted.
+ *
+ * @throws {Error} If the AbortSignal is already aborted or gets aborted during the delay, the promise rejects with an "AbortError".
+ *
+ * @details Usage:
+ * ```typescript
+ * @FlowFunction('test.task.LongRunningTask')
+ * class LongRunningTask extends FlowTask<Properties> {
+ *   private readonly abortController = new AbortController();
+ *
+ *   constructor(...) {...}
+ *
+ *   @InputStream()
+ *   public async loveMeLongTime(event) {
+ *     try {
+ *       await delayWithAbort(this.properties.delay, { signal: this.abortController.signal });
+ *       return this.emitEvent({ foo: 'bar' }, null);
+ *     } catch (err) {
+ *       if (err.message === 'AbortError') {
+ *         return; // Task was aborted
+ *       }
+ *       throw err;
+ *     }
+ *   }
+ *
+ *   public onDestroy = () => { this.abortController.abort(); };
+ * }
+ * ```
+ */
+export declare function delayWithAbort(ms: number, options?: {
+    signal?: AbortSignal;
+}): Promise<void>;
 export declare function deleteFiles(dir: string, ...filenames: string[]): Promise<void>;
 export declare function handleApiError(error: any, logger: FlowLogger): void;
 export declare function runPyScript(scriptPath: string, data: any): Promise<any>;

package/dist/utils.js

@@ -4,6 +4,7 @@ exports.fillTemplate = fillTemplate;
 exports.getCircularReplacer = getCircularReplacer;
 exports.toArray = toArray;
 exports.delay = delay;
+exports.delayWithAbort = delayWithAbort;
 exports.deleteFiles = deleteFiles;
 exports.handleApiError = handleApiError;
 exports.runPyScript = runPyScript;
@@ -63,6 +64,19 @@ function toArray(value = []) {
 function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function delayWithAbort(ms, options) {
+    return new Promise((resolve, reject) => {
+        if (options?.signal?.aborted) {
+            reject(new Error('AbortError'));
+            return;
+        }
+        const timeout = setTimeout(() => resolve(), ms);
+        options?.signal?.addEventListener('abort', () => {
+            clearTimeout(timeout);
+            reject(new Error('AbortError'));
+        });
+    });
+}
 async function deleteFiles(dir, ...filenames) {
     for (const filename of filenames) {
         await fs_1.promises.unlink((0, path_1.join)(dir, filename)).catch((err) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hahnpro/flow-sdk",
-  "version": "9.4.1",
+  "version": "9.6.0",
   "description": "SDK for building Flow Modules",
   "license": "MIT",
   "author": {