flagsmith-nodejs 1.1.0 → 2.0.0-beta.2

package/flagsmith-engine/segments/evaluators.ts

@@ -0,0 +1,72 @@
+import { EnvironmentModel } from '../environments/models';
+import { IdentityModel } from '../identities/models';
+import { TraitModel } from '../identities/traits/models';
+import { getHashedPercentateForObjIds } from '../utils/hashing';
+import { PERCENTAGE_SPLIT } from './constants';
+import { SegmentConditionModel, SegmentModel, SegmentRuleModel } from './models';
+
+export function getIdentitySegments(
+    environment: EnvironmentModel,
+    identity: IdentityModel,
+    overrideTraits?: TraitModel[]
+): SegmentModel[] {
+    return environment.project.segments.filter(segment =>
+        evaluateIdentityInSegment(identity, segment, overrideTraits)
+    );
+}
+
+export function evaluateIdentityInSegment(
+    identity: IdentityModel,
+    segment: SegmentModel,
+    overrideTraits?: TraitModel[]
+): boolean {
+    return (
+        segment.rules.length > 0 &&
+        segment.rules.filter(rule =>
+            traitsMatchSegmentRule(
+                overrideTraits || identity.identityTraits,
+                rule,
+                segment.id,
+                identity.compositeKey
+            )
+        ).length === segment.rules.length
+    );
+}
+
+function traitsMatchSegmentRule(
+    identityTraits: TraitModel[],
+    rule: SegmentRuleModel,
+    segmentId: number | string,
+    identityId: number | string
+): boolean {
+    const matchesConditions =
+        rule.conditions.length > 0
+            ? rule.matchingFunction()(
+                  rule.conditions.map(condition =>
+                      traitsMatchSegmentCondition(identityTraits, condition, segmentId, identityId)
+                  )
+              )
+            : true;
+    return (
+        matchesConditions &&
+        rule.rules.filter(rule =>
+            traitsMatchSegmentRule(identityTraits, rule, segmentId, identityId)
+        ).length === rule.rules.length
+    );
+}
+
+function traitsMatchSegmentCondition(
+    identityTraits: TraitModel[],
+    condition: SegmentConditionModel,
+    segmentId: number | string,
+    identityId: number | string
+): boolean {
+    if (condition.operator == PERCENTAGE_SPLIT) {
+        return getHashedPercentateForObjIds([segmentId, identityId]) <= parseFloat(condition.value);
+    }
+
+    const traits = identityTraits.filter(t => t.traitKey === condition.property_);
+    const trait = traits.length > 0 ? traits[0] : undefined;
+
+    return trait ? condition.matchesTraitValue(trait.traitValue) : false;
+}

package/flagsmith-engine/segments/models.ts

