@forzalabs/remora 0.0.12

package/engines/ai/DeveloperEngine.js

@@ -0,0 +1,70 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Affirm_1 = __importDefault(require("../../core/Affirm"));
+const ProducerEngine_1 = __importDefault(require("../ProducerEngine"));
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+class DeveloperEngineClass {
+    constructor() {
+        this.discover = (producer) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            (0, Affirm_1.default)(producer, 'Invalid producer');
+            const sampleData = yield ProducerEngine_1.default.readSampleData(producer);
+            (0, Affirm_1.default)(sampleData, 'Discover process failed: no result found');
+            const typeDefinitions = this.extractFieldTypes(sampleData);
+            const mappedProducer = {
+                name: producer.name,
+                description: producer.description,
+                source: producer.source,
+                settings: Object.assign({}, producer.settings),
+                dimensions: typeDefinitions.map(field => ({
+                    name: field.name,
+                    type: this.mapFieldTypeToProducerType(field.type),
+                    description: `Auto-mapped field: ${field.name}`
+                })),
+                measures: [],
+                _version: (_a = producer._version) !== null && _a !== void 0 ? _a : 1
+            };
+            // Save the mapped producer to file
+            const producerPath = path_1.default.join(process.cwd(), 'remora', 'producers', `${producer.name}.json`);
+            yield promises_1.default.writeFile(producerPath, JSON.stringify(mappedProducer, null, 4), 'utf-8');
+            return { producer: mappedProducer, fields: typeDefinitions };
+        });
+        this.mapFieldTypeToProducerType = (fieldType) => {
+            switch (fieldType) {
+                case 'number':
+                    return 'number';
+                case 'string':
+                    return 'string';
+                case 'date':
+                case 'datetime':
+                    return 'datetime';
+                default:
+                    return 'string';
+            }
+        };
+        this.extractFieldTypes = (data) => {
+            if (!data || data.length === 0)
+                return [];
+            const sample = data[0];
+            return Object.entries(sample).map(([key, value]) => ({
+                name: key,
+                type: Array.isArray(value) ? 'array' : typeof value
+            }));
+        };
+    }
+}
+const DeveloperEngine = new DeveloperEngineClass();
+exports.default = DeveloperEngine;

package/engines/ai/LLM.js

