flagsmith-nodejs 6.1.0 → 7.0.2

package/build/cjs/flagsmith-engine/evaluation/models.d.ts

@@ -0,0 +1,50 @@
+import type { FlagResult, FeatureMetadata, SegmentMetadata } from './evaluationResult/evaluationResult.types.js';
+import type { FeatureContext, EnvironmentContext, IdentityContext, SegmentContext } from './evaluationContext/evaluationContext.types.js';
+export * from './evaluationContext/evaluationContext.types.js';
+export declare enum SegmentSource {
+    API = "api",
+    IDENTITY_OVERRIDE = "identity_override"
+}
+export interface SDKFeatureMetadata extends FeatureMetadata {
+    id: number;
+}
+export interface FeatureContextWithMetadata<T extends FeatureMetadata = FeatureMetadata> extends FeatureContext {
+    metadata: T;
+    [k: string]: unknown;
+}
+export type FeaturesWithMetadata<T extends FeatureMetadata = FeatureMetadata> = {
+    [k: string]: FeatureContextWithMetadata<T>;
+};
+export type FlagResultWithMetadata<T extends FeatureMetadata = FeatureMetadata> = FlagResult & {
+    metadata: T;
+};
+export type EvaluationResultFlags<T extends FeatureMetadata = FeatureMetadata> = Record<string, FlagResultWithMetadata<T>>;
+export interface SDKSegmentMetadata extends SegmentMetadata {
+    id?: number;
+    source?: SegmentSource;
+}
+export interface SegmentContextWithMetadata<T extends SegmentMetadata = SegmentMetadata> extends SegmentContext {
+    metadata: T;
+    overrides?: FeatureContextWithMetadata<FeatureMetadata>[];
+}
+export type SegmentsWithMetadata<T extends SegmentMetadata = SegmentMetadata> = {
+    [k: string]: SegmentContextWithMetadata<T>;
+};
+export interface SegmentResultWithMetadata {
+    name: string;
+    metadata: SDKSegmentMetadata;
+}
+export type EvaluationResultSegments = SegmentResultWithMetadata[];
+export interface GenericEvaluationContext<T extends FeatureMetadata = FeatureMetadata, S extends SegmentMetadata = SegmentMetadata> {
+    environment: EnvironmentContext;
+    identity?: IdentityContext | null;
+    segments?: SegmentsWithMetadata<S>;
+    features?: FeaturesWithMetadata<T>;
+    [k: string]: unknown;
+}
+export type EvaluationContextWithMetadata = GenericEvaluationContext<SDKFeatureMetadata, SDKSegmentMetadata>;
+export type EvaluationResult<T extends FeatureMetadata = FeatureMetadata> = {
+    flags: EvaluationResultFlags<T>;
+    segments: EvaluationResultSegments;
+};
+export type EvaluationResultWithMetadata = EvaluationResult<SDKFeatureMetadata>;

package/build/cjs/flagsmith-engine/evaluation/models.js

@@ -0,0 +1,26 @@
+"use strict";
+// This file is the entry point for the evaluation module types
+// All types from evaluations should be at least imported here and re-exported
+// Do not use types directly from generated files
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SegmentSource = void 0;
+__exportStar(require("./evaluationContext/evaluationContext.types.js"), exports);
+var SegmentSource;
+(function (SegmentSource) {
+    SegmentSource["API"] = "api";
+    SegmentSource["IDENTITY_OVERRIDE"] = "identity_override";
+})(SegmentSource = exports.SegmentSource || (exports.SegmentSource = {}));

package/build/cjs/flagsmith-engine/features/models.js

