feat: use-evaluation-context-generic-with-node-metadata-implementation

Author: Zaimwa9

flagsmith-engine/evaluation/evaluationContext/mappers.ts

@@ -1,5 +1,5 @@
 import {
-    Features,
+    FeaturesWithMetadata,
     Segments,
     Traits,
     EvaluationContext,
@@ -38,7 +38,7 @@ function mapEnvironmentModelToEvaluationContext(environment: EnvironmentModel):
         name: environment.project.name
     };
 
-    const features: Features = {};
+    const features: FeaturesWithMetadata = {};
     for (const fs of environment.featureStates) {
         const variants =
             fs.multivariateFeatureStateValues?.length > 0

flagsmith-engine/evaluation/models.ts

@@ -2,59 +2,44 @@
 // All types from evaluations should be at least imported here and re-exported
 // Do not use types directly from generated files
 
-import type {
-    EnvironmentContext,
-    IdentityContext,
-    SegmentContext,
-    SegmentRule,
-    SegmentCondition,
-    InSegmentCondition,
-    FeatureContext,
-    FeatureValue as ContextFeatureValue,
-    Traits,
-    Features,
-    Segments
-} from './evaluationContext/evaluationContext.types.js';
-
 import type {
     EvaluationResult as EvaluationContextResult,
-    FlagResult as EvaluationContextResultFlagResult,
+    FlagResult,
     Metadata
 } from './evaluationResult/evaluationResult.types.js';
 
-export type EnvironmentKey = EnvironmentContext['key'];
-export type EnvironmentName = EnvironmentContext['name'];
-
-export type IdentityIdentifier = IdentityContext['identifier'];
-export type IdentityKey = IdentityContext['key'];
-
-export type SegmentKey = SegmentContext['key'];
-export type SegmentName = SegmentContext['name'];
-export type SegmentRuleType = SegmentRule['type'];
-export type ConditionOperator = SegmentCondition['operator'] | InSegmentCondition['operator'];
-export type ConditionProperty = SegmentCondition['property'] | InSegmentCondition['property'];
-export type ConditionValue = SegmentCondition['value'] | InSegmentCondition['value'];
-
-export type FeatureKey = FeatureContext['feature_key'];
-export type FeatureName = FeatureContext['name'];
-export type FeatureEnabled = FeatureContext['enabled'];
-export type FeatureValue = FeatureContext['value'];
-export type FeaturePriority = FeatureContext['priority'];
-export type FeatureVariants = FeatureContext['variants'];
-
-export type VariantValue = ContextFeatureValue['value'];
-export type VariantWeight = ContextFeatureValue['weight'];
+import type {
+    EvaluationContext as GeneratedEvaluationContext,
+    FeatureContext as GeneratedFeatureContext
+} from './evaluationContext/evaluationContext.types.js';
 
-export type TraitMap = Traits;
-export type FeatureMap = Features;
-export type SegmentMap = Segments;
+export interface FeatureMetadata extends Metadata {
+    flagsmithId: number;
+}
 
-export type SegmentConditionOperator = SegmentCondition['operator'];
+export interface FeatureContext<T extends Metadata = Metadata> {
+    key: GeneratedFeatureContext['key'];
+    feature_key: GeneratedFeatureContext['feature_key'];
+    name: GeneratedFeatureContext['name'];
+    enabled: GeneratedFeatureContext['enabled'];
+    value: GeneratedFeatureContext['value'];
+    variants?: GeneratedFeatureContext['variants'];
+    priority?: GeneratedFeatureContext['priority'];
+    metadata?: T;
+    [k: string]: unknown;
+}
 
-export type EvaluationReason = EvaluationContextResultFlagResult['reason'];
+export type FeaturesWithMetadata<T extends Metadata = Metadata> = {
+    [k: string]: FeatureContext<T>;
+};
 
-export type EvaluationResultSegments = EvaluationContextResult['segments'];
-import type { FlagResult } from './evaluationResult/evaluationResult.types.js';
+export interface EvaluationContext<T extends Metadata = Metadata> {
+    environment: GeneratedEvaluationContext['environment'];
+    identity?: GeneratedEvaluationContext['identity'];
+    segments?: GeneratedEvaluationContext['segments'];
+    features?: FeaturesWithMetadata<T>;
+    [k: string]: unknown;
+}
 
 export type FlagResultWithMetadata<T extends Metadata = Metadata> = FlagResult & {
     metadata?: T;
@@ -65,11 +50,16 @@ export type EvaluationResultFlags<T extends Metadata = Metadata> = Record<
     FlagResultWithMetadata<T>
 >;
 
-export type EvaluationResult = {
-    flags: EvaluationResultFlags;
+export type EvaluationResultSegments = EvaluationContextResult['segments'];
+
+export type EvaluationResult<T extends Metadata = Metadata> = {
+    flags: EvaluationResultFlags<T>;
     segments: EvaluationResultSegments;
 };
 
+export type EvaluationResultWithMetadata = EvaluationResult<FeatureMetadata>;
+export type EvaluationContextWithMetadata = EvaluationContext<FeatureMetadata>;
+
 export enum SegmentSource {
     API = 'api',
     IDENTITY_OVERRIDE = 'identity_override'

flagsmith-engine/index.ts

@@ -1,6 +1,12 @@
-import { EvaluationContext, FeatureContext, SegmentSource } from './evaluation/models.js';
+import {
+    EvaluationContextWithMetadata,
+    EvaluationResultSegments,
+    EvaluationResultWithMetadata,
+    FeatureContext,
+    FeatureMetadata
+} from './evaluation/models.js';
 import { getIdentitySegments } from './segments/evaluators.js';
-import { EvaluationResult, EvaluationResultFlags } from './evaluation/models.js';
+import { EvaluationResultFlags } from './evaluation/models.js';
 import { TARGETING_REASONS } from './features/types.js';
 import { getHashedPercentageForObjIds } from './utils/hashing/index.js';
 export { EnvironmentModel } from './environments/models.js';
@@ -11,7 +17,7 @@ export { FeatureModel, FeatureStateModel } from './features/models.js';
 export { OrganisationModel } from './organisations/models.js';
 
 type SegmentOverride = {
-    feature: FeatureContext;
+    feature: FeatureContext<FeatureMetadata>;
     segmentName: string;
 };
 
@@ -27,7 +33,9 @@ export type SegmentOverrides = Record<string, SegmentOverride>;
  * @param context - EvaluationContext containing environment, identity, and segment data
  * @returns EvaluationResult with flags, segments, and original context
  */
-export function getEvaluationResult(context: EvaluationContext): EvaluationResult {
+export function getEvaluationResult(
+    context: EvaluationContextWithMetadata
+): EvaluationResultWithMetadata {
     const { segments, segmentOverrides } = evaluateSegments(context);
     const flags = evaluateFeatures(context, segmentOverrides);
 
@@ -40,12 +48,15 @@ export function getEvaluationResult(context: EvaluationContext): EvaluationResul
  * @param context - EvaluationContext containing identity and segment definitions
  * @returns Object containing segments the identity belongs to and any feature overrides
  */
-export function evaluateSegments(context: EvaluationContext): {
-    segments: EvaluationResult['segments'];
+export function evaluateSegments(context: EvaluationContextWithMetadata): {
+    segments: EvaluationResultSegments;
     segmentOverrides: Record<string, SegmentOverride>;
 } {
     if (!context.identity || !context.segments) {
-        return { segments: [], segmentOverrides: {} };
+        return {
+            segments: [],
+            segmentOverrides: {} as Record<string, SegmentOverride>
+        };
     }
     const identitySegments = getIdentitySegments(context);
 
@@ -108,10 +119,10 @@ export function processSegmentOverrides(identitySegments: any[]): Record<string,
  * @returns EvaluationResultFlags containing evaluated flag results
  */
 export function evaluateFeatures(
-    context: EvaluationContext,
+    context: EvaluationContextWithMetadata,
     segmentOverrides: Record<string, SegmentOverride>
-): EvaluationResultFlags {
-    const flags: EvaluationResultFlags = {};
+): EvaluationResultFlags<FeatureMetadata> {
+    const flags: EvaluationResultFlags<FeatureMetadata> = {};
 
     for (const feature of Object.values(context.features || {})) {
         const segmentOverride = segmentOverrides[feature.feature_key];

sdk/models.ts

@@ -1,4 +1,8 @@
-import { EvaluationResult, FlagResultWithMetadata } from '../flagsmith-engine/evaluation/models.js';
+import {
+    EvaluationResult,
+    FeatureMetadata,
+    FlagResultWithMetadata
+} from '../flagsmith-engine/evaluation/models.js';
 import { FeatureStateModel } from '../flagsmith-engine/features/models.js';
 import { AnalyticsProcessor } from './analytics.js';
 
@@ -81,11 +85,11 @@ export class Flag extends BaseFlag {
         });
     }
 
-    static fromFlagResult(flagResult: FlagResultWithMetadata<{ flagsmithId?: number }>): Flag {
+    static fromFlagResult(flagResult: FlagResultWithMetadata<FeatureMetadata>): Flag {
         return new Flag({
             enabled: flagResult.enabled,
             value: flagResult.value ?? null,
-            featureId: flagResult.metadata?.flagsmithId || Number(flagResult.feature_key),
+            featureId: flagResult.metadata?.flagsmithId ?? Number(flagResult.feature_key),
             featureName: flagResult.name,
             reason: flagResult.reason
         });

tests/engine/e2e/engine.test.ts

@@ -5,7 +5,10 @@ import { getEvaluationResult } from '../../../flagsmith-engine/index.js';
 import { Flags } from '../../../sdk/models.js';
 import { EvaluationContext } from '../../../flagsmith-engine/evaluation/evaluationContext/evaluationContext.types.js';
 import { parse as parseJsonc } from 'jsonc-parser';
-import { EvaluationResult } from '../../../flagsmith-engine/evaluation/models.js';
+import {
+    EvaluationContextWithMetadata,
+    EvaluationResult
+} from '../../../flagsmith-engine/evaluation/models.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -39,7 +42,9 @@ describe('Engine Integration Tests', () => {
 
         test(testName, () => {
             const testCase = loadTestFile(filePath);
-            const engine_response = getEvaluationResult(testCase.context);
+            const engine_response = getEvaluationResult(
+                testCase.context as EvaluationContextWithMetadata
+            );
             expect(engine_response).toStrictEqual(testCase.result);
         });
     });