flagsmith-nodejs 1.0.9 → 2.0.0-beta.1

package/flagsmith-engine/environments/models.ts

@@ -0,0 +1,50 @@
+import { FeatureStateModel } from '../features/models';
+import { ProjectModel } from '../projects/models';
+import { IntegrationModel } from './integrations/models';
+
+export class EnvironmentAPIKeyModel {
+    id: number;
+    key: string;
+    createdAt: number;
+    name: string;
+    clientApiKey: string;
+    expiresAt?: number;
+    active = true;
+
+    constructor(
+        id: number,
+        key: string,
+        created_at: number,
+        name: string,
+        client_api_key: string,
+        expires_at?: number
+    ) {
+        this.id = id;
+        this.key = key;
+        this.createdAt = created_at;
+        this.name = name;
+        this.clientApiKey = client_api_key;
+        this.expiresAt = expires_at;
+    }
+
+    isValid() {
+        return !!this.active && (!this.expiresAt || this.expiresAt > Date.now());
+    }
+}
+
+export class EnvironmentModel {
+    id: number;
+    apiKey: string;
+    project: ProjectModel;
+    featureStates: FeatureStateModel[] = [];
+    amplitude_config?: IntegrationModel;
+    segment_config?: IntegrationModel;
+    mixpanel_config?: IntegrationModel;
+    heap_config?: IntegrationModel;
+
+    constructor(id: number, api_key: string, project: ProjectModel) {
+        this.id = id;
+        this.apiKey = api_key;
+        this.project = project;
+    }
+}

package/flagsmith-engine/environments/util.ts

@@ -0,0 +1,29 @@
+import { buildFeatureStateModel } from '../features/util';
+import { buildProjectModel } from '../projects/util';
+import { EnvironmentAPIKeyModel, EnvironmentModel } from './models';
+
+export function buildEnvironmentModel(environmentJSON: any) {
+    const project = buildProjectModel(environmentJSON.project);
+    const featureStates = environmentJSON.feature_states.map((fs: any) =>
+        buildFeatureStateModel(fs)
+    );
+    const environmentModel = new EnvironmentModel(
+        environmentJSON.id,
+        environmentJSON.api_key,
+        project
+    );
+    environmentModel.featureStates = featureStates;
+    return environmentModel;
+}
+
+export function buildEnvironmentAPIKeyModel(apiKeyJSON: any): EnvironmentAPIKeyModel {
+    const model = new EnvironmentAPIKeyModel(
+        apiKeyJSON.id,
+        apiKeyJSON.key,
+        Date.parse(apiKeyJSON.created_at),
+        apiKeyJSON.name,
+        apiKeyJSON.client_api_key
+    );
+
+    return model;
+}

package/flagsmith-engine/features/constants.ts

@@ -0,0 +1,4 @@
+export const CONSTANTS = {
+    STANDARD: 'STANDARD',
+    MULTIVARIATE: 'MULTIVARIATE'
+};

package/flagsmith-engine/features/models.ts

@@ -0,0 +1,105 @@
+import { v4 as uuidv4 } from 'uuid';
+import { getHashedPercentateForObjIds } from '../utils/hashing';
+
+export class FeatureModel {
+    id: number;
+    name: string;
+    type: string;
+
+    constructor(id: number, name: string, type: string) {
+        this.id = id;
+        this.name = name;
+        this.type = type;
+    }
+
+    eq(other: FeatureModel) {
+        return !!other && this.id === other.id;
+    }
+}
+
+export class MultivariateFeatureOptionModel {
+    value: any;
+    id: number | undefined;
+
+    constructor(value: any, id?: number) {
+        this.value = value;
+        this.id = id;
+    }
+}
+
+export class MultivariateFeatureStateValueModel {
+    multivariateFeatureOption: MultivariateFeatureOptionModel;
+    percentageAllocation: number;
+    id: number;
+    mvFsValueUuid: string = uuidv4();
+
+    constructor(
+        multivariate_feature_option: MultivariateFeatureOptionModel,
+        percentage_allocation: number,
+        id: number,
+        mvFsValueUuid?: string
+    ) {
+        this.id = id;
+        this.percentageAllocation = percentage_allocation;
+        this.multivariateFeatureOption = multivariate_feature_option;
+        this.mvFsValueUuid = mvFsValueUuid || this.mvFsValueUuid;
+    }
+}
+
+export class FeatureStateModel {
+    feature: FeatureModel;
+    enabled: boolean;
+    djangoID: number;
+    featurestateUUID: string = uuidv4();
+    _value: any;
+    multivariateFeatureStateValues: MultivariateFeatureStateValueModel[] = [];
+
+    constructor(
+        feature: FeatureModel,
+        enabled: boolean,
+        djangoID: number,
+        value?: any,
+        featurestate_uuid: string = uuidv4()
+    ) {
+        this.feature = feature;
+        this.enabled = enabled;
+        this.djangoID = djangoID;
+        this._value = value;
+        this.featurestateUUID = featurestate_uuid;
+    }
+
+    setValue(value: any) {
+        this._value = value;
+    }
+
+    getValue(identityId?: number | string) {
+        if (!!identityId && this.multivariateFeatureStateValues.length > 0) {
+            return this.getMultivariateValue(identityId);
+        }
+        return this._value;
+    }
+
+    get_feature_state_value() {
+        return this.getValue();
+    }
+
+    getMultivariateValue(identityID: number | string) {
+        const percentageValue = getHashedPercentateForObjIds([
+            this.djangoID || this.featurestateUUID,
+            identityID
+        ]);
+
+        let startPercentage = 0;
+        const sortedF = this.multivariateFeatureStateValues.sort((a, b) =>
+            !!(a.id && b.id) ? a.id - b.id : a.mvFsValueUuid > b.mvFsValueUuid ? -1 : 1
+        );
+        for (const myValue of sortedF) {
+            const limit = myValue.percentageAllocation + startPercentage;
+            if (startPercentage <= percentageValue && percentageValue < limit) {
+                return myValue.multivariateFeatureOption.value;
+            }
+            startPercentage = limit;
+        }
+        return this._value;
+    }
+}

