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

package/jest.config.ts

@@ -0,0 +1,10 @@
+export default {
+  displayName: 'flow-sdk',
+  preset: '../../jest.preset.js',
+  testEnvironment: 'node',
+  transform: {
+    '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.spec.json' }],
+  },
+  moduleFileExtensions: ['ts', 'js', 'html'],
+  coverageDirectory: '../../coverage/lib/flow-sdk',
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hahnpro/flow-sdk",
-  "version": "9.6.4",
+  "version": "2025.2.0-beta.1",
   "description": "SDK for building Flow Modules",
   "license": "MIT",
   "author": {
@@ -11,34 +11,27 @@
     "type": "git",
     "url": "git@github.com:hahnprojects/flow.git"
   },
-  "directories": {
-    "lib": "lib",
-    "test": "test"
-  },
-  "files": [
-    "dist"
-  ],
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "main": "./src/index.js",
+  "types": "./src/index.d.ts",
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@hahnpro/hpc-api": "2025.5.0",
     "@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",
+    "class-validator": "0.14.2",
     "cloudevents": "10.0.0",
     "lodash": "4.17.21",
-    "object-sizeof": "~2.6.5",
+    "object-sizeof": "2.6.5",
     "python-shell": "5.0.0",
     "reflect-metadata": "0.2.2",
     "rxjs": "7.8.2",
-    "string-interp": "0.3.6"
+    "string-interp": "0.3.6",
+    "@hahnpro/hpc-api": "2025.6.0"
   },
   "devDependencies": {
     "@types/amqplib": "0.10.7",
@@ -58,11 +51,5 @@
   },
   "engines": {
     "node": ">=v22"
-  },
-  "scripts": {
-    "build": "../../node_modules/.bin/tsc -p tsconfig.lib.json",
-    "build:nocomments": "../../node_modules/.bin/tsc -p tsconfig.nocomments.json",
-    "postbuild": "../../node_modules/.bin/copyfiles -u 1 lib/*.py dist",
-    "lint": "eslint '*/**/*.{js,ts}'"
   }
 }

package/project.json

@@ -0,0 +1,41 @@
+{
+  "name": "flow-sdk",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "root": "lib/flow-sdk",
+  "sourceRoot": "lib/flow-sdk/src",
+  "projectType": "library",
+  "release": {
+    "version": {
+      "preserveLocalDependencyProtocols": false,
+      "manifestRootsToUpdate": ["dist/{projectRoot}"]
+    }
+  },
+  "targets": {
+    "build": {
+      "executor": "@nx/js:tsc",
+      "outputs": ["{options.outputPath}"],
+      "options": {
+        "outputPath": "dist/lib/flow-sdk",
+        "main": "lib/flow-sdk/src/index.ts",
+        "tsConfig": "lib/flow-sdk/tsconfig.lib.json",
+        "assets": ["lib/flow-sdk/*.md", "lib/flow-sdk/src/lib/*.py"]
+      }
+    },
+    "nx-release-publish": {
+      "options": {
+        "packageRoot": "dist/{projectRoot}"
+      }
+    },
+    "lint": {
+      "executor": "@nx/eslint:lint"
+    },
+    "test": {
+      "executor": "@nx/jest:jest",
+      "outputs": ["{workspaceRoot}/coverage/{projectRoot}"],
+      "options": {
+        "jestConfig": "lib/flow-sdk/jest.config.ts"
+      }
+    }
+  },
+  "tags": []
+}

package/src/index.ts

@@ -0,0 +1,15 @@
+export * from '@hahnpro/hpc-api';
+
+export * from './lib/flow.interface';
+export * from './lib/utils';
+export * from './lib/FlowApplication';
+export * from './lib/FlowElement';
+export * from './lib/FlowEvent';
+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/lib/ContextManager.ts

@@ -0,0 +1,111 @@
+import { cloneDeep, get, isPlainObject, set } from 'lodash';
+import interp from 'string-interp';
+
+import { Logger } from './FlowLogger';
+
+/**
+ * Class representing a context manager for handling properties.
+ */
+export class ContextManager {
+  private properties: Record<string, any>;
+
+  /**
+   * Constructor of the ContextManager.
+   * @param {Logger} logger - The logger instance for logging messages.
+   * @param {Record<string, any>} [flowProperties={}] - Initial properties to set.
+   */
+  constructor(
+    protected logger: Logger,
+    flowProperties: Record<string, any> = {},
+  ) {
+    this.properties = { flow: flowProperties };
+  }
+
+  /**
+   * Init or overwrite all properties.
+   * @param properties
+   */
+  public overwriteAllProperties(properties: Record<string, any> = {}): void {
+    this.properties = { flow: properties };
+  }
+
+  public updateFlowProperties(properties: Record<string, any> = {}): void {
+    this.properties.flow = properties;
+  }
+
+  /**
+   * Get a copy of the current properties.
+   * @returns {Record<string, any>} A copy of the properties.
+   */
+  public getProperties(): Record<string, any> {
+    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.
+   */
+  public set(keyOrPath: string, value: any): void {
+    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 {
+      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.
+   */
+  public get(keyOrPath: string): any {
+    return get(this.properties, keyOrPath, undefined);
+  }
+
+  public replaceAllPlaceholderProperties(properties: any) {
+    return flowInterpolate(cloneDeep(properties), this.properties);
+  }
+}
+
+export function flowInterpolate(value: any, properties: Record<string, any>): any {
+  if (!properties) {
+    return value;
+  }
+  if (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: RegExpExecArray;
+    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: string, templateVariables: Record<string, any>): string {
+  try {
+    return interp(text, templateVariables) ?? text;
+  } catch (err) {
+    return text;
+  }
+}