@@ -0,0 +1,299 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const openai_1 = __importDefault(require("openai"));
+const zod_1 = require("openai/helpers/zod");
+const zod_2 = require("zod");
+const baseProducersSystemPrompt = `
+# TASK
+You are an agent tasked with creating the mapping between an INPUT DATA SPEC and one or more OUTPUT DATA SPEC.
+The mapping between the two is made by creating PRODUCERS and CONSUMERS.
+You are tasked with creating the PRODUCER(S) that will then be used.
+
+# PRODUCERS
+A producer maps directly to a dataset and exposes it's dimensions.
+
+## FIELDS
+- alias: the reference to the column or property name if different from the desired name property
+- classification: make your best guess if the field falls under any of these regulations
+
+# RULES
+- Add only the required fields to comply with the OUTPUT DATA SPEC
+- Add fields that you think are important
+
+# FORMAT
+The INPUT DATA SPEC will be the first 10 rows from the dataset that the producer needs to map to.
+The OUTPUT DATA SPEC is a JSON of the desired output that the consumer needs to return.
+The result must be returned as a JSON object.
+
+# INPUT DATA SPEC
+{{input data spec}}
+
+# OUTPUT DATA SPEC
+{{output data spec}}
+`;
+const baseConsumersSystemPrompt = `
+# TASK
+You are an agent tasked with creating the mapping between a list of PRODUCERS and one or more OUTPUT DATA SPEC.
+You are going to receive a list of PRODUCERS that expose some dimensions, and you will create the CONSUMERS that comply with the provided OUTPUT DATA SPEC.
+
+# CONSUMERS
+A consumer takes the data from one or more producers and changes it's shape to transform it into the required output schema.
+
+## FIELDS
+- fields.grouping: used when you need to create a nested data structure with many items under a single key. If no groupingKey is used, then don't add this field.
+- fields.from: used to distinct between the producers imported by the consumer. The value is the name of the producer.
+
+# RULES
+- If a field is not needed, do not add it e.g. if there is no need for the "grouping" property, then don't add it.
+- Only import a producer once
+
+# FORMAT
+The INPUT DATA SPEC will be the first 10 rows from the dataset that the producer needs to map to.
+The OUTPUT DATA SPEC is a JSON of the desired output that the consumer needs to return.
+The result must be returned as a JSON object.
+
+# PRODUCERS
+{{producers}}
+
+# OUTPUT DATA SPEC
+{{output data spec}}
+
+# EXAMPLES
+producers: """
+{
+    "name": "claim",
+    "dimensions": [
+        {
+            "name": "id",
+            "type": "string",
+            "pk": true
+        },
+        {
+            "name": "amount",
+            "type": "number"
+        },
+        {
+            "name": "provider",
+            "type": "string"
+        },
+        {
+            "name": "date",
+            "type": "datetime"
+        }
+    ]
+}
+"""
+
+output data spec: """
+{
+    "name": "claim",
+    "fields": [
+        {
+            "name": "id",
+            "type": "string",
+            "pk": true
+        },
+        {
+            "name": "amount",
+            "type": "number"
+        },
+        {
+            "name": "provider",
+            "type": "string"
+        },
+        {
+            "name": "date",
+            "type": "datetime"
+        }
+    ]
+}
+"""
+
+resulting consumer: """
+{
+    "name": "claims",
+    "fields": [
+        {
+            "key": "id"
+        },
+        {
+            "key": "amount"
+        },
+        {
+            "key": "provider"
+        },
+        {
+            "key": "date",
+            "alias": "Creation date"
+        }
+    ],
+    "outputs": [
+        {
+            "format": "JSON"
+        }
+    ],
+    "producers": [
+        {
+            "name": "claim"
+        }
+    ]
+}
+"""
+`;
+const baseQASystemPrompt = `
+# TASK
+You are an agent tasked with ensuring that the CONSUMER(S) created follow the guidelines given.
+You are going to receive a list of CONSUMERS and you need to return in the correct JSON format the same CONSUMERS with the needed updates to ensure that they follow all the rules.
+
+# CONSUMER DEFINITION
+A consumer takes the data from one or more producers and changes it's shape to transform it into the required output schema.
+
+## FIELDS
+- fields.grouping: used when you need to create a nested data structure with many items under a single key. If no groupingKey is used, then don't add this field.
+- fields.from: used to distinct between the producers imported by the consumer. The value is the name of the producer.
+
+# RULES
+- If a field is not needed, do not add it e.g. if there is no need for the "grouping" property, then don't add it.
+- Only import a producer once
+
+# CONSUMERS
+{{consumers}}
+`;
+class LLM {
+    constructor() {
+        this.inferProducers = (input, outputs) => __awaiter(this, void 0, void 0, function* () {
+            let systemPrompt = baseProducersSystemPrompt;
+            systemPrompt = systemPrompt.replace('{{input data spec}}', input.map(x => `- ${JSON.stringify(x)}`).join('\n'));
+            systemPrompt = systemPrompt.replace('{{output data spec}}', outputs.map(x => `- ${JSON.stringify(x)}`).join('\n'));
+            const res = yield this._client.beta.chat.completions.parse({
+                model: 'o3-mini',
+                messages: [
+                    { role: 'system', content: systemPrompt }
+                ],
+                response_format: (0, zod_1.zodResponseFormat)(zod_2.z.object({
+                    producers: zod_2.z.array(zod_2.z.object({
+                        name: zod_2.z.string(),
+                        description: zod_2.z.string(),
+                        dimensions: zod_2.z.array(zod_2.z.object({
+                            name: zod_2.z.string(),
+                            alias: zod_2.z.string().optional(),
+                            description: zod_2.z.string().optional(),
+                            type: zod_2.z.enum(['string', 'number', 'datetime']),
+                            pk: zod_2.z.boolean().optional(),
+                            classification: zod_2.z.array(zod_2.z.enum(['PHI', 'PII', 'GDPR'])).optional()
+                        }))
+                    }))
+                }), 'environment')
+            });
+            const msg = res.choices[0].message;
+            return msg.parsed;
+        });
+        this.inferConsumers = (producers, outputs) => __awaiter(this, void 0, void 0, function* () {
+            let systemPrompt = baseConsumersSystemPrompt;
+            systemPrompt = systemPrompt.replace('{{producers}}', producers.map(x => `- ${JSON.stringify(x)}`).join('\n'));
+            systemPrompt = systemPrompt.replace('{{output data spec}}', outputs.map(x => `- ${JSON.stringify(x)}`).join('\n'));
+            const item = {
+                model: 'o3-mini',
+                messages: [
+                    { role: 'system', content: systemPrompt }
+                ],
+                response_format: (0, zod_1.zodResponseFormat)(zod_2.z.object({
+                    consumers: zod_2.z.array(zod_2.z.object({
+                        name: zod_2.z.string(),
+                        description: zod_2.z.string(),
+                        producers: zod_2.z.array(zod_2.z.object({
+                            name: zod_2.z.string().describe('References one of the producers. Must be unique, there can\'t be two entry with the same name.'),
+                            joins: zod_2.z.array(zod_2.z.object({
+                                otherName: zod_2.z.string(),
+                                relationship: zod_2.z.enum(['one-to-one', 'one-to-many', 'many-to-one']),
+                                sql: zod_2.z.string()
+                            })).optional().describe('Which other producer to join this one with. Omit if empty.')
+                        })),
+                        fields: zod_2.z.array(zod_2.z.object({
+                            key: zod_2.z.string(),
+                            from: zod_2.z.string().optional(),
+                            grouping: zod_2.z.object({
+                                groupingKey: zod_2.z.string(),
+                                subFields: zod_2.z.array(zod_2.z.lazy(() => zod_2.z.object({
+                                    key: zod_2.z.string(),
+                                    from: zod_2.z.string().optional()
+                                })))
+                            }).optional()
+                        })),
+                        outputs: zod_2.z.array(zod_2.z.object({
+                            format: zod_2.z.enum(['SQL', 'API', 'CSV', 'PARQUET', 'JSON'])
+                        }))
+                    }))
+                }), 'environment')
+            };
+            const res = yield this._client.beta.chat.completions.parse(item);
+            const msg = res.choices[0].message;
+            const firstDraft = msg.parsed;
+            const qaSystemPrompt = baseQASystemPrompt.replace('{{consumers}}', firstDraft.consumers.map(x => `- ${JSON.stringify(x)}`).join('\n'));
+            const res2 = yield this._client.beta.chat.completions.parse({
+                model: 'o3-mini',
+                messages: [
+                    { role: 'system', content: qaSystemPrompt }
+                ],
+                response_format: (0, zod_1.zodResponseFormat)(zod_2.z.object({
+                    consumers: zod_2.z.array(zod_2.z.object({
+                        name: zod_2.z.string(),
+                        description: zod_2.z.string(),
+                        producers: zod_2.z.array(zod_2.z.object({
+                            name: zod_2.z.string().describe('References one of the producers. Must be unique, there can\'t be two entry with the same name.'),
+                            joins: zod_2.z.array(zod_2.z.object({
+                                otherName: zod_2.z.string(),
+                                relationship: zod_2.z.enum(['one-to-one', 'one-to-many', 'many-to-one']),
+                                sql: zod_2.z.string()
+                            })).optional().describe('Which other producer to join this one with. Omit if empty.')
+                        })),
+                        fields: zod_2.z.array(zod_2.z.object({
+                            key: zod_2.z.string(),
+                            from: zod_2.z.string().optional(),
+                            grouping: zod_2.z.object({
+                                groupingKey: zod_2.z.string().optional(),
+                                subFields: zod_2.z.array(zod_2.z.lazy(() => zod_2.z.object({
+                                    key: zod_2.z.string(),
+                                    from: zod_2.z.string().optional()
+                                }))).optional()
+                            }).optional()
+                        })),
+                        outputs: zod_2.z.array(zod_2.z.object({
+                            format: zod_2.z.enum(['SQL', 'API', 'CSV', 'PARQUET', 'JSON'])
+                        }))
+                    }))
+                }), 'environment')
+            });
+            const msg2 = res2.choices[0].message;
+            const finalDraft = msg2.parsed;
+            // Do some manual adjustments cause some things still don't work...
+            if (finalDraft && finalDraft.consumers) {
+                for (const cons of finalDraft.consumers) {
+                    for (const field of cons.fields) {
+                        if (field.grouping) {
+                            if (!field.grouping.groupingKey || field.grouping.groupingKey.length === 0)
+                                field.grouping = undefined;
+                        }
+                    }
+                }
+            }
+            return finalDraft;
+        });
+        this._client = new openai_1.default({
+            apiKey: process.env.OPENAI_API_KEY
+        });
+    }
+}
+exports.default = LLM;

