@hahnpro/flow-sdk 4.14.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 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/README.md

@@ -0,0 +1,3 @@
+# `@hahnpro/flow-sdk`
+
+https://gitlab.com/hahnpro/flow

package/dist/FlowApplication.d.ts

@@ -0,0 +1,35 @@
+import 'reflect-metadata';
+import type { CloudEvent } from 'cloudevents';
+import { PartialObserver } from 'rxjs';
+import { AmqpConnection, Nack } from './amqp';
+import { API } from './api';
+import type { ClassType, Flow, FlowElementContext } from './flow.interface';
+import type { FlowEvent } from './FlowEvent';
+import { Logger } from './FlowLogger';
+import { RpcClient } from './RpcClient';
+export declare class FlowApplication {
+    private amqpConnection?;
+    api: API;
+    private context;
+    private declarations;
+    private elements;
+    private logger;
+    private properties;
+    private _rpcClient;
+    private outputStreamMap;
+    constructor(modules: ClassType<any>[], flow: Flow, logger?: Logger, amqpConnection?: AmqpConnection, skipApi?: boolean);
+    subscribe: (streamId: string, observer: PartialObserver<FlowEvent>) => import("rxjs").Subscription;
+    emit: (event: FlowEvent) => void;
+    emitPartial: (completeEvent: FlowEvent, partialEvent: FlowEvent) => void;
+    getProperties(): Record<string, any>;
+    onMessage: (event: CloudEvent) => Promise<Nack | undefined>;
+    publishEvent: (event: FlowEvent) => Promise<void>;
+    get rpcClient(): RpcClient;
+    destroy(exitCode?: number): Promise<void>;
+    private getOutputStream;
+    private truncate;
+}
+export interface Context extends FlowElementContext {
+    app?: FlowApplication;
+    logger?: Logger;
+}

package/dist/FlowApplication.js

