@hahnpro/flow-sdk 2025.2.0-beta.1 → 2025.2.0-beta.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hahnpro/flow-sdk",
-  "version": "2025.2.0-beta.1",
+  "version": "2025.2.0-beta.3",
   "description": "SDK for building Flow Modules",
   "license": "MIT",
   "author": {
@@ -30,8 +30,7 @@
     "python-shell": "5.0.0",
     "reflect-metadata": "0.2.2",
     "rxjs": "7.8.2",
-    "string-interp": "0.3.6",
-    "@hahnpro/hpc-api": "2025.6.0"
+    "string-interp": "0.3.6"
   },
   "devDependencies": {
     "@types/amqplib": "0.10.7",
@@ -51,5 +50,6 @@
   },
   "engines": {
     "node": ">=v22"
-  }
+  },
+  "type": "commonjs"
 }

package/src/{index.ts → index.d.ts}

@@ -1,5 +1,4 @@
 export * from '@hahnpro/hpc-api';
-
 export * from './lib/flow.interface';
 export * from './lib/utils';
 export * from './lib/FlowApplication';
@@ -9,7 +8,5 @@ export * from './lib/FlowLogger';
 export { FlowModule } from './lib/FlowModule';
 export * from './lib/TestModule';
 export * from './lib/unit-decorators';
-
 export * from './lib/ContextManager';
-
 export { IncompatableWith } from './lib/extra-validators';

package/src/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IncompatableWith = exports.FlowModule = void 0;
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("@hahnpro/hpc-api"), exports);
+tslib_1.__exportStar(require("./lib/flow.interface"), exports);
+tslib_1.__exportStar(require("./lib/utils"), exports);
+tslib_1.__exportStar(require("./lib/FlowApplication"), exports);
+tslib_1.__exportStar(require("./lib/FlowElement"), exports);
+tslib_1.__exportStar(require("./lib/FlowEvent"), exports);
+tslib_1.__exportStar(require("./lib/FlowLogger"), exports);
+var FlowModule_1 = require("./lib/FlowModule");
+Object.defineProperty(exports, "FlowModule", { enumerable: true, get: function () { return FlowModule_1.FlowModule; } });
+tslib_1.__exportStar(require("./lib/TestModule"), exports);
+tslib_1.__exportStar(require("./lib/unit-decorators"), exports);
+tslib_1.__exportStar(require("./lib/ContextManager"), exports);
+var extra_validators_1 = require("./lib/extra-validators");
+Object.defineProperty(exports, "IncompatableWith", { enumerable: true, get: function () { return extra_validators_1.IncompatableWith; } });

package/src/lib/ContextManager.d.ts

@@ -0,0 +1,40 @@
+import { Logger } from './FlowLogger';
+/**
+ * Class representing a context manager for handling properties.
+ */
+export declare class ContextManager {
+    protected logger: Logger;
+    private properties;
+    /**
+     * Constructor of the ContextManager.
+     * @param {Logger} logger - The logger instance for logging messages.
+     * @param {Record<string, any>} [flowProperties={}] - Initial properties to set.
+     */
+    constructor(logger: Logger, flowProperties?: Record<string, any>);
+    /**
+     * Init or overwrite all properties.
+     * @param properties
+     */
+    overwriteAllProperties(properties?: Record<string, any>): void;
+    updateFlowProperties(properties?: Record<string, any>): void;
+    /**
+     * Get a copy of the current properties.
+     * @returns {Record<string, any>} A copy of the properties.
+     */
+    getProperties(): Record<string, any>;
+    /**
+     * Set a property.
+     * A property key starting with "flow." is reserved for the properties set by in UI and so it is not allowed to be set.
+     * @param {string} keyOrPath - The key or the path of the property.
+     * @param {any} value - The value of the property.
+     */
+    set(keyOrPath: string, value: any): void;
+    /**
+     * Get a property value by key.
+     * @param {string} keyOrPath - The key or the path of the property.
+     * @returns {any} The value of the property.
+     */
+    get(keyOrPath: string): any;
+    replaceAllPlaceholderProperties(properties: any): any;
+}
+export declare function flowInterpolate(value: any, properties: Record<string, any>): any;

