flagsmith-nodejs 2.0.0-beta.6 → 2.0.1

package/.github/workflows/pull_request.yaml

@@ -1,33 +1,41 @@
 name: Unit/Integration Tests
 
 on:
-    pull_request:
-        types:
-            - opened
-            - synchronize
-            - reopened
-            - ready_for_review
-    push:
-        branches:
-            - main
+  pull_request:
+    types:
+      - opened
+      - synchronize
+      - reopened
+      - ready_for_review
+  push:
+    branches:
+      - main
 jobs:
-    build-and-test:
-        runs-on: ubuntu-latest
-        steps:
-            - uses: actions/checkout@v2
-            - uses: actions/setup-node@v1
-              with:
-                  node-version: '15.x'
-            - name: cache node modules
-              uses: actions/cache@v1
-              with:
-                  path: ~/.npm # npm cache files are stored in `~/.npm` on Linux/macOS
-                  key: npm-${{ hashFiles('package-lock.json') }}
-                  restore-keys: |
-                      npm-${{ hashFiles('package-lock.json') }}
-                      npm-
-            - run: npm i -g npm@7.0.2
-            - run: npm install
-            - run: npm test
-              env:
-                  CI: true
+  build-and-test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Checkout submodules # checkout rest
+        shell: bash
+        run: |
+          # If your submodules are configured to use SSH instead of HTTPS please uncomment the following line
+          git config --global url."https://github.com/".insteadOf "git@github.com:"
+          auth_header="$(git config --local --get http.https://github.com/.extraheader)"
+          git submodule sync --recursive
+          git -c "http.extraheader=$auth_header" -c protocol.version=2 submodule update --init --force --recursive --depth=1
+      - uses: actions/setup-node@v1
+        with:
+          node-version: "15.x"
+      - name: cache node modules
+        uses: actions/cache@v1
+        with:
+          path: ~/.npm # npm cache files are stored in `~/.npm` on Linux/macOS
+          key: npm-${{ hashFiles('package-lock.json') }}
+          restore-keys: |
+            npm-${{ hashFiles('package-lock.json') }}
+            npm-
+      - run: npm i -g npm@7.0.2
+      - run: npm install
+      - run: npm test
+        env:
+          CI: true

package/README.md

