@forzalabs/remora 0.0.19 → 0.0.21

package/engines/execution/ExecutionEnvironment.js

@@ -23,6 +23,7 @@ const SQLBuilder_1 = __importDefault(require("../sql/SQLBuilder"));
 const SQLCompiler_1 = __importDefault(require("../sql/SQLCompiler"));
 const ExecutionPlanner_1 = __importDefault(require("./ExecutionPlanner"));
 const RequestExecutor_1 = __importDefault(require("./RequestExecutor"));
+const TransformationEngine_1 = __importDefault(require("../transform/TransformationEngine"));
 class ExecutionEnvironment {
     constructor(consumer) {
         this.run = (options) => __awaiter(this, void 0, void 0, function* () {
@@ -30,7 +31,8 @@ class ExecutionEnvironment {
             const plan = ExecutionPlanner_1.default.plan(this._consumer, options);
             (0, Affirm_1.default)(plan, `Invalid execution plan`);
             (0, Affirm_1.default)(plan.length > 0, `Empty execution plan`);
-            const result = { shape: ConsumerEngine_1.default.getOutputShape(this._consumer) };
+            const start = performance.now();
+            const result = { shape: ConsumerEngine_1.default.getOutputShape(this._consumer), _elapsedMS: -1 };
             for (const planStep of plan) {
                 switch (planStep.type) {
                     case 'compile-consumer-to-SQL': {
@@ -99,10 +101,15 @@ class ExecutionEnvironment {
                         this._fetchedData = RequestExecutor_1.default._applyFilters(this._fetchedData, this._consumer.filters.map(x => x.rule));
                         break;
                     }
+                    case 'apply-transformations': {
+                        this._fetchedData = TransformationEngine_1.default.apply(this._consumer, this._fetchedData);
+                        break;
+                    }
                     default: throw new Error(`Invalid execution plan step type "${planStep.type}"`);
                 }
             }
             result.data = this._fetchedData;
+            result._elapsedMS = performance.now() - start;
             return result;
         });
         this._consumer = consumer;

package/engines/execution/ExecutionPlanner.js

@@ -18,7 +18,7 @@ class ExecutionPlannerClas {
             }
         };
         this.plan = (consumer, options) => {
-            var _a;
+            var _a, _b;
             (0, Affirm_1.default)(consumer, 'Invalid consumer');
             const [source, producer] = ConsumerManager_1.default.getSource(consumer);
             const producerEngine = source.engine;
@@ -39,7 +39,7 @@ class ExecutionPlannerClas {
                         plan.push({ type: 'read-file-lines', producer: prod, lines: { from: (_a = options.offset) !== null && _a !== void 0 ? _a : 0, to: options.limit ? (options.offset + options.limit) : undefined } });
                     else
                         plan.push({ type: 'read-file-whole', producer: prod });
-                    if (prod.settings.fileType.toUpperCase() === 'CSV') {
+                    if (((_b = prod.settings.fileType) === null || _b === void 0 ? void 0 : _b.toUpperCase()) === 'CSV') {
                         plan.push({ type: 'csv-to-json', producer: prod });
                     }
                     if (prod.dimensions.some(x => { var _a, _b; return ((_a = x.alias) === null || _a === void 0 ? void 0 : _a.includes('{')) || ((_b = x.alias) === null || _b === void 0 ? void 0 : _b.includes('[')); }))
@@ -51,16 +51,20 @@ class ExecutionPlannerClas {
                 }
                 default: throw new Error(`Engine "${producerEngine}" not supported`);
             }
-            // at this point I have the data loaded in memory
+            // At this point I have the data loaded in memory
             // TODO: can I handle streaming data? (e.g. a file that is too big to fit in memory)
             // TODO: how to handle pagination of SQL results?
+            // Apply the transormations to the fields of the consumer
+            // TODO: transformations can also be applied directly to the producer... how???
+            if (consumer.fields.some(x => Algo_1.default.hasVal(x.transform)))
+                plan.push({ type: 'apply-transformations' });
             const engineClass = this.getEngineClass(producerEngine);
             for (const output of consumer.outputs) {
                 switch (output.format.toUpperCase()) {
                     case 'JSON': {
                         if (engineClass === 'file' && Algo_1.default.hasVal(options))
                             plan.push({ type: 'apply-execution-request-to-result' });
-                        // TODO: test if it is need ed and if it doesn't break soething else
+                        // TODO: test if it is needed and if it doesn't break soething else
                         if (engineClass === 'sql')
                             plan.push({ type: 'post-process-json' });
                         plan.push({ type: 'export-file', output });

package/engines/file/FileContentBuilder.js

@@ -0,0 +1,34 @@
+"use strict";
+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 Environment_1 = __importDefault(require("../Environment"));
+class FileContentBuilderClass {
+    constructor() {
+        /**
+         * Converts an array of string to a single string separated with the separator.
+         * In the V8 engine there is a maximum length to a string so I can't just join it all.
+         * I use this to create chunks that are not too long.
+         */
+        this.compose = (lines, separator) => {
+            Affirm_1.default.hasValue(lines, 'Invalid lines');
+            Affirm_1.default.hasValue(lines, 'Invalid separator');
+            const maxStringLength = parseInt(Environment_1.default.get('STRING_MAX_CHARACTERS_LENGTH'));
+            const chunks = [];
+            let currentChunk = '';
+            for (const line of lines) {
+                currentChunk += (line + separator);
+                if (currentChunk.length >= maxStringLength) {
+                    chunks.push(currentChunk);
+                    currentChunk = '';
+                }
+            }
+            chunks.push(currentChunk);
+            return chunks;
+        };
+    }
+}
+const FileContentBuilder = new FileContentBuilderClass();
+exports.default = FileContentBuilder;

package/engines/file/FileExporter.js

@@ -1,37 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 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) {
@@ -50,14 +17,22 @@ const Algo_1 = __importDefault(require("../../core/Algo"));
 const DSTE_1 = __importDefault(require("../../core/dste/DSTE"));
 const DriverFactory_1 = __importDefault(require("../../drivers/DriverFactory"));
 const Environment_1 = __importDefault(require("../Environment"));
-const fs = __importStar(require("fs"));
+const FileContentBuilder_1 = __importDefault(require("./FileContentBuilder"));
 class FileExporterClass {
     constructor() {
         this.export = (consumer, output, data) => __awaiter(this, void 0, void 0, function* () {
             (0, Affirm_1.default)(consumer, `Invalid consumer`);
             (0, Affirm_1.default)(output, `Invalid output`);
             (0, Affirm_1.default)(data, `Invalid export data`);
-            let exportData = null;
+            const preparedData = this._prepareData(consumer, output, data);
+            const writeRes = yield this._writeData(consumer, output, preparedData);
+            return writeRes;
+        });
+        this._prepareData = (consumer, output, data) => {
+            (0, Affirm_1.default)(consumer, `Invalid consumer`);
+            (0, Affirm_1.default)(output, `Invalid output`);
+            (0, Affirm_1.default)(data, `Invalid export data`);
+            let exportDataChunks = null;
             let extension = null;
             // build the actual file in the requested format
             switch (output.format.toUpperCase()) {
@@ -71,8 +46,7 @@ class FileExporterClass {
                         const rowValues = columns.map(c => { var _a; return Algo_1.default.replaceAll((_a = c === null || c === void 0 ? void 0 : c.toString()) !== null && _a !== void 0 ? _a : '', '"', '""'); }).map(c => `"${c}"`).join(',');
                         lines.push(rowValues);
                     }
-                    const csv = lines.join('\n');
-                    exportData = csv;
+                    exportDataChunks = FileContentBuilder_1.default.compose(lines, '\n');
                     extension = 'csv';
                     break;
                 }
@@ -82,8 +56,7 @@ class FileExporterClass {
                         const row = data[i];
                         lines.push(JSON.stringify(row));
                     }
-                    const jsonl = lines.join('\n');
-                    exportData = jsonl;
+                    exportDataChunks = FileContentBuilder_1.default.compose(lines, '\n');
                     extension = 'jsonl';
                     break;
                 }
@@ -91,27 +64,37 @@ class FileExporterClass {
                     throw new Error(`Consumer output "${output.format}" not implemented yet`);
                 }
             }
+            return { textChunks: exportDataChunks, extension };
+        };
+        this._writeData = (consumer, output, preparedData) => __awaiter(this, void 0, void 0, function* () {
+            (0, Affirm_1.default)(consumer, `Invalid consumer`);
+            (0, Affirm_1.default)(output, `Invalid output`);
+            (0, Affirm_1.default)(preparedData, `Invalid prepared data`);
             // export it where it needs to go
             const source = Environment_1.default.getSource(output.exportDestination);
             (0, Affirm_1.default)(source, `Invalid consumer "${consumer.name}" export location source. Make sure that the export location is an available source.`);
+            const { extension, textChunks } = preparedData;
+            const name = this._composeFileName(consumer, extension);
             switch (source.engine) {
                 case 'local': {
-                    const folder = source.authentication.path;
-                    if (!fs.existsSync(folder))
-                        fs.mkdirSync(folder);
-                    const date = DSTE_1.default.now().toISOString().split('.')[0];
-                    const path = `${folder}/${consumer.name}_${Algo_1.default.replaceAll(date, ':', '-')}.${extension}`;
-                    fs.writeFileSync(path, exportData);
-                    return path;
+                    const driver = yield DriverFactory_1.default.instantiateDestination(source);
+                    const res = yield driver.multipartUpload({ contents: textChunks, name });
+                    return res.key;
                 }
                 case 'aws-s3': {
                     const driver = yield DriverFactory_1.default.instantiateDestination(source);
-                    const date = DSTE_1.default.now().toISOString().split('.')[0];
-                    const res = yield driver.uploadFile({ content: exportData, name: `${consumer.name}_${Algo_1.default.replaceAll(date, ':', '-')}.${extension}` });
-                    return res.key;
+                    if (textChunks.length === 1) {
+                        const res = yield driver.uploadFile({ content: textChunks[0], name });
+                        return res.key;
+                    }
+                    else {
+                        const res = yield driver.multipartUpload({ contents: textChunks, name });
+                        return res.key;
+                    }
                 }
             }
         });
+        this._composeFileName = (consumer, extension) => `${consumer.name}_${Algo_1.default.replaceAll(DSTE_1.default.now().toISOString().split('.')[0], ':', '-')}.${extension}`;
     }
 }
 const FileExporter = new FileExporterClass();

package/engines/transform/TransformationEngine.js

@@ -0,0 +1,220 @@
+"use strict";
+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 TypeCaster_1 = __importDefault(require("./TypeCaster"));
+class TransformationEngineClass {
+    constructor() {
+        this.apply = (consumer, data) => {
+            (0, Affirm_1.default)(consumer, 'Invalid consumer');
+            Affirm_1.default.hasValue(data, 'Invalid data');
+            const fieldsToTransform = consumer.fields.filter(field => Algo_1.default.hasVal(field.transform));
+            Affirm_1.default.hasItems(fieldsToTransform, 'No fields with transformations');
+            // Process the data records in place to improve performance instead of copying to a new array
+            for (const record of data) {
+                for (const field of fieldsToTransform) {
+                    if (!field.transform)
+                        continue;
+                    const value = record[field.key];
+                    if (!Algo_1.default.hasVal(value) && Algo_1.default.hasVal(field.default))
+                        record[field.key] = field.default;
+                    else if (!Algo_1.default.hasVal(value))
+                        continue;
+                    try {
+                        record[field.key] = this.applyTransformations(value, field.transform, field.key);
+                    }
+                    catch (error) {
+                        switch (field.onError) {
+                            case 'set_default':
+                                record[field.key] = field.default;
+                                break;
+                            case 'skip':
+                                break;
+                            case 'fail':
+                            default:
+                                throw error;
+                        }
+                    }
+                }
+            }
+            return data;
+        };
+        this.applyTransformations = (value, transformations, fieldName) => {
+            var _a;
+            if (Array.isArray(transformations)) {
+                // Process array transformations without creating intermediate arrays
+                let result = value;
+                for (const transform of transformations) {
+                    result = this.applyTransformations(result, transform, fieldName);
+                }
+                return result;
+            }
+            // Single transformation
+            if ('cast' in transformations) {
+                return TypeCaster_1.default.cast(value, transformations.cast);
+            }
+            if ('multiply' in transformations) {
+                const num = TypeCaster_1.default.cast(value, 'number');
+                if (isNaN(num))
+                    throw new Error(`Cannot multiply non-numeric value in field '${fieldName}'`);
+                return num * transformations.multiply;
+            }
+            if ('add' in transformations) {
+                const num = TypeCaster_1.default.cast(value, 'number');
+                if (isNaN(num))
+                    throw new Error(`Cannot add to non-numeric value in field '${fieldName}'`);
+                return num + transformations.add;
+            }
+            if ('extract' in transformations) {
+                const date = TypeCaster_1.default.cast(value, 'date');
+                if (isNaN(date.getTime()))
+                    throw new Error(`Invalid date for extraction in field '${fieldName}'`);
+                switch (transformations.extract) {
+                    case 'year': return date.getFullYear();
+                    case 'month': return date.getMonth() + 1; // 1-based month
+                    case 'day': return date.getDate();
+                    case 'hour': return date.getHours();
+                    case 'minute': return date.getMinutes();
+                }
+            }
+            if ('concat' in transformations) {
+                if (!Array.isArray(value))
+                    throw new Error(`Cannot concat non-array value in field '${fieldName}'`);
+                return value.join(transformations.concat.separator);
+            }
+            if ('split' in transformations) {
+                if (typeof value !== 'string')
+                    throw new Error(`Cannot split non-string value in field '${fieldName}'`);
+                const parts = value.split(transformations.split.separator);
+                if (transformations.split.index >= parts.length) {
+                    throw new Error(`Split index ${transformations.split.index} out of bounds in field '${fieldName}'`);
+                }
+                return parts[transformations.split.index];
+            }
+            if ('regex_match' in transformations) {
+                if (typeof value !== 'string')
+                    throw new Error(`Cannot apply regex_match to non-string value in field '${fieldName}'`);
+                try {
+                    const regex = new RegExp(transformations.regex_match.pattern, transformations.regex_match.flags);
+                    return regex.test(value);
+                }
+                catch (error) {
+                    throw new Error(`Invalid regex pattern in field '${fieldName}': ${error.message}`);
+                }
+            }
+            if ('regex_replace' in transformations) {
+                if (typeof value !== 'string')
+                    throw new Error(`Cannot apply regex_replace to non-string value in field '${fieldName}'`);
+                try {
+                    const regex = new RegExp(transformations.regex_replace.pattern, transformations.regex_replace.flags);
+                    return value.replace(regex, transformations.regex_replace.replacement);
+                }
+                catch (error) {
+                    throw new Error(`Invalid regex pattern in field '${fieldName}': ${error.message}`);
+                }
+            }
+            if ('regex_extract' in transformations) {
+                if (typeof value !== 'string')
+                    throw new Error(`Cannot apply regex_extract to non-string value in field '${fieldName}'`);
+                try {
+                    const regex = new RegExp(transformations.regex_extract.pattern, transformations.regex_extract.flags);
+                    const matches = value.match(regex);
+                    if (!matches)
+                        return null;
+                    const groupIndex = transformations.regex_extract.group;
+                    return (_a = matches[groupIndex]) !== null && _a !== void 0 ? _a : null;
+                }
+                catch (error) {
+                    throw new Error(`Invalid regex pattern in field '${fieldName}': ${error.message}`);
+                }
+            }
+            if ('trim' in transformations) {
+                if (typeof value !== 'string')
+                    throw new Error(`Cannot trim non-string value in field '${fieldName}'`);
+                return value.trim();
+            }
+            if ('to_lowercase' in transformations) {
+                if (typeof value !== 'string')
+                    throw new Error(`Cannot convert non-string value to lowercase in field '${fieldName}'`);
+                return value.toLowerCase();
+            }
+            if ('to_uppercase' in transformations) {
+                if (typeof value !== 'string')
+                    throw new Error(`Cannot convert non-string value to uppercase in field '${fieldName}'`);
+                return value.toUpperCase();
+            }
+            if ('capitalize' in transformations) {
+                if (typeof value !== 'string')
+                    throw new Error(`Cannot capitalize non-string value in field '${fieldName}'`);
+                return value.charAt(0).toUpperCase() + value.slice(1);
+            }
+            if ('substring' in transformations) {
+                if (typeof value !== 'string')
+                    throw new Error(`Cannot take substring of non-string value in field '${fieldName}'`);
+                const { start, end } = transformations.substring;
+                return end !== undefined ? value.substring(start, end) : value.substring(start);
+            }
+            if ('pad_start' in transformations) {
+                if (typeof value !== 'string')
+                    throw new Error(`Cannot pad non-string value in field '${fieldName}'`);
+                const { length, char } = transformations.pad_start;
+                if (char.length !== 1)
+                    throw new Error(`Pad character must be exactly one character in field '${fieldName}'`);
+                return value.padStart(length, char);
+            }
+            if ('pad_end' in transformations) {
+                if (typeof value !== 'string')
+                    throw new Error(`Cannot pad non-string value in field '${fieldName}'`);
+                const { length, char } = transformations.pad_end;
+                if (char.length !== 1)
+                    throw new Error(`Pad character must be exactly one character in field '${fieldName}'`);
+                return value.padEnd(length, char);
+            }
+            if ('prepend' in transformations)
+                return transformations.prepend + TypeCaster_1.default.cast(value, 'string');
+            if ('append' in transformations)
+                return TypeCaster_1.default.cast(value, 'string') + transformations.append;
+            if ('conditional' in transformations) {
+                for (const clause of transformations.conditional.clauses) {
+                    if (this.evaluateCondition(value, clause.if)) {
+                        return clause.then;
+                    }
+                }
+                return transformations.conditional.else !== undefined ? transformations.conditional.else : value;
+            }
+            return value;
+        };
+        this.evaluateCondition = (value, condition) => {
+            if ('greater_than' in condition) {
+                return TypeCaster_1.default.cast(value, 'number') > condition.greater_than;
+            }
+            if ('greater_than_or_equal' in condition) {
+                return TypeCaster_1.default.cast(value, 'number') >= condition.greater_than_or_equal;
+            }
+            if ('less_than' in condition) {
+                return TypeCaster_1.default.cast(value, 'number') < condition.less_than;
+            }
+            if ('less_than_or_equal' in condition) {
+                return TypeCaster_1.default.cast(value, 'number') <= condition.less_than_or_equal;
+            }
+            if ('equals' in condition) {
+                return value === condition.equals;
+            }
+            if ('not_equals' in condition) {
+                return value !== condition.not_equals;
+            }
+            if ('in' in condition) {
+                return condition.in.includes(value);
+            }
+            if ('not_in' in condition) {
+                return !condition.not_in.includes(value);
+            }
+            return false;
+        };
+    }
+}
+const TransformationEngine = new TransformationEngineClass();
+exports.default = TransformationEngine;

package/engines/transform/TypeCaster.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class TypeCasterClass {
+    /**
+     * Casts the value to the requested type (only if needed)
+     */
+    cast(value, type) {
+        switch (type) {
+            case 'boolean': {
+                if (typeof value === 'boolean')
+                    return value;
+                else
+                    return Boolean(value);
+            }
+            case 'date':
+                return new Date(value);
+            case 'number': {
+                if (typeof value === 'number')
+                    return value;
+                else
+                    return Number(value);
+            }
+            case 'string': {
+                if (typeof value === 'string')
+                    return value;
+                else
+                    return String(value);
+            }
+        }
+    }
+}
+const TypeCaster = new TypeCasterClass();
+exports.default = TypeCaster;

package/engines/validation/Validator.js

@@ -76,7 +76,7 @@ class ValidatorClass {
             (0, Affirm_1.default)(consumer, 'Invalid consumer');
             const errors = [];
             try {
-                // TODO: check that a consumer doens't consume himself
+                // TODO: check that a consumer doesn't consume hitself
                 const allFieldsWithNoFrom = consumer.fields.filter(x => x.key === '*' && !x.from);
                 if (allFieldsWithNoFrom.length > 0 && consumer.producers.length > 1)
                     errors.push(`Field with key "*" was used without specifying the "from" producer and multiple producers were found.`);
@@ -126,17 +126,34 @@ class ValidatorClass {
                     });
                     return errors;
                 };
+                const validateTransformations = (fields) => {
+                    const errors = [];
+                    const trxsFields = fields.filter(x => x.transform);
+                    for (const field of trxsFields) {
+                        const transformations = Object.keys(field.transform);
+                        if (transformations.length !== 1)
+                            errors.push(`There can only be 1 transformation type in your transformation pipeline. Field "${field.key}" got ${transformations.length}`);
+                    }
+                    return errors;
+                };
                 errors.push(...validateGroupingLevels(consumer.fields));
+                errors.push(...validateTransformations(consumer.fields));
                 // Validation outputs
                 const duplicatesOutputs = Algo_1.default.duplicatesObject(consumer.outputs, 'format');
                 if (duplicatesOutputs.length > 0) {
                     const duplicatesTypes = Algo_1.default.uniq(duplicatesOutputs.map(x => x.format));
                     errors.push(`There are outputs with the same type. (duplicates type: ${duplicatesTypes.join(' and ')})`);
                 }
-                for (let i = 0; i < consumer.outputs.length; i++) {
-                    const output = consumer.outputs[i];
-                    if (output.format === 'SQL' && output.accellerated && output.direct)
-                        errors.push(`An output SQL cannot be both direct and accelerated. (output: ${output.format})`);
+                for (const output of consumer.outputs) {
+                    const format = output.format.toUpperCase();
+                    if (format === 'SQL' && output.accellerated && output.direct)
+                        errors.push(`An output SQL cannot be both direct and accelerated (output: ${format})`);
+                    if ((format === 'CSV' || format === 'JSON' || format === 'PARQUET')) {
+                        if (!output.exportDestination)
+                            errors.push(`A static file output must have an export destination set (${format})`);
+                        else if (!Environment_1.default.getSource(output.exportDestination))
+                            errors.push(`The export destination "${output.exportDestination}" was not found in the sources.`);
+                    }
                 }
             }
             catch (e) {

package/helper/Helper.js

@@ -59,6 +59,13 @@ const Helper = {
         }
         read(directory);
         return functionFiles;
+    },
+    formatDateToYYYYMM(date) {
+        if (!date)
+            return '';
+        const year = date.getFullYear();
+        const month = ('0' + (date.getMonth() + 1)).slice(-2);
+        return `${year}-${month}`;
     }
 };
 exports.default = Helper;

package/index.js

@@ -16,8 +16,15 @@ const discover_1 = require("./actions/discover");
 const automap_1 = require("./actions/automap");
 const create_producer_1 = require("./actions/create_producer");
 const create_consumer_1 = require("./actions/create_consumer");
+const LicenceManager_1 = __importDefault(require("./licencing/LicenceManager"));
 dotenv_1.default.configDotenv();
 const program = new commander_1.Command();
+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);
+}
 program
     .version(Constants_1.default.cliVersion + '', '-v, --version', 'Display the version of the CLI')
     .description('CLI tool for setting up and managing Data-Remora');

package/licencing/LicenceManager.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = __importDefault(require("crypto"));
+const PUBLICK_KEY = `-----BEGIN PUBLIC KEY-----
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA7BWugM83YKGzTyZ6kJyy
+M01JoGYBQYn/9H9utQQyC/uugV4g9d7vv87I2yUfqiHtx7BQj0mOGctqnK7vuRcg
+py7fghTjsUj0MDhs8cEpc+47m0xdsU9MQQ8Xze8B3FcdvCc4xtT5nruTAUWMGIAM
+WLHG8lWxkHjTSZn4S0RdpRBB7fw4jyVkc+vXCTtVtYQwMWjcErNFrdCenvci4Vus
+nKlyfKS6ccLQphOc/I2w6zllFwD/l90vQeQ6kDO01aJLOmJPzvlU/TSP/lcxCYTA
+TgQJQxd5UdnTSDjNw+Uu/jzZ5mVlCbtYH1RoJ6cGNglzN8Q50mVk/iVyoZCZ94b4
+bwIDAQAB
+-----END PUBLIC KEY-----`;
+class LicenceManagerClass {
+    constructor() {
+        this.generate = (customer, expirationDays, features, privateKey) => {
+            const now = new Date();
+            const expirationDate = new Date(now.getTime() + expirationDays * 24 * 60 * 60 * 1000);
+            const licenceData = {
+                customer,
+                features,
+                issued: now.toISOString(),
+                expires: expirationDate.toISOString()
+            };
+            const licenceString = JSON.stringify(licenceData);
+            const sign = crypto_1.default.createSign('SHA256');
+            sign.update(licenceString);
+            sign.end();
+            const signature = sign.sign(privateKey, 'base64');
+            const licence = { data: licenceData, signature };
+            return Buffer.from(JSON.stringify(licence)).toString('base64');
+        };
+        this.validate = (licence) => {
+            try {
+                const licenceJSON = Buffer.from(licence, 'base64').toString();
+                const licenceData = JSON.parse(licenceJSON);
+                const { data, signature } = licenceData;
+                const now = new Date();
+                const expirationDate = new Date(data.expires);
+                if (now > expirationDate)
+                    return { valid: false, reason: 'License expired', expiryDate: expirationDate };
+                const verify = crypto_1.default.createVerify('SHA256');
+                verify.update(JSON.stringify(data));
+                const isSignatureValid = verify.verify(PUBLICK_KEY, signature, 'base64');
+                if (!isSignatureValid)
+                    return { valid: false, reason: 'Invalid license signature' };
+                return {
+                    valid: true,
+                    expiryDate: expirationDate,
+                    daysRemaining: Math.ceil((expirationDate.getTime() - now.getTime()) / (24 * 60 * 60 * 1000)),
+                    features: data.features,
+                    customer: data.customer
+                };
+            }
+            catch (error) {
+                return { valid: false, reason: 'License parsing error', details: error.message };
+            }
+        };
+    }
+}
+const LicenceManager = new LicenceManagerClass();
+exports.default = LicenceManager;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@forzalabs/remora",
-    "version": "0.0.19",
+    "version": "0.0.21",
     "description": "A powerful CLI tool for seamless data translation.",
     "main": "index.js",
     "private": false,