package/src/lib/ContextManager.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextManager = void 0;
+exports.flowInterpolate = flowInterpolate;
+const tslib_1 = require("tslib");
+const lodash_1 = require("lodash");
+const string_interp_1 = tslib_1.__importDefault(require("string-interp"));
+/**
+ * Class representing a context manager for handling properties.
+ */
+class ContextManager {
+    /**
+     * Constructor of the ContextManager.
+     * @param {Logger} logger - The logger instance for logging messages.
+     * @param {Record<string, any>} [flowProperties={}] - Initial properties to set.
+     */
+    constructor(logger, flowProperties = {}) {
+        this.logger = logger;
+        this.properties = { flow: flowProperties };
+    }
+    /**
+     * Init or overwrite all properties.
+     * @param properties
+     */
+    overwriteAllProperties(properties = {}) {
+        this.properties = { flow: properties };
+    }
+    updateFlowProperties(properties = {}) {
+        this.properties.flow = properties;
+    }
+    /**
+     * Get a copy of the current properties.
+     * @returns {Record<string, any>} A copy of the properties.
+     */
+    getProperties() {
+        return { ...this.properties };
+    }
+    /**
+     * Set a property.
+     * A property key starting with "flow." is reserved for the properties set by in UI and so it is not allowed to be set.
+     * @param {string} keyOrPath - The key or the path of the property.
+     * @param {any} value - The value of the property.
+     */
+    set(keyOrPath, value) {
+        if (keyOrPath.startsWith('flow.')) {
+            this.logger.error(`Set property of "${keyOrPath}" is not allowed, because it starts with "flow.", so it is reserved for the properties set by in UI.`);
+        }
+        else {
+            (0, lodash_1.set)(this.properties, keyOrPath, value);
+        }
+    }
+    /**
+     * Get a property value by key.
+     * @param {string} keyOrPath - The key or the path of the property.
+     * @returns {any} The value of the property.
+     */
+    get(keyOrPath) {
+        return (0, lodash_1.get)(this.properties, keyOrPath, undefined);
+    }
+    replaceAllPlaceholderProperties(properties) {
+        return flowInterpolate((0, lodash_1.cloneDeep)(properties), this.properties);
+    }
+}
+exports.ContextManager = ContextManager;
+function flowInterpolate(value, properties) {
+    if (!properties) {
+        return value;
+    }
+    if ((0, lodash_1.isPlainObject)(value)) {
+        for (const key of Object.keys(value)) {
+            value[key] = flowInterpolate(value[key], properties);
+        }
+        return value;
+    }
+    else if (Array.isArray(value) && value.length > 0) {
+        value.forEach(function (v, index) {
+            this[index] = flowInterpolate(v, properties);
+        }, value);
+        return value;
+    }
+    else if (value != null && typeof value === 'string' && value.startsWith('${')) {
+        // get ${...} blocks and replace the ones that start with flow. in a new string
+        const blockRegEx = /\$\{\s*(\S+)\s*}/g;
+        let newValue = value;
+        let m;
+        do {
+            m = blockRegEx.exec(value);
+            if (m?.[1].startsWith('flow.')) {
+                newValue = newValue.replace(m[0], interpolate(m[0], { flow: properties.flow }));
+            }
+        } while (m);
+        return newValue;
+    }
+    else {
+        return value;
+    }
+}
+function interpolate(text, templateVariables) {
+    try {
+        return (0, string_interp_1.default)(text, templateVariables) ?? text;
+    }
+    catch (err) {
+        return text;
+    }
+}

package/src/lib/FlowApplication.d.ts

@@ -0,0 +1,85 @@
+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;
+    skipApi?: boolean;
+    explicitInit?: boolean;
+    mockApi?: MockAPI;
+}
+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;
+    private context;
+    private declarations;
+    private elements;
+    private initialized;
+    private readonly logger;
+    private outputStreamMap;
+    private outputQueueMetrics;
+    private performanceMap;
+    private readonly skipApi;
+    private readonly apiClient?;
+    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;
+    get api(): API;
+    get natsConnection(): NatsConnection;
+    getContextManager(): ContextManager;
+    getProperties(): Record<string, any>;
+    private consumeNatsMessagesOfConsumer;
+    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;
+    onMessage: (cloudEvent: CloudEvent) => Promise<void>;
+    /**
+     * Publish a flow event to the amqp flowlogs exchange.
+     * If the event size exceeds the limit it will be truncated
+     *
+     * TODO warum darf hier nicht false zurückgegeben werden? -> erzeugt loop
+     */
+    publishNatsEventFlowlogs: (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;
+}
+export interface Context extends FlowElementContext {
+    app?: FlowApplication;
+    logger?: Logger;
+}
+export {};