package/engines/consumer/ConsumerEngine.js

@@ -0,0 +1,204 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Affirm_1 = __importDefault(require("../../core/Affirm"));
+const Algo_1 = __importDefault(require("../../core/Algo"));
+const DriverFactory_1 = __importDefault(require("../../drivers/DriverFactory"));
+const Helper_1 = __importDefault(require("../../helper/Helper"));
+const DeploymentPlanner_1 = __importDefault(require("../deployment/DeploymentPlanner"));
+const Environment_1 = __importDefault(require("../Environment"));
+const ExecutionEnvironment_1 = __importDefault(require("../execution/ExecutionEnvironment"));
+const SQLCompiler_1 = __importDefault(require("../sql/SQLCompiler"));
+const SQLUtils_1 = __importDefault(require("../sql/SQLUtils"));
+const UsageManager_1 = __importDefault(require("../UsageManager"));
+const ConsumerManager_1 = __importDefault(require("./ConsumerManager"));
+class ConsumerEngineClass {
+    constructor() {
+        this.compile = (consumer) => {
+            var _a, _b;
+            (0, Affirm_1.default)(consumer, `Invalid consumer`);
+            const availableColumns = consumer.producers.flatMap((cProd) => {
+                var _a, _b;
+                const producer = Environment_1.default.getProducer(cProd.name);
+                if (!producer) {
+                    const subConsumer = Environment_1.default.getConsumer(cProd.name);
+                    (0, Affirm_1.default)(subConsumer, `No producer found with name "${cProd.name}"`);
+                    return this.compile(subConsumer);
+                }
+                else {
+                    const dims = producer.dimensions.map(x => ({
+                        consumerAlias: null,
+                        consumerKey: null,
+                        nameInProducer: x.name,
+                        aliasInProducer: x.alias,
+                        dimension: x,
+                        owner: cProd.name
+                    }));
+                    const meas = (_b = (_a = producer.measures) === null || _a === void 0 ? void 0 : _a.map(x => ({
+                        consumerAlias: null,
+                        consumerKey: null,
+                        nameInProducer: x.name,
+                        aliasInProducer: x.name,
+                        measure: x,
+                        owner: cProd.name
+                    }))) !== null && _b !== void 0 ? _b : [];
+                    return [...dims, ...meas];
+                }
+            });
+            const selectedColumns = [];
+            const flat = ConsumerManager_1.default.getConsumerFlatFields(consumer);
+            for (let i = 0; i < flat.length; i++) {
+                const field = flat[i];
+                // TODO: replace with the new funcitons in the consumermanager to reduce diplicate code
+                if (field.key === '*') {
+                    const from = (_a = field.from) !== null && _a !== void 0 ? _a : (consumer.producers.length === 1 ? consumer.producers[0].name : null);
+                    availableColumns.filter(x => x.owner === from).forEach((col) => {
+                        col.consumerKey = col.nameInProducer;
+                        col.consumerAlias = col.nameInProducer;
+                        selectedColumns.push(col);
+                    });
+                }
+                else if (field.grouping) {
+                    // This field should be ignored since it is only created when building the output for supported formats (json)
+                    continue;
+                }
+                else {
+                    const col = ConsumerManager_1.default.searchFieldInColumns(field, availableColumns, consumer);
+                    (0, Affirm_1.default)(col, `Consumer "${consumer.name}" misconfiguration: the requested field "${field.key}" is not found in any of the specified producers ("${consumer.producers.map(x => x.name).join(', ')}")`);
+                    col.consumerKey = field.key;
+                    col.consumerAlias = (_b = field.alias) !== null && _b !== void 0 ? _b : field.key;
+                    selectedColumns.push(col);
+                }
+            }
+            const columnsWithNoAlias = selectedColumns.filter(x => !x.consumerAlias || !x.consumerKey);
+            (0, Affirm_1.default)(columnsWithNoAlias.length === 0, `Consumer "${consumer.name}" compilation error: some selected fields don't have a correct alias or key (${columnsWithNoAlias.map(x => x.nameInProducer).join(', ')})`);
+            return selectedColumns;
+        };
+        this.deploy = (consumer) => __awaiter(this, void 0, void 0, function* () {
+            (0, Affirm_1.default)(consumer, `Invalid consumer`);
+            const firstProd = Environment_1.default.getFirstProducer(consumer.producers[0].name);
+            (0, Affirm_1.default)(firstProd, `Missing producer in consumer "${consumer.name}"`);
+            // For now we only support connecting producers of the same engine type to a consumer, so we give an error if we detect different ones
+            const allSources = consumer.producers.map(x => Environment_1.default.getSource(Environment_1.default.getProducer(x.name).source));
+            const uniqEngines = Algo_1.default.uniqBy(allSources, 'engine');
+            (0, Affirm_1.default)(uniqEngines.length === 1, `Sources with different engines were used in a single consumer (${uniqEngines.join(', ')})`);
+            // For now we also only support consumers that have producers ALL having the same exact source
+            const uniqNames = Algo_1.default.uniqBy(allSources, 'name');
+            (0, Affirm_1.default)(uniqNames.length === 1, `Producers with different sources were used in a single consumer (${uniqNames.join(', ')})`);
+            const source = Environment_1.default.getSource(firstProd.source);
+            const driver = yield DriverFactory_1.default.instantiateSource(source);
+            const plan = DeploymentPlanner_1.default.planConsumer(consumer);
+            for (const planStep of plan) {
+                switch (planStep.type) {
+                    case 'create-materialized-view': {
+                        const sql = SQLCompiler_1.default.compileConsumer(consumer);
+                        (0, Affirm_1.default)(sql, `Invalid SQL from deployment compilation for consumer "${consumer.name}"`);
+                        const internalSchema = Environment_1.default.get('schema');
+                        (0, Affirm_1.default)(internalSchema, `Invalid schema set on the authentication for source "${source.name}"`);
+                        // TODO When I want to update a materialize view there is no way except killing it and recreating it. The problem is that: 1) it is not said that it can be deleted since that materialize view could have some dependencies 2) we should find a way to update it without it going completely offline.
+                        const mvSQL = `
+                    DROP MATERIALIZED VIEW IF EXISTS "${internalSchema}"."${SQLUtils_1.default.acceleratedViewName(consumer.name)}";
+                    CREATE MATERIALIZED VIEW "${internalSchema}"."${SQLUtils_1.default.acceleratedViewName(consumer.name)}" AS ${sql}`;
+                        yield driver.execute(mvSQL);
+                        break;
+                    }
+                    case 'create-view': {
+                        const sql = SQLCompiler_1.default.compileConsumer(consumer);
+                        (0, Affirm_1.default)(sql, `Invalid SQL from deployment compilation for consumer "${consumer.name}"`);
+                        const internalSchema = Environment_1.default.get('schema');
+                        (0, Affirm_1.default)(internalSchema, `Invalid schema set on the authentication for source "${source.name}"`);
+                        const vSQL = `CREATE OR REPLACE VIEW "${internalSchema}"."${SQLUtils_1.default.sanitizeName(consumer.name)}" AS ${sql}`;
+                        yield driver.execute(vSQL);
+                        break;
+                    }
+                    default: throw new Error(`Invalid execution consumer plan step type "${planStep.type}"`);
+                }
+            }
+        });
+        this.execute = (consumer, options, user) => __awaiter(this, void 0, void 0, function* () {
+            (0, Affirm_1.default)(consumer, `Invalid consumer`);
+            (0, Affirm_1.default)(options, `Invalid execute consume options`);
+            const { usageId } = UsageManager_1.default.startUsage(consumer, user);
+            try {
+                const execution = new ExecutionEnvironment_1.default(consumer);
+                const result = yield execution.run(options);
+                UsageManager_1.default.endUsage(usageId, result.data.length);
+                return result;
+            }
+            catch (error) {
+                UsageManager_1.default.failUsage(usageId, Helper_1.default.asError(error).message);
+                throw error;
+            }
+        });
+        this.getOutputShape = (consumer) => {
+            (0, Affirm_1.default)(consumer, `Invalid consumer`);
+            const compiled = this.compile(consumer);
+            const outDimensions = compiled.map(x => {
+                var _a;
+                return ({
+                    name: (_a = x.consumerAlias) !== null && _a !== void 0 ? _a : x.consumerKey,
+                    type: x.dimension.type,
+                    classification: x.dimension.classification,
+                    description: x.dimension.description,
+                    mask: x.dimension.mask,
+                    pk: x.dimension.pk
+                });
+            });
+            return {
+                _version: consumer._version,
+                name: consumer.name,
+                description: consumer.description,
+                metadata: consumer.metadata,
+                dimensions: outDimensions
+            };
+        };
+        /**
+         * Given a consumer, create the entire dependency chain of all the sub-consumers, producers and finally sources that are used by this consumer
+         */
+        this.getDependencyChain = (consumer, depth = 0) => {
+            (0, Affirm_1.default)(consumer, `Invalid consumer`);
+            const chain = [];
+            for (let i = 0; i < consumer.producers.length; i++) {
+                const cProd = consumer.producers[i];
+                const producer = Environment_1.default.getProducer(cProd.name);
+                if (!producer) {
+                    const subConsumer = Environment_1.default.getConsumer(cProd.name);
+                    (0, Affirm_1.default)(subConsumer, `No producer found with name "${cProd.name}"`);
+                    chain.push({
+                        depth: depth,
+                        from: { name: consumer.name, type: 'consumer' },
+                        to: { name: subConsumer.name, type: 'consumer' }
+                    });
+                    if (subConsumer.producers && subConsumer.producers.length > 0)
+                        return [...chain, ...this.getDependencyChain(subConsumer, depth + 1)];
+                }
+                else {
+                    chain.push({
+                        depth: depth,
+                        from: { name: consumer.name, type: 'consumer' },
+                        to: { name: producer.name, type: 'producer' }
+                    });
+                    chain.push({
+                        depth: depth + 1,
+                        from: { name: producer.name, type: 'producer' },
+                        to: { name: producer.source, type: 'source' }
+                    });
+                }
+            }
+            return chain.sort((a, b) => a.depth - b.depth);
+        };
+    }
+}
+const ConsumerEngine = new ConsumerEngineClass();
+exports.default = ConsumerEngine;