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

package/src/lib/FlowElement.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowDashboard = exports.FlowTrigger = exports.FlowTask = exports.FlowResource = exports.FlowElement = void 0;
+exports.InputStream = InputStream;
+exports.FlowFunction = FlowFunction;
+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({ app, logger, ...metadata }, properties, propertiesClassType, whitelist = false) {
+        this.propertiesClassType = propertiesClassType;
+        this.whitelist = whitelist;
+        this.stopPropagateStream = new Map();
+        this.onContextChanged = (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);
+            }
+            else {
+                this.properties = properties;
+            }
+        };
+        this.handleApiError = (error) => (0, utils_1.handleApiError)(error, this.logger);
+        this.interpolate = (value, ...templateVariables) => (0, utils_1.fillTemplate)(value, ...templateVariables, { flow: this.app?.getContextManager?.().getProperties?.().flow ?? {} });
+        this.app = app;
+        this.api = this.app?.api;
+        this.metadata = { ...metadata, functionFqn: this.functionFqn };
+        this.logger = new FlowLogger_1.FlowLogger(this.metadata, logger || undefined, this.app?.publishNatsEventFlowlogs);
+        this.rpcRoutingKey = (this.metadata.flowId || '') + (this.metadata.deploymentId || '') + this.metadata.id;
+        if (properties) {
+            this.setProperties(properties);
+        }
+    }
+    /**
+     * Sets the placeholder properties for this flow element
+     * @param propertiesWithPlaceholders
+     */
+    setPropertiesWithPlaceholders(propertiesWithPlaceholders) {
+        this.propertiesWithPlaceholders = propertiesWithPlaceholders;
+    }
+    /**
+     * Returns the placeholder properties for this flow element
+     */
+    getPropertiesWithPlaceholders() {
+        return this.propertiesWithPlaceholders;
+    }
+    get flowProperties() {
+        return this.app?.getProperties?.() || {};
+    }
+    get natsConnection() {
+        return this.app?.natsConnection;
+    }
+    /**
+     * Replace all placeholder properties with their explicit updated value and set them as the properties of the element
+     */
+    replacePlaceholderAndSetProperties() {
+        const placeholderProperties = this.propertiesWithPlaceholders;
+        if (this.propertiesWithPlaceholders) {
+            this.setProperties(this.app.getContextManager?.()?.replaceAllPlaceholderProperties(placeholderProperties));
+        }
+    }
+    /**
+     * @deprecated since version 4.8.0, will be removed in 5.0.0, use emitEvent(...) instead
+     */
+    emitOutput(data = {}, outputId = 'default', time = new Date()) {
+        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;
+        }
+    }
+    validateProperties(classType, properties = {}, whitelist = false) {
+        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.logValidationErrors(e);
+            }
+            throw new Error('Properties Validation failed');
+        }
+        else {
+            return props;
+        }
+    }
+    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}`);
+        }
+        else if (Array.isArray(children)) {
+            for (const child of children) {
+                this.logValidationErrors(child, name);
+            }
+        }
+    }
+    validateEventData(classType, event, whitelist = false) {
+        return this.validateProperties(classType, event.getData(), whitelist);
+    }
+    async callRpcFunction(functionName, ...args) {
+        return this.app?.rpcClient.callFunction(this.rpcRoutingKey, functionName, ...args);
+    }
+    runPyRpcScript(scriptPath, ...args) {
+        const options = {
+            mode: 'text',
+            pythonOptions: ['-u'],
+            args: [__dirname, this.rpcRoutingKey, ...args.map((v) => v.toString())],
+        };
+        const pyshell = new python_shell_1.PythonShell(scriptPath, options);
+        pyshell.on('message', (message) => {
+            this.logger.debug(message);
+        });
+        pyshell.end((err) => {
+            if (err) {
+                this.logger.error(err);
+            }
+        });
+        return pyshell;
+    }
+}
+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) {
+            if (!this.stopPropagateStream.has(id)) {
+                this.stopPropagateStream.set(id, options?.stopPropagation ?? false);
+            }
+            // add input stream to data to later determine if data should be propagated
+            return method.call(this, new FlowEvent_1.FlowEvent({ id: event.getMetadata().elementId, ...event.getMetadata(), inputStreamId: id }, event.getData(), event.getType(), new Date(event.getTime())));
+        };
+    };
+}
+function FlowFunction(fqn) {
+    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`);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+    return (target) => {
+        Reflect.defineMetadata('element:functionFqn', fqn, target);
+        target.prototype.functionFqn = fqn;
+    };
+}
+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/src/lib/FlowEvent.d.ts

@@ -0,0 +1,25 @@
+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: () => {
+        deploymentId: string;
+        elementId: string;
+        flowId: string;
+        functionFqn: string;
+        inputStreamId: string;
+    };
+    getSource: () => string;
+    getStreamId: () => string;
+    getSubject: () => string;
+    getTime: () => Date;
+    getType: () => string;
+    toJSON: () => any;
+    toString: () => string;
+}

package/src/lib/FlowEvent.js