@@ -19,6 +19,13 @@ Please read [CONTRIBUTING.md](https://gist.github.com/kyle-ssg/c36a03aebe492e45c
 
 If you encounter a bug or feature request we would like to hear about it. Before you submit an issue please search existing issues in order to prevent duplicates.
 
+## Testing
+
+To run the local tests you need to run following command beforehand:
+```
+git submodule add git@github.com:Flagsmith/engine-test-data.git tests/engine/engine-tests/engine-test-data/
+```
+
 ## Get in touch
 
 If you have any questions about our projects you can email <a href="mailto:support@flagsmith.com">support@flagsmith.com</a>.

package/example/server/api/index.js

@@ -1,6 +1,6 @@
 const Router = require('express').Router;
 const Flagsmith = require('../../../build');
-const environmentKey = 'ser.dCxh8XoQc3Sw3JqMqMbhXz';
+const environmentKey = '';
 if (!environmentKey) {
     throw new Error(
         'Please generate a Server Side SDK Key in environment settings to run the example'

package/flagsmith-engine/features/models.ts

@@ -51,6 +51,7 @@ export class FeatureStateModel {
     enabled: boolean;
     djangoID: number;
     featurestateUUID: string = uuidv4();
+    featureSegment?: FeatureSegment;
     private value: any;
     multivariateFeatureStateValues: MultivariateFeatureStateValueModel[] = [];
 
@@ -79,10 +80,23 @@ export class FeatureStateModel {
         return this.value;
     }
 
-    get_feature_state_value() {
-        return this.getValue();
+    /* 
+        Returns `True` if `this` is higher segment priority than `other`
+        (i.e. has lower value for featureSegment.priority)
+        NOTE:
+            A segment will be considered higher priority only if:
+            1. `other` does not have a feature segment(i.e: it is an environment feature state or it's a
+            feature state with feature segment but from an old document that does not have `featureSegment.priority`)
+            but `this` does.
+            2. `other` have a feature segment with high priority
+    */
+    isHigherSegmentPriority(other: FeatureStateModel): boolean {
+        if (!other.featureSegment || !this.featureSegment) {
+            return !!this.featureSegment && !other.featureSegment;
+        }
+        return this.featureSegment.priority < other.featureSegment.priority;
     }
-
+    
     getMultivariateValue(identityID: number | string) {
         const percentageValue = getHashedPercentateForObjIds([
             this.djangoID || this.featurestateUUID,
@@ -90,9 +104,9 @@ export class FeatureStateModel {
         ]);
 
         let startPercentage = 0;
-        const sortedF = this.multivariateFeatureStateValues.sort((a, b) =>
-            !!(a.id && b.id) ? a.id - b.id : a.mvFsValueUuid > b.mvFsValueUuid ? -1 : 1
-        );
+        const sortedF = this.multivariateFeatureStateValues.sort((a, b) =>{
+            return a.id - b.id;
+        });
         for (const myValue of sortedF) {
             const limit = myValue.percentageAllocation + startPercentage;
             if (startPercentage <= percentageValue && percentageValue < limit) {
@@ -103,3 +117,11 @@ export class FeatureStateModel {
         return this.value;
     }
 }
+
+export class FeatureSegment {
+    priority: number;
+
+    constructor(priority: number) {
+        this.priority = priority;
+    }
+}

package/flagsmith-engine/features/util.ts

@@ -1,5 +1,6 @@
 import {
     FeatureModel,
+    FeatureSegment,
     FeatureStateModel,
     MultivariateFeatureOptionModel,
     MultivariateFeatureStateValueModel
@@ -18,6 +19,10 @@ export function buildFeatureStateModel(featuresStateModelJSON: any): FeatureStat
         featuresStateModelJSON.uuid
     );
 
+    featureStateModel.featureSegment = featuresStateModelJSON.feature_segment ? 
+        buildFeatureSegment(featuresStateModelJSON.feature_segment) : 
+        undefined;
+
     const multivariateFeatureStateValues = featuresStateModelJSON.multivariate_feature_state_values
         ? featuresStateModelJSON.multivariate_feature_state_values.map((fsv: any) => {
               const featureOption = new MultivariateFeatureOptionModel(
@@ -36,3 +41,7 @@ export function buildFeatureStateModel(featuresStateModelJSON: any): FeatureStat
 
     return featureStateModel;
 }
+
+export function buildFeatureSegment(featureSegmentJSON: any): FeatureSegment {
+    return new FeatureSegment(featureSegmentJSON.priority);
+}

package/flagsmith-engine/identities/models.ts

@@ -37,7 +37,7 @@ export class IdentityModel {
         return `${env_key}_${identifier}`;
     }
 
-    update_traits(traits: TraitModel[]) {
+    updateTraits(traits: TraitModel[]) {
         const existingTraits: Map<string, TraitModel> = new Map();
         for (const trait of this.identityTraits) {
             existingTraits.set(trait.traitKey, trait);

package/flagsmith-engine/index.ts

@@ -25,15 +25,17 @@ function getIdentityFeatureStatesDict(
     );
     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?
+            if (featureStates[featureState.feature.id]) {
+                if (featureStates[featureState.feature.id].isHigherSegmentPriority(featureState)) {
+                    continue;
+                }
+            }
             featureStates[featureState.feature.id] = featureState;
         }
     }
 
     // Override with any feature states defined directly the identity
-    for (const fs of identity.identityFeatures || []) {
+    for (const fs of identity.identityFeatures) {
         if (featureStates[fs.feature.id]) {
             featureStates[fs.feature.id] = fs;
         }
@@ -79,7 +81,7 @@ export function getEnvironmentFeatureState(environment: EnvironmentModel, featur
     const featuresStates = environment.featureStates.filter(f => f.feature.name === featureName);
 
     if (featuresStates.length === 0) {
-        throw new Error('Feature State Not Found');
+        throw new FeatureStateNotFound('Feature State Not Found');
     }
 
     return featuresStates[0];

package/flagsmith-engine/organisations/models.ts

@@ -19,7 +19,7 @@ export class OrganisationModel {
         this.persistTraitData = persistTraitData;
     }
 
-    get unique_slug() {
+    get uniqueSlug() {
         return this.id.toString() + '-' + this.name;
     }
 }

package/flagsmith-engine/segments/models.ts

@@ -1,3 +1,5 @@
+import semver from 'semver';
+
 import { FeatureStateModel } from '../features/models';
 import { getCastingFunction as getCastingFunction } from '../utils';
 import {
@@ -8,6 +10,7 @@ import {
     REGEX,
     CONDITION_OPERATORS
 } from './constants';
+import { isSemver } from './util';
 
 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;
@@ -23,10 +26,21 @@ export const matchingFunctions = {
     [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 const semverMatchingFunction = {
+    ...matchingFunctions,
+    [CONDITION_OPERATORS.EQUAL]: (thisValue: any, otherValue: any) => semver.eq(thisValue, otherValue),
+    [CONDITION_OPERATORS.GREATER_THAN]: (thisValue: any, otherValue: any) => semver.gt(otherValue, thisValue),
+    [CONDITION_OPERATORS.GREATER_THAN_INCLUSIVE]: (thisValue: any, otherValue: any) =>
+        semver.gte(otherValue, thisValue),
+    [CONDITION_OPERATORS.LESS_THAN]: (thisValue: any, otherValue: any) => semver.gt(thisValue, otherValue),
+    [CONDITION_OPERATORS.LESS_THAN_INCLUSIVE]: (thisValue: any, otherValue: any) =>
+        semver.gte(thisValue, otherValue),
+}
+
+export const getMatchingFunctions = (semver: boolean) => (semver ? semverMatchingFunction : matchingFunctions);
+
 export class SegmentConditionModel {
     EXCEPTION_OPERATOR_METHODS: { [key: string]: string } = {
         [NOT_CONTAINS]: 'evaluateNotContains',
@@ -61,9 +75,12 @@ export class SegmentConditionModel {
 
         const defaultFunction = (x: any, y: any) => false;
 
-        const matchingFunction = matchingFunctions[this.operator] || defaultFunction;
+        const matchingFunctionSet = getMatchingFunctions(isSemver(this.value));
+        const matchingFunction = matchingFunctionSet[this.operator] || defaultFunction;
+
+        const traitType = isSemver(this.value) ? 'semver' : typeof traitValue;
+        const castToTypeOfTraitValue = getCastingFunction(traitType);
 
-        const castToTypeOfTraitValue = getCastingFunction(traitValue);
         return matchingFunction(castToTypeOfTraitValue(this.value), traitValue);
     }
 }

package/flagsmith-engine/segments/util.ts

@@ -27,3 +27,11 @@ export function buildSegmentModel(segmentModelJSON: any): SegmentModel {
 
     return model;
 }
+
+export function isSemver(value: any) {
+    return typeof value == 'string' && value.endsWith(':semver');
+}
+
+export function removeSemverSuffix(value: string) {
+    return value.replace(':semver', '');
+}

package/flagsmith-engine/utils/collections.ts

@@ -1,14 +1,3 @@
 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);
-    }
-}
+export class IdentityFeaturesList extends Array<FeatureStateModel> {}

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

@@ -39,12 +39,15 @@ function h2d(s: any): string {
  * @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);
+    let toHash = makeRepeated(objectIds, iterations).join(',');
+    const hashedValue = md5(toHash);
     const hashedInt = bigInt(h2d(hashedValue));
     const value = (hashedInt.mod(9999).toJSNumber() / 9998) * 100;
 
+    // we ignore this for it's nearly impossible use case to catch
+    /* istanbul ignore next */
     if (value === 100) {
+        /* istanbul ignore next */
         return getHashedPercentateForObjIds(objectIds, iterations + 1);
     }
 

package/flagsmith-engine/utils/index.ts

@@ -1,9 +1,13 @@
-export function getCastingFunction(input: any): CallableFunction {
-    switch (typeof input) {
+import { removeSemverSuffix } from "../segments/util";
+
+export function getCastingFunction(traitType: 'boolean' | 'string' | 'number' | 'semver' | any): CallableFunction {
+    switch (traitType) {
         case 'boolean':
             return (x: any) => !['False', 'false'].includes(x);
         case 'number':
             return (x: any) => parseFloat(x);
+        case 'semver':
+            return (x: any) => removeSemverSuffix(x);
         default:
             return (x: any) => String(x);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flagsmith-nodejs",
-  "version": "2.0.0-beta.6",
+  "version": "2.0.1",
   "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": "build/index.js",
   "repository": {
@@ -46,19 +46,21 @@
     "test:watch": "jest --coverage --watch --coverageReporters='text'",
     "test:debug": "node --inspect-brk node_modules/.bin/jest --coverage --watch --coverageReporters='text'",
     "build": "tsc",
-    "prepublish": "npm run build",
+    "prepublish": "npm i && npm run build",
     "prepare": "husky install"
   },
   "dependencies": {
     "big-integer": "^1.6.51",
     "md5": "^2.3.0",
     "node-fetch": "^2.1.2",
+    "semver": "^7.3.7",
     "uuid": "^8.3.2"
   },
   "devDependencies": {
     "@types/jest": "^27.4.1",
     "@types/md5": "^2.3.2",
     "@types/node-fetch": "^2.6.1",
+    "@types/semver": "^7.3.9",
     "@types/uuid": "^8.3.4",
     "esbuild": "^0.14.25",
     "husky": "^7.0.4",

package/sdk/analytics.ts

@@ -5,8 +5,6 @@ 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;

package/sdk/index.ts

@@ -12,8 +12,9 @@ import { EnvironmentDataPollingManager } from './polling_manager';
 import { generateIdentitiesData, retryFetch } from './utils';
 import { SegmentModel } from '../flagsmith-engine/segments/models';
 import { getIdentitySegments } from '../flagsmith-engine/segments/evaluators';
+import { FlagsmithCache } from './types';
 
-const DEFAULT_API_URL = 'https://api.flagsmith.com/api/v1/';
+const DEFAULT_API_URL = 'https://edge.api.flagsmith.com/api/v1/';
 
 export class Flagsmith {
     environmentKey?: string;
@@ -26,12 +27,16 @@ export class Flagsmith {
     enableAnalytics: boolean = false;
     defaultFlagHandler?: (featureName: string) => DefaultFlag;
 
+
     environmentFlagsUrl: string;
     identitiesUrl: string;
     environmentUrl: string;
 
     environmentDataPollingManager?: EnvironmentDataPollingManager;
     environment!: EnvironmentModel;
+
+    private cache?: FlagsmithCache;
+    private onEnvironmentChange?: (error: Error | null, result: EnvironmentModel) => void;
     private analyticsProcessor?: AnalyticsProcessor;
     /**
      * A Flagsmith client.
@@ -73,6 +78,8 @@ export class Flagsmith {
         retries?: number;
         enableAnalytics?: boolean;
         defaultFlagHandler?: (featureName: string) => DefaultFlag;
+        cache?: FlagsmithCache,
+        onEnvironmentChange?: (error: Error | null, result: EnvironmentModel) => void,
     }) {
         this.environmentKey = data.environmentKey;
         this.apiUrl = data.apiUrl || this.apiUrl;
@@ -88,6 +95,20 @@ export class Flagsmith {
         this.environmentFlagsUrl = `${this.apiUrl}flags/`;
         this.identitiesUrl = `${this.apiUrl}identities/`;
         this.environmentUrl = `${this.apiUrl}environment-document/`;
+        this.onEnvironmentChange = data.onEnvironmentChange;
+
+        if (!!data.cache) {
+            const missingMethods: string[] = ['has', 'get', 'set'].filter(method => data.cache && !data.cache[method]);
+
+            if (missingMethods.length > 0) {
+                throw new Error(
+                    `Please implement the following methods in your cache: ${missingMethods.join(
+                        ', '
+                    )}`
+                );
+            }
+            this.cache = data.cache;
+        }
 
         if (this.enableLocalEvaluation) {
             if (!this.environmentKey.startsWith('ser.')) {
@@ -105,10 +126,10 @@ export class Flagsmith {
 
         this.analyticsProcessor = data.enableAnalytics
             ? new AnalyticsProcessor({
-                  environmentKey: this.environmentKey,
-                  baseApiUrl: this.apiUrl,
-                  timeout: this.requestTimeoutSeconds
-              })
+                environmentKey: this.environmentKey,
+                baseApiUrl: this.apiUrl,
+                timeout: this.requestTimeoutSeconds
+            })
             : undefined;
     }
     /**
@@ -117,8 +138,19 @@ export class Flagsmith {
      * @returns Flags object holding all the flags for the current environment.
      */
     async getEnvironmentFlags(): Promise<Flags> {
+        const cachedItem = !!this.cache && await this.cache.get(`flags`);
+        if (!!cachedItem) {
+            return cachedItem;
+        }
+        if (this.enableLocalEvaluation) {
+            return new Promise(resolve =>
+                this.environmentPromise!.then(() => {
+                    resolve(this.getEnvironmentFlagsFromDocument());
+                })
+            );
+        }
         if (this.environment) {
-            return new Promise(resolve => resolve(this.getEnvironmentFlagsFromDocument()));
+            return this.getEnvironmentFlagsFromDocument();
         }
 
         return this.getEnvironmentFlagsFromApi();
@@ -134,7 +166,11 @@ export class Flagsmith {
             Flagsmith, e.g. {"num_orders": 10}
      * @returns Flags object holding all the flags for the given identity.
      */
-    getIdentityFlags(identifier: string, traits?: { [key: string]: any }): Promise<Flags> {
+    async getIdentityFlags(identifier: string, traits?: { [key: string]: any }): Promise<Flags> {
+        const cachedItem = !!this.cache && await this.cache.get(`flags-${identifier}`);
+        if (!!cachedItem) {
+            return cachedItem;
+        }
         traits = traits || {};
         if (this.enableLocalEvaluation) {
             return new Promise(resolve =>
@@ -188,14 +224,23 @@ export class Flagsmith {
      * You only need to call this if you wish to bypass environmentRefreshIntervalSeconds.
      */
     async updateEnvironment() {
-        const request = this.getEnvironmentFromApi();
-        if (!this.environmentPromise) {
-            this.environmentPromise = request.then(res => {
-                this.environment = res;
-            });
-            await this.environmentPromise;
-        } else {
-            this.environment = await request;
+        try {
+            const request = this.getEnvironmentFromApi();
+            if (!this.environmentPromise) {
+                this.environmentPromise = request.then(res => {
+                    this.environment = res;
+                });
+                await this.environmentPromise;
+            } else {
+                this.environment = await request;
+            }
+            if (this.onEnvironmentChange) {
+                this.onEnvironmentChange(null, this.environment);
+            }
+        } catch (e) {
+            if (this.onEnvironmentChange) {
+                this.onEnvironmentChange(e as Error, this.environment);
+            }
         }
     }
 
@@ -224,7 +269,6 @@ export class Flagsmith {
                 headers: headers
             },
             this.retries,
-            1000,
             (this.requestTimeoutSeconds || 10) * 1000
         );
 
@@ -247,15 +291,19 @@ export class Flagsmith {
         return buildEnvironmentModel(environment_data);
     }
 
-    private getEnvironmentFlagsFromDocument() {
-        return Flags.fromFeatureStateModels({
+    private async getEnvironmentFlagsFromDocument(): Promise<Flags> {
+        const flags = Flags.fromFeatureStateModels({
             featureStates: getEnvironmentFeatureStates(this.environment),
             analyticsProcessor: this.analyticsProcessor,
             defaultFlagHandler: this.defaultFlagHandler
         });
+        if (!!this.cache) {
+            await this.cache.set('flags', flags);
+        }
+        return flags;
     }
 
-    private getIdentityFlagsFromDocument(identifier: string, traits: { [key: string]: any }) {
+    private async getIdentityFlagsFromDocument(identifier: string, traits: { [key: string]: any }): Promise<Flags> {
         const identityModel = this.buildIdentityModel(
             identifier,
             Object.keys(traits).map(key => ({
@@ -266,21 +314,31 @@ export class Flagsmith {
 
         const featureStates = getIdentityFeatureStates(this.environment, identityModel);
 
-        return Flags.fromFeatureStateModels({
+        const flags = Flags.fromFeatureStateModels({
             featureStates: featureStates,
             analyticsProcessor: this.analyticsProcessor,
             defaultFlagHandler: this.defaultFlagHandler
         });
+
+        if (!!this.cache) {
+            await this.cache.set(`flags-${identifier}`, flags);
+        }
+
+        return flags;
     }
 
     private async getEnvironmentFlagsFromApi() {
         try {
             const apiFlags = await this.getJSONResponse(this.environmentFlagsUrl, 'GET');
-            return Flags.fromAPIFlags({
+            const flags = Flags.fromAPIFlags({
                 apiFlags: apiFlags,
                 analyticsProcessor: this.analyticsProcessor,
                 defaultFlagHandler: this.defaultFlagHandler
             });
+            if (!!this.cache) {
+                await this.cache.set('flags', flags);
+            }
+            return flags;
         } catch (e) {
             if (this.defaultFlagHandler) {
                 return new Flags({
@@ -297,11 +355,15 @@ export class Flagsmith {
         try {
             const data = generateIdentitiesData(identifier, traits);
             const jsonResponse = await this.getJSONResponse(this.identitiesUrl, 'POST', data);
-            return Flags.fromAPIFlags({
+            const flags = Flags.fromAPIFlags({
                 apiFlags: jsonResponse['flags'],
                 analyticsProcessor: this.analyticsProcessor,
                 defaultFlagHandler: this.defaultFlagHandler
             });
+            if (!!this.cache) {
+                await this.cache.set(`flags-${identifier}`, flags);
+            }
+            return flags;
         } catch (e) {
             if (this.defaultFlagHandler) {
                 return new Flags({
@@ -315,12 +377,6 @@ export class Flagsmith {
     }
 
     private buildIdentityModel(identifier: string, traits: { key: string; value: any }[]) {
-        if (!this.environment) {
-            throw new FlagsmithClientError(
-                'Unable to build identity model when no local environment present.'
-            );
-        }
-
         const traitModels = traits.map(trait => new TraitModel(trait.key, trait.value));
         return new IdentityModel('0', traitModels, [], this.environment.apiKey, identifier);
     }

package/sdk/polling_manager.ts

@@ -17,7 +17,6 @@ export class EnvironmentDataPollingManager {
                 await this.main.updateEnvironment();
             }, this.refreshIntervalSeconds * 1000);
         };
-        // todo: this call should be awaited for getIdentityFlags/getEnvironmentFlags when enableLocalEvaluation is true
         this.main.updateEnvironment();
         updateEnvironment();
     }

package/sdk/types.ts

@@ -0,0 +1,8 @@
+import { Flags } from "./models";
+
+export interface FlagsmithCache {
+  get(key: string): Promise<Flags>;
+  set(key: string, value: Flags): Promise<void>;
+  has(key: string): Promise<boolean>;
+  [key: string]: any;
+}