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

package/src/lib/utils.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fillTemplate = fillTemplate;
+exports.getCircularReplacer = getCircularReplacer;
+exports.toArray = toArray;
+exports.delay = delay;
+exports.delayWithAbort = delayWithAbort;
+exports.deleteFiles = deleteFiles;
+exports.handleApiError = handleApiError;
+exports.runPyScript = runPyScript;
+exports.truncate = truncate;
+const tslib_1 = require("tslib");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const util_1 = require("util");
+const axios_1 = require("axios");
+const isPlainObject_1 = tslib_1.__importDefault(require("lodash/isPlainObject"));
+const python_shell_1 = require("python-shell");
+const string_interp_1 = tslib_1.__importDefault(require("string-interp"));
+function fillTemplate(value, ...templateVariables) {
+    if ((0, isPlainObject_1.default)(value)) {
+        for (const key of Object.keys(value)) {
+            value[key] = fillTemplate(value[key], ...templateVariables);
+        }
+        return value;
+    }
+    else if (Array.isArray(value) && value.length > 0) {
+        value.forEach(function (v, index) {
+            this[index] = fillTemplate(v, ...templateVariables);
+        }, value);
+        return value;
+    }
+    else if (value != null && typeof value === 'string' && value.includes('${')) {
+        for (const variables of templateVariables) {
+            try {
+                const result = (0, string_interp_1.default)(value, variables || {});
+                if (result) {
+                    return result;
+                }
+            }
+            catch (err) {
+                // ignore
+            }
+        }
+    }
+    else {
+        return value;
+    }
+}
+function getCircularReplacer() {
+    const seen = new WeakSet();
+    return (key, value) => {
+        if (typeof value === 'object' && value !== null) {
+            if (seen.has(value)) {
+                return;
+            }
+            seen.add(value);
+        }
+        return value;
+    };
+}
+function toArray(value = []) {
+    return Array.isArray(value) ? value : value.split(',').map((v) => v.trim());
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * 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(); };
+ * }
+ * ```
+ */
+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) => {
+            /*ignore*/
+        });
+    }
+}
+function handleApiError(error, logger) {
+    if ((0, axios_1.isAxiosError)(error)) {
+        const status = error.response?.status ?? error.code ?? '';
+        const statusText = error.response?.statusText ?? '';
+        const url = error.config?.url ?? '[Unknown URL]';
+        const method = error.config?.method?.toUpperCase() ?? '';
+        let errorText = error.response?.data ?? '';
+        if (typeof errorText !== 'string') {
+            try {
+                errorText = JSON.stringify(errorText, null, 2);
+            }
+            catch (_) {
+                errorText = '[Unserializable error body]';
+            }
+        }
+        logger.error(`${status} ${statusText}: ${method} request to ${url} failed\n${errorText}`);
+        if (error.stack) {
+            logger.error(error.stack);
+        }
+    }
+    else {
+        logger.error(error);
+    }
+}
+function runPyScript(scriptPath, data) {
+    return new Promise((resolve, reject) => {
+        let pyData;
+        const pyshell = new python_shell_1.PythonShell(scriptPath, { mode: 'text', pythonOptions: ['-u'] });
+        pyshell.send(JSON.stringify(data));
+        pyshell.on('message', (message) => {
+            try {
+                pyData = JSON.parse(message);
+            }
+            catch (err) {
+                pyData = message;
+            }
+        });
+        pyshell.end((err, code, signal) => {
+            if (err) {
+                return reject(err);
+            }
+            return resolve(pyData);
+        });
+    });
+}
+/**
+ * Truncates an object or string to the specified max length and depth
+ */
+function truncate(msg, depth = 4, maxStringLength = 1000) {
+    let truncated = (0, util_1.inspect)(msg, { depth, maxStringLength });
+    if (truncated.startsWith("'") && truncated.endsWith("'")) {
+        truncated = truncated.substring(1, truncated.length - 1);
+    }
+    return truncated;
+}

package/jest.config.ts

@@ -1,10 +0,0 @@
-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/project.json

@@ -1,41 +0,0 @@
-{
-  "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/lib/ContextManager.ts

@@ -1,111 +0,0 @@
-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;
-  }
-}