flagsmith-nodejs
Version:
Flagsmith lets you manage features flags and remote config across web, mobile and server side applications. Deliver true Continuous Integration. Get builds out faster. Control who has access to new features.
197 lines (196 loc) • 9.13 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.isHigherPriority = exports.shouldApplyOverride = exports.evaluateFeatures = exports.processSegmentOverrides = exports.evaluateSegments = exports.getEvaluationResult = exports.OrganisationModel = exports.FeatureStateModel = exports.FeatureModel = exports.SegmentModel = exports.TraitModel = exports.IdentityModel = exports.EnvironmentModel = void 0;
const evaluators_js_1 = require("./segments/evaluators.js");
const types_js_1 = require("./features/types.js");
const index_js_1 = require("./utils/hashing/index.js");
var models_js_1 = require("./environments/models.js");
Object.defineProperty(exports, "EnvironmentModel", { enumerable: true, get: function () { return models_js_1.EnvironmentModel; } });
var models_js_2 = require("./identities/models.js");
Object.defineProperty(exports, "IdentityModel", { enumerable: true, get: function () { return models_js_2.IdentityModel; } });
var models_js_3 = require("./identities/traits/models.js");
Object.defineProperty(exports, "TraitModel", { enumerable: true, get: function () { return models_js_3.TraitModel; } });
var models_js_4 = require("./segments/models.js");
Object.defineProperty(exports, "SegmentModel", { enumerable: true, get: function () { return models_js_4.SegmentModel; } });
var models_js_5 = require("./features/models.js");
Object.defineProperty(exports, "FeatureModel", { enumerable: true, get: function () { return models_js_5.FeatureModel; } });
Object.defineProperty(exports, "FeatureStateModel", { enumerable: true, get: function () { return models_js_5.FeatureStateModel; } });
var models_js_6 = require("./organisations/models.js");
Object.defineProperty(exports, "OrganisationModel", { enumerable: true, get: function () { return models_js_6.OrganisationModel; } });
/**
* Evaluates flags and segments for the given context.
*
* This is the main entry point for the evaluation engine. It processes segments,
* applies feature overrides based on segment priority, and returns the final flag states with
* evaluation reasons.
*
* @param context - EvaluationContext containing environment, identity, and segment data
* @returns EvaluationResult with flags, segments, and original context
*/
function getEvaluationResult(context) {
const enrichedContext = getEnrichedContext(context);
const { segments, segmentOverrides } = evaluateSegments(enrichedContext);
const flags = evaluateFeatures(enrichedContext, segmentOverrides);
return { flags, segments };
}
exports.getEvaluationResult = getEvaluationResult;
function getEnrichedContext(context) {
const identityKey = getIdentityKey(context);
if (!identityKey)
return context;
return {
...context,
...(context.identity && {
identity: {
identifier: context.identity.identifier,
key: identityKey,
traits: context.identity.traits || {}
}
})
};
}
/**
* Evaluates which segments the identity belongs to and collects feature overrides.
*
* @param context - EvaluationContext containing identity and segment definitions
* @returns Object containing segments the identity belongs to and any feature overrides
*/
function evaluateSegments(context) {
if (!context.identity || !context.segments) {
return {
segments: [],
segmentOverrides: {}
};
}
const identitySegments = (0, evaluators_js_1.getIdentitySegments)(context);
const segments = identitySegments.map(segment => ({
name: segment.name,
...(segment.metadata
? {
metadata: {
...segment.metadata
}
}
: {})
}));
const segmentOverrides = processSegmentOverrides(identitySegments);
return { segments, segmentOverrides };
}
exports.evaluateSegments = evaluateSegments;
/**
* Processes feature overrides from segments, applying priority rules.
*
* When multiple segments override the same feature, the segment with
* higher priority (lower numeric value) takes precedence.
*
* @param identitySegments - Segments that the identity belongs to
* @returns Map of feature keys to their highest-priority segment overrides
*/
function processSegmentOverrides(identitySegments) {
const segmentOverrides = {};
for (const segment of identitySegments) {
if (!segment.overrides)
continue;
const overridesList = Array.isArray(segment.overrides) ? segment.overrides : [];
for (const override of overridesList) {
if (shouldApplyOverride(override, segmentOverrides)) {
segmentOverrides[override.name] = {
feature: override,
segmentName: segment.name
};
}
}
}
return segmentOverrides;
}
exports.processSegmentOverrides = processSegmentOverrides;
/**
* Evaluates all features in the context, applying segment overrides where applicable.
* For each feature:
* - Checks if a segment override exists
* - Uses override values if present, otherwise evaluates the base feature
* - Determines appropriate evaluation reason
* - Handles multivariate evaluation for features without overrides
*
* @param context - EvaluationContext containing features and identity
* @param segmentOverrides - Map of feature keys to their segment overrides
* @returns EvaluationResultFlags containing evaluated flag results
*/
function evaluateFeatures(context, segmentOverrides) {
const flags = {};
for (const feature of Object.values(context.features || {})) {
const segmentOverride = segmentOverrides[feature.name];
const finalFeature = segmentOverride ? segmentOverride.feature : feature;
const { value: evaluatedValue, reason: evaluatedReason } = evaluateFeatureValue(finalFeature, getIdentityKey(context));
flags[finalFeature.name] = {
name: finalFeature.name,
enabled: finalFeature.enabled,
value: evaluatedValue,
...(finalFeature.metadata ? { metadata: finalFeature.metadata } : {}),
reason: evaluatedReason ??
getTargetingMatchReason({ type: 'SEGMENT', override: segmentOverride })
};
}
return flags;
}
exports.evaluateFeatures = evaluateFeatures;
function evaluateFeatureValue(feature, identityKey) {
if (!!feature.variants && feature.variants.length > 0 && !!identityKey) {
return getMultivariateFeatureValue(feature, identityKey);
}
return { value: feature.value, reason: undefined };
}
/**
* Evaluates a multivariate feature flag to determine which variant value to return for a given identity.
*
* Uses deterministic hashing to ensure the same identity always receives the same variant,
* while distributing variants according to their configured weight percentages.
*
* @param feature - The feature context containing variants and their weights
* @param identityKey - The identity key used for deterministic variant selection
* @returns The variant value if the identity falls within a variant's range, otherwise the default feature value
*/
function getMultivariateFeatureValue(feature, identityKey) {
const percentageValue = (0, index_js_1.getHashedPercentageForObjIds)([feature.key, identityKey]);
const sortedVariants = [...(feature?.variants || [])].sort((a, b) => {
return (a.priority ?? Infinity) - (b.priority ?? Infinity);
});
let startPercentage = 0;
for (const variant of sortedVariants) {
const limit = startPercentage + variant.weight;
if (startPercentage <= percentageValue && percentageValue < limit) {
return {
value: variant.value,
reason: getTargetingMatchReason({ type: 'SPLIT', weight: variant.weight })
};
}
startPercentage = limit;
}
return { value: feature.value, reason: undefined };
}
function shouldApplyOverride(override, existingOverrides) {
const currentOverride = existingOverrides[override.name];
return (!currentOverride || isHigherPriority(override.priority, currentOverride.feature.priority));
}
exports.shouldApplyOverride = shouldApplyOverride;
function isHigherPriority(priorityA, priorityB) {
return (priorityA ?? Infinity) < (priorityB ?? Infinity);
}
exports.isHigherPriority = isHigherPriority;
const getTargetingMatchReason = (matchObject) => {
const { type } = matchObject;
if (type === 'SEGMENT') {
return matchObject.override
? `${types_js_1.TARGETING_REASONS.TARGETING_MATCH}; segment=${matchObject.override.segmentName}`
: types_js_1.TARGETING_REASONS.DEFAULT;
}
if (type === 'SPLIT') {
return `${types_js_1.TARGETING_REASONS.SPLIT}; weight=${matchObject.weight}`;
}
return types_js_1.TARGETING_REASONS.DEFAULT;
};
const getIdentityKey = (context) => {
if (!context.identity)
return undefined;
return context.identity.key || `${context.environment.key}_${context.identity?.identifier}`;
};