flagsmith-nodejs 6.2.0 → 7.0.2

package/.github/workflows/publish.yml

@@ -5,6 +5,10 @@ on:
     tags:
       - '*'
 
+permissions:
+  id-token: write # Required for OIDC
+  contents: read
+
 jobs:
   package:
     runs-on: ubuntu-latest
@@ -12,14 +16,13 @@ jobs:
 
     steps:
       - name: Cloning repo
-        uses: actions/checkout@v3
+        uses: actions/checkout@v5
 
-      - uses: actions/setup-node@v4
+      - uses: actions/setup-node@v5
         with:
-          node-version: '18.x'
+          node-version-file: .nvmrc
           registry-url: 'https://registry.npmjs.org'
 
+      - run: npm install -g npm@latest
       - run: npm ci
       - run: npm run deploy
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/.github/workflows/pull_request.yaml

@@ -35,3 +35,6 @@ jobs:
       - run: npm test
         env:
           CI: true
+      - run: npm run test:esm-build
+        env:
+          CI: true

package/.gitmodules

@@ -1,4 +1,4 @@
 [submodule "tests/engine/engine-tests/engine-test-data"]
 	path = tests/engine/engine-tests/engine-test-data
 	url = git@github.com:Flagsmith/engine-test-data.git
-	branch = v1.0.0
+	branch = v3.5.0

package/.husky/pre-commit

@@ -1,6 +1,7 @@
 #!/bin/sh
 . "$(dirname "$0")/_/husky.sh"
 
+npm run generate-engine-types
 npm run lint
 git add ./flagsmith-engine ./sdk ./tests ./index.ts ./.github
 npm run test

package/.nvmrc

@@ -0,0 +1 @@
+24

package/.release-please-manifest.json

@@ -1 +1 @@
-{".":"6.2.0"}
+{".":"7.0.2"}

package/CHANGELOG.md

@@ -1,5 +1,45 @@
 # Changelog
 
