@featurevisor/core 2.26.1 → 3.0.1

package/lib/promoter/index.js

@@ -0,0 +1,880 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promotePlugin = void 0;
+exports.promoteProjectSets = promoteProjectSets;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const linter_1 = require("../linter");
+const cliFormat_1 = require("../tester/cliFormat");
+const prettyDuration_1 = require("../tester/prettyDuration");
+function isPromotable(entity) {
+    return entity?.promotable !== false;
+}
+function toArray(value) {
+    if (typeof value === "undefined") {
+        return [];
+    }
+    return Array.isArray(value) ? value : [value];
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepEqual(left, right) {
+    return JSON.stringify(left) === JSON.stringify(right);
+}
+function deepMergeWithPolicy(destination, source, policy, conflicts, pathSegments = []) {
+    if (typeof destination === "undefined")
+        return source;
+    if (typeof source === "undefined")
+        return destination;
+    const conflictPath = pathSegments.join(".") || "<root>";
+    if (Array.isArray(destination) && Array.isArray(source)) {
+        if (!deepEqual(destination, source)) {
+            conflicts.push({ path: conflictPath, source, destination });
+        }
+        return policy === "destination" ? destination : source;
+    }
+    if (isPlainObject(destination) && isPlainObject(source)) {
+        const result = { ...destination };
+        for (const key of Object.keys(source)) {
+            result[key] = deepMergeWithPolicy(result[key], source[key], policy, conflicts, [
+                ...pathSegments,
+                key,
+            ]);
+        }
+        return result;
+    }
+    if (!deepEqual(destination, source)) {
+        conflicts.push({ path: conflictPath, source, destination });
+    }
+    return policy === "destination" ? destination : source;
+}
+function matchesPattern(key, patterns) {
+    if (patterns.length === 0) {
+        return false;
+    }
+    return patterns.some((pattern) => {
+        const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+        return new RegExp(`^${escaped}$`).test(key);
+    });
+}
+function matchesTags(candidateTags, selector) {
+    if (!selector)
+        return true;
+    if (Array.isArray(selector)) {
+        return selector.some((tag) => candidateTags.includes(tag));
+    }
+    if ("or" in selector) {
+        return selector.or.some((tag) => candidateTags.includes(tag));
+    }
+    return selector.and.every((tag) => candidateTags.includes(tag));
+}
+function matchesTarget(featureKey, feature, target) {
+    const featureTags = feature.tags || [];
+    if (feature.archived === true)
+        return false;
+    if (target.tag && !featureTags.includes(target.tag))
+        return false;
+    if (target.tags && !matchesTags(featureTags, target.tags))
+        return false;
+    const included = target.includeFeatures
+        ? matchesPattern(featureKey, toArray(target.includeFeatures))
+        : true;
+    const excluded = target.excludeFeatures
+        ? matchesPattern(featureKey, toArray(target.excludeFeatures))
+        : false;
+    return included && !excluded;
+}
+function withoutKey(entity) {
+    const { key: _key, ...rest } = entity; // eslint-disable-line @typescript-eslint/no-unused-vars
+    return rest;
+}
+async function safeRead(keys, read) {
+    const entries = await Promise.all(keys.map(async (key) => [key, await read(key)]));
+    return Object.fromEntries(entries);
+}
+async function readDestination(key, read) {
+    try {
+        return await read(key);
+    }
+    catch {
+        return undefined;
+    }
+}
+function formatLintPreflightErrors(set, errors) {
+    const preview = errors
+        .slice(0, 5)
+        .map((error) => `${error.filePath}: ${error.message}`)
+        .join("\n");
+    const suffix = errors.length > 5 ? `\n...and ${errors.length - 5} more` : "";
+    return `Set "${set}" failed preflight lint with ${errors.length} error(s).\n${preview}${suffix}`;
+}
+async function assertSetLintsClean(set, projectConfig, datasource) {
+    const result = await (0, linter_1.lintProject)({
+        rootDirectoryPath: path.resolve(projectConfig.setsDirectoryPath, ".."),
+        projectConfig,
+        datasource,
+        options: {},
+    }, { json: true });
+    if (result.hasError) {
+        throw new Error(formatLintPreflightErrors(set, result.errors));
+    }
+}
+function assertAllowedPromotionFlow(projectConfig, from, to) {
+    const allowedFlows = projectConfig.promotionFlows;
+    if (typeof allowedFlows === "undefined") {
+        return;
+    }
+    const isAllowed = allowedFlows.some((flow) => flow.from === from && flow.to === to);
+    if (isAllowed) {
+        return;
+    }
+    const allowedList = allowedFlows.map((flow) => `${flow.from} -> ${flow.to}`).join(", ") || "none";
+    throw new Error(`Promotion from "${from}" to "${to}" is not allowed by this project's configured promotionFlows.\nAllowed flows: ${allowedList}.\nChoose one of the allowed promotion paths or update featurevisor.config.js if this flow should be permitted.`);
+}
+function collectGroupSegmentKeys(value, result) {
+    if (!value || value === "*")
+        return;
+    if (typeof value === "string") {
+        result.add(value);
+        return;
+    }
+    if (Array.isArray(value)) {
+        value.forEach((entry) => collectGroupSegmentKeys(entry, result));
+        return;
+    }
+    if ("and" in value)
+        value.and.forEach((entry) => collectGroupSegmentKeys(entry, result));
+    if ("or" in value)
+        value.or.forEach((entry) => collectGroupSegmentKeys(entry, result));
+    if ("not" in value)
+        value.not.forEach((entry) => collectGroupSegmentKeys(entry, result));
+}
+function collectConditionDependencies(value, segments, attributes) {
+    if (!value || value === "*")
+        return;
+    if (typeof value === "string") {
+        segments.add(value);
+        return;
+    }
+    if (Array.isArray(value)) {
+        value.forEach((entry) => collectConditionDependencies(entry, segments, attributes));
+        return;
+    }
+    if ("attribute" in value) {
+        attributes.add(value.attribute.split(".")[0]);
+        return;
+    }
+    if ("and" in value)
+        value.and.forEach((entry) => collectConditionDependencies(entry, segments, attributes));
+    if ("or" in value)
+        value.or.forEach((entry) => collectConditionDependencies(entry, segments, attributes));
+    if ("not" in value)
+        value.not.forEach((entry) => collectConditionDependencies(entry, segments, attributes));
+}
+function collectSchemaReferences(value, schemas) {
+    if (!value || typeof value !== "object") {
+        return;
+    }
+    if (Array.isArray(value)) {
+        value.forEach((entry) => collectSchemaReferences(entry, schemas));
+        return;
+    }
+    const record = value;
+    if (typeof record.schema === "string") {
+        schemas.add(record.schema);
+    }
+    Object.values(record).forEach((entry) => collectSchemaReferences(entry, schemas));
+}
+function collectFeatureDependencies(feature, features, featureKeys, segmentKeys, attributeKeys, schemaKeys) {
+    if (typeof feature.bucketBy === "string") {
+        attributeKeys.add(feature.bucketBy);
+    }
+    else if (Array.isArray(feature.bucketBy)) {
+        feature.bucketBy.forEach((attributeKey) => attributeKeys.add(attributeKey));
+    }
+    else if (feature.bucketBy && "or" in feature.bucketBy) {
+        feature.bucketBy.or.forEach((attributeKey) => attributeKeys.add(attributeKey));
+    }
+    collectSchemaReferences(feature.variablesSchema, schemaKeys);
+    for (const required of feature.required || []) {
+        const requiredKey = typeof required === "string" ? required : required.key;
+        if (!featureKeys.has(requiredKey)) {
+            featureKeys.add(requiredKey);
+            const requiredFeature = features[requiredKey];
+            if (requiredFeature) {
+                collectFeatureDependencies(requiredFeature, features, featureKeys, segmentKeys, attributeKeys, schemaKeys);
+            }
+        }
+    }
+    for (const rules of Object.values((feature.rules || {}))) {
+        const ruleEntries = Array.isArray(rules) ? rules : [rules];
+        for (const rule of ruleEntries) {
+            if (!isPromotable(rule)) {
+                continue;
+            }
+            collectGroupSegmentKeys(rule?.segments, segmentKeys);
+            Object.values(rule?.variableOverrides || {}).forEach((overrides) => {
+                (overrides || []).forEach((override) => {
+                    collectGroupSegmentKeys(override.segments, segmentKeys);
+                    collectConditionDependencies(override.conditions, segmentKeys, attributeKeys);
+                });
+            });
+        }
+    }
+    for (const force of Object.values((feature.force || {}))) {
+        const forceEntries = Array.isArray(force) ? force : [force];
+        for (const forceEntry of forceEntries) {
+            collectGroupSegmentKeys(forceEntry?.segments, segmentKeys);
+            collectConditionDependencies(forceEntry?.conditions, segmentKeys, attributeKeys);
+        }
+    }
+}
+function mergeRuleArray(destination, source, policy, conflicts, pathSegments) {
+    if (typeof source === "undefined")
+        return destination;
+    if (typeof destination === "undefined")
+        return source.filter((rule) => isPromotable(rule));
+    const mergedRuleKeys = new Set();
+    const mergedRules = [];
+    for (const sourceRule of source) {
+        if (!isPromotable(sourceRule)) {
+            continue;
+        }
+        const destinationRule = destination.find((rule) => rule.key === sourceRule.key);
+        mergedRuleKeys.add(sourceRule.key);
+        if (destinationRule && !isPromotable(destinationRule)) {
+            mergedRules.push(destinationRule);
+            continue;
+        }
+        mergedRules.push(deepMergeWithPolicy(destinationRule, sourceRule, policy, conflicts, [
+            ...pathSegments,
+            sourceRule.key,
+        ]));
+    }
+    for (const destinationRule of destination) {
+        if (!mergedRuleKeys.has(destinationRule.key)) {
+            mergedRules.push(destinationRule);
+        }
+    }
+    return mergedRules;
+}
+function isRulesByEnvironment(value) {
+    return isPlainObject(value) && !Array.isArray(value);
+}
+function mergeRules(destination, source, policy, conflicts) {
+    if (Array.isArray(source) || Array.isArray(destination)) {
+        return mergeRuleArray(Array.isArray(destination) ? destination : undefined, Array.isArray(source) ? source : undefined, policy, conflicts, ["rules"]);
+    }
+    if (isRulesByEnvironment(source) || isRulesByEnvironment(destination)) {
+        const environmentKeys = new Set([
+            ...Object.keys((destination || {})),
+            ...Object.keys((source || {})),
+        ]);
+        const result = {};
+        for (const environment of Array.from(environmentKeys).sort()) {
+            const merged = mergeRuleArray(destination?.[environment], source?.[environment], policy, conflicts, ["rules", environment]);
+            if (typeof merged !== "undefined") {
+                result[environment] = merged;
+            }
+        }
+        return Object.keys(result).length > 0 ? result : undefined;
+    }
+    return source;
+}
+function mergeFeature(featureKey, destination, source, policy, conflicts) {
+    const sourceWithoutRules = { ...source, rules: undefined };
+    const destinationWithoutRules = destination ? { ...destination, rules: undefined } : undefined;
+    const featureConflicts = [];
+    const mergedFeature = deepMergeWithPolicy(destinationWithoutRules, sourceWithoutRules, policy, featureConflicts);
+    const ruleConflicts = [];
+    const mergedRules = mergeRules(destination?.rules, source.rules, policy, ruleConflicts);
+    conflicts.push(...featureConflicts.map((conflict) => ({
+        type: "feature",
+        key: featureKey,
+        ...conflict,
+    })), ...ruleConflicts.map((conflict) => ({
+        type: "feature",
+        key: featureKey,
+        ...conflict,
+    })));
+    return {
+        ...mergedFeature,
+        rules: mergedRules,
+    };
+}
+async function getPromotionPlan(sourceDatasource, destinationDatasource, options) {
+    const includeFeatures = toArray(options.includeFeatures);
+    const excludeFeatures = toArray(options.excludeFeatures);
+    const targetSelectors = toArray(options.target);
+    const tagSelectors = toArray(options.tag);
+    const availableTags = sourceDatasource.getConfig().tags;
+    const unknownTag = tagSelectors.find((tag) => !availableTags.includes(tag));
+    if (unknownTag) {
+        throw new Error(`Unknown source tag "${unknownTag}". Available tags: ${availableTags.join(", ") || "none"}.`);
+    }
+    const hasNoFilters = includeFeatures.length === 0 &&
+        excludeFeatures.length === 0 &&
+        targetSelectors.length === 0 &&
+        tagSelectors.length === 0;
+    const [featureKeys, segmentKeys, attributeKeys, groupKeys, schemaKeys, targetKeys, testKeys] = await Promise.all([
+        sourceDatasource.listFeatures(),
+        sourceDatasource.listSegments(),
+        sourceDatasource.listAttributes(),
+        sourceDatasource.listGroups(),
+        sourceDatasource.listSchemas(),
+        sourceDatasource.listTargets(),
+        sourceDatasource.listTests(),
+    ]);
+    const [features, segments, attributes, groups, schemas, targets, tests] = await Promise.all([
+        safeRead(featureKeys, (key) => sourceDatasource.readFeature(key)),
+        safeRead(segmentKeys, (key) => sourceDatasource.readSegment(key)),
+        safeRead(attributeKeys, (key) => sourceDatasource.readAttribute(key)),
+        safeRead(groupKeys, (key) => sourceDatasource.readGroup(key)),
+        safeRead(schemaKeys, (key) => sourceDatasource.readSchema(key)),
+        safeRead(targetKeys, (key) => sourceDatasource.readTarget(key)),
+        safeRead(testKeys, (key) => sourceDatasource.readTest(key)),
+    ]);
+    const promotedFeatureKeys = new Set();
+    const promotedSegmentKeys = new Set();
+    const promotedAttributeKeys = new Set();
+    const promotedGroupKeys = new Set();
+    const promotedSchemaKeys = new Set();
+    const promotedTargetKeys = new Set();
+    const selectedTargets = [];
+    for (const key of targetSelectors) {
+        const target = targets[key];
+        if (!target) {
+            throw new Error(`Unknown source target "${key}". Available targets: ${targetKeys.join(", ") || "none"}.`);
+        }
+        selectedTargets.push(target);
+        promotedTargetKeys.add(key);
+    }
+    if (hasNoFilters) {
+        featureKeys.forEach((key) => promotedFeatureKeys.add(key));
+        segmentKeys.forEach((key) => promotedSegmentKeys.add(key));
+        attributeKeys.forEach((key) => promotedAttributeKeys.add(key));
+        groupKeys.forEach((key) => promotedGroupKeys.add(key));
+        schemaKeys.forEach((key) => promotedSchemaKeys.add(key));
+        targetKeys.forEach((key) => promotedTargetKeys.add(key));
+    }
+    else {
+        for (const key of featureKeys) {
+            const feature = features[key];
+            const matchesIncludes = includeFeatures.length === 0 || matchesPattern(key, includeFeatures);
+            const matchesExcludes = matchesPattern(key, excludeFeatures);
+            const matchesSelectedTags = tagSelectors.length === 0 || tagSelectors.some((tag) => (feature.tags || []).includes(tag));
+            const matchesSelectedTargets = selectedTargets.length === 0 ||
+                selectedTargets.some((target) => matchesTarget(key, feature, target));
+            if (matchesIncludes && !matchesExcludes && matchesSelectedTags && matchesSelectedTargets) {
+                promotedFeatureKeys.add(key);
+            }
+        }
+        if (promotedFeatureKeys.size === 0 && !options.allowEmpty) {
+            throw new Error("No source features matched the promotion filters.");
+        }
+    }
+    let previousFeatureCount = -1;
+    while (previousFeatureCount !== promotedFeatureKeys.size) {
+        previousFeatureCount = promotedFeatureKeys.size;
+        for (const key of Array.from(promotedFeatureKeys)) {
+            const feature = features[key];
+            if (feature) {
+                collectFeatureDependencies(feature, features, promotedFeatureKeys, promotedSegmentKeys, promotedAttributeKeys, promotedSchemaKeys);
+            }
+        }
+        for (const key of groupKeys) {
+            const group = groups[key];
+            const groupFeatureKeys = group.slots
+                .map((slot) => slot.feature)
+                .filter((featureKey) => typeof featureKey === "string");
+            if (groupFeatureKeys.some((featureKey) => promotedFeatureKeys.has(featureKey))) {
+                promotedGroupKeys.add(key);
+                groupFeatureKeys.forEach((featureKey) => promotedFeatureKeys.add(featureKey));
+            }
+        }
+    }
+    const pendingSegments = Array.from(promotedSegmentKeys);
+    for (let index = 0; index < pendingSegments.length; index++) {
+        const segmentKey = pendingSegments[index];
+        const segment = segments[segmentKey];
+        if (!segment)
+            continue;
+        const beforeSize = promotedSegmentKeys.size;
+        collectConditionDependencies(segment.conditions, promotedSegmentKeys, promotedAttributeKeys);
+        if (promotedSegmentKeys.size > beforeSize) {
+            pendingSegments.push(...Array.from(promotedSegmentKeys).filter((key) => !pendingSegments.includes(key)));
+        }
+    }
+    const pendingSchemas = Array.from(promotedSchemaKeys);
+    for (let index = 0; index < pendingSchemas.length; index++) {
+        const schemaKey = pendingSchemas[index];
+        const schema = schemas[schemaKey];
+        if (!schema)
+            continue;
+        const beforeSize = promotedSchemaKeys.size;
+        collectSchemaReferences(schema, promotedSchemaKeys);
+        if (promotedSchemaKeys.size > beforeSize) {
+            pendingSchemas.push(...Array.from(promotedSchemaKeys).filter((key) => !pendingSchemas.includes(key)));
+        }
+    }
+    const promotedTestKeys = testKeys.filter((key) => {
+        const test = tests[key];
+        return promotedFeatureKeys.has(test.feature) || promotedSegmentKeys.has(test.segment);
+    });
+    const plans = [];
+    async function plan(type, key, source, readDestinationEntity, merge = (destination, sourceValue, conflicts) => {
+        const entityConflicts = [];
+        const merged = deepMergeWithPolicy(destination, sourceValue, options.conflicts, entityConflicts);
+        conflicts.push(...entityConflicts.map((conflict) => ({ type, key, ...conflict })));
+        return merged;
+    }) {
+        const cleanedSource = withoutKey(source);
+        const destination = await readDestination(key, readDestinationEntity);
+        const cleanedDestination = destination ? withoutKey(destination) : undefined;
+        if (cleanedDestination && (!isPromotable(cleanedSource) || !isPromotable(cleanedDestination))) {
+            plans.push({
+                type,
+                key,
+                source: cleanedSource,
+                destination: cleanedDestination,
+                merged: cleanedDestination,
+                conflicts: [],
+            });
+            return;
+        }
+        const conflicts = [];
+        const merged = merge(cleanedDestination, cleanedSource, conflicts);
+        plans.push({
+            type,
+            key,
+            source: cleanedSource,
+            destination: cleanedDestination,
+            merged,
+            conflicts,
+        });
+    }
+    for (const key of Array.from(promotedAttributeKeys).sort()) {
+        if (attributes[key])
+            await plan("attribute", key, attributes[key], (entryKey) => destinationDatasource.readAttribute(entryKey));
+    }
+    for (const key of Array.from(promotedSegmentKeys).sort()) {
+        if (segments[key])
+            await plan("segment", key, segments[key], (entryKey) => destinationDatasource.readSegment(entryKey));
+    }
+    for (const key of Array.from(promotedGroupKeys).sort()) {
+        if (groups[key])
+            await plan("group", key, groups[key], (entryKey) => destinationDatasource.readGroup(entryKey));
+    }
+    for (const key of Array.from(promotedSchemaKeys).sort()) {
+        if (schemas[key])
+            await plan("schema", key, schemas[key], (entryKey) => destinationDatasource.readSchema(entryKey));
+    }
+    for (const key of Array.from(promotedFeatureKeys).sort()) {
+        if (features[key])
+            await plan("feature", key, features[key], (entryKey) => destinationDatasource.readFeature(entryKey), (destination, source, conflicts) => mergeFeature(key, destination, source, options.conflicts, conflicts));
+    }
+    for (const key of Array.from(promotedTargetKeys).sort()) {
+        if (targets[key])
+            await plan("target", key, targets[key], (entryKey) => destinationDatasource.readTarget(entryKey));
+    }
+    for (const key of promotedTestKeys.sort()) {
+        if (tests[key])
+            await plan("test", key, tests[key], (entryKey) => destinationDatasource.readTest(entryKey));
+    }
+    return plans;
+}
+async function writePlan(destinationDatasource, plans) {
+    for (const plan of plans) {
+        if (deepEqual(plan.destination, plan.merged)) {
+            continue;
+        }
+        if (plan.type === "attribute")
+            await destinationDatasource.writeAttribute(plan.key, plan.merged);
+        if (plan.type === "segment")
+            await destinationDatasource.writeSegment(plan.key, plan.merged);
+        if (plan.type === "group")
+            await destinationDatasource.writeGroup(plan.key, plan.merged);
+        if (plan.type === "schema")
+            await destinationDatasource.writeSchema(plan.key, plan.merged);
+        if (plan.type === "target")
+            await destinationDatasource.writeTarget(plan.key, plan.merged);
+        if (plan.type === "feature")
+            await destinationDatasource.writeFeature(plan.key, plan.merged);
+        if (plan.type === "test")
+            await destinationDatasource.writeTest(plan.key, plan.merged);
+    }
+}
+function normalizeConflictPolicy(value) {
+    if (typeof value === "undefined" || value === false) {
+        return "source";
+    }
+    if (value === "source" || value === "destination" || value === "fail") {
+        return value;
+    }
+    throw new Error(`Invalid --conflicts value "${String(value)}". Use source, destination, or fail.`);
+}
+function normalizeAuditFormat(value) {
+    if (typeof value === "undefined" || value === false || value === "false") {
+        return false;
+    }
+    if (value === true || value === "true") {
+        return "json";
+    }
+    if (value === "json" || value === "markdown") {
+        return value;
+    }
+    throw new Error(`Invalid --audit value "${String(value)}". Use json or markdown.`);
+}
+function getTimestamp() {
+    const date = new Date();
+    const pad = (value) => (value < 10 ? `0${value}` : String(value));
+    return [
+        date.getUTCFullYear(),
+        pad(date.getUTCMonth() + 1),
+        pad(date.getUTCDate()),
+        "T",
+        pad(date.getUTCHours()),
+        pad(date.getUTCMinutes()),
+        pad(date.getUTCSeconds()),
+    ].join("");
+}
+function getEntityFilePath(projectConfig, type, key) {
+    const directories = {
+        attribute: projectConfig.attributesDirectoryPath,
+        segment: projectConfig.segmentsDirectoryPath,
+        feature: projectConfig.featuresDirectoryPath,
+        group: projectConfig.groupsDirectoryPath,
+        schema: projectConfig.schemasDirectoryPath,
+        target: projectConfig.targetsDirectoryPath,
+        test: projectConfig.testsDirectoryPath,
+    };
+    const extension = projectConfig.parser.extension || "yml";
+    const pathSegments = key.split(projectConfig.namespaceCharacter);
+    if (type === "test" &&
+        pathSegments.length > 1 &&
+        pathSegments[pathSegments.length - 1] === "spec") {
+        pathSegments[pathSegments.length - 2] = `${pathSegments[pathSegments.length - 2]}.spec`;
+        pathSegments.pop();
+    }
+    return path.join(directories[type], ...pathSegments) + `.${extension}`;
+}
+function formatProjectPath(projectConfig, filePath) {
+    const root = path.resolve(projectConfig.setsDirectoryPath, "..");
+    const relative = path.relative(root, filePath);
+    return relative.startsWith("..") ? filePath : relative;
+}
+async function getPromotionAuditFilePath(projectConfig, result, format) {
+    const extension = format === "markdown" ? "md" : "json";
+    const baseFileName = `${getTimestamp()}-${result.from}-to-${result.to}`;
+    const directoryPath = path.join(projectConfig.stateDirectoryPath, "promotions");
+    let suffix = 0;
+    while (true) {
+        const fileName = `${baseFileName}${suffix === 0 ? "" : `-${suffix}`}.${extension}`;
+        const filePath = path.join(directoryPath, fileName);
+        if (!fs.existsSync(filePath)) {
+            return filePath;
+        }
+        suffix++;
+    }
+}
+function getAuditPayload(result) {
+    return {
+        from: result.from,
+        to: result.to,
+        apply: result.apply,
+        filters: result.filters,
+        dependencies: result.dependencies,
+        files: result.files,
+        conflicts: result.conflicts.map((conflict) => ({
+            type: conflict.type,
+            key: conflict.key,
+            path: conflict.path,
+            source: conflict.source,
+            destination: conflict.destination,
+        })),
+        duration: result.duration,
+    };
+}
+function stringifyMarkdownAudit(result) {
+    const lines = [
+        "# Featurevisor Promotion",
+        "",
+        `- From: ${result.from}`,
+        `- To: ${result.to}`,
+        `- Mode: ${result.apply ? "apply" : "preview"}`,
+        `- Conflicts: ${result.filters.conflicts}`,
+        `- Duration: ${(0, prettyDuration_1.prettyDuration)(result.duration)}`,
+        "",
+        "## Dependencies",
+        "",
+        `- Attributes: ${result.dependencies.attribute}`,
+        `- Segments: ${result.dependencies.segment}`,
+        `- Features: ${result.dependencies.feature}`,
+        `- Groups: ${result.dependencies.group}`,
+        `- Schemas: ${result.dependencies.schema}`,
+        `- Targets: ${result.dependencies.target}`,
+        `- Tests: ${result.dependencies.test}`,
+        "",
+        "## Files",
+        "",
+    ];
+    for (const [label, files] of [
+        ["Created", result.files.created],
+        ["Updated", result.files.updated],
+        ["Unchanged", result.files.unchanged],
+    ]) {
+        lines.push(`### ${label}`, "");
+        lines.push(...(files.length > 0 ? files.map((filePath) => `- ${filePath}`) : ["- None"]));
+        lines.push("");
+    }
+    if (result.conflicts.length > 0) {
+        lines.push("## Conflicts", "");
+        lines.push(...result.conflicts.map((conflict) => `- ${conflict.type} ${conflict.key} at ${conflict.path}`));
+        lines.push("");
+    }
+    return `${lines.join("\n")}\n`;
+}
+async function writePromotionAudit(projectConfig, result, format) {
+    const filePath = await getPromotionAuditFilePath(projectConfig, result, format);
+    await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+    const content = format === "markdown"
+        ? stringifyMarkdownAudit(result)
+        : `${JSON.stringify(getAuditPayload(result), null, 2)}\n`;
+    await fs.promises.writeFile(filePath, content);
+    return formatProjectPath(projectConfig, filePath);
+}
+async function promoteProjectSets(projectConfig, datasource, options) {
+    const startTime = Date.now();
+    const conflictPolicy = normalizeConflictPolicy(options.conflicts);
+    const auditFormat = normalizeAuditFormat(options.audit);
+    if (!projectConfig.sets) {
+        throw new Error("Promotion is only available when `sets: true` is configured.");
+    }
+    if (!options.from)
+        throw new Error("Pass --from=<set>.");
+    if (!options.to)
+        throw new Error("Pass --to=<set>.");
+    if (options.from === options.to)
+        throw new Error("--from and --to must be different sets.");
+    const sets = await datasource.listSets();
+    if (!sets.includes(options.from)) {
+        throw new Error(`Unknown source set "${options.from}". Available sets: ${sets.join(", ") || "none"}.`);
+    }
+    if (!sets.includes(options.to)) {
+        throw new Error(`Unknown destination set "${options.to}". Available sets: ${sets.join(", ") || "none"}.`);
+    }
+    assertAllowedPromotionFlow(projectConfig, options.from, options.to);
+    const sourceDatasource = datasource.forSet(options.from);
+    const destinationDatasource = datasource.forSet(options.to);
+    await assertSetLintsClean(options.from, sourceDatasource.getConfig(), sourceDatasource);
+    await assertSetLintsClean(options.to, destinationDatasource.getConfig(), destinationDatasource);
+    const plans = await getPromotionPlan(sourceDatasource, destinationDatasource, {
+        includeFeatures: options.includeFeatures || [],
+        excludeFeatures: options.excludeFeatures || [],
+        target: options.target || [],
+        tag: options.tag || [],
+        allowEmpty: options.allowEmpty === true,
+        conflicts: conflictPolicy,
+    });
+    const conflicts = plans.flatMap((plan) => plan.conflicts);
+    if (conflictPolicy === "fail" && conflicts.length > 0) {
+        const preview = conflicts
+            .slice(0, 5)
+            .map((conflict) => `${conflict.type} "${conflict.key}" at ${conflict.path}`)
+            .join("\n");
+        const suffix = conflicts.length > 5 ? `\n...and ${conflicts.length - 5} more` : "";
+        throw new Error(`Promotion has ${conflicts.length} conflict(s) and --conflicts=fail was used.\n${preview}${suffix}`);
+    }
+    if (options.apply === true) {
+        await writePlan(destinationDatasource, plans);
+    }
+    const created = plans
+        .filter((plan) => !plan.destination)
+        .map((plan) => formatProjectPath(projectConfig, getEntityFilePath(destinationDatasource.getConfig(), plan.type, plan.key)));
+    const updated = plans
+        .filter((plan) => plan.destination && !deepEqual(plan.destination, plan.merged))
+        .map((plan) => formatProjectPath(projectConfig, getEntityFilePath(destinationDatasource.getConfig(), plan.type, plan.key)));
+    const unchanged = plans
+        .filter((plan) => plan.destination && deepEqual(plan.destination, plan.merged))
+        .map((plan) => formatProjectPath(projectConfig, getEntityFilePath(destinationDatasource.getConfig(), plan.type, plan.key)));
+    const dependencies = {
+        attribute: plans.filter((plan) => plan.type === "attribute").length,
+        segment: plans.filter((plan) => plan.type === "segment").length,
+        feature: plans.filter((plan) => plan.type === "feature").length,
+        group: plans.filter((plan) => plan.type === "group").length,
+        schema: plans.filter((plan) => plan.type === "schema").length,
+        target: plans.filter((plan) => plan.type === "target").length,
+        test: plans.filter((plan) => plan.type === "test").length,
+    };
+    const result = {
+        from: options.from,
+        to: options.to,
+        apply: options.apply === true,
+        duration: Date.now() - startTime,
+        filters: {
+            includeFeatures: toArray(options.includeFeatures),
+            excludeFeatures: toArray(options.excludeFeatures),
+            targets: toArray(options.target),
+            tags: toArray(options.tag),
+            conflicts: conflictPolicy,
+        },
+        dependencies,
+        files: { created, updated, unchanged },
+        conflicts,
+    };
+    if (result.apply && auditFormat) {
+        result.auditFilePath = await writePromotionAudit(projectConfig, result, auditFormat);
+    }
+    return result;
+}
+function printFileGroup(label, files, color) {
+    if (files.length === 0) {
+        return;
+    }
+    console.log(cliFormat_1.CLI_FORMAT_BOLD, label);
+    for (const filePath of files) {
+        console.log(`  ${(0, cliFormat_1.colorize)(filePath, color)}`);
+    }
+    console.log("");
+}
+function printConflictPreview(conflicts) {
+    if (conflicts.length === 0) {
+        return;
+    }
+    console.log(cliFormat_1.CLI_FORMAT_BOLD, "Conflicts");
+    for (const conflict of conflicts.slice(0, 10)) {
+        console.log(`  ${(0, cliFormat_1.colorize)(conflict.type, cliFormat_1.CLI_COLOR_YELLOW)} ${conflict.key} ${(0, cliFormat_1.colorize)(conflict.path, cliFormat_1.CLI_COLOR_DIM)}`);
+    }
+    if (conflicts.length > 10) {
+        console.log(`  ${(0, cliFormat_1.colorize)(`...and ${conflicts.length - 10} more`, cliFormat_1.CLI_COLOR_DIM)}`);
+    }
+    console.log("");
+}
+function printPromoteResult(result, options = {}) {
+    console.log("");
+    console.log(cliFormat_1.CLI_FORMAT_BOLD, "Promoting Featurevisor set definitions");
+    console.log(`  From: ${result.from}`);
+    console.log(`  To:   ${result.to}`);
+    console.log(`  Mode: ${result.apply ? "apply" : "preview"}`);
+    if (result.filters.includeFeatures.length > 0) {
+        console.log(`  Include features: ${result.filters.includeFeatures.join(", ")}`);
+    }
+    if (result.filters.excludeFeatures.length > 0) {
+        console.log(`  Exclude features: ${result.filters.excludeFeatures.join(", ")}`);
+    }
+    if (result.filters.targets.length > 0) {
+        console.log(`  Targets: ${result.filters.targets.join(", ")}`);
+    }
+    if (result.filters.tags.length > 0) {
+        console.log(`  Tags: ${result.filters.tags.join(", ")}`);
+    }
+    console.log(`  Conflict policy: ${result.filters.conflicts}`);
+    console.log("");
+    console.log(`  Dependencies: ${result.dependencies.attribute} attributes, ${result.dependencies.segment} segments, ${result.dependencies.feature} features, ${result.dependencies.group} groups, ${result.dependencies.schema} schemas, ${result.dependencies.target} targets, ${result.dependencies.test} tests`);
+    console.log(`  Created:   ${result.files.created.length}`);
+    console.log(`  Updated:   ${result.files.updated.length}`);
+    console.log(`  Unchanged: ${result.files.unchanged.length}`);
+    console.log(`  Conflicts: ${result.conflicts.length}`);
+    console.log("");
+    printFileGroup("Created", result.files.created, cliFormat_1.CLI_COLOR_GREEN);
+    printFileGroup("Updated", result.files.updated, cliFormat_1.CLI_COLOR_YELLOW);
+    if (options.showUnchanged === true) {
+        printFileGroup("Unchanged", result.files.unchanged, cliFormat_1.CLI_COLOR_DIM);
+    }
+    printConflictPreview(result.conflicts);
+    if (result.auditFilePath) {
+        console.log(`  Audit: ${(0, cliFormat_1.colorize)(result.auditFilePath, cliFormat_1.CLI_COLOR_CYAN)}`);
+        console.log("");
+    }
+    console.log(cliFormat_1.CLI_FORMAT_GREEN, result.apply ? "Promotion applied" : "Promotion preview complete");
+    console.log(cliFormat_1.CLI_FORMAT_BOLD, `Time: ${(0, prettyDuration_1.prettyDuration)(result.duration)}`);
+}
+exports.promotePlugin = {
+    command: "promote",
+    handler: async ({ projectConfig, datasource, parsed }) => {
+        const result = await promoteProjectSets(projectConfig, datasource, {
+            from: parsed.from,
+            to: parsed.to,
+            includeFeatures: parsed.includeFeatures,
+            excludeFeatures: parsed.excludeFeatures,
+            target: parsed.target,
+            tag: parsed.tag,
+            conflicts: parsed.conflicts,
+            allowEmpty: parsed.allowEmpty === true || parsed.allowEmpty === "true",
+            apply: parsed.apply === true || parsed.apply === "true",
+            audit: parsed.audit,
+        });
+        printPromoteResult(result, {
+            showUnchanged: parsed.showUnchanged === true || parsed.showUnchanged === "true",
+        });
+    },
+    examples: [
+        {
+            command: "promote --from=dev --to=staging",
+            description: "preview definitions that can be promoted from one set to another",
+        },
+        {
+            command: "promote --from=dev --to=staging --target=web",
+            description: "preview the target and every definition needed to build its datafile",
+        },
+        {
+            command: "promote --from=dev --to=staging --tag=web",
+            description: "preview definitions affecting features with a tag",
+        },
+        {
+            command: 'promote --from=dev --to=staging --includeFeatures="checkout*"',
+            description: "preview definitions affecting matching features",
+        },
+        {
+            command: "promote --from=dev --to=staging --conflicts=fail",
+            description: "fail instead of overwriting conflicting destination fields",
+        },
+        {
+            command: "promote --from=dev --to=staging --apply",
+            description: "apply a promotion and write destination files",
+        },
+        {
+            command: "promote --from=dev --to=staging --apply --audit=markdown",
+            description: "write a promotion audit file",
+        },
+        {
+            command: "promote --from=dev --to=staging --showUnchanged",
+            description: "preview a promotion and include unchanged entries",
+        },
+    ],
+};
+//# sourceMappingURL=index.js.map