package/flagsmith-engine/features/util.ts

@@ -0,0 +1,38 @@
+import {
+    FeatureModel,
+    FeatureStateModel,
+    MultivariateFeatureOptionModel,
+    MultivariateFeatureStateValueModel
+} from './models';
+
+export function buildFeatureModel(featuresModelJSON: any): FeatureModel {
+    return new FeatureModel(featuresModelJSON.id, featuresModelJSON.name, featuresModelJSON.type);
+}
+
+export function buildFeatureStateModel(featuresStateModelJSON: any): FeatureStateModel {
+    const featureStateModel = new FeatureStateModel(
+        buildFeatureModel(featuresStateModelJSON.feature),
+        featuresStateModelJSON.enabled,
+        featuresStateModelJSON.django_id,
+        featuresStateModelJSON.feature_state_value,
+        featuresStateModelJSON.uuid
+    );
+
+    const multivariateFeatureStateValues = featuresStateModelJSON.multivariate_feature_state_values
+        ? featuresStateModelJSON.multivariate_feature_state_values.map((fsv: any) => {
+              const featureOption = new MultivariateFeatureOptionModel(
+                  fsv.multivariate_feature_option.value,
+                  fsv.multivariate_feature_option.id
+              );
+              return new MultivariateFeatureStateValueModel(
+                  featureOption,
+                  fsv.percentage_allocation,
+                  fsv.id
+              );
+          })
+        : [];
+
+    featureStateModel.multivariateFeatureStateValues = multivariateFeatureStateValues;
+
+    return featureStateModel;
+}

package/flagsmith-engine/identities/models.ts

@@ -0,0 +1,60 @@
+import { FeatureStateModel } from '../features/models';
+import { IdentityFeaturesList } from '../utils/collections';
+import { TraitModel } from './traits/models';
+
+const { v4: uuidv4 } = require('uuid');
+
+export class IdentityModel {
+    identifier: string;
+    environmentApiKey: string;
+    createdDate?: number;
+    identityFeatures: IdentityFeaturesList;
+    identityTraits: TraitModel[];
+    identityUuid: string;
+    djangoID: number | undefined;
+
+    constructor(
+        created_date: string,
+        identity_traits: TraitModel[],
+        identity_features: IdentityFeaturesList,
+        environment_api_key: string,
+        identifier: string,
+        identity_uuid?: string
+    ) {
+        this.identityUuid = identity_uuid || uuidv4();
+        this.createdDate = Date.parse(created_date) || Date.now();
+        this.identityTraits = identity_traits;
+        this.identityFeatures = new IdentityFeaturesList(...identity_features);
+        this.environmentApiKey = environment_api_key;
+        this.identifier = identifier;
+    }
+
+    get compositeKey() {
+        return IdentityModel.generateCompositeKey(this.environmentApiKey, this.identifier);
+    }
+
+    static generateCompositeKey(env_key: string, identifier: string) {
+        return `${env_key}_${identifier}`;
+    }
+
+    update_traits(traits: TraitModel[]) {
+        const existingTraits: Map<string, TraitModel> = new Map();
+        for (const trait of this.identityTraits) {
+            existingTraits.set(trait.traitKey, trait);
+        }
+
+        for (const trait of traits) {
+            if (!!trait.traitValue) {
+                existingTraits.set(trait.traitKey, trait);
+            } else {
+                existingTraits.delete(trait.traitKey);
+            }
+        }
+
+        this.identityTraits = [];
+
+        for (const [k, v] of existingTraits.entries()) {
+            this.identityTraits.push(v);
+        }
+    }
+}