@@ -0,0 +1,103 @@
+import { FeatureStateModel } from '../features/models';
+import { getCastingFunction as getCastingFunction } from '../utils';
+import {
+    ALL_RULE,
+    ANY_RULE,
+    NONE_RULE,
+    NOT_CONTAINS,
+    REGEX,
+    CONDITION_OPERATORS
+} from './constants';
+
+export const all = (iterable: Array<any>) => iterable.filter(e => !!e).length === iterable.length;
+export const any = (iterable: Array<any>) => iterable.filter(e => !!e).length > 0;
+
+export const matchingFunctions = {
+    [CONDITION_OPERATORS.EQUAL]: (thisValue: any, otherValue: any) => thisValue == otherValue,
+    [CONDITION_OPERATORS.GREATER_THAN]: (thisValue: any, otherValue: any) => otherValue > thisValue,
+    [CONDITION_OPERATORS.GREATER_THAN_INCLUSIVE]: (thisValue: any, otherValue: any) =>
+        otherValue >= thisValue,
+    [CONDITION_OPERATORS.LESS_THAN]: (thisValue: any, otherValue: any) => thisValue > otherValue,
+    [CONDITION_OPERATORS.LESS_THAN_INCLUSIVE]: (thisValue: any, otherValue: any) =>
+        thisValue >= otherValue,
+    [CONDITION_OPERATORS.NOT_EQUAL]: (thisValue: any, otherValue: any) => thisValue != otherValue,
+    [CONDITION_OPERATORS.CONTAINS]: (thisValue: any, otherValue: any) =>
+        otherValue.includes(thisValue),
+    [CONDITION_OPERATORS.NOT_CONTAINS]: (thisValue: any, otherValue: any) =>
+        !otherValue.includes(thisValue)
+};
+
+export class SegmentConditionModel {
+    EXCEPTION_OPERATOR_METHODS: { [key: string]: string } = {
+        [NOT_CONTAINS]: 'evaluateNotContains',
+        [REGEX]: 'evaluateRegex'
+    };
+
+    operator: string;
+    value: string;
+    property_: string | undefined;
+
+    constructor(operator: string, value: string, property?: string) {
+        this.operator = operator;
+        this.value = value;
+        this.property_ = property;
+    }
+
+    matchesTraitValue(traitValue: any) {
+        const evaluators: { [key: string]: CallableFunction } = {
+            evaluateNotContains: (traitValue: any) => {
+                return !traitValue.includes(this.value);
+            },
+            evaluateRegex: (traitValue: any) => {
+                return !!traitValue.match(new RegExp(this.value));
+            }
+        };
+
+        // 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: any, y: any) => false;
+
+        const matchingFunction = matchingFunctions[this.operator] || defaultFunction;
+
+        const castToTypeOfTraitValue = getCastingFunction(traitValue);
+        return matchingFunction(castToTypeOfTraitValue(this.value), traitValue);
+    }
+}
+
+export class SegmentRuleModel {
+    type: string;
+    rules: SegmentRuleModel[] = [];
+    conditions: SegmentConditionModel[] = [];
+
+    constructor(type: string) {
+        this.type = type;
+    }
+
+    static none(iterable: Array<any>) {
+        return iterable.filter(e => !!e).length === 0;
+    }
+
+    matchingFunction(): CallableFunction {
+        return {
+            [ANY_RULE]: any,
+            [ALL_RULE]: all,
+            [NONE_RULE]: SegmentRuleModel.none
+        }[this.type] as CallableFunction;
+    }
+}
+
+export class SegmentModel {
+    id: number;
+    name: string;
+    rules: SegmentRuleModel[] = [];
+    featureStates: FeatureStateModel[] = [];
+
+    constructor(id: number, name: string) {
+        this.id = id;
+        this.name = name;
+    }
+}

package/flagsmith-engine/segments/util.ts

@@ -0,0 +1,29 @@
+import { buildFeatureStateModel } from '../features/util';
+import { SegmentConditionModel, SegmentModel, SegmentRuleModel } from './models';
+
+export function buildSegmentConditionModel(segmentConditionJSON: any): SegmentConditionModel {
+    return new SegmentConditionModel(
+        segmentConditionJSON.operator,
+        segmentConditionJSON.value,
+        segmentConditionJSON.property_
+    );
+}
+
+export function buildSegmentRuleModel(ruleModelJSON: any): SegmentRuleModel {
+    const ruleModel = new SegmentRuleModel(ruleModelJSON.type);
+
+    ruleModel.rules = ruleModelJSON.rules.map((r: any) => buildSegmentRuleModel(r));
+    ruleModel.conditions = ruleModelJSON.conditions.map((c: any) => buildSegmentConditionModel(c));
+    return ruleModel;
+}
+
+export function buildSegmentModel(segmentModelJSON: any): SegmentModel {
+    const model = new SegmentModel(segmentModelJSON.id, segmentModelJSON.name);
+
+    model.featureStates = segmentModelJSON['feature_states'].map((fs: any) =>
+        buildFeatureStateModel(fs)
+    );
+    model.rules = segmentModelJSON['rules'].map((r: any) => buildSegmentRuleModel(r));
+
+    return model;
+}

package/flagsmith-engine/utils/collections.ts

@@ -0,0 +1,14 @@
+import { FeatureStateModel } from '../features/models';
+
+export class IdentityFeaturesList extends Array<FeatureStateModel> {
+    public push(...e: FeatureStateModel[]): number {
+        for (const [_, item] of e.entries()) {
+            for (const [k, v] of this.entries()) {
+                if (v.djangoID === item.djangoID) {
+                    throw new Error('feature state for this feature already exists');
+                }
+            }
+        }
+        return super.push(...e);
+    }
+}

