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

package/test/validation.spec.ts

@@ -0,0 +1,174 @@
+import { Type } from 'class-transformer';
+import { IsArray, IsNumber, IsString, ValidateNested } from 'class-validator';
+
+import { FlowFunction, FlowTask } from '../src';
+import { loggerMock } from './mocks/logger.mock';
+
+describe('Property Validation', () => {
+  afterEach(() => {
+    loggerMock.log.mockReset();
+    loggerMock.warn.mockReset();
+    loggerMock.error.mockReset();
+    jest.restoreAllMocks();
+  });
+
+  it('PCKG.FLW.SDK.VLDTN.1 should handle simple validation', () => {
+    @FlowFunction('test')
+    class Task extends FlowTask<Properties> {
+      constructor(context, properties) {
+        super(context, properties, Properties);
+      }
+    }
+
+    class Properties {
+      @IsNumber()
+      aNumber: number;
+    }
+
+    expect(() => new Task({ logger: loggerMock }, { aNumber: 42 })).not.toThrow('Properties Validation failed');
+
+    expect(() => new Task({ logger: loggerMock }, {})).toThrow('Properties Validation failed');
+    expect(loggerMock.error).toHaveBeenLastCalledWith(
+      expect.stringContaining(
+        'Validation for property "aNumber" failed:\n{"isNumber":"aNumber must be a number conforming to the specified constraints"}\nvalue: undefined',
+      ),
+      { functionFqn: 'test' },
+    );
+
+    expect(() => new Task({ logger: loggerMock }, { aNumber: 'a string' })).toThrow('Properties Validation failed');
+    expect(loggerMock.error).toHaveBeenLastCalledWith(
+      expect.stringContaining(
+        'Validation for property "aNumber" failed:\n{"isNumber":"aNumber must be a number conforming to the specified constraints"}\nvalue: a string',
+      ),
+      { functionFqn: 'test' },
+    );
+  });
+
+  it('PCKG.FLW.SDK.VLDTN.2 should handle array validation', () => {
+    @FlowFunction('test')
+    class Task extends FlowTask<Properties> {
+      constructor(context, properties) {
+        super(context, properties, Properties);
+      }
+    }
+
+    class Properties {
+      @IsArray()
+      @IsString({ each: true })
+      aStringArray: string[];
+    }
+
+    expect(() => new Task({ logger: loggerMock }, { aStringArray: [] })).not.toThrow('Properties Validation failed');
+    expect(() => new Task({ logger: loggerMock }, { aStringArray: ['foo'] })).not.toThrow('Properties Validation failed');
+    expect(() => new Task({ logger: loggerMock }, { aStringArray: ['foo', 'bar'] })).not.toThrow('Properties Validation failed');
+
+    expect(() => new Task({ logger: loggerMock }, {})).toThrow('Properties Validation failed');
+    expect(loggerMock.error).toHaveBeenLastCalledWith(
+      expect.stringContaining(
+        'Validation for property "aStringArray" failed:\n{"isString":"each value in aStringArray must be a string","isArray":"aStringArray must be an array"}\nvalue: undefined',
+      ),
+      { functionFqn: 'test' },
+    );
+
+    expect(() => new Task({ logger: loggerMock }, { aStringArray: 'foo' })).toThrow('Properties Validation failed');
+    expect(loggerMock.error).toHaveBeenLastCalledWith(
+      expect.stringContaining('Validation for property "aStringArray" failed:\n{"isArray":"aStringArray must be an array"}\nvalue: foo'),
+      { functionFqn: 'test' },
+    );
+
+    expect(() => new Task({ logger: loggerMock }, { aStringArray: ['foo', 42] })).toThrow('Properties Validation failed');
+    expect(loggerMock.error).toHaveBeenLastCalledWith(
+      expect.stringContaining(
+        'Validation for property "aStringArray" failed:\n{"isString":"each value in aStringArray must be a string"}\nvalue: foo,42',
+      ),
+      { functionFqn: 'test' },
+    );
+  });
+
+  it('PCKG.FLW.SDK.VLDTN.3 should handle nested validation', () => {
+    @FlowFunction('test')
+    class Task extends FlowTask<Properties> {
+      constructor(context, properties) {
+        super(context, properties, Properties);
+      }
+    }
+
+    class Nested {
+      @IsString()
+      aString: string;
+    }
+
+    class Properties {
+      @Type(() => Nested)
+      @ValidateNested()
+      nested: Nested;
+    }
+
+    expect(() => new Task({ logger: loggerMock }, { nested: { aString: 'foo' } })).not.toThrow('Properties Validation failed');
+
+    expect(() => new Task({ logger: loggerMock }, { nested: {} })).toThrow('Properties Validation failed');
+    expect(loggerMock.error).toHaveBeenLastCalledWith(
+      expect.stringContaining(
+        'Validation for property "nested.aString" failed:\n{"isString":"aString must be a string"}\nvalue: undefined',
+      ),
+      { functionFqn: 'test' },
+    );
+
+    expect(() => new Task({ logger: loggerMock }, { nested: { aString: 42 } })).toThrow('Properties Validation failed');
+    expect(loggerMock.error).toHaveBeenLastCalledWith(
+      expect.stringContaining('Validation for property "nested.aString" failed:\n{"isString":"aString must be a string"}\nvalue: 42'),
+      { functionFqn: 'test' },
+    );
+  });
+
+  it('PCKG.FLW.SDK.VLDTN.4 should handle arrays with nested validation', () => {
+    @FlowFunction('test')
+    class Task extends FlowTask<Properties> {
+      constructor(context, properties) {
+        super(context, properties, Properties);
+      }
+    }
+
+    class Nested {
+      @IsString()
+      aString: string;
+    }
+
+    class Properties {
+      @IsArray()
+      @Type(() => Nested)
+      @ValidateNested({ each: true })
+      nested: Nested[];
+    }
+
+    expect(() => new Task({ logger: loggerMock }, { nested: [] })).not.toThrow('Properties Validation failed');
+    expect(() => new Task({ logger: loggerMock }, { nested: [{ aString: 'foo' }] })).not.toThrow('Properties Validation failed');
+
+    expect(() => new Task({ logger: loggerMock }, { nested: [{}] })).toThrow('Properties Validation failed');
+    expect(loggerMock.error).toHaveBeenLastCalledWith(
+      expect.stringContaining(
+        'Validation for property "nested.0.aString" failed:\n{"isString":"aString must be a string"}\nvalue: undefined',
+      ),
+      { functionFqn: 'test' },
+    );
+
+    expect(() => new Task({ logger: loggerMock }, { nested: 42 })).toThrow('Properties Validation failed');
+    expect(loggerMock.error).toHaveBeenLastCalledWith(
+      expect.stringContaining(
+        'Validation for property "nested" failed:\n{"isArray":"nested must be an array","nestedValidation":"each value in nested property nested must be either object or array"}\nvalue: 42',
+      ),
+      { functionFqn: 'test' },
+    );
+    expect(() => new Task({ logger: loggerMock }, {})).toThrow('Properties Validation failed');
+    expect(loggerMock.error).toHaveBeenLastCalledWith(
+      expect.stringContaining('Validation for property "nested" failed:\n{"isArray":"nested must be an array"}\nvalue: undefined'),
+      { functionFqn: 'test' },
+    );
+
+    expect(() => new Task({ logger: loggerMock }, { nested: [{ aString: 42 }] })).toThrow('Properties Validation failed');
+    expect(loggerMock.error).toHaveBeenLastCalledWith(
+      expect.stringContaining('Validation for property "nested.0.aString" failed:\n{"isString":"aString must be a string"}\nvalue: 42'),
+      { functionFqn: 'test' },
+    );
+  });
+});

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ]
+}

