@forzalabs/remora 1.0.1 → 1.0.3

package/engines/Validator.js

@@ -1,157 +0,0 @@
-"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 ConsumerManager_1 = __importDefault(require("./consumer/ConsumerManager"));
-const Environment_1 = __importDefault(require("./Environment"));
-const ExecutionPlanner_1 = __importDefault(require("./execution/ExecutionPlanner"));
-class ValidatorClass {
-    constructor() {
-        this.validateSources = (sources) => {
-            (0, Affirm_1.default)(sources, 'Invalid sources');
-            const errors = [];
-            try {
-                const dupes = Algo_1.default.duplicatesObject(sources, 'name');
-                if (dupes.length > 0)
-                    errors.push(`Duplicate name(s) found in sources: "${dupes.map(x => x.name).join(', ')}"`);
-                for (let i = 0; i < sources.length; i++) {
-                    const source = sources[i];
-                    if (source.engine === 'local' && !source.authentication.path)
-                        errors.push(`For source ${source.name}, the path has not been configured`);
-                }
-            }
-            catch (e) {
-                if (errors.length === 0)
-                    errors.push(`There was an error in the validation Sources. (error: ${e})`);
-            }
-            return errors;
-        };
-        this.validateProducers = (producers) => {
-            (0, Affirm_1.default)(producers, 'Invalid producers');
-            const errors = [];
-            try {
-                const dupes = Algo_1.default.duplicatesObject(producers, 'name');
-                if (dupes.length > 0)
-                    errors.push(`Duplicate name(s) found in producers: "${dupes.map(x => x.name).join(', ')}"`);
-            }
-            catch (e) {
-                if (errors.length === 0)
-                    errors.push(`There was an error in the validation Producers. (error: ${e})`);
-            }
-            return errors;
-        };
-        this.validateProducer = (producer) => {
-            (0, Affirm_1.default)(producer, 'Invalid producer');
-            const errors = [];
-            try {
-                if (!producer.source || producer.source.length === 0)
-                    errors.push(`Missing parameter "source" in producer`);
-                if (producer.dimensions.some(x => x.name.includes('{') || x.name.includes('[')))
-                    errors.push(`Invalid dimension name found in producer "${producer.name}": can't use characters "{" or "[" in dimension names`);
-            }
-            catch (e) {
-                if (errors.length === 0)
-                    errors.push(`There was an error in the validation Producer. (error: ${e})`);
-            }
-            return errors;
-        };
-        this.validateConsumers = (consumers) => {
-            (0, Affirm_1.default)(consumers, 'Invalid consumers');
-            const errors = [];
-            try {
-                const dupes = Algo_1.default.duplicatesObject(consumers, 'name');
-                if (dupes.length > 0)
-                    errors.push(`Duplicate name(s) found in consumers: "${dupes.map(x => x.name).join(', ')}"`);
-            }
-            catch (e) {
-                if (errors.length === 0)
-                    errors.push(`There was an error in the validation Consumers. (error: ${e})`);
-            }
-            return errors;
-        };
-        this.validateConsumer = (consumer) => {
-            (0, Affirm_1.default)(consumer, 'Invalid consumer');
-            const errors = [];
-            try {
-                // 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.`);
-                if (consumer.fields.some(x => x.key === '*' && x.grouping))
-                    errors.push(`Field with key "*" can't be used for "grouping". Either remove the grouping or change the key.`);
-                // Validation on producers
-                if (consumer.producers.length === 0)
-                    errors.push(`Consumer must have at least 1 producer.`);
-                const producers = consumer.producers.map(x => Environment_1.default.getProducer(x.name));
-                if (producers.length === 0)
-                    errors.push('No producers found');
-                if (producers.some(x => !x))
-                    errors.push(`Invalid producer found in consumer "${consumer.name}"`);
-                // Validation on sources
-                const sources = producers.map(x => Environment_1.default.getSource(x.source));
-                if (sources.length === 0)
-                    errors.push('No sources found');
-                if (sources.some(x => !x))
-                    errors.push(`Invalid source found 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 uniqEngines = Algo_1.default.uniqBy(sources, 'engine');
-                if (uniqEngines.length !== 1)
-                    errors.push(`Sources with different engines were used in the consumer "${consumer.name}" (${uniqEngines.join(', ')})`);
-                // For now we also only support consumers that have producers ALL having the same exact source
-                const uniqNames = Algo_1.default.uniqBy(sources, 'name');
-                if (uniqNames.length !== 1)
-                    errors.push(`Producers with different sources were used in the consumer "${consumer.name}" (${uniqNames.join(', ')})`);
-                if (consumer.filters && consumer.filters.length > 0) {
-                    if (consumer.filters.some(x => x.sql && x.rule))
-                        errors.push(`A single consumer can't have both filters based on SQL and filters based on rules.`);
-                    const [source] = ConsumerManager_1.default.getSource(consumer);
-                    const engineClass = ExecutionPlanner_1.default.getEngineClass(source.engine);
-                    if (engineClass === 'file' && consumer.filters.some(x => x.sql))
-                        errors.push(`Filters based on SQL are only valid for SQL based sources. (source: ${source.name})`);
-                    if (engineClass === 'sql' && consumer.filters.some(x => x.rule))
-                        errors.push(`Filters based on rules are only valid for non-SQL based sources. (source: ${source.name})`);
-                }
-                // Validation on fields
-                const validateGroupingLevels = (fields, level = 0) => {
-                    let errors = [];
-                    const groupingFields = fields.filter(x => x.grouping);
-                    if (groupingFields.length > 1)
-                        errors.push(`There can't be 2 fields with grouping defined at the same level (${groupingFields.map(x => x.key).join(', ')}). Level: ${level}`);
-                    groupingFields.forEach((field) => {
-                        if (field.grouping)
-                            errors = [...errors, ...validateGroupingLevels(field.grouping.subFields, level + 1)];
-                    });
-                    return errors;
-                };
-                errors.push(...validateGroupingLevels(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 (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) {
-                if (errors.length === 0)
-                    errors.push(`There was an error in the validation Consumer. (error: ${e})`);
-            }
-            return errors;
-        };
-    }
-}
-const Validator = new ValidatorClass();
-exports.default = Validator;

package/engines/consumer/ConsumerEngine.js

@@ -1,128 +0,0 @@
-"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"));
-const ProducerManager_1 = __importDefault(require("../producer/ProducerManager"));
-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 {
-                    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.getOutputShape = (consumer) => {
-            (0, Affirm_1.default)(consumer, `Invalid consumer`);
-            const compiled = this.compile(consumer);
-            const outDimensions = compiled.map(x => {
-                var _a, _b, _c, _d, _e, _f, _g;
-                return ({
-                    name: (_a = x.consumerAlias) !== null && _a !== void 0 ? _a : x.consumerKey,
-                    type: (_b = x.dimension) === null || _b === void 0 ? void 0 : _b.type,
-                    classification: (_c = x.dimension) === null || _c === void 0 ? void 0 : _c.classification,
-                    description: (_e = (_d = x.dimension) === null || _d === void 0 ? void 0 : _d.description) !== null && _e !== void 0 ? _e : (_f = x.measure) === null || _f === void 0 ? void 0 : _f.description,
-                    mask: ProducerManager_1.default.getMask(x.dimension),
-                    pk: (_g = x.dimension) === null || _g === void 0 ? void 0 : _g.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;

package/engines/consumer/PostProcessor.js

@@ -1,253 +0,0 @@
-"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 CryptoEngine_1 = __importDefault(require("../CryptoEngine"));
-const DatasetManager_1 = __importDefault(require("../dataset/DatasetManager"));
-const DatasetRecord_1 = __importDefault(require("../dataset/DatasetRecord"));
-const Environment_1 = __importDefault(require("../Environment"));
-const FileCompiler_1 = __importDefault(require("../file/FileCompiler"));
-const ProducerManager_1 = __importDefault(require("../producer/ProducerManager"));
-const TypeCaster_1 = __importDefault(require("../transform/TypeCaster"));
-const ConsumerManager_1 = __importDefault(require("./ConsumerManager"));
-class PostProcessorClass {
-    constructor() {
-        /**
-         * Maps an array of objects and projects it to another array of objects but with different shape:
-         * - updates the dimensions of the dataset (drop, rename, reorder, hide)
-         * - type casting
-         * - default field values
-         * - masking/hashing of data
-         */
-        this.doProjection = (consumer, dataset, options) => __awaiter(this, void 0, void 0, function* () {
-            (0, Affirm_1.default)(consumer, 'Invalid consumer');
-            (0, Affirm_1.default)(dataset, 'Invalid dataset');
-            const fields = ConsumerManager_1.default.getExpandedFields(consumer);
-            const dimensionsUpdates = DatasetManager_1.default.computeDimensionsUpdates(dataset, consumer);
-            let updatedDimensions = null;
-            dataset = yield dataset.map(record => {
-                var _a, _b;
-                // First apply the updates to the dimensions of this record
-                if (dimensionsUpdates.length > 0) {
-                    for (const update of dimensionsUpdates) {
-                        record.wholeUpdateDimension(update);
-                    }
-                    record.sortDimensions();
-                }
-                if (!updatedDimensions)
-                    updatedDimensions = record._dimensions;
-                // Finally apply the rules and changes of the consumer fields to the record
-                for (const field of fields) {
-                    const { key, alias } = field.cField;
-                    const fieldKey = alias !== null && alias !== void 0 ? alias : key;
-                    const maskType = ProducerManager_1.default.getMask(field.dimension);
-                    const fieldType = (_b = (_a = field.dimension) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : 'string';
-                    const fieldValue = this._getFieldValue(record, field);
-                    if (Algo_1.default.hasVal(maskType))
-                        record.setValue(fieldKey, CryptoEngine_1.default.hashValue(maskType, fieldValue, fieldType));
-                    else
-                        record.setValue(fieldKey, TypeCaster_1.default.cast(fieldValue, fieldType));
-                }
-                return record;
-            }, options);
-            if (!updatedDimensions || updatedDimensions.length === 0) {
-                // This means that no updates were applied cause no records were present
-                // I need to force a fake update to get the new dimensions, since those might still have changed
-                const fakeRecord = new DatasetRecord_1.default('', dataset.getDimensions(), dataset.getDelimiter());
-                for (const update of dimensionsUpdates)
-                    fakeRecord.wholeUpdateDimension(update);
-                updatedDimensions = fakeRecord._dimensions;
-            }
-            dataset.setDimensions(updatedDimensions);
-            return dataset;
-        });
-        /**
-         * Gets an array of objects (with potentially nested fields) and unpacks them to an array of objects with no nested fields
-         * If some nested keys are lists, then a logic similar to a SQL JOIN is used and rows are duplicated
-         */
-        this.unpack = (dataset, producer) => __awaiter(this, void 0, void 0, function* () {
-            (0, Affirm_1.default)(dataset, 'Invalid dataset');
-            (0, Affirm_1.default)(producer, 'Invalid producer');
-            const source = Environment_1.default.getSource(producer.source);
-            (0, Affirm_1.default)(source, `No source found for producer "${producer.name}" with name "${producer.source}"`);
-            const columns = FileCompiler_1.default.compileProducer(producer, source);
-            (0, Affirm_1.default)(columns, `Invalid columns from compilation for producer "${producer.name}"`);
-            const unpackDimension = (item, dimension) => {
-                var _a, _b;
-                const { nameInProducer, aliasInProducer } = dimension;
-                const maskType = ProducerManager_1.default.getMask(dimension.dimension);
-                const fieldType = (_b = (_a = dimension.dimension) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : 'string';
-                const keys = aliasInProducer.split('.');
-                // Parse the JSON content from the DatasetRecord first
-                let prevValue;
-                try {
-                    // Try to parse as JSON if the raw content looks like JSON
-                    const rawContent = item.getRaw();
-                    if (rawContent.trim().startsWith('{') || rawContent.trim().startsWith('[')) {
-                        prevValue = JSON.parse(rawContent);
-                    }
-                    else {
-                        // For non-JSON data, create an object from the record's values
-                        const recordObj = {};
-                        const dimensions = dataset.getDimensions();
-                        for (const dim of dimensions) {
-                            recordObj[dim.name] = item.getValue(dim.name);
-                        }
-                        prevValue = recordObj;
-                    }
-                }
-                catch (_c) {
-                    // Fallback to using the record's values directly
-                    const recordObj = {};
-                    const dimensions = dataset.getDimensions();
-                    for (const dim of dimensions) {
-                        recordObj[dim.name] = item.getValue(dim.name);
-                    }
-                    prevValue = recordObj;
-                }
-                // Navigate through the nested structure
-                for (const key of keys) {
-                    if (key.includes('{')) {
-                        const cleanedKey = key.replace('{', '').replace('}', '');
-                        if (Array.isArray(prevValue))
-                            prevValue = prevValue === null || prevValue === void 0 ? void 0 : prevValue.map((x) => x[cleanedKey]);
-                        else
-                            prevValue = prevValue === null || prevValue === void 0 ? void 0 : prevValue[cleanedKey];
-                    }
-                    else if (key.includes('[')) {
-                        const cleanedKey = key.replace('[', '').replace(']', '');
-                        if (Array.isArray(prevValue))
-                            prevValue = prevValue === null || prevValue === void 0 ? void 0 : prevValue.flatMap((x) => x[cleanedKey]);
-                        else
-                            prevValue = prevValue === null || prevValue === void 0 ? void 0 : prevValue[cleanedKey];
-                    }
-                    else {
-                        if (Array.isArray(prevValue))
-                            prevValue = prevValue === null || prevValue === void 0 ? void 0 : prevValue.map((x) => x[key]);
-                        else
-                            prevValue = prevValue === null || prevValue === void 0 ? void 0 : prevValue[key];
-                    }
-                }
-                // Apply masking/hashing
-                const valueAsString = prevValue !== null && prevValue !== undefined ? String(prevValue) : '';
-                prevValue = CryptoEngine_1.default.hashValue(maskType, valueAsString, fieldType);
-                const res = { [nameInProducer]: prevValue };
-                return res;
-            };
-            const splitArrayFields = (item) => {
-                const keysWithArrayValues = Object.keys(item).filter(key => Array.isArray(item[key]));
-                if (keysWithArrayValues.length === 0)
-                    return [item];
-                const key = keysWithArrayValues[0];
-                const values = item[key];
-                const remainingItem = Object.assign({}, item);
-                delete remainingItem[key];
-                const splitRemaining = splitArrayFields(remainingItem);
-                return values.flatMap((value) => {
-                    return splitRemaining.map((remaining) => {
-                        return Object.assign(Object.assign({}, remaining), { [key]: value });
-                    });
-                });
-            };
-            const unpackSingle = (item) => {
-                var _a;
-                const unpackedRecord = {};
-                // Extract values from all columns
-                for (const column of columns) {
-                    const value = unpackDimension(item, column);
-                    Object.assign(unpackedRecord, value);
-                }
-                // Split array fields to create multiple records
-                const splitRecords = splitArrayFields(unpackedRecord);
-                // Convert back to DatasetRecord objects
-                const resultRecords = [];
-                // Get the expected field names from all columns to maintain consistent dimensions
-                const expectedFieldNames = columns.map(col => col.nameInProducer);
-                for (const splitRecord of splitRecords) {
-                    // Ensure all expected fields are present, filling with empty string if missing
-                    const normalizedRecord = {};
-                    for (const fieldName of expectedFieldNames) {
-                        normalizedRecord[fieldName] = (_a = splitRecord[fieldName]) !== null && _a !== void 0 ? _a : '';
-                    }
-                    // Create dimensions based on the expected field names
-                    const newDimensions = expectedFieldNames.map((key, index) => {
-                        var _a, _b, _c;
-                        return ({
-                            name: key,
-                            key: key,
-                            index: index,
-                            hidden: null,
-                            type: (_c = (_b = (_a = columns[index]) === null || _a === void 0 ? void 0 : _a.dimension) === null || _b === void 0 ? void 0 : _b.type) !== null && _c !== void 0 ? _c : 'string'
-                        });
-                    });
-                    // Create the row string
-                    const values = newDimensions.map(dim => {
-                        const value = normalizedRecord[dim.name];
-                        return value !== null && value !== undefined ? String(value) : '';
-                    });
-                    const rowString = values.join(dataset.getDelimiter());
-                    // Create new DatasetRecord
-                    const newRecord = new DatasetRecord_1.default(rowString, newDimensions, dataset.getDelimiter());
-                    resultRecords.push(newRecord);
-                }
-                return resultRecords;
-            };
-            const resDataset = yield dataset.flatMap(record => unpackSingle(record));
-            // Update the dataset dimensions to match the unpacked structure
-            // TODO: 99% certain this will cause a bug
-            if (columns.length > 0) {
-                const newDimensions = columns.map((col, index) => {
-                    var _a;
-                    return ({
-                        name: col.nameInProducer,
-                        key: col.nameInProducer,
-                        index: index,
-                        hidden: null,
-                        type: (_a = col.dimension) === null || _a === void 0 ? void 0 : _a.type
-                    });
-                });
-                resDataset.setDimensions(newDimensions);
-            }
-            return resDataset;
-        });
-        this._getFieldValue = (record, field) => {
-            var _a, _b, _c;
-            const { key, alias, fixed, default: defaultValue } = field.cField;
-            if (fixed && Algo_1.default.hasVal(defaultValue))
-                return defaultValue;
-            const fieldKey = alias !== null && alias !== void 0 ? alias : key;
-            const fieldValue = record.getValue(fieldKey);
-            const fieldType = (_b = (_a = field.dimension) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : 'string';
-            if (Algo_1.default.hasVal(fieldValue) && !isNaN(fieldValue)) {
-                if (fieldType === 'number' && typeof fieldValue === 'string' && fieldValue.length === 0)
-                    return (_c = field.cField.default) !== null && _c !== void 0 ? _c : fieldValue;
-                else
-                    return fieldValue;
-            }
-            else if ((!Algo_1.default.hasVal(fieldValue) || (isNaN(fieldValue) && fieldType === 'number')) && Algo_1.default.hasVal(field.cField.default)) {
-                return field.cField.default;
-            }
-            else {
-                return fieldValue;
-            }
-        };
-        this.distinct = (dataset) => __awaiter(this, void 0, void 0, function* () {
-            (0, Affirm_1.default)(dataset, 'Invalid dataset');
-            return yield dataset.distinct();
-        });
-    }
-}
-const PostProcessor = new PostProcessorClass();
-exports.default = PostProcessor;