package/flagsmith-engine/utils/errors.ts

@@ -0,0 +1 @@
+export class FeatureStateNotFound extends Error {}

package/flagsmith-engine/utils/hashing/index.ts

@@ -0,0 +1,52 @@
+import md5 from 'md5';
+import bigInt from 'big-integer';
+
+const makeRepeated = (arr: Array<any>, repeats: number) =>
+    Array.from({ length: repeats }, () => arr).flat();
+
+// https://stackoverflow.com/questions/12532871/how-to-convert-a-very-large-hex-number-to-decimal-in-javascript
+function h2d(s: any): string {
+    function add(x: any, y: any) {
+        var c = 0,
+            r = [];
+        var x = x.split('').map(Number);
+        var y = y.split('').map(Number);
+        while (x.length || y.length) {
+            var s = (x.pop() || 0) + (y.pop() || 0) + c;
+            r.unshift(s < 10 ? s : s - 10);
+            c = s < 10 ? 0 : 1;
+        }
+        if (c) r.unshift(c);
+        return r.join('');
+    }
+
+    var dec = '0';
+    s.split('').forEach(function (chr: any) {
+        var n = parseInt(chr, 16);
+        for (var t = 8; t; t >>= 1) {
+            dec = add(dec, dec);
+            if (n & t) dec = add(dec, '1');
+        }
+    });
+    return dec;
+}
+/**
+ * Given a list of object ids, get a floating point number between 0 and 1 based on
+ * the hash of those ids. This should give the same value every time for any list of ids.
+ *
+ * @param  {Array<any>} objectIds list of object ids to calculate the has for
+ * @param  {} iterations=1 num times to include each id in the generated string to hash
+ * @returns number number between 0 (inclusive) and 100 (exclusive)
+ */
+export function getHashedPercentateForObjIds(objectIds: Array<any>, iterations = 1): number {
+    let to_hash = makeRepeated(objectIds, iterations).join(',');
+    const hashedValue = md5(to_hash);
+    const hashedInt = bigInt(h2d(hashedValue));
+    const value = (hashedInt.mod(9999).toJSNumber() / 9998) * 100;
+
+    if (value === 100) {
+        return getHashedPercentateForObjIds(objectIds, iterations + 1);
+    }
+
+    return value;
+}

package/flagsmith-engine/utils/index.ts

@@ -0,0 +1,10 @@
+export function getCastingFunction(input: any): CallableFunction {
+    switch (typeof input) {
+        case 'boolean':
+            return (x: any) => !['False', 'false'].includes(x);
+        case 'number':
+            return (x: any) => parseFloat(x);
+        default:
+            return (x: any) => String(x);
+    }
+}

package/index.ts

@@ -0,0 +1,6 @@
+import Flagsmith from './sdk';
+
+export { Flagsmith } from './sdk';
+// export default Flagsmith;
+
+module.exports = Flagsmith;

package/jest.config.js

@@ -0,0 +1,5 @@
+/** @type {import('ts-jest/dist/types').InitialOptionsTsJest} */
+module.exports = {
+    preset: 'ts-jest',
+    testEnvironment: 'node'
+};

package/package.json