@@ -0,0 +1,270 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowApplication = void 0;
+const tslib_1 = require("tslib");
+require("reflect-metadata");
+const object_sizeof_1 = (0, tslib_1.__importDefault)(require("object-sizeof"));
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const util_1 = require("util");
+const uuid_1 = require("uuid");
+const amqp_1 = require("./amqp");
+const api_1 = require("./api");
+const FlowLogger_1 = require("./FlowLogger");
+const RpcClient_1 = require("./RpcClient");
+const MAX_EVENT_SIZE_BYTES = 512 * 1024;
+class FlowApplication {
+    constructor(modules, flow, logger, amqpConnection, skipApi) {
+        var _a, _b, _c;
+        this.amqpConnection = amqpConnection;
+        this.declarations = {};
+        this.elements = {};
+        this.outputStreamMap = {};
+        this.subscribe = (streamId, observer) => this.getOutputStream(streamId).subscribe(observer);
+        this.emit = (event) => {
+            if (event) {
+                try {
+                    this.publishEvent(event);
+                    this.getOutputStream(event.getStreamId()).next(event);
+                }
+                catch (err) {
+                    this.logger.error(err);
+                }
+            }
+        };
+        this.emitPartial = (completeEvent, partialEvent) => {
+            try {
+                if (completeEvent) {
+                    this.getOutputStream(completeEvent.getStreamId()).next(completeEvent);
+                }
+                if (partialEvent) {
+                    this.publishEvent(partialEvent);
+                }
+            }
+            catch (err) {
+                this.logger.error(err);
+            }
+        };
+        this.onMessage = async (event) => {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+            if (event.type === 'com.flowstudio.deployment.update') {
+                try {
+                    const flow = event.data;
+                    if (!flow) {
+                        return new amqp_1.Nack(false);
+                    }
+                    let context = {};
+                    if (flow.context) {
+                        this.context = Object.assign(Object.assign({}, this.context), flow.context);
+                        context = this.context;
+                    }
+                    if (flow.properties) {
+                        this.properties = flow.properties;
+                        for (const element of Object.values(this.elements)) {
+                            (_a = element.onFlowPropertiesChanged) === null || _a === void 0 ? void 0 : _a.call(element, flow.properties);
+                        }
+                    }
+                    if (Object.keys(context).length > 0) {
+                        for (const element of flow.elements || []) {
+                            context = Object.assign(Object.assign({}, context), { name: element.name });
+                            (_c = (_b = this.elements) === null || _b === void 0 ? void 0 : _b[element.id]) === null || _c === void 0 ? void 0 : _c.onContextChanged(context);
+                        }
+                    }
+                    for (const element of flow.elements || []) {
+                        (_e = (_d = this.elements) === null || _d === void 0 ? void 0 : _d[element.id]) === null || _e === void 0 ? void 0 : _e.onPropertiesChanged(element.properties);
+                    }
+                    const statusEvent = {
+                        eventId: (0, uuid_1.v4)(),
+                        eventTime: new Date().toISOString(),
+                        eventType: 'com.hahnpro.event.health',
+                        contentType: 'application/json',
+                        data: { deploymentId: this.context.deploymentId, status: 'updated' },
+                    };
+                    (_f = this.amqpConnection) === null || _f === void 0 ? void 0 : _f.publish('deployment', 'health', statusEvent).catch((err) => this.logger.error(err));
+                }
+                catch (err) {
+                    this.logger.error(err);
+                    const statusEvent = {
+                        eventId: (0, uuid_1.v4)(),
+                        eventTime: new Date().toISOString(),
+                        eventType: 'com.hahnpro.event.health',
+                        contentType: 'application/json',
+                        data: { deploymentId: this.context.deploymentId, status: 'updating failed' },
+                    };
+                    (_g = this.amqpConnection) === null || _g === void 0 ? void 0 : _g.publish('deployment', 'health', statusEvent).catch((err) => this.logger.error(err));
+                }
+            }
+            else if (event.type === 'com.flowstudio.deployment.message') {
+                const data = event.data;
+                const elementId = data === null || data === void 0 ? void 0 : data.elementId;
+                if (elementId) {
+                    (_k = (_j = (_h = this.elements) === null || _h === void 0 ? void 0 : _h[elementId]) === null || _j === void 0 ? void 0 : _j.onMessage) === null || _k === void 0 ? void 0 : _k.call(_j, data);
+                }
+                else {
+                    for (const element of Object.values(this.elements)) {
+                        (_l = element === null || element === void 0 ? void 0 : element.onMessage) === null || _l === void 0 ? void 0 : _l.call(element, data);
+                    }
+                }
+            }
+            else if (event.type === 'com.flowstudio.deployment.destroy') {
+                this.destroy();
+            }
+            else {
+                return new amqp_1.Nack(false);
+            }
+            return undefined;
+        };
+        this.publishEvent = (event) => {
+            if (!this.amqpConnection) {
+                return;
+            }
+            try {
+                const message = event.format();
+                if ((0, object_sizeof_1.default)(message) > MAX_EVENT_SIZE_BYTES) {
+                    message.data = this.truncate(message.data);
+                }
+                return this.amqpConnection.publish('flowlogs', '', message);
+            }
+            catch (err) {
+                this.logger.error(err);
+            }
+        };
+        this.logger = new FlowLogger_1.FlowLogger(Object.assign({ id: 'none', functionFqn: 'FlowApplication' }, flow === null || flow === void 0 ? void 0 : flow.context), logger || undefined, this.publishEvent);
+        process.on('uncaughtException', (err) => {
+            this.logger.error('Uncaught exception!');
+            this.logger.error(err);
+            this.destroy(1);
+        });
+        process.on('unhandledRejection', (reason) => {
+            this.logger.error('Unhandled promise rejection!');
+            this.logger.error(reason);
+        });
+        process.on('SIGTERM', () => {
+            this.logger.log('Flow Deployment is terminating');
+            this.destroy(0);
+        });
+        try {
+            if (skipApi !== true) {
+                this.api = new api_1.API();
+            }
+        }
+        catch (err) {
+            this.logger.error((err === null || err === void 0 ? void 0 : err.message) || err);
+        }
+        try {
+            this.context = Object.assign({}, flow.context);
+            this.properties = flow.properties || {};
+            for (const module of modules) {
+                const moduleName = Reflect.getMetadata('module:name', module);
+                const moduleDeclarations = Reflect.getMetadata('module:declarations', module);
+                if (!moduleName || !moduleDeclarations || !Array.isArray(moduleDeclarations)) {
+                    throw new Error(`FlowModule (${module.name}) metadata is missing or invalid`);
+                }
+                for (const declaration of moduleDeclarations) {
+                    const functionFqn = Reflect.getMetadata('element:functionFqn', declaration);
+                    if (!functionFqn) {
+                        throw new Error(`FlowFunction (${declaration.name}) metadata is missing or invalid`);
+                    }
+                    this.declarations[`${moduleName}.${functionFqn}`] = declaration;
+                }
+            }
+            for (const element of flow.elements) {
+                const { id, name, properties, module, functionFqn } = element;
+                try {
+                    const context = Object.assign(Object.assign({}, this.context), { id, name, logger, app: this });
+                    this.elements[id] = new this.declarations[`${module}.${functionFqn}`](context, properties);
+                }
+                catch (err) {
+                    throw new Error(`Could not create FlowElement for ${module}.${functionFqn}`);
+                }
+            }
+            for (const connection of flow.connections) {
+                const { source, target, sourceStream = 'default', targetStream = 'default' } = connection;
+                if (!source || !target) {
+                    continue;
+                }
+                const streamId = `${source}.${sourceStream}`;
+                const element = this.elements[target];
+                if (!element || !element.constructor) {
+                    throw new Error(target + ' has not been initialized');
+                }
+                const streamHandler = Reflect.getMetadata(`stream:${targetStream}`, element.constructor);
+                if (!streamHandler || !element[streamHandler]) {
+                    throw new Error(`${target} does not implement a handler for ${targetStream}`);
+                }
+                const streamOptions = Reflect.getMetadata(`stream:options:${targetStream}`, element.constructor) || {};
+                const concurrent = streamOptions.concurrent || 1;
+                const outputStream = this.getOutputStream(streamId);
+                outputStream
+                    .pipe((0, operators_1.mergeMap)((event) => element[streamHandler](event), concurrent), (0, operators_1.catchError)((err, observable) => {
+                    element.handleApiError(err);
+                    return observable;
+                }))
+                    .subscribe();
+            }
+            (_c = (_b = (_a = this.amqpConnection) === null || _a === void 0 ? void 0 : _a.managedChannel.assertExchange('deployment', 'direct', { durable: true })) === null || _b === void 0 ? void 0 : _b.then(() => this.amqpConnection.managedChannel.assertExchange('flowlogs', 'fanout', { durable: true }))) === null || _c === void 0 ? void 0 : _c.then(() => this.amqpConnection.createSubscriber((msg) => this.onMessage(msg), {
+                exchange: 'deployment',
+                routingKey: this.context.deploymentId,
+                queueOptions: { durable: false, exclusive: true },
+            })).catch((error) => {
+                this.logger.error('could not assert Exchange!\nError:\n' + error.toString());
+            });
+            this.logger.log('Flow Deployment is running');
+        }
+        catch (err) {
+            this.logger.error(err);
+            this.destroy(1);
+        }
+    }
+    getProperties() {
+        return this.properties;
+    }
+    get rpcClient() {
+        var _a;
+        if (!((_a = this.amqpConnection) === null || _a === void 0 ? void 0 : _a.managedConnection)) {
+            throw new Error('No AMQP connection available');
+        }
+        if (!this._rpcClient) {
+            this._rpcClient = new RpcClient_1.RpcClient(this.amqpConnection.managedConnection);
+        }
+        return this._rpcClient;
+    }
+    async destroy(exitCode = 0) {
+        var _a, _b, _c, _d;
+        try {
+            try {
+                for (const element of Object.values(this.elements)) {
+                    (_a = element === null || element === void 0 ? void 0 : element.onDestroy) === null || _a === void 0 ? void 0 : _a.call(element);
+                }
+                await ((_b = this._rpcClient) === null || _b === void 0 ? void 0 : _b.close());
+            }
+            catch (err) {
+                this.logger.error(err);
+            }
+            await new Promise((res) => setTimeout(res, 250));
+            await ((_d = (_c = this.amqpConnection) === null || _c === void 0 ? void 0 : _c.managedConnection) === null || _d === void 0 ? void 0 : _d.close());
+        }
+        catch (err) {
+            console.error(err);
+        }
+        finally {
+            process.exit(exitCode);
+        }
+    }
+    getOutputStream(id) {
+        const stream = this.outputStreamMap[id];
+        if (!stream) {
+            this.outputStreamMap[id] = new rxjs_1.Subject();
+            return this.outputStreamMap[id];
+        }
+        return stream;
+    }
+    truncate(msg) {
+        let truncated = (0, util_1.inspect)(msg, { depth: 4, maxStringLength: 1000 });
+        if (truncated.startsWith("'") && truncated.endsWith("'")) {
+            truncated = truncated.substring(1, truncated.length - 1);
+        }
+        return truncated;
+    }
+}
+exports.FlowApplication = FlowApplication;

