@featurevisor/core 1.35.3 → 2.0.0

package/lib/builder/buildDatafile.js

@@ -1,407 +1,330 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-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 __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCustomDatafile = getCustomDatafile;
 exports.buildDatafile = buildDatafile;
-var fs = require("fs");
-var config_1 = require("../config");
-var utils_1 = require("../utils");
-var traffic_1 = require("./traffic");
-var getFeatureRanges_1 = require("./getFeatureRanges");
-function getCustomDatafile(options) {
-    return __awaiter(this, void 0, void 0, function () {
-        var featuresToInclude, requiredChain, existingState, datafileContent;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    if (!options.featureKey) return [3 /*break*/, 2];
-                    return [4 /*yield*/, options.datasource.getRequiredFeaturesChain(options.featureKey)];
-                case 1:
-                    requiredChain = _a.sent();
-                    featuresToInclude = Array.from(requiredChain);
-                    _a.label = 2;
-                case 2: return [4 /*yield*/, options.datasource.readState(options.environment)];
-                case 3:
-                    existingState = _a.sent();
-                    return [4 /*yield*/, buildDatafile(options.projectConfig, options.datasource, {
-                            schemaVersion: options.schemaVersion || config_1.SCHEMA_VERSION,
-                            revision: options.revision || "tester",
-                            environment: options.environment,
-                            features: featuresToInclude,
-                            inflate: options.inflate,
-                        }, existingState)];
-                case 4:
-                    datafileContent = _a.sent();
-                    return [2 /*return*/, datafileContent];
-            }
-        });
-    });
+const fs = require("fs");
+const config_1 = require("../config");
+const utils_1 = require("../utils");
+const hashes_1 = require("./hashes");
+const traffic_1 = require("./traffic");
+const getFeatureRanges_1 = require("./getFeatureRanges");
+const convertToV1_1 = require("./convertToV1");
+async function getCustomDatafile(options) {
+    let featuresToInclude;
+    if (options.featureKey) {
+        const requiredChain = await options.datasource.getRequiredFeaturesChain(options.featureKey);
+        featuresToInclude = Array.from(requiredChain);
+    }
+    const existingState = await options.datasource.readState(options.environment);
+    const datafileContent = await buildDatafile(options.projectConfig, options.datasource, {
+        schemaVersion: options.schemaVersion || config_1.SCHEMA_VERSION,
+        revision: options.revision || "tester",
+        environment: options.environment,
+        features: featuresToInclude,
+        inflate: options.inflate,
+    }, existingState);
+    return datafileContent;
 }
