@forzalabs/remora 0.1.8-nasco.3 → 0.2.0

package/Constants.js

@@ -1,9 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const CONSTANTS = {
-    cliVersion: '0.1.8-nasco',
-    lambdaVersion: 1,
-    port: 5069,
+    cliVersion: '0.2.0',
+    backendVersion: 1,
+    backendPort: 5088,
+    workerVersion: 2,
+    workerPort: 5069,
+    /**
+     * Column name for the dynamically injected source filename dimension.
+     * Prefixed with $ to indicate it's a system-generated dynamic value.
+     */
+    SOURCE_FILENAME_COLUMN: '$source_filename',
     defaults: {
         PRODUCER_TEMP_FOLDER: '.temp',
         SQL_MAX_QUERY_ROWS: 10000,

package/actions/automap.js

@@ -0,0 +1,77 @@
+"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 });
+exports.automap = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const compile_1 = require("./compile");
+const AutoMapperEngine_1 = __importDefault(require("../engines/ai/AutoMapperEngine"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const Environment_1 = __importDefault(require("../engines/Environment"));
+const ProducerEngine_1 = __importDefault(require("../engines/producer/ProducerEngine"));
+/**
+ * e.g. npm run automap -- myclaims Claim
+ */
+const automap = (producerName, schemaNames) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        (0, compile_1.compile)();
+        const spinner = (0, ora_1.default)(chalk_1.default.blue('Auto-mapping producer data...\n')).start();
+        // Get the producer
+        const producer = Environment_1.default.getProducer(producerName);
+        if (!producer) {
+            throw new Error(`Producer ${producerName} not found`);
+        }
+        const source = Environment_1.default.getSource(producer.source);
+        if (!source) {
+            throw new Error(`Source ${producer.source} not found`);
+        }
+        // Get the specified schemas
+        const schemas = [];
+        for (const schemaName of schemaNames) {
+            const schema = Environment_1.default.getSchema(schemaName);
+            if (!schema) {
+                throw new Error(`Schema ${schemaName} not found`);
+            }
+            schemas.push(schema);
+        }
+        // Read and convert sample data
+        const sampleData = yield ProducerEngine_1.default.readSampleData(producer);
+        // Convert sample data to strings for AutoMapperEngine
+        const sampleStrings = sampleData.map(item => JSON.stringify(item));
+        // Call the automapper
+        const mapResult = yield AutoMapperEngine_1.default.map(sampleStrings, schemas, producer.settings.fileKey, [source]);
+        // Create the producers based on the mapping
+        for (const producer of mapResult.producers) {
+            const producerPath = path_1.default.join('remora/producers', `${producer.name}.json`);
+            fs_1.default.writeFileSync(producerPath, JSON.stringify(producer, null, 4));
+            console.log(chalk_1.default.blue(`Created producer: ${producer.name}`));
+        }
+        // Create the consumers based on the mapping
+        for (const consumer of mapResult.consumers) {
+            const consumerPath = path_1.default.join('remora/consumers', `${consumer.name}.json`);
+            fs_1.default.writeFileSync(consumerPath, JSON.stringify(consumer, null, 4));
+            console.log(chalk_1.default.blue(`Created consumer: ${consumer.name}`));
+        }
+        spinner.succeed('Producer has been successfully mapped');
+        console.log(chalk_1.default.green(`\n✅ Created ${mapResult.producers.length} producers!`));
+        console.log(chalk_1.default.green(`✅ Created ${mapResult.consumers.length} consumers!`));
+        process.exit(0);
+    }
+    catch (err) {
+        console.error(chalk_1.default.red.bold('\n❌ Unexpected error during automapping:'), err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+});
+exports.automap = automap;

package/actions/deploy.js

@@ -51,7 +51,7 @@ const deploy = (options) => __awaiter(void 0, void 0, void 0, function* () {
                 // Read the zip file as a buffer
                 const zipBuffer = fs_1.default.readFileSync(tempZipPath);
                 const host = process.env.REMORA_WORKER_HOST;
-                const version = Constants_1.default.lambdaVersion;
+                const version = Constants_1.default.workerVersion;
                 const workerAPI = `${host}/cli/v${version}/uploaddeployment`;
                 const formData = new FormData();
                 const blob = new Blob([zipBuffer], { type: 'application/zip' });

package/actions/run.js

@@ -16,16 +16,15 @@ exports.run = void 0;
 const chalk_1 = __importDefault(require("chalk"));
 const ora_1 = __importDefault(require("ora"));
 const Environment_1 = __importDefault(require("../engines/Environment"));
-const UserManager_1 = __importDefault(require("../engines/UserManager"));
 const ConsumerEngine_1 = __importDefault(require("../engines/consumer/ConsumerEngine"));
 const compile_1 = require("./compile");
 const Helper_1 = __importDefault(require("../helper/Helper"));
+const LicenceManager_1 = __importDefault(require("../licencing/LicenceManager"));
 const run = (consumerName) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         (0, compile_1.compile)();
-        console.log();
+        console.log(); // needed for newline
         const spinner = (0, ora_1.default)(chalk_1.default.blue('Running consumer(s)...\n')).start();
-        const user = UserManager_1.default.getUser();
         const consumersToExecute = [];
         if (consumerName && consumerName.length > 0) {
             const cons = Environment_1.default.getConsumer(consumerName);
@@ -40,7 +39,13 @@ const run = (consumerName) => __awaiter(void 0, void 0, void 0, function* () {
         for (let i = 0; i < consumersToExecute.length; i++) {
             const consumer = consumersToExecute[i];
             try {
-                const response = yield ConsumerEngine_1.default.execute(consumer, {}, user);
+                const remoraLicenceKey = process.env.REMORA_LICENCE_KEY;
+                const check = LicenceManager_1.default.validate(remoraLicenceKey);
+                if (!check.valid) {
+                    console.error(`Invalid Remora licence key, the product is not active: remember to set "REMORA_LICENCE_KEY" environment variable.`);
+                    process.exit(1);
+                }
+                const response = yield ConsumerEngine_1.default.execute(consumer, {}, { _id: check.customer, name: check.customer, type: 'licence' }, { invokedBy: 'CLI' });
                 results.push({ success: true, consumer, response });
             }
             catch (error) {

package/actions/sample.js

@@ -0,0 +1,176 @@
+"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 });
+exports.sample = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const Environment_1 = __importDefault(require("../engines/Environment"));
+const ProducerEngine_1 = __importDefault(require("../engines/producer/ProducerEngine"));
+const DatasetRecord_1 = __importDefault(require("../engines/dataset/DatasetRecord"));
+const compile_1 = require("./compile");
+const Helper_1 = __importDefault(require("../helper/Helper"));
+const sample = (resourceName_1, ...args_1) => __awaiter(void 0, [resourceName_1, ...args_1], void 0, function* (resourceName, sampleSize = 10) {
+    try {
+        (0, compile_1.compile)();
+        console.log(); // needed for newline
+        const spinner = (0, ora_1.default)(chalk_1.default.blue('Sampling dataset...')).start();
+        // Try to find the resource as a producer first, then as a consumer
+        const producer = Environment_1.default.getProducer(resourceName);
+        const consumer = Environment_1.default.getConsumer(resourceName);
+        if (!producer && !consumer) {
+            spinner.fail(chalk_1.default.red(`Resource "${resourceName}" not found. Please check if it exists as a producer or consumer.`));
+            process.exit(1);
+        }
+        let sampleData;
+        let resourceType;
+        if (producer) {
+            resourceType = 'Producer';
+            spinner.text = chalk_1.default.blue(`Sampling from producer "${resourceName}"...`);
+            sampleData = yield ProducerEngine_1.default.readSampleData(producer, sampleSize, false);
+        }
+        else {
+            resourceType = 'Consumer';
+            spinner.text = chalk_1.default.blue(`Sampling from consumer "${resourceName}"...`);
+            sampleData = yield sampleFromConsumer(consumer, sampleSize);
+        }
+        spinner.succeed(chalk_1.default.green(`Sample data retrieved from ${resourceType.toLowerCase()} "${resourceName}"`));
+        if (sampleData.length === 0) {
+            console.log(chalk_1.default.yellow('No data found in the dataset.'));
+            return;
+        }
+        // Display the sample data
+        console.log(chalk_1.default.cyan(`\n📊 Sample Data (showing ${sampleData.length} rows):`));
+        console.log(chalk_1.default.gray('─'.repeat(80)));
+        displayDataAsTable(sampleData);
+        console.log(chalk_1.default.gray('─'.repeat(80)));
+        console.log(chalk_1.default.green(`✅ Successfully sampled ${sampleData.length} rows from ${resourceType.toLowerCase()} "${resourceName}"`));
+    }
+    catch (err) {
+        const myErr = Helper_1.default.asError(err);
+        console.error(chalk_1.default.red.bold('\n❌ Error during sampling:'), myErr.message);
+        if (Helper_1.default.isDev())
+            console.log(myErr.stack);
+        process.exit(1);
+    }
+});
+exports.sample = sample;
+const sampleFromConsumer = (consumer, sampleSize) => __awaiter(void 0, void 0, void 0, function* () {
+    // For consumers, we need to get sample data from the first producer
+    // and then apply the consumer's field mappings to show what the output would look like
+    const firstProducerRef = consumer.producers[0];
+    if (!firstProducerRef) {
+        throw new Error(`Consumer "${consumer.name}" has no producers configured`);
+    }
+    const producer = Environment_1.default.getProducer(firstProducerRef.name);
+    if (!producer) {
+        const subConsumer = Environment_1.default.getConsumer(firstProducerRef.name);
+        if (!subConsumer) {
+            throw new Error(`Producer or consumer "${firstProducerRef.name}" not found for consumer "${consumer.name}"`);
+        }
+        // If it's a consumer that references another consumer, sample from that consumer
+        return yield sampleFromConsumer(subConsumer, sampleSize);
+    }
+    // Get raw sample data from the producer
+    const rawSampleData = yield ProducerEngine_1.default.readSampleData(producer, sampleSize, false);
+    // For consumers with wildcard fields ("*"), return all data as-is
+    const hasWildcard = consumer.fields.some(field => field.key === '*');
+    if (hasWildcard) {
+        return rawSampleData;
+    }
+    // For consumers with specific field mappings, show only the mapped fields
+    // This gives users a preview of what the consumer output would look like
+    const mappedData = rawSampleData.map(record => {
+        const mappedRecord = new DatasetRecord_1.default('', [], record._delimiter);
+        consumer.fields.forEach(field => {
+            if (field.key !== '*' && !field.grouping) {
+                const sourceValue = record.getValue(field.key);
+                const outputKey = field.alias || field.key;
+                mappedRecord.setValue(outputKey, sourceValue);
+            }
+        });
+        return mappedRecord;
+    });
+    return mappedData;
+});
+const displayDataAsTable = (data) => {
+    if (data.length === 0)
+        return;
+    // Get all unique field names from the sample data
+    const allFields = new Set();
+    data.forEach(record => {
+        Object.keys(record._value).forEach(key => allFields.add(key));
+    });
+    const fields = Array.from(allFields);
+    // Calculate column widths
+    const columnWidths = {};
+    // Start with header widths
+    fields.forEach(field => {
+        columnWidths[field] = field.length;
+    });
+    // Check data widths
+    data.forEach(record => {
+        fields.forEach(field => {
+            const value = record._value[field];
+            const displayValue = formatValue(value);
+            columnWidths[field] = Math.max(columnWidths[field], displayValue.length);
+        });
+    });
+    // Limit column width to prevent overly wide tables
+    const maxColumnWidth = 30;
+    fields.forEach(field => {
+        columnWidths[field] = Math.min(columnWidths[field], maxColumnWidth);
+    });
+    // Print header
+    const headerRow = fields.map(field => chalk_1.default.bold(field.padEnd(columnWidths[field]))).join(' │ ');
+    console.log('│ ' + headerRow + ' │');
+    // Print separator
+    const separator = fields.map(field => '─'.repeat(columnWidths[field])).join('─┼─');
+    console.log('├─' + separator + '─┤');
+    // Print data rows
+    data.forEach((record, index) => {
+        const dataRow = fields.map(field => {
+            const value = record._value[field];
+            const displayValue = formatValue(value);
+            const truncatedValue = displayValue.length > maxColumnWidth
+                ? displayValue.substring(0, maxColumnWidth - 3) + '...'
+                : displayValue;
+            return truncatedValue.padEnd(columnWidths[field]);
+        }).join(' │ ');
+        // Alternate row colors for better readability
+        if (index % 2 === 0) {
+            console.log('│ ' + chalk_1.default.white(dataRow) + ' │');
+        }
+        else {
+            console.log('│ ' + chalk_1.default.gray(dataRow) + ' │');
+        }
+    });
+};
+const formatValue = (value) => {
+    if (value === null || value === undefined) {
+        return chalk_1.default.dim('null');
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (typeof value === 'number') {
+        return chalk_1.default.cyan(value.toString());
+    }
+    if (typeof value === 'boolean') {
+        return chalk_1.default.yellow(value.toString());
+    }
+    if (value instanceof Date) {
+        return chalk_1.default.magenta(value.toISOString());
+    }
+    return chalk_1.default.dim(JSON.stringify(value));
+};

package/database/DatabaseEngine.js

@@ -21,7 +21,8 @@ class DatabaseEngineClass {
         this.db = () => this._db;
         this.connect = () => __awaiter(this, void 0, void 0, function* () {
             var _a;
-            // WARNING: this was changed during the deployment to ECS... I've reverted, but maybe it needs to be changed or looked into...
+            // WARNING: this was changed during the deployment to ECS...
+            // I've reverted it, but maybe it needs to be changed or looked into...
             this._uri = ((_a = process.env.MONGO_URI) !== null && _a !== void 0 ? _a : Helper_1.default.isDev())
                 ? 'mongodb://mongo:27017/remora'
                 : 'mongodb://localhost:27017/remora';
@@ -29,7 +30,7 @@ class DatabaseEngineClass {
             const errors = [];
             for (let i = 0; i < this.MAX_TRY_CONNECTION; i++) {
                 try {
-                    console.log(`Attempting to connect to mongo: "${this._uri}"`);
+                    console.log(`Attempting to connect to mongo: "${this._uri}" (${i})`);
                     yield this._client.connect();
                     this._db = this._client.db(Settings_1.default.db.name);
                     this._connected = true;
@@ -37,7 +38,7 @@ class DatabaseEngineClass {
                     break;
                 }
                 catch (error) {
-                    errors.push((i + 1) + ': connection to MongoDB throws this error:', error);
+                    errors.push((i + 1) + ': connection to MongoDB throws this error: ' + error);
                 }
             }
             if (!this._connected)
@@ -54,6 +55,7 @@ class DatabaseEngineClass {
         });
         this.query = (collectionName, filter, options) => __awaiter(this, void 0, void 0, function* () {
             try {
+                yield this._checkConnection();
                 const collection = this._db.collection(collectionName);
                 const result = yield collection.find(filter, options).toArray();
                 return result;
@@ -65,6 +67,7 @@ class DatabaseEngineClass {
         });
         this.aggregate = (collectionName, aggregation) => __awaiter(this, void 0, void 0, function* () {
             try {
+                yield this._checkConnection();
                 const collection = this._db.collection(collectionName);
                 return yield collection.aggregate(aggregation).toArray();
             }
@@ -75,6 +78,7 @@ class DatabaseEngineClass {
         });
         this.get = (collectionName, id) => __awaiter(this, void 0, void 0, function* () {
             try {
+                yield this._checkConnection();
                 const collection = this._db.collection(collectionName);
                 return yield collection.findOne({ _id: id });
             }
@@ -85,6 +89,7 @@ class DatabaseEngineClass {
         });
         this.findOne = (collectionName, query) => __awaiter(this, void 0, void 0, function* () {
             try {
+                yield this._checkConnection();
                 const collection = this._db.collection(collectionName);
                 return yield collection.findOne(query);
             }
@@ -95,6 +100,7 @@ class DatabaseEngineClass {
         });
         this.upsert = (collectionName, id, update) => __awaiter(this, void 0, void 0, function* () {
             try {
+                yield this._checkConnection();
                 const collection = this._db.collection(collectionName);
                 const result = yield collection.findOneAndUpdate({ _id: id }, { $set: update }, { upsert: true, returnDocument: 'after' });
                 return result;
@@ -106,6 +112,7 @@ class DatabaseEngineClass {
         });
         this.addToList = (collectionName, id, arrayField, arrayItem) => __awaiter(this, void 0, void 0, function* () {
             try {
+                yield this._checkConnection();
                 const collection = this._db.collection(collectionName);
                 const result = yield collection.findOneAndUpdate({ _id: id }, { $push: { [arrayField]: arrayItem } }, { returnDocument: 'after' });
                 return result;
@@ -117,6 +124,7 @@ class DatabaseEngineClass {
         });
         this.doUpdate = (collectionName, id, update) => __awaiter(this, void 0, void 0, function* () {
             try {
+                yield this._checkConnection();
                 const collection = this._db.collection(collectionName);
                 const result = yield collection.findOneAndUpdate({ _id: id }, update, { returnDocument: 'after' });
                 return result;
@@ -126,6 +134,13 @@ class DatabaseEngineClass {
                 throw error;
             }
         });
+        this._checkConnection = () => __awaiter(this, void 0, void 0, function* () {
+            if (this._connected)
+                return;
+            yield this.connect();
+            if (!this._connected)
+                throw new Error(`Can't to perform db operation: unable to connect to the database (${this._uri})`);
+        });
     }
 }
 const DatabaseEngine = new DatabaseEngineClass();

package/definitions/DatasetDefinitions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/definitions/json_schemas/producer-schema.json

@@ -76,6 +76,10 @@
                             "none",
                             "{REMORA_MASK_IN_DEV}"
                         ]
+                    },
+                    "sourceFilename": {
+                        "type": "boolean",
+                        "description": "When true, this dimension will be populated with the source filename. Only valid for file-based producers (local, aws-s3) and only one dimension per producer can have this set to true. Useful when reading multiple files with wildcard patterns to track which file each row came from."
                     }
                 },
                 "required": [
@@ -130,7 +134,7 @@
                 },
                 "fileKey": {
                     "type": "string",
-                    "description": "If the source is a bucket, this is the file key that identifies the file to read"
+                    "description": "For S3/local sources: the file key/path that identifies the file to read. For HTTP API sources: the API endpoint path (e.g., '/api/v1/users')"
                 },
                 "fileType": {
                     "type": "string",
@@ -252,6 +256,40 @@
                 "fileType": "CSV"
             },
             "_version": 2
+        },
+        {
+            "name": "APIUsers",
+            "description": "Producer for user data from REST API",
+            "source": "REST API with Bearer Token",
+            "dimensions": [
+                {
+                    "name": "user_id",
+                    "type": "string",
+                    "pk": true
+                },
+                {
+                    "name": "username",
+                    "type": "string"
+                },
+                {
+                    "name": "email",
+                    "type": "string",
+                    "classification": [
+                        "PII",
+                        "GDPR"
+                    ],
+                    "mask": "mask"
+                },
+                {
+                    "name": "created_at",
+                    "type": "datetime"
+                }
+            ],
+            "settings": {
+                "fileKey": "/api/v1/users",
+                "fileType": "JSON"
+            },
+            "_version": 1
         }
     ]
 }

package/definitions/json_schemas/source-schema.json

@@ -24,7 +24,8 @@
                 "aws-s3",
                 "postgres",
                 "local",
-                "delta-share"
+                "delta-share",
+                "http-api"
             ],
             "description": "The type of data engine"
         },
@@ -39,7 +40,10 @@
                         "username-password",
                         "access-secret-key",
                         "arn",
-                        "implicit"
+                        "implicit",
+                        "bearer-token",
+                        "api-key",
+                        "none"
                     ],
                     "description": "The authentication method to use"
                 },
@@ -113,7 +117,47 @@
                 },
                 "bearerToken": {
                     "type": "string",
-                    "description": "Delta Sharing bearer token used for authentication"
+                    "description": "Bearer token used for authentication (Delta Sharing or HTTP API)"
+                },
+                "url": {
+                    "type": "string",
+                    "format": "uri",
+                    "description": "Base URL for HTTP API sources"
+                },
+                "headers": {
+                    "type": "object",
+                    "description": "Custom HTTP headers for API requests",
+                    "additionalProperties": {
+                        "type": "string"
+                    }
+                },
+                "queryParams": {
+                    "type": "object",
+                    "description": "Default query parameters for API requests",
+                    "additionalProperties": {
+                        "type": "string"
+                    }
+                },
+                "httpMethod": {
+                    "type": "string",
+                    "enum": ["GET", "POST", "PUT", "PATCH", "DELETE"],
+                    "description": "HTTP method to use for API requests",
+                    "default": "GET"
+                },
+                "apiKey": {
+                    "type": "string",
+                    "description": "API key for api-key authentication method"
+                },
+                "apiKeyHeader": {
+                    "type": "string",
+                    "description": "Header name for API key (defaults to X-API-Key)",
+                    "default": "X-API-Key"
+                },
+                "timeout": {
+                    "type": "number",
+                    "description": "Request timeout in milliseconds",
+                    "default": 30000,
+                    "minimum": 1000
                 }
             },
             "required": ["method"]
@@ -172,6 +216,35 @@
                 "clusterId": "analytics-cluster"
             },
             "_version": 1
+        },
+        {
+            "name": "REST API with Bearer Token",
+            "description": "HTTP API source with bearer token authentication",
+            "engine": "http-api",
+            "authentication": {
+                "method": "bearer-token",
+                "url": "https://api.example.com",
+                "bearerToken": "{API_BEARER_TOKEN}",
+                "headers": {
+                    "Accept": "application/json"
+                },
+                "timeout": 30000
+            },
+            "_version": 1
+        },
+        {
+            "name": "Public REST API",
+            "description": "Public HTTP API with no authentication",
+            "engine": "http-api",
+            "authentication": {
+                "method": "none",
+                "url": "https://api.publicapis.org",
+                "headers": {
+                    "Accept": "application/json"
+                },
+                "httpMethod": "GET"
+            },
+            "_version": 1
         }
     ]
 }

package/drivers/DriverFactory.js

@@ -16,6 +16,7 @@ const LocalDriver_1 = require("./LocalDriver");
 const RedshiftDriver_1 = __importDefault(require("./RedshiftDriver"));
 const S3Driver_1 = require("./S3Driver");
 const DeltaShareDriver_1 = __importDefault(require("./DeltaShareDriver"));
+const HttpApiDriver_1 = require("./HttpApiDriver");
 class DriverFactoryClass {
     constructor() {
         this.instantiateSource = (source) => __awaiter(this, void 0, void 0, function* () {
@@ -41,6 +42,11 @@ class DriverFactoryClass {
                     yield driver.init(source);
                     return driver;
                 }
+                case 'http-api': {
+                    const driver = new HttpApiDriver_1.HttpApiSourceDriver();
+                    yield driver.init(source);
+                    return driver;
+                }
                 default: throw new Error(`Invalid driver type "${source.engine}". This driver is not implemented yet`);
             }
         });