@hahnpro/flow-sdk 5.0.0-0 → 5.0.1

package/dist/FlowElement.js

@@ -1,26 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowDashboard = exports.FlowTrigger = exports.FlowTask = exports.FlowResource = exports.FlowFunction = exports.InputStream = exports.FlowElement = void 0;
-const tslib_1 = require("tslib");
 const class_transformer_1 = require("class-transformer");
 const class_validator_1 = require("class-validator");
 const python_shell_1 = require("python-shell");
-const string_interp_1 = tslib_1.__importDefault(require("string-interp"));
 const FlowEvent_1 = require("./FlowEvent");
 const FlowLogger_1 = require("./FlowLogger");
 const utils_1 = require("./utils");
 class FlowElement {
-    constructor(_a, properties, propertiesClassType, whitelist = false) {
-        var _b, _c;
-        var { app, logger } = _a, metadata = tslib_1.__rest(_a, ["app", "logger"]);
+    constructor({ app, logger, ...metadata }, properties, propertiesClassType, whitelist = false) {
         this.propertiesClassType = propertiesClassType;
         this.whitelist = whitelist;
+        this.stopPropagateStream = new Map();
         this.onContextChanged = (context) => {
-            this.metadata = Object.assign(Object.assign({}, this.metadata), context);
+            this.metadata = { ...this.metadata, ...context };
         };
         this.onPropertiesChanged = (properties) => {
             this.setProperties(properties);
         };
+        this.getMetadata = () => this.metadata;
         this.setProperties = (properties) => {
             if (this.propertiesClassType) {
                 this.properties = this.validateProperties(this.propertiesClassType, properties, this.whitelist);
@@ -29,33 +27,42 @@ class FlowElement {
                 this.properties = properties;
             }
         };
-        this.handleApiError = (error) => utils_1.handleApiError(error, this.logger);
+        this.handleApiError = (error) => (0, utils_1.handleApiError)(error, this.logger);
+        this.interpolate = (value, ...templateVariables) => (0, utils_1.fillTemplate)(value, ...templateVariables);
         this.app = app;
-        this.api = (_b = this.app) === null || _b === void 0 ? void 0 : _b.api;
-        this.metadata = Object.assign(Object.assign({}, metadata), { functionFqn: this.functionFqn });
-        this.logger = new FlowLogger_1.FlowLogger(this.metadata, logger || undefined, (_c = this.app) === null || _c === void 0 ? void 0 : _c.publishEvent);
+        this.api = this.app?.api;
+        this.metadata = { ...metadata, functionFqn: this.functionFqn };
+        this.logger = new FlowLogger_1.FlowLogger(this.metadata, logger || undefined, this.app?.publishEvent);
         this.rpcRoutingKey = (this.metadata.flowId || '') + (this.metadata.deploymentId || '') + this.metadata.id;
         if (properties) {
             this.setProperties(properties);
         }
     }
     get flowProperties() {
-        var _a, _b;
-        return ((_b = (_a = this.app) === null || _a === void 0 ? void 0 : _a.getProperties) === null || _b === void 0 ? void 0 : _b.call(_a)) || {};
+        return this.app?.getProperties?.() || {};
     }
     emitOutput(data = {}, outputId = 'default', time = new Date()) {
-        const event = new FlowEvent_1.FlowEvent(this.metadata, data, outputId, time);
-        if (this.app) {
-            this.app.emit(event);
+        return this.emitEvent(data, null, outputId, time);
+    }
+    emitEvent(data, inputEvent, outputId = 'default', time = new Date()) {
+        const partialEvent = new FlowEvent_1.FlowEvent(this.metadata, data, outputId, time);
+        const completeEvent = new FlowEvent_1.FlowEvent(this.metadata, { ...(inputEvent?.getData() || {}), ...data }, outputId, time);
+        const streamID = inputEvent?.getMetadata()?.inputStreamId || '';
+        if ((this.stopPropagateStream.has(streamID) && this.stopPropagateStream.get(streamID)) || !this.stopPropagateStream.has(streamID)) {
+            this.app?.emit(partialEvent);
+            return partialEvent;
+        }
+        else {
+            this.app?.emitPartial(completeEvent, partialEvent);
+            return completeEvent;
         }
-        return event;
     }
     validateProperties(classType, properties = {}, whitelist = false) {
-        const props = class_transformer_1.plainToClass(classType, properties);
-        const errors = class_validator_1.validateSync(props, { whitelist });
-        if (errors && Array.isArray(errors) && errors.length > 0) {
+        const props = (0, class_transformer_1.plainToInstance)(classType, properties);
+        const errors = (0, class_validator_1.validateSync)(props, { forbidUnknownValues: false, whitelist });
+        if (Array.isArray(errors) && errors.length > 0) {
             for (const e of errors) {
-                this.logger.error(`Validation for property "${e.property}" failed:\n${JSON.stringify(e.constraints || {})}\nvalue: ${e.value}`);
+                this.logValidationErrors(e);
             }
             throw new Error('Properties Validation failed');
         }
@@ -63,36 +70,29 @@ class FlowElement {
             return props;
         }
     }
-    validateEventData(classType, event, whitelist = false) {
-        return this.validateProperties(classType, event.getData(), whitelist);
-    }
-    interpolate(text, ...templateVariables) {
-        var _a;
-        if (!((_a = text === null || text === void 0 ? void 0 : text.includes) === null || _a === void 0 ? void 0 : _a.call(text, '${'))) {
-            return text;
+    logValidationErrors(error, parent) {
+        const { children, constraints, property, value } = error;
+        const name = parent ? parent + '.' + property : property;
+        if (constraints) {
+            this.logger.error(`Validation for property "${name}" failed:\n${JSON.stringify(constraints || {})}\nvalue: ${value}`);
         }
-        for (const variables of templateVariables) {
-            const result = string_interp_1.default(text, variables || {});
-            if (result) {
-                return result;
+        else if (Array.isArray(children)) {
+            for (const child of children) {
+                this.logValidationErrors(child, name);
             }
         }
-        return text;
+    }
+    validateEventData(classType, event, whitelist = false) {
+        return this.validateProperties(classType, event.getData(), whitelist);
     }
     async callRpcFunction(functionName, ...args) {
-        var _a, _b;
-        try {
-            return (_b = (_a = this.app) === null || _a === void 0 ? void 0 : _a.rpcClient) === null || _b === void 0 ? void 0 : _b.callFunction(this.rpcRoutingKey, functionName, ...args);
-        }
-        catch (err) {
-            this.logger.error(err);
-        }
+        return this.app?.rpcClient.callFunction(this.rpcRoutingKey, functionName, ...args);
     }
-    runPyRpcScript(scriptPath) {
+    runPyRpcScript(scriptPath, ...args) {
         const options = {
             mode: 'text',
             pythonOptions: ['-u'],
-            args: [__dirname, this.rpcRoutingKey],
+            args: [__dirname, this.rpcRoutingKey, ...args.map((v) => v.toString())],
         };
         return python_shell_1.PythonShell.run(scriptPath, options, (err, outputs) => {
             if (err) {
@@ -110,18 +110,17 @@ function InputStream(id = 'default', options) {
             Reflect.defineMetadata(`stream:options:${id}`, options, target.constructor);
         }
         const method = propertyDescriptor.value;
-        propertyDescriptor.value = async function (event) {
-            const savedEmitOutput = this.emitOutput;
-            this.emitOutput = (data = {}, outputId = 'default', time = new Date()) => {
-                return savedEmitOutput.call(this, Object.assign(Object.assign({}, event.getData()), data), outputId, time);
-            };
-            return method.call(this, event);
+        propertyDescriptor.value = function (event) {
+            if (!this.stopPropagateStream.has(id)) {
+                this.stopPropagateStream.set(id, options?.stopPropagation ?? false);
+            }
+            return method.call(this, new FlowEvent_1.FlowEvent({ id: event.getMetadata().elementId, ...event.getMetadata(), inputStreamId: id }, event.getData(), event.getType(), new Date(event.getTime())));
         };
     };
 }
 exports.InputStream = InputStream;
 function FlowFunction(fqn) {
-    const fqnRegExp = new RegExp('^([a-zA-Z][a-zA-Z0-9]*[.-])*[a-zA-Z][a-zA-Z0-9]*$');
+    const fqnRegExp = /^([a-zA-Z][a-zA-Z\d]*[.-])*[a-zA-Z][a-zA-Z\d]*$/;
     if (!fqnRegExp.test(fqn)) {
         throw new Error(`Flow Function FQN (${fqn}) is not valid`);
     }

package/dist/FlowEvent.d.ts

@@ -8,7 +8,13 @@ export declare class FlowEvent {
     getDataContentType: () => string;
     getDataschema: () => string;
     getId: () => string;
-    getMetadata: () => any;
+    getMetadata: () => {
+        deploymentId: string;
+        elementId: string;
+        flowId: string;
+        functionFqn: string;
+        inputStreamId: string;
+    };
     getSource: () => string;
     getStreamId: () => string;
     getSubject: () => string;

package/dist/FlowEvent.js

@@ -16,7 +16,7 @@ class FlowEvent {
             }
             return event;
         };
-        this.getData = () => lodash_1.cloneDeep(this.event.data || {});
+        this.getData = () => (0, lodash_1.cloneDeep)(this.event.data || {});
         this.getDataContentType = () => this.event.datacontenttype;
         this.getDataschema = () => this.event.dataschema;
         this.getId = () => this.event.id;
@@ -28,13 +28,13 @@ class FlowEvent {
         this.getType = () => this.event.type;
         this.toJSON = () => this.event.toJSON();
         this.toString = () => this.event.toString();
-        const { id: elementId, deploymentId, flowId, functionFqn } = metadata;
+        const { id: elementId, deploymentId, flowId, functionFqn, inputStreamId } = metadata;
         if (data instanceof Error) {
             const error = { message: data.message, stack: data.stack };
             data = error;
         }
         else {
-            data = lodash_1.cloneDeep(data);
+            data = (0, lodash_1.cloneDeep)(data);
         }
         if (data == null) {
             data = {};
@@ -49,7 +49,7 @@ class FlowEvent {
                     dataType = 'text/plain';
                 }
             }
-            else if (typeof data === 'object' && data != null) {
+            else if (typeof data === 'object') {
                 dataType = 'application/json';
             }
             else {
@@ -57,7 +57,7 @@ class FlowEvent {
                 dataType = 'text/plain';
             }
         }
-        this.metadata = { deploymentId, elementId, flowId, functionFqn };
+        this.metadata = { deploymentId, elementId, flowId, functionFqn, inputStreamId };
         this.event = new cloudevents_1.CloudEvent({
             source: `flows/${flowId}/deployments/${deploymentId}/elements/${elementId}`,
             type: outputId,

package/dist/FlowLogger.d.ts

@@ -8,16 +8,19 @@ export interface Logger {
     verbose(message: any, metadata?: any): void;
 }
 export declare const defaultLogger: Logger;
+export interface LoggerOptions {
+    truncate: boolean;
+}
 export declare class FlowLogger implements Logger {
     private readonly metadata;
     private readonly logger;
     private readonly publishEvent?;
     private static getStackTrace;
-    constructor(metadata: FlowElementContext, logger?: Logger, publishEvent?: (event: FlowEvent) => Promise<void>);
-    debug: (message: any) => void;
-    error: (message: any) => void;
-    log: (message: any) => void;
-    warn: (message: any) => void;
-    verbose: (message: any) => void;
+    constructor(metadata: FlowElementContext, logger?: Logger, publishEvent?: (event: FlowEvent) => void);
+    debug: (message: any, options?: LoggerOptions) => void;
+    error: (message: any, options?: LoggerOptions) => void;
+    log: (message: any, options?: LoggerOptions) => void;
+    warn: (message: any, options?: LoggerOptions) => void;
+    verbose: (message: any, options?: LoggerOptions) => void;
     private publish;
 }

package/dist/FlowLogger.js

@@ -10,16 +10,6 @@ exports.defaultLogger = {
     verbose: (msg, metadata) => console.log(msg, metadata),
 };
 class FlowLogger {
-    constructor(metadata, logger = exports.defaultLogger, publishEvent) {
-        this.metadata = metadata;
-        this.logger = logger;
-        this.publishEvent = publishEvent;
-        this.debug = (message) => this.publish(message, 'debug');
-        this.error = (message) => this.publish(message, 'error');
-        this.log = (message) => this.publish(message, 'info');
-        this.warn = (message) => this.publish(message, 'warn');
-        this.verbose = (message) => this.publish(message, 'verbose');
-    }
     static getStackTrace() {
         let stack;
         try {
@@ -34,23 +24,32 @@ class FlowLogger {
             .filter((value) => !value.includes('Logger'));
         return stack.splice(1).join('\n');
     }
-    publish(message, level) {
-        var _a;
+    constructor(metadata, logger = exports.defaultLogger, publishEvent) {
+        this.metadata = metadata;
+        this.logger = logger;
+        this.publishEvent = publishEvent;
+        this.debug = (message, options) => this.publish(message, 'debug', options);
+        this.error = (message, options) => this.publish(message, 'error', options);
+        this.log = (message, options) => this.publish(message, 'info', options);
+        this.warn = (message, options) => this.publish(message, 'warn', options);
+        this.verbose = (message, options) => this.publish(message, 'verbose', options);
+    }
+    publish(message, level, options) {
         if (this.publishEvent) {
             const event = new FlowEvent_1.FlowEvent(this.metadata, message, `flow.log.${level}`);
-            (_a = this.publishEvent(event)) === null || _a === void 0 ? void 0 : _a.catch((err) => this.logger.error(err, this.metadata));
+            this.publishEvent(event);
         }
         switch (level) {
             case 'debug':
-                return this.logger.debug(message, this.metadata);
+                return this.logger.debug(message, { ...this.metadata, ...options });
             case 'error':
-                return this.logger.error(message, this.metadata);
+                return this.logger.error(message, { ...this.metadata, ...options });
             case 'warn':
-                return this.logger.warn(message, this.metadata);
+                return this.logger.warn(message, { ...this.metadata, ...options });
             case 'verbose':
-                return this.logger.verbose(message, this.metadata);
+                return this.logger.verbose(message, { ...this.metadata, ...options });
             default:
-                this.logger.log(message, this.metadata);
+                this.logger.log(message, { ...this.metadata, ...options });
         }
     }
 }

package/dist/FlowModule.d.ts

@@ -3,5 +3,5 @@ export declare function FlowModule(metadata: {
     name: string;
     declarations: Array<ClassType<FlowElement>>;
 }): ClassDecorator;
-declare type ClassType<T> = new (...args: any[]) => T;
+type ClassType<T> = new (...args: any[]) => T;
 export {};

package/dist/FlowModule.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowModule = void 0;
 function FlowModule(metadata) {
-    const fqnRegExp = new RegExp('^([a-zA-Z][a-zA-Z0-9]*[.-])*[a-zA-Z][a-zA-Z0-9]*$');
-    if (!fqnRegExp.test(metadata.name)) {
-        throw new Error(`Flow Module name (${metadata.name}) is not valid`);
+    const validateNameRegExp = new RegExp(/^(@[a-z][a-z0-9-]*\/)?[a-z][a-z0-9-]*$/);
+    if (!validateNameRegExp.test(metadata.name)) {
+        throw new Error(`Flow Module name (${metadata.name}) is not valid. Name must be all lowercase and not contain any special characters except for hyphens. Can optionally start with a scope "@scopename/"`);
     }
     return (target) => {
         Reflect.defineMetadata('module:name', metadata.name, target);

package/dist/RpcClient.d.ts

@@ -1,8 +1,10 @@
-import { AmqpConnectionManager } from 'amqp-connection-manager';
+import type { AmqpConnectionManager } from 'amqp-connection-manager';
+import { FlowLogger } from './FlowLogger';
 export declare class RpcClient {
-    private channel;
+    private readonly logger?;
+    private readonly channel;
     private openRequests;
-    constructor(connection: AmqpConnectionManager);
+    constructor(amqpConnection: AmqpConnectionManager, logger?: FlowLogger);
     private onMessage;
     callFunction: (routingKey: string, functionName: string, ...args: any[]) => Promise<unknown>;
     declareFunction: (routingKey: string, name: string) => (...args: any[]) => Promise<unknown>;

package/dist/RpcClient.js

@@ -1,9 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RpcClient = void 0;
-const uuid_1 = require("uuid");
+const tslib_1 = require("tslib");
+const crypto_1 = require("crypto");
+const object_sizeof_1 = tslib_1.__importDefault(require("object-sizeof"));
+const MAX_MSG_SIZE = +process.env.MAX_RPC_MSG_SIZE_BYTES;
+const WARN_MSG_SIZE = +process.env.WARN_RPC_MSG_SIZE_BYTES;
 class RpcClient {
-    constructor(connection) {
+    constructor(amqpConnection, logger) {
+        this.logger = logger;
         this.openRequests = new Map();
         this.onMessage = (msg) => {
             if (this.openRequests.has(msg.properties.correlationId)) {
@@ -38,8 +43,17 @@ class RpcClient {
         this.callFunction = (routingKey, functionName, ...args) => {
             const stack = new Error('test').stack;
             return new Promise((resolve, reject) => {
+                if (MAX_MSG_SIZE || WARN_MSG_SIZE) {
+                    const messageSize = (0, object_sizeof_1.default)(args);
+                    if (messageSize > MAX_MSG_SIZE) {
+                        throw new Error(`Max RPC message size exceeded: ${messageSize} bytes / ${MAX_MSG_SIZE} bytes`);
+                    }
+                    if (messageSize > WARN_MSG_SIZE) {
+                        this.logger?.warn(`Large RPC message size detected: ${messageSize} bytes`);
+                    }
+                }
                 const call = { functionName, arguments: args };
-                const correlationId = uuid_1.v4();
+                const correlationId = (0, crypto_1.randomUUID)();
                 this.openRequests.set(correlationId, { resolve, reject, trace: RpcClient.formatTrace(stack) });
                 this.channel
                     .publish('rpc_direct_exchange', routingKey, call, { correlationId, replyTo: 'amq.rabbitmq.reply-to' })
@@ -49,15 +63,15 @@ class RpcClient {
         this.declareFunction = (routingKey, name) => {
             return (...args) => this.callFunction(routingKey, name, ...args);
         };
-        if (!connection) {
+        if (!amqpConnection) {
             throw new Error('currently no amqp connection available');
         }
-        this.channel = connection.createChannel({
+        this.channel = amqpConnection.createChannel({
             json: true,
-            setup: (channel) => Promise.all([
-                channel.assertExchange('rpc_direct_exchange', 'direct', { durable: false }),
-                channel.consume('amq.rabbitmq.reply-to', this.onMessage, { noAck: true }),
-            ]),
+            setup: async (channel) => {
+                await channel.assertExchange('rpc_direct_exchange', 'direct', { durable: false });
+                await channel.consume('amq.rabbitmq.reply-to', this.onMessage, { noAck: true });
+            },
         });
     }
     close() {

package/dist/TestModule.js

@@ -7,21 +7,21 @@ const FlowEvent_1 = require("./FlowEvent");
 const FlowModule_1 = require("./FlowModule");
 let TestTrigger = class TestTrigger extends FlowElement_1.FlowTask {
     async onDefault(event) {
-        return this.emitOutput(event.getData());
+        return this.emitEvent({}, event);
     }
 };
 tslib_1.__decorate([
-    FlowElement_1.InputStream('default'),
+    (0, FlowElement_1.InputStream)('default'),
     tslib_1.__metadata("design:type", Function),
     tslib_1.__metadata("design:paramtypes", [FlowEvent_1.FlowEvent]),
     tslib_1.__metadata("design:returntype", Promise)
 ], TestTrigger.prototype, "onDefault", null);
 TestTrigger = tslib_1.__decorate([
-    FlowElement_1.FlowFunction('test.task.Trigger')
+    (0, FlowElement_1.FlowFunction)('test.task.Trigger')
 ], TestTrigger);
 let TestModule = class TestModule {
 };
-TestModule = tslib_1.__decorate([
-    FlowModule_1.FlowModule({ name: 'test', declarations: [TestTrigger] })
-], TestModule);
 exports.TestModule = TestModule;
+exports.TestModule = TestModule = tslib_1.__decorate([
+    (0, FlowModule_1.FlowModule)({ name: 'test', declarations: [TestTrigger] })
+], TestModule);

package/dist/amqp.d.ts

@@ -0,0 +1,14 @@
+import { AmqpConnectionManager, ChannelWrapper } from 'amqp-connection-manager';
+export interface AmqpConnection {
+    managedChannel: ChannelWrapper;
+    managedConnection: AmqpConnectionManager;
+}
+export interface AmqpConnectionConfig {
+    protocol?: string;
+    hostname?: string;
+    vhost?: string;
+    user?: string;
+    password?: string;
+    port?: number;
+}
+export declare function createAmqpConnection(config: AmqpConnectionConfig): AmqpConnectionManager;

package/dist/amqp.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAmqpConnection = void 0;
+const amqp_connection_manager_1 = require("amqp-connection-manager");
+function createAmqpConnection(config) {
+    if (!config) {
+        return;
+    }
+    const { protocol = process.env.RABBIT_PROTOCOL || 'amqp', hostname = process.env.RABBIT_HOST || 'localhost', port = +process.env.RABBIT_PORT || 5672, user = process.env.RABBIT_USER || 'guest', password = process.env.RABBIT_PASSWORD || 'guest', vhost = process.env.RABBIT_VHOST || '', } = config;
+    const uri = `${protocol}://${user}:${password}@${hostname}:${port}${vhost ? '/' + vhost : ''}`;
+    return (0, amqp_connection_manager_1.connect)(uri);
+}
+exports.createAmqpConnection = createAmqpConnection;

package/dist/extra-validators.js

@@ -5,24 +5,31 @@ const tslib_1 = require("tslib");
 const class_validator_1 = require("class-validator");
 let IsNotSiblingOfConstraint = class IsNotSiblingOfConstraint {
     validate(value, args) {
-        if (class_validator_1.isDefined(value)) {
+        if ((0, class_validator_1.isDefined)(value)) {
             return this.getFailedConstraints(args).length === 0;
         }
-        return true;
+        else {
+            return !args.constraints.every((prop) => !(0, class_validator_1.isDefined)(args.object[prop]));
+        }
     }
     defaultMessage(args) {
-        return `${args.property} cannot exist alongside the following defined properties: ${this.getFailedConstraints(args).join(', ')}`;
+        if (args.value) {
+            return `${args.property} cannot exist alongside the following defined properties: ${this.getFailedConstraints(args).join(', ')}`;
+        }
+        else {
+            return `at least one of the properties must be defined`;
+        }
     }
     getFailedConstraints(args) {
-        return args.constraints.filter((prop) => class_validator_1.isDefined(args.object[prop]));
+        return args.constraints.filter((prop) => (0, class_validator_1.isDefined)(args.object[prop]));
     }
 };
 IsNotSiblingOfConstraint = tslib_1.__decorate([
-    class_validator_1.ValidatorConstraint({ async: false })
+    (0, class_validator_1.ValidatorConstraint)({ async: false })
 ], IsNotSiblingOfConstraint);
 function IsNotSiblingOf(props, validationOptions) {
     return (object, propertyName) => {
-        class_validator_1.registerDecorator({
+        (0, class_validator_1.registerDecorator)({
             target: object.constructor,
             propertyName,
             options: validationOptions,
@@ -32,11 +39,11 @@ function IsNotSiblingOf(props, validationOptions) {
     };
 }
 function incompatibleSiblingsNotPresent(incompatibleSiblings) {
-    return (o, v) => Boolean(class_validator_1.isDefined(v) || incompatibleSiblings.every((prop) => !class_validator_1.isDefined(o[prop])));
+    return (o, v) => Boolean((0, class_validator_1.isDefined)(v) || incompatibleSiblings.every((prop) => !(0, class_validator_1.isDefined)(o[prop])));
 }
 function IncompatableWith(incompatibleSiblings) {
     const notSibling = IsNotSiblingOf(incompatibleSiblings);
-    const validateIf = class_validator_1.ValidateIf(incompatibleSiblingsNotPresent(incompatibleSiblings));
+    const validateIf = (0, class_validator_1.ValidateIf)(incompatibleSiblingsNotPresent(incompatibleSiblings));
     return (target, key) => {
         notSibling(target, key);
         validateIf(target, key);

package/dist/flow.interface.d.ts

@@ -7,6 +7,7 @@ export interface FlowElementContext extends FlowContext {
     id: string;
     name?: string;
     functionFqn?: string;
+    inputStreamId?: string;
 }
 export interface DeploymentMessage extends Record<string, any> {
     elementId?: string;
@@ -36,5 +37,10 @@ export interface Flow {
 export interface StreamOptions {
     concurrent?: number;
 }
-export declare type ClassType<T> = new (...args: any[]) => T;
+export type ClassType<T> = new (...args: any[]) => T;
+export declare enum LifecycleEvent {
+    ACTIVATED = "com.hahnpro.flow_function.activated",
+    COMPLETED = "com.hahnpro.flow_function.completed",
+    TERMINATED = "com.hahnpro.flow_function.terminated"
+}
 export {};

package/dist/flow.interface.js

@@ -1,2 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.LifecycleEvent = void 0;
+var LifecycleEvent;
+(function (LifecycleEvent) {
+    LifecycleEvent["ACTIVATED"] = "com.hahnpro.flow_function.activated";
+    LifecycleEvent["COMPLETED"] = "com.hahnpro.flow_function.completed";
+    LifecycleEvent["TERMINATED"] = "com.hahnpro.flow_function.terminated";
+})(LifecycleEvent || (exports.LifecycleEvent = LifecycleEvent = {}));

package/dist/index.d.ts

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

package/dist/index.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IncompatableWith = void 0;
 const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./api"), exports);
+tslib_1.__exportStar(require("@hahnpro/hpc-api"), exports);
 tslib_1.__exportStar(require("./flow.interface"), exports);
 tslib_1.__exportStar(require("./utils"), exports);
 tslib_1.__exportStar(require("./FlowApplication"), exports);
@@ -11,5 +11,6 @@ tslib_1.__exportStar(require("./FlowEvent"), exports);
 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);
 var extra_validators_1 = require("./extra-validators");
 Object.defineProperty(exports, "IncompatableWith", { enumerable: true, get: function () { return extra_validators_1.IncompatableWith; } });