+## [7.0.2](https://github.com/Flagsmith/flagsmith-nodejs-client/compare/v7.0.1...v7.0.2) (2025-12-02)
+
+
+### CI
+
+* use-nvmrc-for-version ([#236](https://github.com/Flagsmith/flagsmith-nodejs-client/issues/236)) ([a56f073](https://github.com/Flagsmith/flagsmith-nodejs-client/commit/a56f0736f6c31d3c273932ede8204710de7cf853))
+
+## [7.0.1](https://github.com/Flagsmith/flagsmith-nodejs-client/compare/v7.0.0...v7.0.1) (2025-12-02)
+
+
+### CI
+
+* use-latest-npm ([#234](https://github.com/Flagsmith/flagsmith-nodejs-client/issues/234)) ([6a741f3](https://github.com/Flagsmith/flagsmith-nodejs-client/commit/6a741f3b12af3bea31150561dee1e6f7c7045e56))
+
+## [7.0.0](https://github.com/Flagsmith/flagsmith-nodejs-client/compare/v6.2.0...v7.0.0) (2025-12-02)
+
+
+### ⚠ BREAKING CHANGES
+
+* implement context values ([#203](https://github.com/Flagsmith/flagsmith-nodejs-client/issues/203))
+
+### Features
+
+* implement context values ([#203](https://github.com/Flagsmith/flagsmith-nodejs-client/issues/203)) ([41258f2](https://github.com/Flagsmith/flagsmith-nodejs-client/commit/41258f2e24ef7e89207a0f10116ffbd1229c0a30))
+* removed-feature-key-and-segment-key-from-schema ([#210](https://github.com/Flagsmith/flagsmith-nodejs-client/issues/210)) ([014f38b](https://github.com/Flagsmith/flagsmith-nodejs-client/commit/014f38bf33af77fb706e4e130e8a571914632408))
+
+
+### Bug Fixes
+
+* exclude-identities-when-traits-is-undefined ([#230](https://github.com/Flagsmith/flagsmith-nodejs-client/issues/230)) ([f7488e1](https://github.com/Flagsmith/flagsmith-nodejs-client/commit/f7488e17fe524111dd18c06a30be1c44ae15ec5d))
+* fix-mv-evaluation ([#222](https://github.com/Flagsmith/flagsmith-nodejs-client/issues/222)) ([ae1fb7e](https://github.com/Flagsmith/flagsmith-nodejs-client/commit/ae1fb7eb0551defd0823c94d37b860be7eb88a5d))
+* properly-map-environment-name ([#226](https://github.com/Flagsmith/flagsmith-nodejs-client/issues/226)) ([3c1d200](https://github.com/Flagsmith/flagsmith-nodejs-client/commit/3c1d200e656ec9926fdc6d4627bb259963d06a2e))
+* removed-dango-id-usage-in-mapper ([#229](https://github.com/Flagsmith/flagsmith-nodejs-client/issues/229)) ([29c7613](https://github.com/Flagsmith/flagsmith-nodejs-client/commit/29c761370a7e8d6d733a45293c60297843e7e1e7))
+* use-default-on-jsonpath-import ([#231](https://github.com/Flagsmith/flagsmith-nodejs-client/issues/231)) ([7a8d949](https://github.com/Flagsmith/flagsmith-nodejs-client/commit/7a8d9498fbc0297c881b3f32fc8d0d024fe8366f))
+
+
+### CI
+
+* use NPM trusted publishing ([#217](https://github.com/Flagsmith/flagsmith-nodejs-client/issues/217)) ([7d01563](https://github.com/Flagsmith/flagsmith-nodejs-client/commit/7d015635f4bc41246519799dddaea7ff8da2c50a))
+
 ## [6.2.0](https://github.com/Flagsmith/flagsmith-nodejs-client/compare/v6.1.0...v6.2.0) (2025-11-04)
 
 

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

@@ -18,5 +18,6 @@ export declare class EnvironmentModel {
     project: ProjectModel;
     featureStates: FeatureStateModel[];
     identityOverrides: IdentityModel[];
-    constructor(id: number, apiKey: string, project: ProjectModel);
+    name: string;
+    constructor(id: number, apiKey: string, project: ProjectModel, name: string);
 }

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

@@ -28,10 +28,12 @@ class EnvironmentModel {
     project;
     featureStates = [];
     identityOverrides = [];
-    constructor(id, apiKey, project) {
+    name;
+    constructor(id, apiKey, project, name) {
         this.id = id;
         this.apiKey = apiKey;
         this.project = project;
+        this.name = name;
     }
 }
 exports.EnvironmentModel = EnvironmentModel;

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

@@ -8,7 +8,7 @@ const models_js_1 = require("./models.js");
 function buildEnvironmentModel(environmentJSON) {
     const project = (0, util_js_3.buildProjectModel)(environmentJSON.project);
     const featureStates = environmentJSON.feature_states.map((fs) => (0, util_js_1.buildFeatureStateModel)(fs));
-    const environmentModel = new models_js_1.EnvironmentModel(environmentJSON.id, environmentJSON.api_key, project);
+    const environmentModel = new models_js_1.EnvironmentModel(environmentJSON.id, environmentJSON.api_key, project, environmentJSON.name);
     environmentModel.featureStates = featureStates;
     if (!!environmentJSON.identity_overrides) {
         environmentModel.identityOverrides = environmentJSON.identity_overrides.map((identityData) => (0, util_js_2.buildIdentityModel)(identityData));

package/build/cjs/flagsmith-engine/evaluation/evaluationContext/evaluationContext.types.d.ts

@@ -0,0 +1,230 @@
+/**
+ * This file was automatically generated by json-schema-to-typescript.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and run json-schema-to-typescript to regenerate this file.
+ */
+/**
+ * Unique environment key. May be used for selecting a value for a multivariate feature, or for % split segmentation.
+ */
+export type Key = string;
+/**
+ * An environment's human-readable name.
+ */
+export type Name = string;
+/**
+ * A unique identifier for an identity as displayed in the Flagsmith UI.
+ */
+export type Identifier = string;
+/**
+ * Key used when selecting a value for a multivariate feature, or for % split segmentation. Set to an internal identifier or a composite value based on the environment key and identifier, depending on Flagsmith implementation.
+ */
+export type Key1 = string;
+/**
+ * Unique segment key used for % split segmentation.
+ */
+export type Key2 = string;
+/**
+ * The name of the segment.
+ */
+export type Name1 = string;
+/**
+ * Segment rule type. Represents a logical quantifier for the conditions and sub-rules.
+ */
+export type Type = 'ALL' | 'ANY' | 'NONE';
+export type SegmentCondition = SegmentCondition1 | InSegmentCondition;
+/**
+ * A reference to the identity trait or value in the evaluation context.
+ */
+export type Property = string;
+/**
+ * The operator to use for evaluating the condition.
+ */
+export type Operator = 'EQUAL' | 'GREATER_THAN' | 'LESS_THAN' | 'LESS_THAN_INCLUSIVE' | 'CONTAINS' | 'GREATER_THAN_INCLUSIVE' | 'NOT_CONTAINS' | 'NOT_EQUAL' | 'REGEX' | 'PERCENTAGE_SPLIT' | 'MODULO' | 'IS_SET' | 'IS_NOT_SET' | 'IN';
+/**
+ * The value to compare against the trait or context value.
+ */
+export type Value = string;
+/**
+ * A reference to the identity trait or value in the evaluation context.
+ */
+export type Property1 = string;
+/**
+ * The operator to use for evaluating the condition.
+ */
+export type Operator1 = 'IN';
+/**
+ * The values to compare against the trait or context value.
+ */
+export type Value1 = string[];
+/**
+ * Conditions that must be met for the rule to apply.
+ */
+export type Conditions = SegmentCondition[];
+/**
+ * Sub-rules nested within the segment rule.
+ */
+export type SubRules = SegmentRule[];
+/**
+ * Rules that define the segment.
+ */
+export type Rules = SegmentRule[];
+/**
+ * Unique feature key used when selecting a variant if the feature is multivariate. Set to an internal identifier or a UUID, depending on Flagsmith implementation.
+ */
+export type Key3 = string;
+/**
+ * Feature name.
+ */
+export type Name2 = string;
+/**
+ * Indicates whether the feature is enabled in the environment.
+ */
+export type Enabled = boolean;
+/**
+ * A default environment value for the feature. If the feature is multivariate, this will be the control value.
+ */
+export type Value2 = string | number | boolean | null;
+/**
+ * The value of the feature.
+ */
+export type Value3 = string | number | boolean | null;
+/**
+ * The weight of the feature value variant, as a percentage number (i.e. 100.0).
+ */
+export type Weight = number;
+/**
+ * Priority of the feature flag variant. Lower values indicate a higher priority when multiple variants apply to the same context key.
+ */
+export type VariantPriority = number;
+/**
+ * An array of environment default values associated with the feature. Empty for standard features, or contains multiple values for multivariate features.
+ */
+export type Variants = FeatureValue[];
+/**
+ * Priority of the feature context. Lower values indicate a higher priority when multiple contexts apply to the same feature.
+ */
+export type FeaturePriority = number;
+/**
+ * Feature overrides for the segment.
+ */
+export type Overrides = FeatureContext[];
+/**
+ * A context object containing the necessary information to evaluate Flagsmith feature flags.
+ */
+export interface EvaluationContext {
+    environment: EnvironmentContext;
+    /**
+     * Identity context used for identity-based evaluation.
+     */
+    identity?: IdentityContext | null;
+    segments?: Segments;
+    features?: Features;
+    [k: string]: unknown;
+}
+/**
+ * Environment context required for evaluation.
+ */
+export interface EnvironmentContext {
+    key: Key;
+    name: Name;
+    [k: string]: unknown;
+}
+/**
+ * Represents an identity context for feature flag evaluation.
+ */
+export interface IdentityContext {
+    identifier: Identifier;
+    key?: Key1;
+    traits?: Traits;
+    [k: string]: unknown;
+}
+/**
+ * A map of traits associated with the identity, where the key is the trait name and the value is the trait value.
+ */
+export interface Traits {
+    [k: string]: string | number | boolean | null;
+}
+/**
+ * Segments applicable to the evaluation context.
+ */
+export interface Segments {
+    [k: string]: SegmentContext;
+}
+/**
+ * Represents a segment context for feature flag evaluation.
+ */
+export interface SegmentContext {
+    key: Key2;
+    name: Name1;
+    rules: Rules;
+    overrides?: Overrides;
+    metadata?: SegmentMetadata;
+    [k: string]: unknown;
+}
+/**
+ * Represents a rule within a segment for feature flag evaluation.
+ */
+export interface SegmentRule {
+    type: Type;
+    conditions?: Conditions;
+    rules?: SubRules;
+    [k: string]: unknown;
+}
+/**
+ * Represents a condition within a segment rule for feature flag evaluation.
+ */
+export interface SegmentCondition1 {
+    property: Property;
+    operator: Operator;
+    value: Value;
+    [k: string]: unknown;
+}
+/**
+ * Represents an IN condition within a segment rule for feature flag evaluation.
+ */
+export interface InSegmentCondition {
+    property: Property1;
+    operator: Operator1;
+    value: Value1;
+    [k: string]: unknown;
+}
+/**
+ * Represents a feature context for feature flag evaluation.
+ */
+export interface FeatureContext {
+    key: Key3;
+    name: Name2;
+    enabled: Enabled;
+    value: Value2;
+    variants?: Variants;
+    priority?: FeaturePriority;
+    metadata?: FeatureMetadata;
+    [k: string]: unknown;
+}
+/**
+ * Represents a multivariate value for a feature flag.
+ */
+export interface FeatureValue {
+    value: Value3;
+    weight: Weight;
+    priority: VariantPriority;
+    [k: string]: unknown;
+}
+/**
+ * Additional metadata associated with the feature.
+ */
+export interface FeatureMetadata {
+    [k: string]: unknown;
+}
+/**
+ * Additional metadata associated with the segment.
+ */
+export interface SegmentMetadata {
+    [k: string]: unknown;
+}
+/**
+ * Features to be evaluated in the context.
+ */
+export interface Features {
+    [k: string]: FeatureContext;
+}

package/build/cjs/flagsmith-engine/evaluation/evaluationContext/evaluationContext.types.js

@@ -0,0 +1,8 @@
+"use strict";
+/* eslint-disable */
+/**
+ * This file was automatically generated by json-schema-to-typescript.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and run json-schema-to-typescript to regenerate this file.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/cjs/flagsmith-engine/evaluation/evaluationContext/mappers.d.ts

@@ -0,0 +1,5 @@
+import { GenericEvaluationContext } from '../models.js';
+import { EnvironmentModel } from '../../environments/models.js';
+import { IdentityModel } from '../../identities/models.js';
+import { TraitModel } from '../../identities/traits/models.js';
+export declare function getEvaluationContext(environment: EnvironmentModel, identity?: IdentityModel, overrideTraits?: TraitModel[], isEnvironmentEvaluation?: boolean): GenericEvaluationContext;

package/build/cjs/flagsmith-engine/evaluation/evaluationContext/mappers.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEvaluationContext = void 0;
+const models_js_1 = require("../models.js");
+const constants_js_1 = require("../../segments/constants.js");
+const node_crypto_1 = require("node:crypto");
+const util_js_1 = require("../../features/util.js");
+function getEvaluationContext(environment, identity, overrideTraits, isEnvironmentEvaluation = false) {
+    const environmentContext = mapEnvironmentModelToEvaluationContext(environment);
+    if (isEnvironmentEvaluation) {
+        return environmentContext;
+    }
+    const identityContext = identity
+        ? mapIdentityModelToIdentityContext(identity, overrideTraits)
+        : undefined;
+    const context = {
+        ...environmentContext,
+        ...(identityContext && { identity: identityContext })
+    };
+    return context;
+}
+exports.getEvaluationContext = getEvaluationContext;
+function mapEnvironmentModelToEvaluationContext(environment) {
+    const environmentContext = {
+        key: environment.apiKey,
+        name: environment.name
+    };
+    const features = {};
+    for (const fs of environment.featureStates) {
+        const variants = fs.multivariateFeatureStateValues?.length > 0
+            ? fs.multivariateFeatureStateValues.map(mv => ({
+                value: mv.multivariateFeatureOption.value,
+                weight: mv.percentageAllocation,
+                priority: mv.id ?? (0, util_js_1.uuidToBigInt)(mv.mvFsValueUuid)
+            }))
+            : undefined;
+        features[fs.feature.name] = {
+            key: fs.djangoID?.toString() || fs.featurestateUUID,
+            name: fs.feature.name,
+            enabled: fs.enabled,
+            value: fs.getValue(),
+            variants,
+            priority: fs.featureSegment?.priority,
+            metadata: {
+                id: fs.feature.id
+            }
+        };
+    }
+    const segmentOverrides = {};
+    for (const segment of environment.project.segments) {
+        segmentOverrides[segment.id.toString()] = {
+            key: segment.id.toString(),
+            name: segment.name,
+            rules: segment.rules.map(rule => mapSegmentRuleModelToRule(rule)),
+            overrides: segment.featureStates.length > 0
+                ? segment.featureStates.map(fs => ({
+                    key: fs.djangoID?.toString() || fs.featurestateUUID,
+                    name: fs.feature.name,
+                    enabled: fs.enabled,
+                    value: fs.getValue(),
+                    priority: fs.featureSegment?.priority,
+                    metadata: {
+                        id: fs.feature.id
+                    }
+                }))
+                : [],
+            metadata: {
+                source: models_js_1.SegmentSource.API,
+                id: segment.id
+            }
+        };
+    }
+    let identityOverrideSegments = {};
+    if (environment.identityOverrides && environment.identityOverrides.length > 0) {
+        identityOverrideSegments = mapIdentityOverridesToSegments(environment.identityOverrides);
+    }
+    return {
+        environment: environmentContext,
+        features,
+        segments: {
+            ...segmentOverrides,
+            ...identityOverrideSegments
+        }
+    };
+}
+function mapIdentityModelToIdentityContext(identity, overrideTraits) {
+    const traits = overrideTraits || identity.identityTraits;
+    const traitsContext = {};
+    for (const trait of traits) {
+        traitsContext[trait.traitKey] = trait.traitValue;
+    }
+    const identityContext = {
+        identifier: identity.identifier,
+        traits: traitsContext
+    };
+    return identityContext;
+}
+function mapSegmentRuleModelToRule(rule) {
+    return {
+        type: rule.type,
+        conditions: rule.conditions.map((condition) => ({
+            property: condition.property,
+            operator: condition.operator,
+            value: condition.value
+        })),
+        rules: rule.rules.map((subRule) => mapSegmentRuleModelToRule(subRule))
+    };
+}
+function mapIdentityOverridesToSegments(identityOverrides) {
+    const segments = {};
+    const featuresToIdentifiers = new Map();
+    for (const identity of identityOverrides) {
+        if (!identity.identityFeatures || identity.identityFeatures.length === 0) {
+            continue;
+        }
+        const sortedFeatures = [...identity.identityFeatures].sort((a, b) => a.feature.name.localeCompare(b.feature.name));
+        const overridesKey = sortedFeatures.map(fs => ({
+            name: fs.feature.name,
+            enabled: fs.enabled,
+            value: fs.getValue(),
+            priority: -Infinity,
+            metadata: {
+                id: fs.feature.id
+            }
+        }));
+        const overridesHash = (0, node_crypto_1.createHash)('sha1').update(JSON.stringify(overridesKey)).digest('hex');
+        if (!featuresToIdentifiers.has(overridesHash)) {
+            featuresToIdentifiers.set(overridesHash, { identifiers: [], overrides: overridesKey });
+        }
+        featuresToIdentifiers.get(overridesHash).identifiers.push(identity.identifier);
+    }
+    for (const [overrideHash, { identifiers, overrides }] of featuresToIdentifiers.entries()) {
+        const segmentKey = `identity_override_${overrideHash}`;
+        segments[segmentKey] = {
+            key: segmentKey,
+            name: constants_js_1.IDENTITY_OVERRIDE_SEGMENT_NAME,
+            rules: [
+                {
+                    type: 'ALL',
+                    conditions: [
+                        {
+                            property: '$.identity.identifier',
+                            operator: 'IN',
+                            value: identifiers.join(',')
+                        }
+                    ]
+                }
+            ],
+            metadata: {
+                source: models_js_1.SegmentSource.IDENTITY_OVERRIDE
+            },
+            overrides: overrides
+        };
+    }
+    return segments;
+}