package/dist/FlowElement.d.ts

@@ -0,0 +1,50 @@
+import { PythonShell } from 'python-shell';
+import { API } from './api';
+import { ClassType, DeploymentMessage, FlowContext, FlowElementContext } from './flow.interface';
+import { Context } from './FlowApplication';
+import { FlowEvent } from './FlowEvent';
+import { FlowLogger } from './FlowLogger';
+export declare abstract class FlowElement<T = any> {
+    private readonly propertiesClassType?;
+    private readonly whitelist;
+    readonly functionFqn: string;
+    protected readonly api?: API;
+    protected readonly logger: FlowLogger;
+    protected metadata: FlowElementContext;
+    protected properties: T;
+    private readonly app?;
+    private readonly rpcRoutingKey;
+    private stopPropagateStream;
+    constructor({ app, logger, ...metadata }: Context, properties?: unknown, propertiesClassType?: ClassType<T>, whitelist?: boolean);
+    get flowProperties(): Record<string, any>;
+    onDestroy?: () => void;
+    onMessage?: (message: DeploymentMessage) => void;
+    onFlowPropertiesChanged?: (properties: Record<string, any>) => void;
+    onContextChanged: (context: Partial<FlowContext>) => void;
+    onPropertiesChanged: (properties: T) => void;
+    protected setProperties: (properties: T) => void;
+    handleApiError: (error: any) => void;
+    /**
+     * @deprecated since version 4.8.0, will be removed in 5.0.0, use emitEvent(...) instead
+     */
+    protected emitOutput(data?: any, outputId?: string, time?: Date): FlowEvent;
+    protected emitEvent(data: any, inputEvent: FlowEvent, outputId?: string, time?: Date): FlowEvent;
+    protected validateProperties<P>(classType: ClassType<P>, properties?: any, whitelist?: boolean): P;
+    protected validateEventData<E>(classType: ClassType<E>, event: FlowEvent, whitelist?: boolean): E;
+    protected interpolate: (value: any, ...templateVariables: any) => any;
+    protected callRpcFunction(functionName: string, ...args: any[]): Promise<unknown>;
+    protected runPyRpcScript(scriptPath: string, ...args: (string | boolean | number)[]): PythonShell;
+}
+export declare function InputStream(id?: string, options?: {
+    concurrent?: number;
+    stopPropagation?: boolean;
+}): MethodDecorator;
+export declare function FlowFunction(fqn: string): ClassDecorator;
+export declare abstract class FlowResource<T = any> extends FlowElement<T> {
+}
+export declare abstract class FlowTask<T = any> extends FlowElement<T> {
+}
+export declare abstract class FlowTrigger<T = any> extends FlowElement<T> {
+}
+export declare abstract class FlowDashboard<T = any> extends FlowResource<T> {
+}

