flagsmith-nodejs 1.1.0 → 2.0.0-beta.2

package/example/package.json

@@ -1,10 +1,10 @@
 {
-  "name": "node-minimal",
+  "name": "flagsmith-nodejs-example",
   "version": "0.1.1",
-  "description": "Node Express Boilerplate",
+  "description": "An example using the flagsmith nodejs library",
   "main": "index.js",
   "scripts": {
-    "start": "node --inspect ./server",
+    "start": "cd ../ && npm run build && cd ./example && node --inspect ./server",
     "dev": "nodemon --exec npm start",
     "test": "nodemon ./server/tests/"
   },
@@ -15,6 +15,7 @@
     "npm": "3.10.x"
   },
   "dependencies": {
+    "flagsmith-nodejs": "^2.0.0-beta.1",
     "node-cache": "^5.1.2",
     "ssg-node-express": "4.16.4",
     "ssg-util": "0.0.3"

package/example/server/api/index.js

@@ -1,32 +1,32 @@
 const Router = require('express').Router;
-const environmentID = 'uCDQzKWgejrutqSYYsKWen';
-const flagsmith = require('../../../');
-const NodeCache = require('node-cache');
-
-flagsmith.init({
-    environmentID
-    // this is an example of a user-defined cache
-    /*cache: new NodeCache({
-        stdTTL: 5
-    })*/
+const Flagsmith = require('../../../build');
+const environmentKey = '';
+if (!environmentKey) {
+    throw new Error(
+        'Please generate a Server Side SDK Key in environment settings to run the example'
+    );
+}
+const flagsmith = new Flagsmith({
+    environmentKey,
+    enableLocalEvaluation: true,
+    defaultFlagHandler: str => {
+        return { enabled: false, isDefault: true, value: null };
+    }
 });
 
 module.exports = () => {
     const api = Router();
 
     api.get('/', async (req, res) => {
-        const font_size = await flagsmith.getValue('font_size');
-        res.json({ font_size });
-    });
-
-    api.get('/flags', async (req, res) => {
-        const flags = await flagsmith.getFlags();
+        const flags = await flagsmith.getEnvironmentFlags();
         res.json(flags);
     });
 
     api.get('/:user', async (req, res) => {
-        const font_size = await flagsmith.getValue('font_size', req.params.user);
-        res.json({ font_size });
+        const flags = await flagsmith.getIdentityFlags(req.params.user, { checkout_v2: 1 });
+        const fontSize = flags.getFeatureValue('font_size');
+        const checkoutV2 = flags.isFeatureEnabled('checkout_v2');
+        res.json({ fontSize, checkoutV2 });
     });
 
     return api;

package/example/server/index.js

@@ -12,17 +12,15 @@ app.server = http.createServer(app);
 app.use(bodyParser.json());
 
 // api router
-app.use('/', api());
+app.use('/api', api());
 
 app.server.listen(PORT);
 console.log('Server started on port ' + app.server.address().port);
 console.log();
-console.log('Go to http://localhost:' + PORT + '/');
-console.log('To get an example feature state');
+console.log('Go to http://localhost:' + PORT + '/api');
+console.log('To get an example response for getFlags');
 console.log();
-console.log('Go to http://localhost:' + PORT + '/flagsmith_sample_user');
+console.log('Go to http://localhost:' + PORT + '/api/flagsmith_sample_user');
 console.log('To get an example feature state for a user');
-console.log('Go to http://localhost:' + PORT + '/flags');
-console.log('To get an example response for getFlags');
 
 module.exports = app;

package/flagsmith-engine/environments/integrations/models.ts

@@ -0,0 +1,4 @@
+export class IntegrationModel {
+    api_key?: string = undefined;
+    base_url?: string = undefined;
+}

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,
+        createdAt: number,
+        name: string,
+        clientApiKey: string,
+        expiresAt?: number
+    ) {
+        this.id = id;
+        this.key = key;
+        this.createdAt = createdAt;
+        this.name = name;
+        this.clientApiKey = clientApiKey;
+        this.expiresAt = expiresAt;
+    }
+
+    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, apiKey: string, project: ProjectModel) {
+        this.id = id;
+        this.apiKey = apiKey;
+        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();
+    private value: any;
+    multivariateFeatureStateValues: MultivariateFeatureStateValueModel[] = [];
+
+    constructor(
+        feature: FeatureModel,
+        enabled: boolean,
+        djangoID: number,
+        value?: any,
+        featurestateUuid: string = uuidv4()
+    ) {
+        this.feature = feature;
+        this.enabled = enabled;
+        this.djangoID = djangoID;
+        this.value = value;
+        this.featurestateUUID = featurestateUuid;
+    }
+
+    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,
+        identityTraits: TraitModel[],
+        identityFeatures: IdentityFeaturesList,
+        environmentApiKey: string,
+        identifier: string,
+        identityUuid?: string
+    ) {
+        this.identityUuid = identityUuid || uuidv4();
+        this.createdDate = Date.parse(created_date) || Date.now();
+        this.identityTraits = identityTraits;
+        this.identityFeatures = new IdentityFeaturesList(...identityFeatures);
+        this.environmentApiKey = environmentApiKey;
+        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,93 @@
+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';
+import { FeatureStateNotFound } from './utils/errors';
+
+function getIdentityFeatureStatesDict(
+    environment: EnvironmentModel,
+    identity: IdentityModel,
+    overrideTraits?: TraitModel[]
+) {
+    // Get feature states from the environment
+    const featureStates: { [key: number]: FeatureStateModel } = {};
+    for (const fs of environment.featureStates) {
+        featureStates[fs.feature.id] = fs;
+    }
+
+    // Override with any feature states defined by matching segments
+    const identitySegments: SegmentModel[] = getIdentitySegments(
+        environment,
+        identity,
+        overrideTraits
+    );
+    for (const matchingSegment of identitySegments) {
+        for (const featureState of matchingSegment.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?
+            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;
+        }
+    }
+    return featureStates;
+}
+
+export function getIdentityFeatureState(
+    environment: EnvironmentModel,
+    identity: IdentityModel,
+    featureName: string,
+    overrideTraits?: TraitModel[]
+): FeatureStateModel {
+    const featureStates = getIdentityFeatureStatesDict(environment, identity, overrideTraits);
+
+    const matchingFeature = Object.values(featureStates).filter(
+        f => f.feature.name === featureName
+    );
+
+    if (matchingFeature.length === 0) {
+        throw new FeatureStateNotFound('Feature State Not Found');
+    }
+
+    return matchingFeature[0];
+}
+
+export function getIdentityFeatureStates(
+    environment: EnvironmentModel,
+    identity: IdentityModel,
+    overrideTraits?: TraitModel[]
+): FeatureStateModel[] {
+    const featureStates = Object.values(
+        getIdentityFeatureStatesDict(environment, identity, overrideTraits)
+    );
+
+    if (environment.project.hideDisabledFlags) {
+        return featureStates.filter(fs => !!fs.enabled);
+    }
+    return featureStates;
+}
+
+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,
+        featureAnalytics: boolean,
+        stopServingFlags: boolean,
+        persistTraitData: boolean
+    ) {
+        this.id = id;
+        this.name = name;
+        this.featureAnalytics = featureAnalytics;
+        this.stopServingFlags = stopServingFlags;
+        this.persistTraitData = persistTraitData;
+    }
+
+    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,22 @@
+import { OrganisationModel } from '../organisations/models';
+import { SegmentModel } from '../segments/models';
+
+export class ProjectModel {
+    id: number;
+    name: string;
+    organisation: OrganisationModel;
+    hideDisabledFlags: boolean;
+    segments: SegmentModel[] = [];
+
+    constructor(
+        id: number,
+        name: string,
+        hideDisabledFlags: boolean,
+        organization: OrganisationModel
+    ) {
+        this.id = id;
+        this.name = name;
+        this.hideDisabledFlags = hideDisabledFlags;
+        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
+};