@@ -0,0 +1,72 @@
+"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) {
+                    /* ignore error */
+                }
+            }
+            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/src/lib/FlowLogger.d.ts

@@ -0,0 +1,44 @@
+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 enum STACK_TRACE {
+    FULL = "full",
+    ONLY_LOG_CALL = "only-log-call"
+}
+export interface LoggerOptions {
+    truncate: boolean;
+    stackTrace?: STACK_TRACE;
+}
+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) => 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;
+    /**
+     * Parses a message into a FlowLog object, including optional stack trace information.
+     *
+     * @details Requirements for the output format of messages:
+     * - Necessary for consistent logging and event publishing, because the OpenSearch index expects a specific structure: flat_object.
+     * - The current UI expects a `message` property to be present, so we ensure it is always set.
+     *
+     * @param {any} message - The message to be logged. Can be a string, an object with a `message` property, or any other type.
+     * @param {string} level - The log level (e.g., 'error', 'debug', 'warn', 'verbose').
+     * @param {LoggerOptions} options - Additional options for logging, such as whether to include a stack trace.
+     * @returns {FlowLog} - An object containing the parsed log message and optional stack trace.
+     */
+    private parseMessageToFlowLog;
+    private publish;
+}

package/src/lib/FlowLogger.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowLogger = exports.STACK_TRACE = exports.defaultLogger = void 0;
+const FlowEvent_1 = require("./FlowEvent");
+/* eslint-disable no-console */
+exports.defaultLogger = {
+    debug: (msg, metadata) => console.debug(msg),
+    error: (msg, metadata) => console.error(msg),
+    log: (msg, metadata) => console.log(msg),
+    warn: (msg, metadata) => console.warn(msg),
+    verbose: (msg, metadata) => console.log(msg, metadata),
+};
+/* eslint-enable no-console */
+var STACK_TRACE;
+(function (STACK_TRACE) {
+    STACK_TRACE["FULL"] = "full";
+    STACK_TRACE["ONLY_LOG_CALL"] = "only-log-call";
+})(STACK_TRACE || (exports.STACK_TRACE = STACK_TRACE = {}));
+class FlowLogger {
+    static getStackTrace(stacktrace = STACK_TRACE.FULL) {
+        // get stacktrace without extra dependencies
+        let stack;
+        try {
+            throw new Error('');
+        }
+        catch (error) {
+            stack = error.stack || '';
+        }
+        // cleanup stacktrace and remove calls within this file
+        stack = stack
+            .split('\n')
+            .map((line) => line.trim())
+            .filter((value) => value.includes('at ') && !value.includes('Logger'));
+        if (stacktrace === STACK_TRACE.ONLY_LOG_CALL && stack.length > 0) {
+            stack = stack[0];
+        }
+        else {
+            stack = stack.splice(1).join('\n');
+        }
+        return stack;
+    }
+    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);
+    }
+    /**
+     * Parses a message into a FlowLog object, including optional stack trace information.
+     *
+     * @details Requirements for the output format of messages:
+     * - Necessary for consistent logging and event publishing, because the OpenSearch index expects a specific structure: flat_object.
+     * - The current UI expects a `message` property to be present, so we ensure it is always set.
+     *
+     * @param {any} message - The message to be logged. Can be a string, an object with a `message` property, or any other type.
+     * @param {string} level - The log level (e.g., 'error', 'debug', 'warn', 'verbose').
+     * @param {LoggerOptions} options - Additional options for logging, such as whether to include a stack trace.
+     * @returns {FlowLog} - An object containing the parsed log message and optional stack trace.
+     */
+    parseMessageToFlowLog(message, level, options) {
+        let flowLogMessage;
+        if (!message) {
+            flowLogMessage = 'No message provided!';
+        }
+        else if (typeof message.message === 'string') {
+            flowLogMessage = message.message;
+        }
+        else if (typeof message === 'string') {
+            flowLogMessage = message;
+        }
+        else {
+            try {
+                flowLogMessage = JSON.stringify(message.message ?? message);
+            }
+            catch (e) {
+                flowLogMessage = 'Error: Could not stringify the message.';
+            }
+        }
+        const flowLog = { message: flowLogMessage };
+        if (['error', 'debug', 'warn', 'verbose'].includes(level) || options?.stackTrace) {
+            flowLog.stackTrace = FlowLogger.getStackTrace(options?.stackTrace ?? STACK_TRACE.ONLY_LOG_CALL);
+        }
+        return flowLog;
+    }
+    publish(message, level, options) {
+        const flowLogData = this.parseMessageToFlowLog(message, level, options);
+        if (this.publishEvent) {
+            const event = new FlowEvent_1.FlowEvent(this.metadata, flowLogData, `flow.log.${level}`);
+            this.publishEvent(event);
+        }
+        const messageWithStackTrace = flowLogData.stackTrace ? `${flowLogData.message}\n${flowLogData.stackTrace}` : flowLogData.message;
+        switch (level) {
+            case 'debug':
+                return this.logger.debug(messageWithStackTrace, { ...this.metadata, ...options });
+            case 'error':
+                return this.logger.error(messageWithStackTrace, { ...this.metadata, ...options });
+            case 'warn':
+                return this.logger.warn(messageWithStackTrace, { ...this.metadata, ...options });
+            case 'verbose':
+                return this.logger.verbose(messageWithStackTrace, { ...this.metadata, ...options });
+            default:
+                this.logger.log(messageWithStackTrace, { ...this.metadata, ...options });
+        }
+    }
+}
+exports.FlowLogger = FlowLogger;