package/flagsmith-engine/identities/traits/models.ts

@@ -0,0 +1,9 @@
+export class TraitModel {
+    traitKey: string;
+    traitValue: any;
+
+    constructor(key: string, value: any) {
+        this.traitKey = key;
+        this.traitValue = value;
+    }
+}

package/flagsmith-engine/identities/util.ts

@@ -0,0 +1,30 @@
+import { buildFeatureStateModel } from '../features/util';
+import { IdentityFeaturesList } from '../utils/collections';
+import { IdentityModel } from './models';
+import { TraitModel } from './traits/models';
+
+export function buildTraitModel(traitJSON: any): TraitModel {
+    return new TraitModel(traitJSON.trait_key, traitJSON.trait_value);
+}
+
+export function buildIdentityModel(identityJSON: any): IdentityModel {
+    const featureList = identityJSON.identity_features
+        ? new IdentityFeaturesList(
+              ...identityJSON.identity_features.map((f: any) => buildFeatureStateModel(f))
+          )
+        : [];
+
+    const model = new IdentityModel(
+        identityJSON.created_date,
+        identityJSON.identity_traits
+            ? identityJSON.identity_traits.map((trait: any) => buildTraitModel(trait))
+            : [],
+        featureList,
+        identityJSON.environment_api_key,
+        identityJSON.identifier,
+        identityJSON.identity_uuid
+    );
+
+    model.djangoID = identityJSON['django_id'];
+    return model;
+}

package/flagsmith-engine/index.ts

@@ -0,0 +1,92 @@
+import { EnvironmentModel } from './environments/models';
+import { FeatureStateModel } from './features/models';
+import { IdentityModel } from './identities/models';
+import { TraitModel } from './identities/traits/models';
+import { getIdentitySegments } from './segments/evaluators';
+import { SegmentModel } from './segments/models';
+
+function getIdentityFeatureStatesDict(
+    environment: EnvironmentModel,
+    identity: IdentityModel,
+    override_traits?: TraitModel[]
+) {
+    // Get feature states from the environment
+    const feature_states: { [key: number]: FeatureStateModel } = {};
+    for (const fs of environment.featureStates) {
+        feature_states[fs.feature.id] = fs;
+    }
+
+    // Override with any feature states defined by matching segments
+    const identity_segments: SegmentModel[] = getIdentitySegments(
+        environment,
+        identity,
+        override_traits
+    );
+    for (const matching_segment of identity_segments) {
+        for (const feature_state of matching_segment.featureStates) {
+            // note that feature states are stored on the segment in descending priority
+            // order so we only care that the last one is added
+            // TODO: can we optimise this?
+            feature_states[feature_state.feature.id] = feature_state;
+        }
+    }
+
+    // Override with any feature states defined directly the identity
+    for (const fs of identity.identityFeatures || []) {
+        if (feature_states[fs.feature.id]) {
+            feature_states[fs.feature.id] = fs;
+        }
+    }
+    return feature_states;
+}
+
+export function getIdentityFeatureState(
+    environment: EnvironmentModel,
+    identity: IdentityModel,
+    feature_name: string,
+    override_traits?: TraitModel[]
+): FeatureStateModel {
+    const featureStates = getIdentityFeatureStatesDict(environment, identity, override_traits);
+
+    const matchingFeature = Object.values(featureStates).filter(
+        f => f.feature.name === feature_name
+    );
+
+    if (matchingFeature.length === 0) {
+        throw new Error('Feature State Not Found');
+    }
+
+    return matchingFeature[0];
+}
+
+export function getIdentityFeatureStates(
+    environment: EnvironmentModel,
+    identity: IdentityModel,
+    overrideTraits?: TraitModel[]
+): FeatureStateModel[] {
+    const feature_states = Object.values(
+        getIdentityFeatureStatesDict(environment, identity, overrideTraits)
+    );
+
+    if (environment.project.hideDisabledFlags) {
+        return feature_states.filter(fs => !!fs.enabled);
+    }
+    return feature_states;
+}
+
+export function getEnvironmentFeatureState(environment: EnvironmentModel, featureName: string) {
+    const featuresStates = environment.featureStates.filter(f => f.feature.name === featureName);
+
+    if (featuresStates.length === 0) {
+        throw new Error('Feature State Not Found');
+    }
+
+    return featuresStates[0];
+}
+
+export function getEnvironmentFeatureStates(environment: EnvironmentModel): FeatureStateModel[] {
+    if (environment.project.hideDisabledFlags) {
+        return environment.featureStates.filter(fs => !!fs.enabled);
+    }
+    return environment.featureStates;
+}