@@ -93,7 +93,7 @@ class FeatureStateModel {
                     return myValue.multivariateFeatureOption.value;
                 default:
                     if (percentageValue === undefined) {
-                        percentageValue = (0, index_js_1.getHashedPercentateForObjIds)([
+                        percentageValue = (0, index_js_1.getHashedPercentageForObjIds)([
                             this.djangoID || this.featurestateUUID,
                             identityID
                         ]);

package/build/cjs/flagsmith-engine/features/types.d.ts

@@ -0,0 +1,5 @@
+export declare enum TARGETING_REASONS {
+    DEFAULT = "DEFAULT",
+    TARGETING_MATCH = "TARGETING_MATCH",
+    SPLIT = "SPLIT"
+}

package/build/cjs/flagsmith-engine/features/types.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TARGETING_REASONS = void 0;
+var TARGETING_REASONS;
+(function (TARGETING_REASONS) {
+    TARGETING_REASONS["DEFAULT"] = "DEFAULT";
+    TARGETING_REASONS["TARGETING_MATCH"] = "TARGETING_MATCH";
+    TARGETING_REASONS["SPLIT"] = "SPLIT";
+})(TARGETING_REASONS = exports.TARGETING_REASONS || (exports.TARGETING_REASONS = {}));

package/build/cjs/flagsmith-engine/features/util.d.ts

@@ -2,3 +2,4 @@ import { FeatureModel, FeatureSegment, FeatureStateModel } from './models.js';
 export declare function buildFeatureModel(featuresModelJSON: any): FeatureModel;
 export declare function buildFeatureStateModel(featuresStateModelJSON: any): FeatureStateModel;
 export declare function buildFeatureSegment(featureSegmentJSON: any): FeatureSegment;
+export declare function uuidToBigInt(uuid: string): BigInt;

package/build/cjs/flagsmith-engine/features/util.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildFeatureSegment = exports.buildFeatureStateModel = exports.buildFeatureModel = void 0;
+exports.uuidToBigInt = exports.buildFeatureSegment = exports.buildFeatureStateModel = exports.buildFeatureModel = void 0;
 const models_js_1 = require("./models.js");
 function buildFeatureModel(featuresModelJSON) {
     return new models_js_1.FeatureModel(featuresModelJSON.id, featuresModelJSON.name, featuresModelJSON.type);
@@ -25,3 +25,7 @@ function buildFeatureSegment(featureSegmentJSON) {
     return new models_js_1.FeatureSegment(featureSegmentJSON.priority);
 }
 exports.buildFeatureSegment = buildFeatureSegment;
+function uuidToBigInt(uuid) {
+    return BigInt('0x' + uuid.replace(/-/g, ''));
+}
+exports.uuidToBigInt = uuidToBigInt;

package/build/cjs/flagsmith-engine/index.d.ts

@@ -1,14 +1,66 @@
-import { EnvironmentModel } from './environments/models.js';
-import { FeatureStateModel } from './features/models.js';
-import { IdentityModel } from './identities/models.js';
-import { TraitModel } from './identities/traits/models.js';
+import { EvaluationContextWithMetadata, EvaluationResultSegments, EvaluationResultWithMetadata, FeatureContextWithMetadata, SDKFeatureMetadata } from './evaluation/models.js';
+import { EvaluationResultFlags } from './evaluation/models.js';
 export { EnvironmentModel } from './environments/models.js';
-export { FeatureModel, FeatureStateModel } from './features/models.js';
 export { IdentityModel } from './identities/models.js';
 export { TraitModel } from './identities/traits/models.js';
 export { SegmentModel } from './segments/models.js';
+export { FeatureModel, FeatureStateModel } from './features/models.js';
 export { OrganisationModel } from './organisations/models.js';
-export declare function getIdentityFeatureState(environment: EnvironmentModel, identity: IdentityModel, featureName: string, overrideTraits?: TraitModel[]): FeatureStateModel;
-export declare function getIdentityFeatureStates(environment: EnvironmentModel, identity: IdentityModel, overrideTraits?: TraitModel[]): FeatureStateModel[];
-export declare function getEnvironmentFeatureState(environment: EnvironmentModel, featureName: string): FeatureStateModel;
-export declare function getEnvironmentFeatureStates(environment: EnvironmentModel): FeatureStateModel[];
+type SegmentOverride = {
+    feature: FeatureContextWithMetadata<SDKFeatureMetadata>;
+    segmentName: string;
+};
+export type SegmentOverrides = Record<string, SegmentOverride>;
+/**
+ * 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
+ */
+export declare function getEvaluationResult(context: EvaluationContextWithMetadata): EvaluationResultWithMetadata;
+/**
+ * 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
+ */
+export declare function evaluateSegments(context: EvaluationContextWithMetadata): {
+    segments: EvaluationResultSegments;
+    segmentOverrides: Record<string, SegmentOverride>;
+};
+/**
+ * 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
+ */
+export declare function processSegmentOverrides(identitySegments: any[]): Record<string, SegmentOverride>;
+/**
+ * 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
+ */
+export declare function evaluateFeatures(context: EvaluationContextWithMetadata, segmentOverrides: Record<string, SegmentOverride>): EvaluationResultFlags<SDKFeatureMetadata>;
+export declare function shouldApplyOverride(override: any, existingOverrides: Record<string, SegmentOverride>): boolean;
+export declare function isHigherPriority(priorityA: number | undefined, priorityB: number | undefined): boolean;
+export type TargetingMatchReason = {
+    type: 'SEGMENT';
+    override: SegmentOverride;
+} | {
+    type: 'SPLIT';
+    weight: number;
+};

package/build/cjs/flagsmith-engine/index.js

@@ -1,76 +1,196 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEnvironmentFeatureStates = exports.getEnvironmentFeatureState = exports.getIdentityFeatureStates = exports.getIdentityFeatureState = exports.OrganisationModel = exports.SegmentModel = exports.TraitModel = exports.IdentityModel = exports.FeatureStateModel = exports.FeatureModel = exports.EnvironmentModel = void 0;
+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 errors_js_1 = require("./utils/errors.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("./features/models.js");
-Object.defineProperty(exports, "FeatureModel", { enumerable: true, get: function () { return models_js_2.FeatureModel; } });
-Object.defineProperty(exports, "FeatureStateModel", { enumerable: true, get: function () { return models_js_2.FeatureStateModel; } });
-var models_js_3 = require("./identities/models.js");
-Object.defineProperty(exports, "IdentityModel", { enumerable: true, get: function () { return models_js_3.IdentityModel; } });
-var models_js_4 = require("./identities/traits/models.js");
-Object.defineProperty(exports, "TraitModel", { enumerable: true, get: function () { return models_js_4.TraitModel; } });
-var models_js_5 = require("./segments/models.js");
-Object.defineProperty(exports, "SegmentModel", { enumerable: true, get: function () { return models_js_5.SegmentModel; } });
+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; } });
-function getIdentityFeatureStatesDict(environment, identity, overrideTraits) {
-    // Get feature states from the environment
-    const featureStates = {};
-    for (const fs of environment.featureStates) {
-        featureStates[fs.feature.id] = fs;
+/**
+ * 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: {}
+        };
     }
-    // Override with any feature states defined by matching segments
-    const identitySegments = (0, evaluators_js_1.getIdentitySegments)(environment, identity, overrideTraits);
-    for (const matchingSegment of identitySegments) {
-        for (const featureState of matchingSegment.featureStates) {
-            if (featureStates[featureState.feature.id]) {
-                if (featureStates[featureState.feature.id].isHigherSegmentPriority(featureState)) {
-                    continue;
+    const identitySegments = (0, evaluators_js_1.getIdentitySegments)(context);
+    const segments = identitySegments.map(segment => ({
+        name: segment.name,
+        ...(segment.metadata
+            ? {
+                metadata: {
+                    ...segment.metadata
                 }
             }
-            featureStates[featureState.feature.id] = featureState;
-        }
-    }
-    // Override with any feature states defined directly the identity
-    for (const fs of identity.identityFeatures) {
-        if (featureStates[fs.feature.id]) {
-            featureStates[fs.feature.id] = fs;
+            : {})
+    }));
+    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 featureStates;
+    return segmentOverrides;
 }
-function getIdentityFeatureState(environment, identity, featureName, overrideTraits) {
-    const featureStates = getIdentityFeatureStatesDict(environment, identity, overrideTraits);
-    const matchingFeature = Object.values(featureStates).filter(f => f.feature.name === featureName);
-    if (matchingFeature.length === 0) {
-        throw new errors_js_1.FeatureStateNotFound('Feature State Not Found');
+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 matchingFeature[0];
+    return flags;
 }
-exports.getIdentityFeatureState = getIdentityFeatureState;
-function getIdentityFeatureStates(environment, identity, overrideTraits) {
-    const featureStates = Object.values(getIdentityFeatureStatesDict(environment, identity, overrideTraits));
-    if (environment.project.hideDisabledFlags) {
-        return featureStates.filter(fs => !!fs.enabled);
+exports.evaluateFeatures = evaluateFeatures;
+function evaluateFeatureValue(feature, identityKey) {
+    if (!!feature.variants && feature.variants.length > 0 && !!identityKey) {
+        return getMultivariateFeatureValue(feature, identityKey);
     }
-    return featureStates;
+    return { value: feature.value, reason: undefined };
 }
-exports.getIdentityFeatureStates = getIdentityFeatureStates;
-function getEnvironmentFeatureState(environment, featureName) {
-    const featuresStates = environment.featureStates.filter(f => f.feature.name === featureName);
-    if (featuresStates.length === 0) {
-        throw new errors_js_1.FeatureStateNotFound('Feature State Not Found');
+/**
+ * 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 featuresStates[0];
+    return { value: feature.value, reason: undefined };
 }
-exports.getEnvironmentFeatureState = getEnvironmentFeatureState;
-function getEnvironmentFeatureStates(environment) {
-    if (environment.project.hideDisabledFlags) {
-        return environment.featureStates.filter(fs => !!fs.enabled);
-    }
-    return environment.featureStates;
+function shouldApplyOverride(override, existingOverrides) {
+    const currentOverride = existingOverrides[override.name];
+    return (!currentOverride || isHigherPriority(override.priority, currentOverride.feature.priority));
 }
-exports.getEnvironmentFeatureStates = getEnvironmentFeatureStates;
+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}`;
+};

package/build/cjs/flagsmith-engine/segments/constants.d.ts

@@ -2,6 +2,7 @@ export declare const ALL_RULE = "ALL";
 export declare const ANY_RULE = "ANY";
 export declare const NONE_RULE = "NONE";
 export declare const RULE_TYPES: string[];
+export declare const IDENTITY_OVERRIDE_SEGMENT_NAME = "identity_overrides";
 export declare const EQUAL = "EQUAL";
 export declare const GREATER_THAN = "GREATER_THAN";
 export declare const LESS_THAN = "LESS_THAN";

package/build/cjs/flagsmith-engine/segments/constants.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CONDITION_OPERATORS = exports.IN = exports.MODULO = exports.IS_NOT_SET = exports.IS_SET = exports.PERCENTAGE_SPLIT = exports.REGEX = exports.NOT_EQUAL = exports.NOT_CONTAINS = exports.GREATER_THAN_INCLUSIVE = exports.CONTAINS = exports.LESS_THAN_INCLUSIVE = exports.LESS_THAN = exports.GREATER_THAN = exports.EQUAL = exports.RULE_TYPES = exports.NONE_RULE = exports.ANY_RULE = exports.ALL_RULE = void 0;
+exports.CONDITION_OPERATORS = exports.IN = exports.MODULO = exports.IS_NOT_SET = exports.IS_SET = exports.PERCENTAGE_SPLIT = exports.REGEX = exports.NOT_EQUAL = exports.NOT_CONTAINS = exports.GREATER_THAN_INCLUSIVE = exports.CONTAINS = exports.LESS_THAN_INCLUSIVE = exports.LESS_THAN = exports.GREATER_THAN = exports.EQUAL = exports.IDENTITY_OVERRIDE_SEGMENT_NAME = exports.RULE_TYPES = exports.NONE_RULE = exports.ANY_RULE = exports.ALL_RULE = void 0;
 // Segment Rules
 exports.ALL_RULE = 'ALL';
 exports.ANY_RULE = 'ANY';
 exports.NONE_RULE = 'NONE';
 exports.RULE_TYPES = [exports.ALL_RULE, exports.ANY_RULE, exports.NONE_RULE];
+exports.IDENTITY_OVERRIDE_SEGMENT_NAME = 'identity_overrides';
 // Segment Condition Operators
 exports.EQUAL = 'EQUAL';
 exports.GREATER_THAN = 'GREATER_THAN';

package/build/cjs/flagsmith-engine/segments/evaluators.d.ts

@@ -1,7 +1,41 @@
-import { EnvironmentModel } from '../environments/models.js';
-import { IdentityModel } from '../identities/models.js';
-import { TraitModel } from '../identities/traits/models.js';
-import { SegmentConditionModel, SegmentModel } from './models.js';
-export declare function getIdentitySegments(environment: EnvironmentModel, identity: IdentityModel, overrideTraits?: TraitModel[]): SegmentModel[];
-export declare function evaluateIdentityInSegment(identity: IdentityModel, segment: SegmentModel, overrideTraits?: TraitModel[]): boolean;
-export declare function traitsMatchSegmentCondition(identityTraits: TraitModel[], condition: SegmentConditionModel, segmentId: number | string, identityId: number | string): boolean;
+import { GenericEvaluationContext, InSegmentCondition, SegmentCondition, SegmentContext } from '../evaluation/models.js';
+/**
+ * Returns all segments that the identity belongs to based on segment rules evaluation.
+ *
+ * An identity belongs to a segment if it matches ALL of the segment's rules.
+ * If the context has no identity or segments, returns an empty array.
+ *
+ * @param context - Evaluation context containing identity and segment definitions
+ * @returns Array of segments that the identity matches
+ */
+export declare function getIdentitySegments(context: GenericEvaluationContext): SegmentContext[];
+/**
+ * Evaluates whether a segment condition matches the identity's traits or context values.
+ *
+ * Handles different types of conditions:
+ * - PERCENTAGE_SPLIT: Deterministic percentage-based bucketing using identity key
+ * - IS_SET/IS_NOT_SET: Checks for trait existence
+ * - Standard operators: EQUAL, NOT_EQUAL, etc. via SegmentConditionModel
+ * - JSONPath expressions: $.identity.identifier, $.environment.name, etc.
+ *
+ * @param condition - The condition to evaluate (property, operator, value)
+ * @param segmentKey - Key of the segment (used for percentage split hashing)
+ * @param context - Evaluation context containing identity, traits, and environment
+ * @returns true if the condition matches
+ */
+export declare function traitsMatchSegmentCondition(condition: SegmentCondition | InSegmentCondition, segmentKey: string, context?: GenericEvaluationContext): boolean;
+/**
+ * Evaluates JSONPath expressions against the evaluation context.
+ *
+ * Supports accessing nested context values using JSONPath syntax.
+ * Commonly used paths:
+ * - $.identity.identifier - User's unique identifier
+ * - $.identity.key - User's internal key
+ * - $.environment.name - Environment name
+ * - $.environment.key - Environment key
+ *
+ * @param jsonPath - JSONPath expression starting with '$.'
+ * @param context - Evaluation context to query against
+ * @returns The resolved value, or undefined if path doesn't exist or is invalid
+ */
+export declare function getContextValue(jsonPath: string, context?: GenericEvaluationContext): any;