package/dist/FlowElement.js

@@ -0,0 +1,143 @@
+"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 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 = (0, tslib_1.__rest)(_a, ["app", "logger"]);
+        this.propertiesClassType = propertiesClassType;
+        this.whitelist = whitelist;
+        this.stopPropagateStream = new Map();
+        this.onContextChanged = (context) => {
+            this.metadata = Object.assign(Object.assign({}, this.metadata), context);
+        };
+        this.onPropertiesChanged = (properties) => {
+            this.setProperties(properties);
+        };
+        this.setProperties = (properties) => {
+            if (this.propertiesClassType) {
+                this.properties = this.validateProperties(this.propertiesClassType, properties, this.whitelist);
+            }
+            else {
+                this.properties = properties;
+            }
+        };
+        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.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)) || {};
+    }
+    emitOutput(data = {}, outputId = 'default', time = new Date()) {
+        return this.emitEvent(data, null, outputId, time);
+    }
+    emitEvent(data, inputEvent, outputId = 'default', time = new Date()) {
+        var _a, _b, _c;
+        const partialEvent = new FlowEvent_1.FlowEvent(this.metadata, data, outputId, time);
+        const completeEvent = new FlowEvent_1.FlowEvent(this.metadata, Object.assign(Object.assign({}, ((inputEvent === null || inputEvent === void 0 ? void 0 : inputEvent.getData()) || {})), data), outputId, time);
+        const streamID = ((_a = inputEvent === null || inputEvent === void 0 ? void 0 : inputEvent.getMetadata()) === null || _a === void 0 ? void 0 : _a.inputStreamId) || '';
+        if ((this.stopPropagateStream.has(streamID) && this.stopPropagateStream.get(streamID)) || !this.stopPropagateStream.has(streamID)) {
+            (_b = this.app) === null || _b === void 0 ? void 0 : _b.emit(partialEvent);
+            return partialEvent;
+        }
+        else {
+            (_c = this.app) === null || _c === void 0 ? void 0 : _c.emitPartial(completeEvent, partialEvent);
+            return completeEvent;
+        }
+    }
+    validateProperties(classType, properties = {}, whitelist = false) {
+        const props = (0, class_transformer_1.plainToClass)(classType, properties);
+        const errors = (0, class_validator_1.validateSync)(props, { whitelist });
+        if (errors && 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}`);
+            }
+            throw new Error('Properties Validation failed');
+        }
+        else {
+            return props;
+        }
+    }
+    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);
+        }
+    }
+    runPyRpcScript(scriptPath, ...args) {
+        const options = {
+            mode: 'text',
+            pythonOptions: ['-u'],
+            args: [__dirname, this.rpcRoutingKey, ...args.map((v) => v.toString())],
+        };
+        return python_shell_1.PythonShell.run(scriptPath, options, (err, outputs) => {
+            if (err) {
+                this.logger.error(err);
+            }
+            this.logger.debug(outputs);
+        });
+    }
+}
+exports.FlowElement = FlowElement;
+function InputStream(id = 'default', options) {
+    return (target, propertyKey, propertyDescriptor) => {
+        Reflect.defineMetadata(`stream:${id}`, propertyKey, target.constructor);
+        if (options) {
+            Reflect.defineMetadata(`stream:options:${id}`, options, target.constructor);
+        }
+        const method = propertyDescriptor.value;
+        propertyDescriptor.value = function (event) {
+            var _a;
+            if (!this.stopPropagateStream.has(id)) {
+                this.stopPropagateStream.set(id, (_a = options === null || options === void 0 ? void 0 : options.stopPropagation) !== null && _a !== void 0 ? _a : false);
+            }
+            return method.call(this, new FlowEvent_1.FlowEvent(Object.assign(Object.assign({}, 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]*$');
+    if (!fqnRegExp.test(fqn)) {
+        throw new Error(`Flow Function FQN (${fqn}) is not valid`);
+    }
+    return (target) => {
+        Reflect.defineMetadata('element:functionFqn', fqn, target);
+        target.prototype.functionFqn = fqn;
+    };
+}
+exports.FlowFunction = FlowFunction;
+class FlowResource extends FlowElement {
+}
+exports.FlowResource = FlowResource;
+class FlowTask extends FlowElement {
+}
+exports.FlowTask = FlowTask;
+class FlowTrigger extends FlowElement {
+}
+exports.FlowTrigger = FlowTrigger;
+class FlowDashboard extends FlowResource {
+}
+exports.FlowDashboard = FlowDashboard;

package/dist/FlowEvent.d.ts

@@ -0,0 +1,19 @@
+import { FlowElementContext } from './flow.interface';
+export declare class FlowEvent {
+    private event;
+    private metadata;
+    constructor(metadata: FlowElementContext, data: any, outputId?: string, time?: Date, dataType?: string);
+    format: () => any;
+    getData: () => any;
+    getDataContentType: () => string;
+    getDataschema: () => string;
+    getId: () => string;
+    getMetadata: () => any;
+    getSource: () => string;
+    getStreamId: () => string;
+    getSubject: () => string;
+    getTime: () => Date;
+    getType: () => string;
+    toJSON: () => any;
+    toString: () => string;
+}

package/dist/FlowEvent.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowEvent = void 0;
+const cloudevents_1 = require("cloudevents");
+const lodash_1 = require("lodash");
+class FlowEvent {
+    constructor(metadata, data, outputId = 'default', time = new Date(), dataType) {
+        this.format = () => {
+            const event = this.event.toJSON();
+            if (event.datacontenttype === 'application/json') {
+                try {
+                    event.data = JSON.parse(event.data);
+                }
+                catch (err) {
+                }
+            }
+            return event;
+        };
+        this.getData = () => (0, lodash_1.cloneDeep)(this.event.data || {});
+        this.getDataContentType = () => this.event.datacontenttype;
+        this.getDataschema = () => this.event.dataschema;
+        this.getId = () => this.event.id;
+        this.getMetadata = () => this.metadata;
+        this.getSource = () => this.event.source;
+        this.getStreamId = () => `${this.metadata.elementId}.${this.event.type}`;
+        this.getSubject = () => this.event.subject;
+        this.getTime = () => new Date(this.event.time);
+        this.getType = () => this.event.type;
+        this.toJSON = () => this.event.toJSON();
+        this.toString = () => this.event.toString();
+        const { id: elementId, deploymentId, flowId, functionFqn, inputStreamId } = metadata;
+        if (data instanceof Error) {
+            const error = { message: data.message, stack: data.stack };
+            data = error;
+        }
+        else {
+            data = (0, lodash_1.cloneDeep)(data);
+        }
+        if (data == null) {
+            data = {};
+        }
+        if (dataType == null) {
+            if (typeof data === 'string') {
+                try {
+                    JSON.parse(data);
+                    dataType = 'application/json';
+                }
+                catch (err) {
+                    dataType = 'text/plain';
+                }
+            }
+            else if (typeof data === 'object') {
+                dataType = 'application/json';
+            }
+            else {
+                data = String(data);
+                dataType = 'text/plain';
+            }
+        }
+        this.metadata = { deploymentId, elementId, flowId, functionFqn, inputStreamId };
+        this.event = new cloudevents_1.CloudEvent({
+            source: `flows/${flowId}/deployments/${deploymentId}/elements/${elementId}`,
+            type: outputId,
+            subject: functionFqn,
+            datacontenttype: dataType,
+            data,
+            time: time.toISOString(),
+        });
+    }
+}
+exports.FlowEvent = FlowEvent;

package/dist/FlowLogger.d.ts

@@ -0,0 +1,23 @@
+import { FlowElementContext } from './flow.interface';
+import { FlowEvent } from './FlowEvent';
+export interface Logger {
+    debug(message: any, metadata?: any): void;
+    error(message: any, metadata?: any): void;
+    log(message: any, metadata?: any): void;
+    warn(message: any, metadata?: any): void;
+    verbose(message: any, metadata?: any): void;
+}
+export declare const defaultLogger: Logger;
+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;
+    private publish;
+}