@hahnpro/flow-sdk 7.0.2 → 8.0.0

package/dist/ContextManager.d.ts

@@ -0,0 +1,39 @@
+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>} [properties={}] - Initial properties to set.
+     */
+    constructor(logger: Logger, properties?: Record<string, any>);
+    /**
+     * Init or overwrite all properties.
+     * @param properties
+     */
+    overwriteAllProperties(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/dist/ContextManager.js

@@ -0,0 +1,74 @@
+"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 ContextManager {
+    constructor(logger, properties = {}) {
+        this.logger = logger;
+        this.properties = properties;
+    }
+    overwriteAllProperties(properties = {}) {
+        this.properties = properties;
+    }
+    getProperties() {
+        return { ...this.properties };
+    }
+    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(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('${')) {
+        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/dist/FlowApplication.d.ts

@@ -9,6 +9,7 @@ import { FlowEvent } from './FlowEvent';
 import { Logger } from './FlowLogger';
 import { RpcClient } from './RpcClient';
 import { NatsConnection, ConnectionOptions as NatsConnectionOptions } from 'nats';
+import { ContextManager } from './ContextManager';
 interface FlowAppConfig {
     logger?: Logger;
     amqpConfig?: AmqpConnectionConfig;
@@ -38,14 +39,16 @@ export declare class FlowApplication {
     private outputStreamMap;
     private outputQueueMetrics;
     private performanceMap;
-    private properties;
     private readonly skipApi;
     private readonly apiClient?;
+    private readonly contextManager;
     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>;
     init(): Promise<void>;
     private publishLifecycleEvent;
     private setQueueMetrics;
@@ -53,7 +56,6 @@ export declare class FlowApplication {
     subscribe: (streamId: string, observer: PartialObserver<FlowEvent>) => import("rxjs").Subscription;
     emit: (event: FlowEvent) => void;
     emitPartial: (completeEvent: FlowEvent, partialEvent: FlowEvent) => void;
-    getProperties(): Record<string, any>;
     onMessage: (msg: ConsumeMessage) => Promise<void>;
     /**
      * Publish a flow event to the amqp flowlogs exchange.

package/dist/FlowApplication.js

@@ -10,12 +10,14 @@ 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 lodash_1 = require("lodash");
 const amqp_1 = require("./amqp");
 const flow_interface_1 = require("./flow.interface");
 const FlowLogger_1 = require("./FlowLogger");
 const RpcClient_1 = require("./RpcClient");
 const utils_1 = require("./utils");
 const nats_1 = require("./nats");
+const ContextManager_1 = require("./ContextManager");
 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;
@@ -125,8 +127,9 @@ class FlowApplication {
                         context = this.context;
                     }
                     if (flow.properties) {
-                        this.properties = flow.properties;
+                        this.contextManager.overwriteAllProperties({ ...this.contextManager.getProperties(), ...flow.properties });
                         for (const element of Object.values(this.elements)) {
+                            element.replacePlaceholderAndSetProperties();
                             element.onFlowPropertiesChanged?.(flow.properties);
                         }
                     }
@@ -137,7 +140,8 @@ class FlowApplication {
                         }
                     }
                     for (const element of flow.elements || []) {
-                        this.elements?.[element.id]?.onPropertiesChanged(element.properties);
+                        this.elements?.[element.id]?.setPropertiesWithPlaceholders((0, lodash_1.cloneDeep)(element.properties));
+                        this.elements?.[element.id]?.onPropertiesChanged(this.contextManager.replaceAllPlaceholderProperties(this.elements[element.id].getPropertiesWithPlaceholders()));
                     }
                     const statusEvent = {
                         eventId: (0, crypto_1.randomUUID)(),
@@ -224,6 +228,7 @@ class FlowApplication {
             this._api = mockApi || null;
         }
         this.logger = new FlowLogger_1.FlowLogger({ id: 'none', functionFqn: 'FlowApplication', ...flow?.context }, this.baseLogger || undefined, this.publishEvent);
+        this.contextManager = new ContextManager_1.ContextManager(this.logger, this.flow?.properties);
         process.once('uncaughtException', (err) => {
             this.logger.error('Uncaught exception!');
             this.logger.error(err);
@@ -253,14 +258,25 @@ class FlowApplication {
     get natsConnection() {
         return this._natsConnection;
     }
+    getContextManager() {
+        return this.contextManager;
+    }
+    getProperties() {
+        return this.contextManager.getProperties();
+    }
     async init() {
         if (this.initialized)
             return;
         this.context = { ...this.flow.context };
-        this.properties = this.flow.properties || {};
+        this.contextManager.overwriteAllProperties(this.flow.properties ?? {});
         try {
             if (!this.skipApi && !(this._api instanceof hpc_api_1.MockAPI)) {
-                this._api = new hpc_api_1.API(this.apiClient);
+                let tokenSubject;
+                const { owner, runAsOwner } = this.context;
+                if (runAsOwner && owner) {
+                    tokenSubject = owner.type === 'org' ? 'org-admin-' + owner.id : owner.id;
+                }
+                this._api = new hpc_api_1.API(this.apiClient, { tokenSubject });
             }
         }
         catch (err) {
@@ -322,7 +338,8 @@ class FlowApplication {
             const { id, name, properties, module, functionFqn } = element;
             try {
                 const context = { ...this.context, id, name, logger: this.baseLogger, app: this };
-                this.elements[id] = new this.declarations[`${module}.${functionFqn}`](context, properties);
+                this.elements[id] = new this.declarations[`${module}.${functionFqn}`](context, this.contextManager.replaceAllPlaceholderProperties(properties));
+                this.elements[id].setPropertiesWithPlaceholders((0, lodash_1.cloneDeep)(properties));
             }
             catch (err) {
                 await logErrorAndExit(`Could not create FlowElement for ${module}.${functionFqn}`);
@@ -387,9 +404,6 @@ class FlowApplication {
         this.initialized = true;
         this.logger.log('Flow Deployment is running');
     }
-    getProperties() {
-        return this.properties;
-    }
     async destroy(exitCode = 0) {
         try {
             try {

package/dist/FlowElement.d.ts

@@ -12,14 +12,28 @@ export declare abstract class FlowElement<T = any> {
     protected readonly logger: FlowLogger;
     protected metadata: FlowElementContext;
     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);
+    /**
+     * Sets the placeholder properties for this flow element
+     * @param propertiesWithPlaceholders
+     */
+    setPropertiesWithPlaceholders(propertiesWithPlaceholders: T): void;
+    /**
+     * Returns the placeholder properties for this flow element
+     */
+    getPropertiesWithPlaceholders(): T;
     get flowProperties(): Record<string, any>;
     get natsConnection(): import("nats").NatsConnection;
     onDestroy?: () => void;
     onMessage?: (message: DeploymentMessage) => void;
+    /**
+     * Replace all placeholder properties with their explicit updated value and set them as the properties of the element
+     */
+    replacePlaceholderAndSetProperties(): void;
     onFlowPropertiesChanged?: (properties: Record<string, any>) => void;
     onContextChanged: (context: Partial<FlowContext>) => void;
     onPropertiesChanged: (properties: T) => void;

package/dist/FlowElement.js

@@ -30,7 +30,7 @@ class FlowElement {
             }
         };
         this.handleApiError = (error) => (0, utils_1.handleApiError)(error, this.logger);
-        this.interpolate = (value, ...templateVariables) => (0, utils_1.fillTemplate)(value, ...templateVariables);
+        this.interpolate = (value, ...templateVariables) => (0, utils_1.fillTemplate)(value, ...templateVariables, { flow: this.app?.getContextManager().getProperties().flow ?? {} });
         this.app = app;
         this.api = this.app?.api;
         this.metadata = { ...metadata, functionFqn: this.functionFqn };
@@ -40,12 +40,24 @@ class FlowElement {
             this.setProperties(properties);
         }
     }
+    setPropertiesWithPlaceholders(propertiesWithPlaceholders) {
+        this.propertiesWithPlaceholders = propertiesWithPlaceholders;
+    }
+    getPropertiesWithPlaceholders() {
+        return this.propertiesWithPlaceholders;
+    }
     get flowProperties() {
         return this.app?.getProperties?.() || {};
     }
     get natsConnection() {
         return this.app?.natsConnection;
     }
+    replacePlaceholderAndSetProperties() {
+        const placeholderProperties = this.propertiesWithPlaceholders;
+        if (this.propertiesWithPlaceholders) {
+            this.setProperties(this.app.getContextManager()?.replaceAllPlaceholderProperties(placeholderProperties));
+        }
+    }
     emitOutput(data = {}, outputId = 'default', time = new Date()) {
         return this.emitEvent(data, null, outputId, time);
     }

package/dist/flow.interface.d.ts

@@ -1,7 +1,10 @@
+import { Owner } from '@hahnpro/hpc-api';
 export interface FlowContext {
     deploymentId?: string;
     diagramId?: string;
     flowId?: string;
+    owner?: Owner;
+    runAsOwner?: boolean;
 }
 export interface FlowElementContext extends FlowContext {
     id: string;

package/dist/index.d.ts

@@ -8,4 +8,5 @@ export * from './FlowLogger';
 export * from './FlowModule';
 export * from './TestModule';
 export * from './unit-decorators';
+export * from './ContextManager';
 export { IncompatableWith } from './extra-validators';

package/dist/index.js

@@ -12,5 +12,6 @@ tslib_1.__exportStar(require("./FlowLogger"), exports);
 tslib_1.__exportStar(require("./FlowModule"), exports);
 tslib_1.__exportStar(require("./TestModule"), exports);
 tslib_1.__exportStar(require("./unit-decorators"), exports);
+tslib_1.__exportStar(require("./ContextManager"), exports);
 var extra_validators_1 = require("./extra-validators");
 Object.defineProperty(exports, "IncompatableWith", { enumerable: true, get: function () { return extra_validators_1.IncompatableWith; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hahnpro/flow-sdk",
-  "version": "7.0.2",
+  "version": "8.0.0",
   "description": "SDK for building Flow Modules",
   "license": "MIT",
   "author": {
@@ -36,19 +36,19 @@
     "reflect-metadata": "0.2.2",
     "rxjs": "7.8.1",
     "string-interp": "0.3.6",
-    "@hahnpro/hpc-api": "5.2.8"
+    "@hahnpro/hpc-api": "5.3.0"
   },
   "devDependencies": {
     "@types/amqplib": "0.10.5",
     "@types/jest": "29.5.12",
     "@types/lodash": "4.17.7",
-    "@types/node": "20.14.15",
+    "@types/node": "20.16.5",
     "class-validator-jsonschema": "5.0.1",
     "jest": "29.7.0",
-    "typescript": "5.5.4"
+    "typescript": "5.6.2"
   },
   "peerDependencies": {
-    "axios": "1.7.4",
+    "axios": "1.7.7",
     "class-transformer": "0.5.1",
     "class-validator": "0.14.1",
     "lodash": "4.17.21",