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.
205 lines (204 loc) • 8.91 kB
JavaScript
import * as semver from 'semver';
import { FeatureModel, FeatureStateModel, MultivariateFeatureOptionModel, MultivariateFeatureStateValueModel } from '../features/models.js';
import { getCastingFunction as getCastingFunction } from '../utils/index.js';
import { ALL_RULE, ANY_RULE, NONE_RULE, NOT_CONTAINS, REGEX, MODULO, IN, CONDITION_OPERATORS } from './constants.js';
import { isSemver } from './util.js';
import { CONSTANTS } from '../features/constants.js';
import { SegmentSource } from '../evaluation/models.js';
export const all = (iterable) => iterable.filter(e => !!e).length === iterable.length;
export const any = (iterable) => iterable.filter(e => !!e).length > 0;
export const matchingFunctions = {
[CONDITION_OPERATORS.EQUAL]: (thisValue, otherValue) => thisValue == otherValue,
[CONDITION_OPERATORS.GREATER_THAN]: (thisValue, otherValue) => otherValue > thisValue,
[CONDITION_OPERATORS.GREATER_THAN_INCLUSIVE]: (thisValue, otherValue) => otherValue >= thisValue,
[CONDITION_OPERATORS.LESS_THAN]: (thisValue, otherValue) => thisValue > otherValue,
[CONDITION_OPERATORS.LESS_THAN_INCLUSIVE]: (thisValue, otherValue) => thisValue >= otherValue,
[CONDITION_OPERATORS.NOT_EQUAL]: (thisValue, otherValue) => thisValue != otherValue,
[CONDITION_OPERATORS.CONTAINS]: (thisValue, otherValue) => {
try {
return !!otherValue && otherValue.includes(thisValue);
}
catch {
return false;
}
}
};
// Semver library throws an error if the version is invalid, in this case, we want to catch and return false
const safeSemverCompare = (semverMatchingFunction) => {
return (conditionValue, traitValue) => {
try {
return semverMatchingFunction(conditionValue, traitValue);
}
catch {
return false;
}
};
};
export const semverMatchingFunction = {
...matchingFunctions,
[CONDITION_OPERATORS.EQUAL]: safeSemverCompare((conditionValue, traitValue) => semver.eq(traitValue, conditionValue)),
[CONDITION_OPERATORS.GREATER_THAN]: safeSemverCompare((conditionValue, traitValue) => semver.gt(traitValue, conditionValue)),
[CONDITION_OPERATORS.GREATER_THAN_INCLUSIVE]: safeSemverCompare((conditionValue, traitValue) => semver.gte(traitValue, conditionValue)),
[CONDITION_OPERATORS.LESS_THAN]: safeSemverCompare((conditionValue, traitValue) => semver.lt(traitValue, conditionValue)),
[CONDITION_OPERATORS.LESS_THAN_INCLUSIVE]: safeSemverCompare((conditionValue, traitValue) => semver.lte(traitValue, conditionValue))
};
export const getMatchingFunctions = (semver) => semver ? semverMatchingFunction : matchingFunctions;
export class SegmentConditionModel {
EXCEPTION_OPERATOR_METHODS = {
[NOT_CONTAINS]: 'evaluateNotContains',
[REGEX]: 'evaluateRegex',
[MODULO]: 'evaluateModulo',
[IN]: 'evaluateIn'
};
operator;
value;
property;
constructor(operator, value, property) {
this.operator = operator;
this.value = value;
this.property = property;
}
matchesTraitValue(traitValue) {
const evaluators = {
evaluateNotContains: (traitValue) => {
return (typeof traitValue == 'string' &&
!!this.value &&
!traitValue.includes(this.value?.toString()));
},
evaluateRegex: (traitValue) => {
try {
if (!this.value) {
return false;
}
const regex = new RegExp(this.value?.toString());
return !!traitValue?.toString().match(regex);
}
catch {
return false;
}
},
evaluateModulo: (traitValue) => {
const parsedTraitValue = parseFloat(traitValue);
if (isNaN(parsedTraitValue) || !this.value) {
return false;
}
const parts = this.value.toString().split('|');
if (parts.length !== 2) {
return false;
}
const divisor = parseFloat(parts[0]);
const remainder = parseFloat(parts[1]);
if (isNaN(divisor) || isNaN(remainder) || divisor === 0) {
return false;
}
return parsedTraitValue % divisor === remainder;
},
evaluateIn: (traitValue) => {
if (!traitValue || typeof traitValue === 'boolean') {
return false;
}
if (Array.isArray(this.value)) {
return this.value.includes(traitValue.toString());
}
if (typeof this.value === 'string') {
try {
const parsed = JSON.parse(this.value);
if (Array.isArray(parsed)) {
return parsed.includes(traitValue.toString());
}
}
catch { }
}
return this.value?.split(',').includes(traitValue.toString());
}
};
// TODO: move this logic to the evaluator module
if (this.EXCEPTION_OPERATOR_METHODS[this.operator]) {
const evaluatorFunction = evaluators[this.EXCEPTION_OPERATOR_METHODS[this.operator]];
return evaluatorFunction(traitValue);
}
const defaultFunction = (x, y) => false;
const matchingFunctionSet = getMatchingFunctions(isSemver(this.value));
const matchingFunction = matchingFunctionSet[this.operator] || defaultFunction;
const traitType = isSemver(this.value) ? 'semver' : typeof traitValue;
const castToTypeOfTraitValue = getCastingFunction(traitType);
return matchingFunction(castToTypeOfTraitValue(this.value), traitValue);
}
}
export class SegmentRuleModel {
type;
rules = [];
conditions = [];
constructor(type) {
this.type = type;
}
static none(iterable) {
return iterable.filter(e => !!e).length === 0;
}
matchingFunction() {
return {
[ANY_RULE]: any,
[ALL_RULE]: all,
[NONE_RULE]: SegmentRuleModel.none
}[this.type];
}
}
export class SegmentModel {
id;
name;
rules = [];
featureStates = [];
constructor(id, name) {
this.id = id;
this.name = name;
}
static fromSegmentResult(segmentResults, evaluationContext) {
const segmentModels = [];
if (!evaluationContext.segments) {
return [];
}
for (const segmentResult of segmentResults) {
if (segmentResult.metadata?.source === SegmentSource.IDENTITY_OVERRIDE) {
continue;
}
const segmentMetadataId = segmentResult.metadata?.id;
if (!segmentMetadataId) {
continue;
}
const segmentContext = evaluationContext.segments[segmentMetadataId.toString()];
if (segmentContext) {
const segment = new SegmentModel(segmentMetadataId, segmentContext.name);
segment.rules = segmentContext.rules.map(rule => new SegmentRuleModel(rule.type));
segment.featureStates = SegmentModel.createFeatureStatesFromOverrides(segmentContext.overrides || []);
segmentModels.push(segment);
}
}
return segmentModels;
}
static createFeatureStatesFromOverrides(overrides) {
if (!overrides)
return [];
return overrides
.filter(override => {
const overrideMetadataId = override?.metadata?.id;
return typeof overrideMetadataId === 'number';
})
.map(override => {
const overrideMetadataId = override.metadata.id;
const feature = new FeatureModel(overrideMetadataId, override.name, override.variants?.length && override.variants.length > 0
? CONSTANTS.MULTIVARIATE
: CONSTANTS.STANDARD);
const featureState = new FeatureStateModel(feature, override.enabled, override.priority || 0);
if (override.value !== undefined) {
featureState.setValue(override.value);
}
if (override.variants && override.variants.length > 0) {
featureState.multivariateFeatureStateValues = this.createMultivariateValues(override.variants);
}
return featureState;
});
}
static createMultivariateValues(variants) {
return variants.map(variant => new MultivariateFeatureStateValueModel(new MultivariateFeatureOptionModel(variant.value, variant.id), variant.weight, variant.id));
}
}