-function buildDatafile(projectConfig, datasource, options, existingState) {
-    return __awaiter(this, void 0, void 0, function () {
-        var datafileContent, segmentKeysUsedByTag, attributeKeysUsedByTag, _a, featureRanges, featureIsInGroup, features, featuresDirectory, featureFiles, _i, featureFiles_1, featureKey, parsedFeature, expose, rules, force, exposeTags, _b, rules_1, parsedRule, extractedSegmentKeys, feature, segments, segmentsDirectory, segmentFiles, _c, segmentFiles_1, segmentKey, parsedSegment, extractedAttributeKeys, segment, attributes, attributesDirectory, attributeFiles, _d, attributeFiles_1, attributeKey, parsedAttribute, attribute, allFeatureKeys, allSegmentKeys, allAttributeKeys, i, _loop_1, _e, allFeatureKeys_1, featureKey, _loop_2, _f, allSegmentKeys_1, segmentKey, _loop_3, _g, allAttributeKeys_1, attributeKey, datafileContentV2;
-        var _h;
-        return __generator(this, function (_j) {
-            switch (_j.label) {
-                case 0:
-                    datafileContent = {
-                        schemaVersion: options.schemaVersion,
-                        revision: options.revision,
-                        attributes: [],
-                        segments: [],
-                        features: [],
-                    };
-                    segmentKeysUsedByTag = new Set();
-                    attributeKeysUsedByTag = new Set();
-                    return [4 /*yield*/, (0, getFeatureRanges_1.getFeatureRanges)(projectConfig, datasource)];
-                case 1:
-                    _a = _j.sent(), featureRanges = _a.featureRanges, featureIsInGroup = _a.featureIsInGroup;
-                    features = [];
-                    featuresDirectory = projectConfig.featuresDirectoryPath;
-                    if (!fs.existsSync(featuresDirectory)) return [3 /*break*/, 6];
-                    return [4 /*yield*/, datasource.listFeatures()];
-                case 2:
-                    featureFiles = _j.sent();
-                    _i = 0, featureFiles_1 = featureFiles;
-                    _j.label = 3;
-                case 3:
-                    if (!(_i < featureFiles_1.length)) return [3 /*break*/, 6];
-                    featureKey = featureFiles_1[_i];
-                    return [4 /*yield*/, datasource.readFeature(featureKey)];
-                case 4:
-                    parsedFeature = _j.sent();
-                    if (parsedFeature.archived === true) {
-                        return [3 /*break*/, 5];
-                    }
-                    if (options.tag && parsedFeature.tags.indexOf(options.tag) === -1) {
-                        return [3 /*break*/, 5];
-                    }
-                    if (options.features && options.features.indexOf(featureKey) === -1) {
-                        return [3 /*break*/, 5];
-                    }
-                    expose = void 0;
-                    rules = void 0;
-                    force = void 0;
-                    if (options.environment && parsedFeature.environments) {
-                        expose = parsedFeature.environments[options.environment].expose;
-                        rules = parsedFeature.environments[options.environment].rules;
-                        force = parsedFeature.environments[options.environment].force;
-                    }
-                    else {
-                        expose = parsedFeature.expose;
-                        rules = parsedFeature.rules;
-                        force = parsedFeature.force;
-                    }
-                    if (expose === false) {
-                        return [3 /*break*/, 5];
-                    }
-                    if (Array.isArray(expose)) {
-                        exposeTags = expose;
-                        if (options.tag && exposeTags.indexOf(options.tag) === -1) {
-                            return [3 /*break*/, 5];
-                        }
-                    }
-                    for (_b = 0, rules_1 = rules; _b < rules_1.length; _b++) {
-                        parsedRule = rules_1[_b];
-                        extractedSegmentKeys = (0, utils_1.extractSegmentKeysFromGroupSegments)(parsedRule.segments);
-                        extractedSegmentKeys.forEach(function (segmentKey) { return segmentKeysUsedByTag.add(segmentKey); });
-                    }
-                    feature = {
-                        key: featureKey,
-                        deprecated: parsedFeature.deprecated === true ? true : undefined,
-                        bucketBy: parsedFeature.bucketBy || projectConfig.defaultBucketBy,
-                        required: parsedFeature.required,
-                        variations: Array.isArray(parsedFeature.variations)
-                            ? parsedFeature.variations.map(function (variation) {
-                                var mappedVariation = {
-                                    value: variation.value,
-                                    weight: variation.weight, // @TODO: added so state files can maintain weight info, but datafiles don't need this. find a way to remove it from datafiles later
-                                };
-                                if (!variation.variables) {
-                                    return mappedVariation;
-                                }
-                                mappedVariation.variables = variation.variables.map(function (variable) {
-                                    var mappedVariable = {
-                                        key: variable.key,
-                                        value: variable.value,
-                                    };
-                                    if (!variable.overrides) {
-                                        return mappedVariable;
+async function buildDatafile(projectConfig, datasource, options, existingState) {
+    const segmentKeysUsedByTag = new Set();
+    const attributeKeysUsedByTag = new Set();
+    const { featureRanges, featureIsInGroup } = await (0, getFeatureRanges_1.getFeatureRanges)(projectConfig, datasource);
+    // features
+    const features = [];
+    const featuresDirectory = projectConfig.featuresDirectoryPath;
+    if (fs.existsSync(featuresDirectory)) {
+        const featureFiles = await datasource.listFeatures();
+        for (const featureKey of featureFiles) {
+            const parsedFeature = await datasource.readFeature(featureKey);
+            if (parsedFeature.archived === true) {
+                continue;
+            }
+            if (options.tag && parsedFeature.tags.indexOf(options.tag) === -1) {
+                continue;
+            }
+            if (options.features && options.features.indexOf(featureKey) === -1) {
+                continue;
+            }
+            let expose;
+            let rules;
+            let force;
+            if (options.environment) {
+                expose = parsedFeature.expose?.[options.environment];
+                rules = parsedFeature.rules?.[options.environment];
+                force = parsedFeature.force?.[options.environment];
+            }
+            else {
+                expose = parsedFeature.expose;
+                rules = parsedFeature.rules;
+                force = parsedFeature.force;
+            }
+            if (expose === false) {
+                continue;
+            }
+            if (Array.isArray(expose)) {
+                const exposeTags = expose;
+                if (options.tag && exposeTags.indexOf(options.tag) === -1) {
+                    continue;
+                }
+            }
+            for (const parsedRule of rules) {
+                const extractedSegmentKeys = (0, utils_1.extractSegmentKeysFromGroupSegments)(parsedRule.segments);
+                extractedSegmentKeys.forEach((segmentKey) => segmentKeysUsedByTag.add(segmentKey));
+            }
+            const feature = {
+                key: featureKey,
+                deprecated: parsedFeature.deprecated === true ? true : undefined,
+                bucketBy: parsedFeature.bucketBy || projectConfig.defaultBucketBy,
+                required: parsedFeature.required,
+                disabledVariationValue: parsedFeature.disabledVariationValue,
+                variations: Array.isArray(parsedFeature.variations)
+                    ? parsedFeature.variations.map((variation) => {
+                        const mappedVariation = {
+                            value: variation.value,
+                            weight: variation.weight, // @NOTE: added so state files can maintain weight info, but datafiles don't need this. find a way to remove it from datafiles later
+                            variables: variation.variables,
+                            variableOverrides: variation.variableOverrides,
+                        };
+                        if (variation.variableOverrides) {
+                            const variableOverrides = variation.variableOverrides;
+                            const variableKeys = Object.keys(variableOverrides);
+                            for (const variableKey of variableKeys) {
+                                mappedVariation.variableOverrides[variableKey] = variableOverrides[variableKey].map((override) => {
+                                    if (typeof override.conditions !== "undefined") {
+                                        const extractedAttributeKeys = (0, utils_1.extractAttributeKeysFromConditions)(override.conditions);
+                                        extractedAttributeKeys.forEach((attributeKey) => attributeKeysUsedByTag.add(attributeKey));
+                                        return {
+                                            conditions: projectConfig.stringify && typeof override.conditions !== "string"
+                                                ? JSON.stringify(override.conditions)
+                                                : override.conditions,
+                                            value: override.value,
+                                        };
+                                    }
+                                    if (typeof override.segments !== "undefined") {
+                                        const extractedSegmentKeys = (0, utils_1.extractSegmentKeysFromGroupSegments)(override.segments);
+                                        extractedSegmentKeys.forEach((segmentKey) => segmentKeysUsedByTag.add(segmentKey));
+                                        return {
+                                            segments: projectConfig.stringify && typeof override.segments !== "string"
+                                                ? JSON.stringify(override.segments)
+                                                : override.segments,
+                                            value: override.value,
+                                        };
                                     }
-                                    mappedVariable.overrides = variable.overrides.map(function (override) {
-                                        if (typeof override.conditions !== "undefined") {
-                                            var extractedAttributeKeys = (0, utils_1.extractAttributeKeysFromConditions)(override.conditions);
-                                            extractedAttributeKeys.forEach(function (attributeKey) {
-                                                return attributeKeysUsedByTag.add(attributeKey);
-                                            });
-                                            return {
-                                                conditions: projectConfig.stringify
-                                                    ? JSON.stringify(override.conditions)
-                                                    : override.conditions,
-                                                value: override.value,
-                                            };
-                                        }
-                                        if (typeof override.segments !== "undefined") {
-                                            var extractedSegmentKeys = (0, utils_1.extractSegmentKeysFromGroupSegments)(override.segments);
-                                            extractedSegmentKeys.forEach(function (segmentKey) {
-                                                return segmentKeysUsedByTag.add(segmentKey);
-                                            });
-                                            return {
-                                                segments: typeof override.segments !== "string" && projectConfig.stringify
-                                                    ? JSON.stringify(override.segments)
-                                                    : override.segments,
-                                                value: override.value,
-                                            };
-                                        }
-                                        return override;
-                                    });
-                                    return mappedVariable;
+                                    return override;
                                 });
-                                return mappedVariation;
-                            })
-                            : undefined,
-                        traffic: (0, traffic_1.getTraffic)(parsedFeature.variations, rules, existingState.features[featureKey], featureRanges.get(featureKey) || []).map(function (t) {
-                            return __assign(__assign({}, t), { segments: typeof t.segments !== "string" && projectConfig.stringify
-                                    ? JSON.stringify(t.segments)
-                                    : t.segments });
-                        }),
-                        ranges: featureRanges.get(featureKey) || undefined,
+                            }
+                        }
+                        return mappedVariation;
+                    })
+                    : undefined,
+                traffic: (0, traffic_1.getTraffic)(parsedFeature.variations, rules, existingState.features[featureKey], featureRanges.get(featureKey) || []).map((t) => {
+                    return {
+                        ...t,
+                        segments: typeof t.segments !== "string" && projectConfig.stringify
+                            ? JSON.stringify(t.segments)
+                            : t.segments,
                     };
-                    // update state in memory, so that next datafile build can use it (in case it contains the same feature)
-                    existingState.features[featureKey] = {
-                        variations: Array.isArray(feature.variations)
-                            ? feature.variations.map(function (v) {
+                }),
+                ranges: featureRanges.get(featureKey) || undefined,
+            };
+            // update state in memory, so that next datafile build can use it (in case it contains the same feature)
+            existingState.features[featureKey] = {
+                variations: Array.isArray(feature.variations)
+                    ? feature.variations.map((v) => {
+                        return {
+                            value: v.value,
+                            weight: v.weight || 0,
+                        };
+                    })
+                    : undefined,
+                traffic: feature.traffic.map((t) => {
+                    return {
+                        key: t.key,
+                        percentage: t.percentage,
+                        allocation: t.allocation &&
+                            t.allocation.map((a) => {
                                 return {
-                                    value: v.value,
-                                    weight: v.weight || 0,
+                                    variation: a.variation,
+                                    range: a.range,
                                 };
-                            })
-                            : undefined,
-                        traffic: feature.traffic.map(function (t) {
-                            return {
-                                key: t.key,
-                                percentage: t.percentage,
-                                allocation: t.allocation.map(function (a) {
-                                    return {
-                                        variation: a.variation,
-                                        range: a.range,
-                                    };
-                                }),
-                            };
-                        }),
-                    };
-                    if (featureIsInGroup[featureKey] === true) {
-                        feature.ranges = featureRanges.get(feature.key);
-                    }
-                    if (parsedFeature.variablesSchema) {
-                        feature.variablesSchema = parsedFeature.variablesSchema.map(function (v) {
-                            return {
-                                key: v.key,
-                                type: v.type,
-                                defaultValue: v.defaultValue,
-                                deprecated: v.deprecated === true ? true : undefined,
-                            };
-                        });
-                    }
-                    if (force) {
-                        feature.force = force;
-                        (_h = feature.force) === null || _h === void 0 ? void 0 : _h.forEach(function (f) {
-                            if (f.segments) {
-                                var extractedSegmentKeys = (0, utils_1.extractSegmentKeysFromGroupSegments)(f.segments);
-                                extractedSegmentKeys.forEach(function (segmentKey) { return segmentKeysUsedByTag.add(segmentKey); });
-                            }
-                        });
-                    }
-                    features.push(feature);
-                    _j.label = 5;
-                case 5:
-                    _i++;
-                    return [3 /*break*/, 3];
-                case 6:
-                    segments = [];
-                    segmentsDirectory = projectConfig.segmentsDirectoryPath;
-                    if (!fs.existsSync(segmentsDirectory)) return [3 /*break*/, 11];
-                    return [4 /*yield*/, datasource.listSegments()];
-                case 7:
-                    segmentFiles = _j.sent();
-                    _c = 0, segmentFiles_1 = segmentFiles;
-                    _j.label = 8;
-                case 8:
-                    if (!(_c < segmentFiles_1.length)) return [3 /*break*/, 11];
-                    segmentKey = segmentFiles_1[_c];
-                    return [4 /*yield*/, datasource.readSegment(segmentKey)];
-                case 9:
-                    parsedSegment = _j.sent();
-                    if (parsedSegment.archived === true) {
-                        return [3 /*break*/, 10];
-                    }
-                    if (segmentKeysUsedByTag.has(segmentKey) === false) {
-                        return [3 /*break*/, 10];
-                    }
-                    extractedAttributeKeys = (0, utils_1.extractAttributeKeysFromConditions)(parsedSegment.conditions);
-                    extractedAttributeKeys.forEach(function (attributeKey) { return attributeKeysUsedByTag.add(attributeKey); });
-                    segment = {
-                        key: segmentKey,
-                        conditions: typeof parsedSegment.conditions !== "string" && projectConfig.stringify === true
-                            ? JSON.stringify(parsedSegment.conditions)
-                            : parsedSegment.conditions,
+                            }),
                     };
-                    segments.push(segment);
-                    _j.label = 10;
-                case 10:
-                    _c++;
-                    return [3 /*break*/, 8];
-                case 11:
-                    attributes = [];
-                    attributesDirectory = projectConfig.attributesDirectoryPath;
-                    if (!fs.existsSync(attributesDirectory)) return [3 /*break*/, 16];
-                    return [4 /*yield*/, datasource.listAttributes()];
-                case 12:
-                    attributeFiles = _j.sent();
-                    _d = 0, attributeFiles_1 = attributeFiles;
-                    _j.label = 13;
-                case 13:
-                    if (!(_d < attributeFiles_1.length)) return [3 /*break*/, 16];
-                    attributeKey = attributeFiles_1[_d];
-                    return [4 /*yield*/, datasource.readAttribute(attributeKey)];
-                case 14:
-                    parsedAttribute = _j.sent();
-                    if (parsedAttribute.archived === true) {
-                        return [3 /*break*/, 15];
-                    }
-                    if (attributeKeysUsedByTag.has(attributeKey) === false && !parsedAttribute.capture) {
-                        return [3 /*break*/, 15];
-                    }
-                    attribute = {
-                        key: attributeKey,
-                        type: parsedAttribute.type,
+                }),
+            };
+            if (featureIsInGroup[featureKey] === true) {
+                feature.ranges = featureRanges.get(featureKey);
+            }
+            if (parsedFeature.variablesSchema) {
+                const variableKeys = Object.keys(parsedFeature.variablesSchema);
+                feature.variablesSchema = {};
+                for (const variableKey of variableKeys) {
+                    const v = parsedFeature.variablesSchema[variableKey];
+                    feature.variablesSchema[variableKey] = {
+                        key: variableKey,
+                        type: v.type,
+                        defaultValue: v.defaultValue,
+                        deprecated: v.deprecated === true ? true : undefined,
+                        useDefaultWhenDisabled: v.useDefaultWhenDisabled === true ? true : undefined,
+                        disabledValue: typeof v.disabledValue !== "undefined" ? v.disabledValue : undefined,
                     };
-                    if (parsedAttribute.capture === true) {
-                        attribute.capture = true;
-                    }
-                    attributes.push(attribute);
-                    _j.label = 15;
-                case 15:
-                    _d++;
-                    return [3 /*break*/, 13];
-                case 16:
-                    // inflate
-                    if (options.inflate) {
-                        allFeatureKeys = features.map(function (f) { return f.key; });
-                        allSegmentKeys = segments.map(function (s) { return s.key; });
-                        allAttributeKeys = attributes.map(function (a) { return a.key; });
-                        for (i = 0; i < options.inflate; i++) {
-                            _loop_1 = function (featureKey) {
-                                var originalFeature = features.find(function (f) { return f.key === featureKey; });
-                                features.unshift(__assign(__assign({}, originalFeature), { key: "".concat(originalFeature.key, "-").concat(i) }));
-                            };
-                            // feature
-                            for (_e = 0, allFeatureKeys_1 = allFeatureKeys; _e < allFeatureKeys_1.length; _e++) {
-                                featureKey = allFeatureKeys_1[_e];
-                                _loop_1(featureKey);
-                            }
-                            _loop_2 = function (segmentKey) {
-                                var originalSegment = segments.find(function (s) { return s.key === segmentKey; });
-                                segments.unshift(__assign(__assign({}, originalSegment), { key: "".concat(originalSegment.key, "-").concat(i) }));
-                            };
-                            // segment
-                            for (_f = 0, allSegmentKeys_1 = allSegmentKeys; _f < allSegmentKeys_1.length; _f++) {
-                                segmentKey = allSegmentKeys_1[_f];
-                                _loop_2(segmentKey);
-                            }
-                            _loop_3 = function (attributeKey) {
-                                var originalAttribute = attributes.find(function (a) { return a.key === attributeKey; });
-                                attributes.unshift(__assign(__assign({}, originalAttribute), { key: "".concat(originalAttribute.key, "-").concat(i) }));
-                            };
-                            // attribute
-                            for (_g = 0, allAttributeKeys_1 = allAttributeKeys; _g < allAttributeKeys_1.length; _g++) {
-                                attributeKey = allAttributeKeys_1[_g];
-                                _loop_3(attributeKey);
-                            }
-                        }
+                }
+            }
+            if (force) {
+                feature.force = force.map((f) => {
+                    if (f.segments) {
+                        const extractedSegmentKeys = (0, utils_1.extractSegmentKeysFromGroupSegments)(f.segments);
+                        extractedSegmentKeys.forEach((segmentKey) => segmentKeysUsedByTag.add(segmentKey));
+                        f.segments =
+                            typeof f.segments !== "string" && projectConfig.stringify
+                                ? JSON.stringify(f.segments)
+                                : f.segments;
                     }
-                    // schema v2
-                    if (options.schemaVersion === "2") {
-                        datafileContentV2 = {
-                            schemaVersion: "2",
-                            revision: options.revision,
-                            attributes: {},
-                            segments: {},
-                            features: {},
-                        };
-                        datafileContentV2.attributes = attributes.reduce(function (acc, attribute) {
-                            acc[attribute.key] = attribute;
-                            return acc;
-                        }, {});
-                        datafileContentV2.segments = segments.reduce(function (acc, segment) {
-                            acc[segment.key] = segment;
-                            return acc;
-                        }, {});
-                        datafileContentV2.features = features.reduce(function (acc, feature) {
-                            if (Array.isArray(feature.variablesSchema)) {
-                                feature.variablesSchema = feature.variablesSchema.reduce(function (vAcc, variableSchema) {
-                                    vAcc[variableSchema.key] = variableSchema;
-                                    return vAcc;
-                                }, {});
-                            }
-                            acc[feature.key] = feature;
-                            return acc;
-                        }, {});
-                        return [2 /*return*/, datafileContentV2];
+                    if (f.conditions) {
+                        f.conditions =
+                            typeof f.conditions !== "string" && projectConfig.stringify
+                                ? JSON.stringify(f.conditions)
+                                : f.conditions;
                     }
-                    // default behaviour
-                    datafileContent.attributes = attributes;
-                    datafileContent.segments = segments;
-                    datafileContent.features = features;
-                    return [2 /*return*/, datafileContent];
+                    return f;
+                });
             }
+            features.push(feature);
+        }
+    }
+    // segments
+    const segments = [];
+    const segmentsDirectory = projectConfig.segmentsDirectoryPath;
+    if (fs.existsSync(segmentsDirectory)) {
+        const segmentFiles = await datasource.listSegments();
+        for (const segmentKey of segmentFiles) {
+            const parsedSegment = await datasource.readSegment(segmentKey);
+            if (parsedSegment.archived === true) {
+                continue;
+            }
+            if (segmentKeysUsedByTag.has(segmentKey) === false) {
+                continue;
+            }
+            const extractedAttributeKeys = (0, utils_1.extractAttributeKeysFromConditions)(parsedSegment.conditions);
+            extractedAttributeKeys.forEach((attributeKey) => attributeKeysUsedByTag.add(attributeKey));
+            const segment = {
+                key: segmentKey,
+                conditions: typeof parsedSegment.conditions !== "string" && projectConfig.stringify === true
+                    ? JSON.stringify(parsedSegment.conditions)
+                    : parsedSegment.conditions,
+            };
+            segments.push(segment);
+        }
+    }
+    // attributes
+    const attributes = [];
+    const attributesDirectory = projectConfig.attributesDirectoryPath;
+    if (fs.existsSync(attributesDirectory)) {
+        const attributeFiles = await datasource.listAttributes();
+        for (const attributeKey of attributeFiles) {
+            const parsedAttribute = await datasource.readAttribute(attributeKey);
+            if (parsedAttribute.archived === true) {
+                continue;
+            }
+            if (attributeKeysUsedByTag.has(attributeKey) === false) {
+                continue;
+            }
+            const attribute = {
+                key: attributeKey,
+                type: parsedAttribute.type,
+            };
+            attributes.push(attribute);
+        }
+    }
+    // inflate
+    if (options.inflate && options.inflate >= 2) {
+        const allFeatureKeys = features.map((f) => f.key);
+        const allSegmentKeys = segments.map((s) => s.key);
+        const allAttributeKeys = attributes.map((a) => a.key);
+        for (let i = 0; i < options.inflate - 1; i++) {
+            // feature
+            for (const featureKey of allFeatureKeys) {
+                const originalFeature = features.find((f) => f.key === featureKey);
+                features.unshift({
+                    ...originalFeature,
+                    key: `${originalFeature.key}-${i}`,
+                });
+            }
+            // segment
+            for (const segmentKey of allSegmentKeys) {
+                const originalSegment = segments.find((s) => s.key === segmentKey);
+                segments.unshift({
+                    ...originalSegment,
+                    key: `${originalSegment.key}-${i}`,
+                });
+            }
+            // attribute
+            for (const attributeKey of allAttributeKeys) {
+                const originalAttribute = attributes.find((a) => a.key === attributeKey);
+                attributes.unshift({
+                    ...originalAttribute,
+                    key: `${originalAttribute.key}-${i}`,
+                });
+            }
+        }
+    }
+    // schema v1
+    if (options.schemaVersion === "1") {
+        return (0, convertToV1_1.convertToV1)({
+            revision: options.revision,
+            projectConfig,
+            attributes,
+            features,
+            segments,
         });
+    }
+    // schema v2
+    const datafileContentV2 = {
+        schemaVersion: "2",
+        revision: options.revision,
+        segments: {},
+        features: {},
+    };
+    datafileContentV2.segments = segments.reduce((acc, segment) => {
+        // key check needed for supporting v1 datafile generation
+        if (segment.key) {
+            acc[segment.key] = segment;
+            delete acc[segment.key].key; // remove key from segment, as it is not needed in v2 datafile
+        }
+        return acc;
+    }, {});
+    datafileContentV2.features = features.reduce((acc, feature) => {
+        if (!feature.key) {
+            return acc;
+        }
+        const featureKey = feature.key;
+        const featureV2 = feature;
+        // remove key, as it is not needed in v2 datafile
+        delete featureV2.key;
+        // remove variablesSchema[key].key
+        if (featureV2.variablesSchema) {
+            for (const [variableKey, variable] of Object.entries(featureV2.variablesSchema)) {
+                if (variable.key) {
+                    delete featureV2.variablesSchema[variableKey].key;
+                }
+            }
+        }
+        acc[featureKey] = featureV2;
+        return acc;
+    }, {});
+    // add feature hashes for change detection
+    const segmentHashes = (0, hashes_1.getSegmentHashes)(datafileContentV2.segments);
+    Object.keys(datafileContentV2.features).forEach((featureKey) => {
+        const hash = (0, hashes_1.generateHashForFeature)(featureKey, datafileContentV2.features, segmentHashes);
+        datafileContentV2.features[featureKey].hash = hash;
+        // check needed to support --inflate option
+        if (existingState.features[featureKey]) {
+            existingState.features[featureKey].hash = hash;
+        }
     });
+    if (options.revisionFromHash) {
+        const datafileHash = (0, hashes_1.generateHashForDatafile)(datafileContentV2);
+        datafileContentV2.revision = `${datafileHash}`;
+    }
+    return datafileContentV2;
 }
 //# sourceMappingURL=buildDatafile.js.map