package/src/lib/FlowModule.d.ts

@@ -0,0 +1,7 @@
+import { FlowElement } from './FlowElement';
+export declare function FlowModule(metadata: {
+    name: string;
+    declarations: Array<ClassType<FlowElement>>;
+}): ClassDecorator;
+type ClassType<T> = new (...args: any[]) => T;
+export {};

package/src/lib/FlowModule.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowModule = FlowModule;
+function FlowModule(metadata) {
+    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/"`);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+    return (target) => {
+        Reflect.defineMetadata('module:name', metadata.name, target);
+        Reflect.defineMetadata('module:declarations', metadata.declarations, target);
+    };
+}

package/src/lib/RpcClient.d.ts

@@ -0,0 +1,13 @@
+import type { AmqpConnectionManager } from 'amqp-connection-manager';
+import { FlowLogger } from './FlowLogger';
+export declare class RpcClient {
+    private readonly logger?;
+    private readonly channel;
+    private openRequests;
+    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>;
+    close(): Promise<void>;
+    static formatTrace(stack?: string): string;
+}

package/src/lib/RpcClient.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RpcClient = void 0;
+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(amqpConnection, logger) {
+        this.logger = logger;
+        this.openRequests = new Map();
+        this.onMessage = (msg) => {
+            if (this.openRequests.has(msg.properties.correlationId)) {
+                const { resolve, reject, trace } = this.openRequests.get(msg.properties.correlationId);
+                const response = JSON.parse(msg.content.toString());
+                switch (response.type) {
+                    case 'reply':
+                        resolve(response.value);
+                        break;
+                    case 'error': {
+                        const err = new Error(response.message);
+                        if (response.stack) {
+                            const stack = RpcClient.formatTrace(response.stack);
+                            err.stack = 'Remote Stack\n'.concat(stack, '\nLocal Stack\n', trace);
+                        }
+                        else {
+                            err.stack = trace;
+                        }
+                        reject(err);
+                        break;
+                    }
+                    default:
+                        reject(response);
+                        break;
+                }
+            }
+            else {
+                const message = `received unexpected response correlationID: ${msg.properties.correlationId}`;
+                /* eslint-disable-next-line no-console */
+                console.warn(message);
+            }
+        };
+        this.callFunction = (routingKey, functionName, ...args) => {
+            // in case remote returns error add this to the trace
+            const stack = new Error('test').stack;
+            return new Promise((resolve, reject) => {
+                // save to correlationId-> resolve/reject map
+                // on return resolve or reject promise
+                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 = (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' })
+                    .catch((err) => reject(err));
+            });
+        };
+        this.declareFunction = (routingKey, name) => {
+            return (...args) => this.callFunction(routingKey, name, ...args);
+        };
+        if (!amqpConnection) {
+            throw new Error('currently no amqp connection available');
+        }
+        this.channel = amqpConnection.createChannel({
+            json: 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() {
+        return this.channel.close();
+    }
+    static formatTrace(stack = '') {
+        return stack.split('\n').splice(1).join('\n');
+    }
+}
+exports.RpcClient = RpcClient;

package/src/lib/TestModule.d.ts

@@ -0,0 +1,2 @@
+export declare class TestModule {
+}

package/src/lib/TestModule.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestModule = void 0;
+const tslib_1 = require("tslib");
+const FlowElement_1 = require("./FlowElement");
+const FlowEvent_1 = require("./FlowEvent");
+const FlowModule_1 = require("./FlowModule");
+let TestTrigger = class TestTrigger extends FlowElement_1.FlowTask {
+    async onDefault(event) {
+        return this.emitEvent({}, event);
+    }
+};
+tslib_1.__decorate([
+    (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([
+    (0, FlowElement_1.FlowFunction)('test.task.Trigger')
+], TestTrigger);
+let TestModule = class TestModule {
+};
+exports.TestModule = TestModule;
+exports.TestModule = TestModule = tslib_1.__decorate([
+    (0, FlowModule_1.FlowModule)({ name: 'test', declarations: [TestTrigger] })
+], TestModule);

package/src/lib/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/src/lib/amqp.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAmqpConnection = createAmqpConnection;
+const amqp_connection_manager_1 = require("amqp-connection-manager");
+function createAmqpConnection(config) {
+    if (!config) {
+        return null;
+    }
+    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);
+}

package/src/lib/extra-validators.d.ts

@@ -0,0 +1 @@
+export declare function IncompatableWith(incompatibleSiblings: string[]): (target: any, key: string) => void;