@@ -1,24 +1,25 @@
 {
   "name": "flagsmith-nodejs",
-  "version": "1.1.0",
+  "version": "2.0.0-beta.2",
   "description": "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.",
-  "main": "index.js",
+  "main": "build/index.js",
   "repository": {
     "type": "git",
-    "url": "https://github.com/SolidStateGroup/bullet-train-nodejs-client"
+    "url": "https://github.com/Flagsmith/flagsmith-nodejs-client"
   },
   "keywords": [
     "nodejs",
-    "bullet train",
     "flagsmith",
-    "feature flagger",
+    "feature flags",
+    "feature toggles",
+    "remote configuration",
     "continuous deployment"
   ],
   "bugs": {
-    "url": "https://github.com/SolidStateGroup/bullet-train-nodejs-client/issues"
+    "url": "https://github.com/Flagsmith/flagsmith-nodejs-client/issues"
   },
-  "homepage": "http://bullet-train.io",
-  "author": "SSG",
+  "homepage": "http://flagsmith.com/",
+  "author": "Flagsmith",
   "contributors": [
     {
       "name": "Tom Stuart",
@@ -26,7 +27,7 @@
     },
     {
       "name": "Kyle Johnson",
-      "email": "kyle@solidstategroup.com",
+      "email": "kyle.johnson@flagsmith.com",
       "url": "https://www.npmjs.com/~kyle-ssg"
     },
     {
@@ -40,12 +41,27 @@
   ],
   "license": "MIT",
   "scripts": {
-    "lint": "prettier --write ."
+    "lint": "prettier --write .",
+    "test": "jest --coverage --coverageReporters='text'",
+    "build": "tsc",
+    "prepare": "husky install"
   },
   "dependencies": {
-    "node-fetch": "^2.1.2"
+    "big-integer": "^1.6.51",
+    "md5": "^2.3.0",
+    "node-fetch": "^2.1.2",
+    "uuid": "^8.3.2"
   },
   "devDependencies": {
-    "prettier": "^2.2.1"
+    "@types/jest": "^27.4.1",
+    "@types/md5": "^2.3.2",
+    "@types/node-fetch": "^2.6.1",
+    "@types/uuid": "^8.3.4",
+    "esbuild": "^0.14.25",
+    "husky": "^7.0.4",
+    "jest": "^27.5.1",
+    "prettier": "^2.2.1",
+    "ts-jest": "^27.1.3",
+    "typescript": "^4.6.2"
   }
 }

package/sdk/analytics.ts

@@ -0,0 +1,60 @@
+import fetch from 'node-fetch';
+
+const ANALYTICS_ENDPOINT = 'analytics/flags/';
+
+// Used to control how often we send data(in seconds)
+const ANALYTICS_TIMER = 10;
+
+const delay = (ms: number) => new Promise(resolve => setTimeout(() => resolve(undefined), ms));
+
+export class AnalyticsProcessor {
+    private analyticsEndpoint: string;
+    private environmentKey: string;
+    private lastFlushed: number;
+    analyticsData: { [key: string]: any };
+    private timeout: number = 3;
+    /**
+     * AnalyticsProcessor is used to track how often individual Flags are evaluated within 
+     * the Flagsmith SDK. Docs: https://docs.flagsmith.com/advanced-use/flag-analytics.
+     * 
+     * @param data.environmentKey environment key obtained from the Flagsmith UI
+     * @param data.baseApiUrl base api url to override when using self hosted version
+     * @param data.timeout used to tell requests to stop waiting for a response after a
+            given number of seconds
+     */
+    constructor(data: { environmentKey: string; baseApiUrl: string; timeout?: number }) {
+        this.analyticsEndpoint = data.baseApiUrl + ANALYTICS_ENDPOINT;
+        this.environmentKey = data.environmentKey;
+        this.lastFlushed = Date.now();
+        this.analyticsData = {};
+        this.timeout = data.timeout || this.timeout;
+    }
+    /**
+     * Sends all the collected data to the api asynchronously and resets the timer
+     */
+    async flush() {
+        if (!Object.keys(this.analyticsData).length) {
+            return;
+        }
+
+        await fetch(this.analyticsEndpoint, {
+            method: 'POST',
+            body: JSON.stringify(this.analyticsData),
+            timeout: this.timeout,
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Environment-Key': this.environmentKey
+            }
+        });
+
+        this.analyticsData = {};
+        this.lastFlushed = Date.now();
+    }
+
+    trackFeature(featureId: number) {
+        this.analyticsData[featureId] = (this.analyticsData[featureId] || 0) + 1;
+        if (Date.now() - this.lastFlushed > ANALYTICS_TIMER * 1000) {
+            this.flush();
+        }
+    }
+}

package/sdk/errors.ts

@@ -0,0 +1,2 @@
+export class FlagsmithClientError extends Error {}
+export class FlagsmithAPIError extends Error {}