package/tsconfig.lib.json

@@ -0,0 +1,22 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "rootDir": "src",
+    "outDir": "dist",
+    "declaration": true,
+    "emitDeclarationOnly": false,
+    "forceConsistentCasingInFileNames": true,
+    "isolatedModules": true,
+    "moduleResolution": "Node16",
+    "module": "Node16",
+    "noImplicitOverride": false,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noPropertyAccessFromIndexSignature": false,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"],
+  "references": [],
+  "exclude": ["jest.config.ts", "src/**/*.spec.ts", "src/**/*.test.ts"]
+}

package/tsconfig.spec.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.lib.json",
+  "compilerOptions": {
+    "outDir": "./out-tsc/jest",
+    "types": ["jest", "node"]
+  },
+  "include": ["jest.config.ts", "test/**/*.test.ts", "test/**/*.spec.ts", "test/**/*.d.ts"]
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2021 Hahn PRO
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/dist/ContextManager.d.ts

@@ -1,40 +0,0 @@
-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/dist/ContextManager.js

@@ -1,77 +0,0 @@
-"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, flowProperties = {}) {
-        this.logger = logger;
-        this.properties = { flow: flowProperties };
-    }
-    overwriteAllProperties(properties = {}) {
-        this.properties = { flow: properties };
-    }
-    updateFlowProperties(properties = {}) {
-        this.properties.flow = 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

@@ -1,85 +0,0 @@
-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 { ClassType, Flow, FlowElementContext } from './flow.interface';
-import { FlowEvent } from './FlowEvent';
-import { Logger } from './FlowLogger';
-import { RpcClient } from './RpcClient';
-import { ContextManager } from './ContextManager';
-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 {};