package/flagsmith-engine/organisations/models.ts

@@ -0,0 +1,25 @@
+export class OrganisationModel {
+    id: number;
+    name: string;
+    featureAnalytics: boolean;
+    stopServingFlags: boolean;
+    persistTraitData: boolean;
+
+    constructor(
+        id: number,
+        name: string,
+        feature_analytics: boolean,
+        stop_serving_flags: boolean,
+        persist_trait_data: boolean
+    ) {
+        this.id = id;
+        this.name = name;
+        this.featureAnalytics = feature_analytics;
+        this.stopServingFlags = stop_serving_flags;
+        this.persistTraitData = persist_trait_data;
+    }
+
+    get unique_slug() {
+        return this.id.toString() + '-' + this.name;
+    }
+}

package/flagsmith-engine/organisations/util.ts

@@ -0,0 +1,11 @@
+import { OrganisationModel } from './models';
+
+export function buildOrganizationModel(organizationJSON: any): OrganisationModel {
+    return new OrganisationModel(
+        organizationJSON.id,
+        organizationJSON.name,
+        organizationJSON.feature_analytics,
+        organizationJSON.stop_serving_flags,
+        organizationJSON.persist_trait_data
+    );
+}

package/flagsmith-engine/projects/models.ts

@@ -0,0 +1,23 @@
+import { OrganisationModel } from '../organisations/models';
+import { SegmentModel } from '../segments/models';
+
+export class ProjectModel {
+    id: number;
+    name: string;
+    organisation: OrganisationModel;
+    hideDisabledFlags: boolean;
+    // FIXME
+    segments: SegmentModel[] = [];
+
+    constructor(
+        id: number,
+        name: string,
+        hide_disabled_flags: boolean,
+        organization: OrganisationModel
+    ) {
+        this.id = id;
+        this.name = name;
+        this.hideDisabledFlags = hide_disabled_flags;
+        this.organisation = organization;
+    }
+}

package/flagsmith-engine/projects/util.ts

@@ -0,0 +1,18 @@
+import { buildOrganizationModel } from '../organisations/util';
+import { SegmentModel } from '../segments/models';
+import { buildSegmentModel } from '../segments/util';
+import { ProjectModel } from './models';
+
+export function buildProjectModel(projectJSON: any): ProjectModel {
+    const segments: SegmentModel[] = projectJSON['segments']
+        ? projectJSON['segments'].map((s: any) => buildSegmentModel(s))
+        : [];
+    const model = new ProjectModel(
+        projectJSON.id,
+        projectJSON.name,
+        projectJSON.hide_disabled_flags,
+        buildOrganizationModel(projectJSON.organisation)
+    );
+    model.segments = segments;
+    return model;
+}

package/flagsmith-engine/segments/constants.ts

@@ -0,0 +1,31 @@
+// Segment Rules
+export const ALL_RULE = 'ALL';
+export const ANY_RULE = 'ANY';
+export const NONE_RULE = 'NONE';
+
+export const RULE_TYPES = [ALL_RULE, ANY_RULE, NONE_RULE];
+
+// Segment Condition Operators
+export const EQUAL = 'EQUAL';
+export const GREATER_THAN = 'GREATER_THAN';
+export const LESS_THAN = 'LESS_THAN';
+export const LESS_THAN_INCLUSIVE = 'LESS_THAN_INCLUSIVE';
+export const CONTAINS = 'CONTAINS';
+export const GREATER_THAN_INCLUSIVE = 'GREATER_THAN_INCLUSIVE';
+export const NOT_CONTAINS = 'NOT_CONTAINS';
+export const NOT_EQUAL = 'NOT_EQUAL';
+export const REGEX = 'REGEX';
+export const PERCENTAGE_SPLIT = 'PERCENTAGE_SPLIT';
+
+export const CONDITION_OPERATORS = {
+    EQUAL,
+    GREATER_THAN,
+    LESS_THAN,
+    LESS_THAN_INCLUSIVE,
+    CONTAINS,
+    GREATER_THAN_INCLUSIVE,
+    NOT_CONTAINS,
+    NOT_EQUAL,
+    REGEX,
+    PERCENTAGE_SPLIT
+};

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(
+    identity_traits: TraitModel[],
+    condition: SegmentConditionModel,
+    segmentId: number | string,
+    identityId: number | string
+): boolean {
+    if (condition.operator == PERCENTAGE_SPLIT) {
+        return getHashedPercentateForObjIds([segmentId, identityId]) <= parseFloat(condition.value);
+    }
+
+    const traits = identity_traits.filter(t => t.traitKey === condition.property_);
+    const trait = traits.length > 0 ? traits[0] : undefined;
+
+    return trait ? condition.matchesTraitValue(trait.traitValue) : false;
+}