@splitsoftware/openfeature-js-split-provider 1.0.2

package/CHANGES.txt

@@ -0,0 +1,8 @@
+1.0.0
+- First release. Up to date with spec 0.4.0, and @openfeature/nodejs-sdk v0.2.0
+1.0.1
+- Fixes issues with flag details and error codes in negative cases, adds unit tests
+- Up to date with spec 0.4.0 and @openfeature/nodejs-sdk v0.3.2
+1.0.2
+- Changes name from Node-specific implementation to generic JSON
+- Up to date with spec 0.4.0 and @openfeature/js-sdk 0.4.0

package/CONTRIBUTORS-GUIDE.md

@@ -0,0 +1,28 @@
+# Contributing to the Split OpenFeature Provider
+
+The Split Provider is an open source project and we welcome feedback and contribution. The information below describes how to build the project with your changes, run the tests, and send the Pull Request(PR).
+
+## Development
+
+### Development process
+
+1. Fork the repository and create a topic branch from `development` branch. Please use a descriptive name for your branch.
+2. While developing, use descriptive messages in your commits. Avoid short or meaningless sentences like "fix bug".
+3. Make sure to add tests for both positive and negative cases.
+4. Run the build script and make sure it runs with no errors.
+5. Run all tests and make sure there are no failures.
+6. `git push` your changes to GitHub within your topic branch.
+7. Open a Pull Request(PR) from your forked repo and into the `development` branch of the original repository.
+8. When creating your PR, please fill out all the fields of the PR template, as applicable, for the project.
+9. Check for conflicts once the pull request is created to make sure your PR can be merged cleanly into `development`.
+10. Keep an eye out for any feedback or comments from the Split team.
+
+### Building the Split Provider
+- `npm run build`
+
+### Running tests
+- `npm run test`
+
+# Contact
+
+If you have any other questions or need to contact us directly in a private manner send us a note at sdks@split.io

package/LICENSE

@@ -0,0 +1,13 @@
+Copyright © 2022 Split Software, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,85 @@
+# Split OpenFeature Provider for NodeJS
+[![Twitter Follow](https://img.shields.io/twitter/follow/splitsoftware.svg?style=social&label=Follow&maxAge=1529000)](https://twitter.com/intent/follow?screen_name=splitsoftware)
+
+## Overview
+This Provider is designed to allow the use of OpenFeature with Split, the platform for controlled rollouts, serving features to your users via the Split feature flag to manage your complete customer experience.
+
+## Compatibility
+
+
+## Getting started
+Below is a simple example that describes the instantiation of the Split Provider. Please see the [OpenFeature Documentation](https://docs.openfeature.dev/docs/reference/concepts/evaluation-api) for details on how to use the OpenFeature SDK.
+
+```js
+const OpenFeature = require('@openfeature/js-sdk').OpenFeature;
+const SplitFactory = require('@splitsoftware/splitio').SplitFactory;
+const OpenFeatureSplitProvider = require('@splitsoftware/openfeature-nodejs-split-provider').OpenFeatureSplitProvider;
+
+splitClient = SplitFactory({core: {authorizationKey: 'localhost'}}).client();
+provider = new OpenFeatureSplitProvider({splitClient});
+openFeature.setProvider(provider);
+```
+
+## Use of OpenFeature with Split
+After the initial setup you can use OpenFeature according to their [documentation](https://docs.openfeature.dev/docs/reference/concepts/evaluation-api/).
+
+One important note is that the Split Provider **requires a targeting key** to be set. Often times this should be set when evaluating the value of a flag by [setting an EvaluationContext](https://docs.openfeature.dev/docs/reference/concepts/evaluation-context) which contains the targeting key. An example flag evaluation is
+```js
+const client = openFeature.getClient('CLIENT_NAME');
+
+const context: EvaluationContext = {
+  targetingKey: 'TARGETING_KEY',
+};
+const boolValue = await client.getBooleanValue('boolFlag', false, context);
+```
+If the same targeting key is used repeatedly, the evaluation context may be set at the client level 
+```js
+const context: EvaluationContext = {
+  targetingKey: 'TARGETING_KEY',
+};
+client.setEvaluationContext(context)
+```
+or at the OpenFeatureAPI level 
+```js
+const context: EvaluationContext = {
+  targetingKey: 'TARGETING_KEY',
+};
+OpenFeatureAPI.getInstance().setCtx(context)
+````
+If the context was set at the client or api level, it is not required to provide it during flag evaluation.
+
+## Submitting issues
+ 
+The Split team monitors all issues submitted to this [issue tracker](https://github.com/splitio/split-openfeature-provider-nodejs/issues). We encourage you to use this issue tracker to submit any bug reports, feedback, and feature enhancements. We'll do our best to respond in a timely manner.
+
+## Contributing
+Please see [Contributors Guide](CONTRIBUTORS-GUIDE.md) to find all you need to submit a Pull Request (PR).
+
+## License
+Licensed under the Apache License, Version 2.0. See: [Apache License](http://www.apache.org/licenses/).
+
+## About Split
+ 
+Split is the leading Feature Delivery Platform for engineering teams that want to confidently deploy features as fast as they can develop them. Split’s fine-grained management, real-time monitoring, and data-driven experimentation ensure that new features will improve the customer experience without breaking or degrading performance. Companies like Twilio, Salesforce, GoDaddy and WePay trust Split to power their feature delivery.
+ 
+To learn more about Split, contact hello@split.io, or get started with feature flags for free at https://www.split.io/signup.
+ 
+Split has built and maintains SDKs for:
+ 
+* Java [Github](https://github.com/splitio/java-client) [Docs](https://help.split.io/hc/en-us/articles/360020405151-Java-SDK)
+* Javascript [Github](https://github.com/splitio/javascript-client) [Docs](https://help.split.io/hc/en-us/articles/360020448791-JavaScript-SDK)
+* Node [Github](https://github.com/splitio/javascript-client) [Docs](https://help.split.io/hc/en-us/articles/360020564931-Node-js-SDK)
+* .NET [Github](https://github.com/splitio/dotnet-client) [Docs](https://help.split.io/hc/en-us/articles/360020240172--NET-SDK)
+* Ruby [Github](https://github.com/splitio/ruby-client) [Docs](https://help.split.io/hc/en-us/articles/360020673251-Ruby-SDK)
+* PHP [Github](https://github.com/splitio/php-client) [Docs](https://help.split.io/hc/en-us/articles/360020350372-PHP-SDK)
+* Python [Github](https://github.com/splitio/python-client) [Docs](https://help.split.io/hc/en-us/articles/360020359652-Python-SDK)
+* GO [Github](https://github.com/splitio/go-client) [Docs](https://help.split.io/hc/en-us/articles/360020093652-Go-SDK)
+* Android [Github](https://github.com/splitio/android-client) [Docs](https://help.split.io/hc/en-us/articles/360020343291-Android-SDK)
+* iOS [Github](https://github.com/splitio/ios-client) [Docs](https://help.split.io/hc/en-us/articles/360020401491-iOS-SDK)
+ 
+For a comprehensive list of open source projects visit our [Github page](https://github.com/splitio?utf8=%E2%9C%93&query=%20only%3Apublic%20).
+ 
+**Learn more about Split:**
+ 
+Visit [split.io/product](https://www.split.io/product) for an overview of Split, or visit our documentation at [help.split.io](http://help.split.io) for more detailed information.
+

package/es/index.js

@@ -0,0 +1 @@
+export * from './lib/js-split-provider';

package/es/lib/js-split-provider.js

@@ -0,0 +1,163 @@
+import { __assign, __awaiter, __generator, __rest } from "tslib";
+import { ParseError, FlagNotFoundError, StandardResolutionReasons } from '@openfeature/js-sdk';
+var OpenFeatureSplitProvider = /** @class */ (function () {
+    function OpenFeatureSplitProvider(options) {
+        var _this = this;
+        this.metadata = {
+            name: 'split',
+        };
+        this.client = options.splitClient;
+        this.initialized = new Promise(function (resolve) {
+            _this.client.on(_this.client.Event.SDK_READY, function () {
+                console.log(_this.metadata.name + " provider initialized");
+                resolve();
+            });
+        });
+    }
+    OpenFeatureSplitProvider.prototype.resolveBooleanEvaluation = function (flagKey, defaultValue, context) {
+        return __awaiter(this, void 0, void 0, function () {
+            var details, value;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.evaluateTreatment(flagKey, this.transformContext(context))];
+                    case 1:
+                        details = _a.sent();
+                        switch (details.value) {
+                            case 'on':
+                                value = true;
+                                break;
+                            case 'off':
+                                value = false;
+                                break;
+                            case 'true':
+                                value = true;
+                                break;
+                            case 'false':
+                                value = false;
+                                break;
+                            case true:
+                                value = true;
+                                break;
+                            case false:
+                                value = false;
+                                break;
+                            case 'control':
+                                value = defaultValue;
+                                details.reason = 'FLAG_NOT_FOUND';
+                                break;
+                            default:
+                                throw new ParseError("Invalid boolean value for " + details.value);
+                        }
+                        return [2 /*return*/, __assign(__assign({}, details), { value: value })];
+                }
+            });
+        });
+    };
+    OpenFeatureSplitProvider.prototype.resolveStringEvaluation = function (flagKey, _, context) {
+        return __awaiter(this, void 0, void 0, function () {
+            var details;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.evaluateTreatment(flagKey, this.transformContext(context))];
+                    case 1:
+                        details = _a.sent();
+                        if (details.value == 'control') {
+                            throw new FlagNotFoundError("Got error for split " + flagKey);
+                        }
+                        return [2 /*return*/, details];
+                }
+            });
+        });
+    };
+    OpenFeatureSplitProvider.prototype.resolveNumberEvaluation = function (flagKey, _, context) {
+        return __awaiter(this, void 0, void 0, function () {
+            var details;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.evaluateTreatment(flagKey, this.transformContext(context))];
+                    case 1:
+                        details = _a.sent();
+                        return [2 /*return*/, __assign(__assign({}, details), { value: this.parseValidNumber(details.value) })];
+                }
+            });
+        });
+    };
+    OpenFeatureSplitProvider.prototype.resolveObjectEvaluation = function (flagKey, _, context) {
+        return __awaiter(this, void 0, void 0, function () {
+            var details;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.evaluateTreatment(flagKey, this.transformContext(context))];
+                    case 1:
+                        details = _a.sent();
+                        return [2 /*return*/, __assign(__assign({}, details), { value: this.parseValidJsonObject(details.value) })];
+                }
+            });
+        });
+    };
+    OpenFeatureSplitProvider.prototype.evaluateTreatment = function (flagKey, consumer) {
+        return __awaiter(this, void 0, void 0, function () {
+            var details, value, details;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!!consumer.key) return [3 /*break*/, 1];
+                        details = {
+                            value: 'control',
+                            variant: 'control',
+                            reason: StandardResolutionReasons.ERROR,
+                            errorCode: 'TARGETING_KEY_MISSING'
+                        };
+                        return [2 /*return*/, details];
+                    case 1: return [4 /*yield*/, this.initialized];
+                    case 2:
+                        _a.sent();
+                        value = this.client.getTreatment(consumer.key, flagKey, consumer.attributes);
+                        details = {
+                            value: value,
+                            variant: value,
+                            reason: StandardResolutionReasons.TARGETING_MATCH
+                        };
+                        return [2 /*return*/, details];
+                }
+            });
+        });
+    };
+    //Transform the context into an object useful for the Split API, an key string with arbitrary Split "Attributes".
+    OpenFeatureSplitProvider.prototype.transformContext = function (context) {
+        var targetingKey = context.targetingKey, attributes = __rest(context, ["targetingKey"]);
+        return {
+            key: targetingKey,
+            // Stringify context objects include date.
+            attributes: JSON.parse(JSON.stringify(attributes)),
+        };
+    };
+    OpenFeatureSplitProvider.prototype.parseValidNumber = function (stringValue) {
+        if (stringValue === undefined) {
+            throw new ParseError("Invalid 'undefined' value.");
+        }
+        var result = Number.parseFloat(stringValue);
+        if (Number.isNaN(result)) {
+            throw new ParseError("Invalid numeric value " + stringValue);
+        }
+        return result;
+    };
+    OpenFeatureSplitProvider.prototype.parseValidJsonObject = function (stringValue) {
+        if (stringValue === undefined) {
+            throw new ParseError("Invalid 'undefined' JSON value.");
+        }
+        // we may want to allow the parsing to be customized.
+        try {
+            var value = JSON.parse(stringValue);
+            if (typeof value !== 'object') {
+                throw new ParseError("Flag value " + stringValue + " had unexpected type " + typeof value + ", expected \"object\"");
+            }
+            return value;
+        }
+        catch (err) {
+            throw new ParseError("Error parsing " + stringValue + " as JSON, " + err);
+        }
+    };
+    return OpenFeatureSplitProvider;
+}());
+export { OpenFeatureSplitProvider };

package/lib/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+(0, tslib_1.__exportStar)(require("./lib/js-split-provider"), exports);

package/lib/lib/js-split-provider.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenFeatureSplitProvider = void 0;
+var tslib_1 = require("tslib");
+var js_sdk_1 = require("@openfeature/js-sdk");
+var OpenFeatureSplitProvider = /** @class */ (function () {
+    function OpenFeatureSplitProvider(options) {
+        var _this = this;
+        this.metadata = {
+            name: 'split',
+        };
+        this.client = options.splitClient;
+        this.initialized = new Promise(function (resolve) {
+            _this.client.on(_this.client.Event.SDK_READY, function () {
+                console.log(_this.metadata.name + " provider initialized");
+                resolve();
+            });
+        });
+    }
+    OpenFeatureSplitProvider.prototype.resolveBooleanEvaluation = function (flagKey, defaultValue, context) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var details, value;
+            return (0, tslib_1.__generator)(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.evaluateTreatment(flagKey, this.transformContext(context))];
+                    case 1:
+                        details = _a.sent();
+                        switch (details.value) {
+                            case 'on':
+                                value = true;
+                                break;
+                            case 'off':
+                                value = false;
+                                break;
+                            case 'true':
+                                value = true;
+                                break;
+                            case 'false':
+                                value = false;
+                                break;
+                            case true:
+                                value = true;
+                                break;
+                            case false:
+                                value = false;
+                                break;
+                            case 'control':
+                                value = defaultValue;
+                                details.reason = 'FLAG_NOT_FOUND';
+                                break;
+                            default:
+                                throw new js_sdk_1.ParseError("Invalid boolean value for " + details.value);
+                        }
+                        return [2 /*return*/, (0, tslib_1.__assign)((0, tslib_1.__assign)({}, details), { value: value })];
+                }
+            });
+        });
+    };
+    OpenFeatureSplitProvider.prototype.resolveStringEvaluation = function (flagKey, _, context) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var details;
+            return (0, tslib_1.__generator)(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.evaluateTreatment(flagKey, this.transformContext(context))];
+                    case 1:
+                        details = _a.sent();
+                        if (details.value == 'control') {
+                            throw new js_sdk_1.FlagNotFoundError("Got error for split " + flagKey);
+                        }
+                        return [2 /*return*/, details];
+                }
+            });
+        });
+    };
+    OpenFeatureSplitProvider.prototype.resolveNumberEvaluation = function (flagKey, _, context) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var details;
+            return (0, tslib_1.__generator)(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.evaluateTreatment(flagKey, this.transformContext(context))];
+                    case 1:
+                        details = _a.sent();
+                        return [2 /*return*/, (0, tslib_1.__assign)((0, tslib_1.__assign)({}, details), { value: this.parseValidNumber(details.value) })];
+                }
+            });
+        });
+    };
+    OpenFeatureSplitProvider.prototype.resolveObjectEvaluation = function (flagKey, _, context) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var details;
+            return (0, tslib_1.__generator)(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.evaluateTreatment(flagKey, this.transformContext(context))];
+                    case 1:
+                        details = _a.sent();
+                        return [2 /*return*/, (0, tslib_1.__assign)((0, tslib_1.__assign)({}, details), { value: this.parseValidJsonObject(details.value) })];
+                }
+            });
+        });
+    };
+    OpenFeatureSplitProvider.prototype.evaluateTreatment = function (flagKey, consumer) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var details, value, details;
+            return (0, tslib_1.__generator)(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!!consumer.key) return [3 /*break*/, 1];
+                        details = {
+                            value: 'control',
+                            variant: 'control',
+                            reason: js_sdk_1.StandardResolutionReasons.ERROR,
+                            errorCode: 'TARGETING_KEY_MISSING'
+                        };
+                        return [2 /*return*/, details];
+                    case 1: return [4 /*yield*/, this.initialized];
+                    case 2:
+                        _a.sent();
+                        value = this.client.getTreatment(consumer.key, flagKey, consumer.attributes);
+                        details = {
+                            value: value,
+                            variant: value,
+                            reason: js_sdk_1.StandardResolutionReasons.TARGETING_MATCH
+                        };
+                        return [2 /*return*/, details];
+                }
+            });
+        });
+    };
+    //Transform the context into an object useful for the Split API, an key string with arbitrary Split "Attributes".
+    OpenFeatureSplitProvider.prototype.transformContext = function (context) {
+        var targetingKey = context.targetingKey, attributes = (0, tslib_1.__rest)(context, ["targetingKey"]);
+        return {
+            key: targetingKey,
+            // Stringify context objects include date.
+            attributes: JSON.parse(JSON.stringify(attributes)),
+        };
+    };
+    OpenFeatureSplitProvider.prototype.parseValidNumber = function (stringValue) {
+        if (stringValue === undefined) {
+            throw new js_sdk_1.ParseError("Invalid 'undefined' value.");
+        }
+        var result = Number.parseFloat(stringValue);
+        if (Number.isNaN(result)) {
+            throw new js_sdk_1.ParseError("Invalid numeric value " + stringValue);
+        }
+        return result;
+    };
+    OpenFeatureSplitProvider.prototype.parseValidJsonObject = function (stringValue) {
+        if (stringValue === undefined) {
+            throw new js_sdk_1.ParseError("Invalid 'undefined' JSON value.");
+        }
+        // we may want to allow the parsing to be customized.
+        try {
+            var value = JSON.parse(stringValue);
+            if (typeof value !== 'object') {
+                throw new js_sdk_1.ParseError("Flag value " + stringValue + " had unexpected type " + typeof value + ", expected \"object\"");
+            }
+            return value;
+        }
+        catch (err) {
+            throw new js_sdk_1.ParseError("Error parsing " + stringValue + " as JSON, " + err);
+        }
+    };
+    return OpenFeatureSplitProvider;
+}());
+exports.OpenFeatureSplitProvider = OpenFeatureSplitProvider;

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@splitsoftware/openfeature-js-split-provider",
+  "version": "1.0.2",
+  "description": "Split OpenFeature Provider",
+  "files": [
+    "README.md",
+    "CONTRIBUTORS-GUIDE.md",
+    "LICENSE",
+    "CHANGES.txt",
+    "lib",
+    "types",
+    "es",
+    "src"
+  ],
+  "repository": "splitio/openfeature-split-provider-js",
+  "homepage": "https://github.com/splitio/openfeature-split-provider-nodejs#readme",
+  "bugs": "https://github.com/splitio/openfeature-split-provider-nodejs/issues",
+  "license": "Apache-2.0",
+  "author": "Josh Sirota <josh.sirota@split.io>",
+  "contributors": [
+  ],
+  "main": "lib/index.js",
+  "module": "es/index.js",
+  "types": "types",
+  "engines": {
+    "npm": ">=3",
+    "node": ">=6"
+  },
+  "dependencies": {
+    "@openfeature/js-sdk": "^0.4.0",
+    "@splitsoftware/splitio": "^10.21.1"
+  },
+  "devDependencies": {
+    "copyfiles": "^2.4.1",
+    "cross-env": "^7.0.3",
+    "replace": "^1.2.1",
+    "rimraf": "^3.0.2",
+    "tap-min": "^2.0.0",
+    "tape": "4.13.2",
+    "tape-catch": "1.0.6",
+    "ts-node": "^10.5.0",
+    "typescript": "4.4.4"
+  },
+  "scripts": {
+    "build-esm": "rimraf es && tsc -outDir es",
+    "postbuild-esm": "cross-env NODE_ENV=es node scripts/copy.packages.json.js && ./scripts/build_esm_replace_imports.sh",
+    "build-cjs": "rimraf lib && tsc -outDir lib -m CommonJS",
+    "postbuild-cjs": "cross-env NODE_ENV=cjs node scripts/copy.packages.json.js && ./scripts/build_cjs_replace_imports.sh",
+    "build": "rimraf lib es && npm run build-cjs && npm run build-esm",
+    "check": "npm run check:version",
+    "check:version": "cross-env NODE_ENV=test tape -r ./ts-node.register src/settings/__tests__/defaults.spec.js",
+    "pretest-ts-decls": "npm run build-esm && npm run build-cjs && npm link",
+    "test-ts-decls": "./scripts/ts-tests.sh",
+    "posttest-ts-decls": "npm unlink && npm install",
+    "test": "cross-env NODE_ENV=test tape -r ./ts-node.register src/__tests__/node.spec.js | tap-min",
+    "publish:rc": "npm run check && npm run build && npm publish --tag canary",
+    "publish:stable": "npm run check && npm run build && npm publish"
+  },
+  "greenkeeper": {
+    "ignore": [
+      "karma",
+      "karma-tap",
+      "karma-webpack"
+    ]
+  }
+}

package/src/__tests__/node.spec.js

@@ -0,0 +1,8 @@
+import tape from 'tape-catch';
+
+import clientSuite from './nodeSuites/client.spec.js';
+import providerSuite from './nodeSuites/provider.spec.js';
+
+tape('## OpenFeature NodeJS Split Provider - tests', async function (assert) {
+  assert.test('Client Tests', clientSuite);
+});

package/src/__tests__/nodeSuites/client.spec.js

@@ -0,0 +1,188 @@
+const OpenFeature = require('@openfeature/js-sdk').OpenFeature;
+const SplitFactory = require('@splitsoftware/splitio').SplitFactory;
+import { OpenFeatureSplitProvider } from '../..';
+
+export default async function(assert) {
+
+  const useDefaultTest = async (client) => {
+    let flagName = 'random-non-existent-feature';
+
+    let result = await client.getBooleanValue(flagName, false);
+    assert.equal(result, false);
+
+    let result2 = await client.getBooleanValue(flagName, true);
+    assert.equal(result2, true);
+
+    let defaultString = 'blah';
+    let resultString = await client.getStringValue(flagName, defaultString);
+    assert.equals(resultString, defaultString);
+
+    let defaultInt = 100;
+    let resultInt = await client.getNumberValue(flagName, defaultInt);
+    assert.equals(resultInt, defaultInt);
+
+    let defaultStructure = {
+      foo: 'bar'
+    };
+    let resultStructure = await client.getObjectValue(flagName, defaultStructure);
+    assert.equals(resultStructure, defaultStructure);
+  };
+
+  const missingTargetingKeyTest = async (client) => {
+    let details = await client.getBooleanDetails('non-existent-feature', false, { targetingKey: undefined });
+    assert.equals(details.value, false);
+    assert.equals(details.errorCode, 'TARGETING_KEY_MISSING');
+  };
+
+  const getControlVariantNonExistentSplit = async (client) => {
+    let details = await client.getBooleanDetails('non-existent-feature', false);
+    assert.equals(details.value, false);
+    assert.equals(details.variant, 'control');
+    assert.equals(details.reason, 'FLAG_NOT_FOUND');
+  };
+
+  const getBooleanSplitTest = async (client) => {
+    let result = await client.getBooleanValue('some_other_feature', true);
+    assert.equals(result, false);
+  };
+
+  const getBooleanSplitWithKeyTest = async (client) => {
+    let result = await client.getBooleanValue('my_feature', false);
+    assert.equals(result, true);
+
+    result = await client.getBooleanValue('my_feature', true, { targetingKey: 'randomKey' });
+    assert.equals(result, false);
+  };
+
+  const getStringSplitTest = async (client) => {
+    let result = await client.getStringValue('some_other_feature', 'on');
+    assert.equals(result, 'off');
+  };
+
+  const getNumberSplitTest = async (client) => {
+    let result = await client.getNumberValue('int_feature', 0);
+    assert.equals(result, 32);
+  };
+
+  const getObjectSplitTest = async (client) => {
+    let result = await client.getObjectValue('obj_feature', {});
+    assert.looseEquals(result, { 'key': 'value' });
+  };
+
+  const getMetadataNameTest = async (client) => {
+    assert.equals(client.metadata.name, 'test');
+  };
+
+  const getBooleanDetailsTest = async (client) => {
+    let details = await client.getBooleanDetails('some_other_feature', true);
+    assert.equals(details.flagKey, 'some_other_feature');
+    assert.equals(details.reason, 'TARGETING_MATCH');
+    assert.equals(details.value, false);
+    assert.equals(details.variant, 'off');
+    assert.equals(details.errorCode, undefined);
+  };
+
+  const getNumberDetailsTest = async (client) => {
+    let details = await client.getNumberDetails('int_feature', 0);
+    assert.equals(details.flagKey, 'int_feature');
+    assert.equals(details.reason, 'TARGETING_MATCH');
+    assert.equals(details.value, 32);
+    assert.equals(details.variant, '32');
+    assert.equals(details.errorCode, undefined);
+  };
+
+  const getStringDetailsTest = async (client) => {
+    let details = await client.getStringDetails('some_other_feature', 'blah');
+    assert.equals(details.flagKey, 'some_other_feature');
+    assert.equals(details.reason, 'TARGETING_MATCH');
+    assert.equals(details.value, 'off');
+    assert.equals(details.variant, 'off');
+    assert.equals(details.errorCode, undefined);
+  };
+
+  const getObjectDetailsTest = async (client) => {
+    let details = await client.getObjectDetails('obj_feature', {});
+    assert.equals(details.flagKey, 'obj_feature');
+    assert.equals(details.reason, 'TARGETING_MATCH');
+    assert.looseEquals(details.value, { key: 'value' });
+    assert.equals(details.variant, '{"key": "value"}');
+    assert.equals(details.errorCode, undefined);
+  };
+
+  const getBooleanFailTest = async (client) => {
+    let value = await client.getBooleanValue('obj_feature', false);
+    assert.equals(value, false);
+
+    let details = await client.getBooleanDetails('obj_feature', false);
+    assert.equals(details.value, false);
+    assert.equals(details.errorCode, 'PARSE_ERROR');
+    assert.equals(details.reason, 'ERROR');
+    assert.equals(details.variant, undefined);
+  };
+
+  const getNumberFailTest = async (client) => {
+    let value = await client.getNumberValue('obj_feature', 10);
+    assert.equals(value, 10);
+
+    let details = await client.getNumberDetails('obj_feature', 10);
+    assert.equals(details.value, 10);
+    assert.equals(details.errorCode, 'PARSE_ERROR');
+    assert.equals(details.reason, 'ERROR');
+    assert.equals(details.variant, undefined);
+  };
+
+  const getObjectFailTest = async (client) => {
+    let defaultObject = { foo: 'bar' };
+    let value = await client.getObjectValue('int_feature', defaultObject);
+    assert.equals(value, defaultObject);
+
+    let details = await client.getObjectDetails('int_feature', defaultObject);
+    assert.equals(details.value, defaultObject);
+    assert.equals(details.errorCode, 'PARSE_ERROR');
+    assert.equals(details.reason, 'ERROR');
+    assert.equals(details.variant, undefined);
+  };
+
+  let splitClient = SplitFactory({
+    core: {
+      authorizationKey: 'localhost'
+    },
+    features: './split.yaml',
+    debug: 'DEBUG'
+  }).client();
+
+  let provider = new OpenFeatureSplitProvider({splitClient});
+  OpenFeature.setProvider(provider);
+
+  let client = OpenFeature.getClient('test');
+  let evaluationContext = {
+    targetingKey: 'key'
+  };
+  client.setContext(evaluationContext);
+
+  await useDefaultTest(client);
+  await missingTargetingKeyTest(client);  
+  await getControlVariantNonExistentSplit(client);
+
+  await getBooleanSplitTest(client);
+  await getBooleanSplitWithKeyTest(client);
+ 
+  await getStringSplitTest(client);
+  await getNumberSplitTest(client);
+  await getObjectSplitTest(client);
+ 
+  await getMetadataNameTest(client);
+ 
+  await getBooleanDetailsTest(client);
+  await getNumberDetailsTest(client);
+  await getStringDetailsTest(client);
+  await getObjectDetailsTest(client);
+ 
+  await getBooleanFailTest(client);
+  await getNumberFailTest(client);
+  await getObjectFailTest(client);
+
+  splitClient.destroy(); // Shut down open handles
+
+  assert.end();
+}

package/src/__tests__/nodeSuites/provider.spec.js

@@ -0,0 +1,109 @@
+export default async function(assert) {
+
+  const shouldFailWithBadApiKeyTest = () => {
+    assert.equal(1, 1);
+  };
+
+  const evalBooleanNullEmptyTest = () => {
+    assert.equal(2, 2);
+  };
+
+  const evalBooleanControlTest = () => {
+    assert.equal(1, 1);
+  };
+
+  const evalBooleanTrueTest = () => {
+    assert.equal(1, 1);
+  };
+
+  const evalBooleanOnTest = () => {
+    assert.equal(1, 1);
+  };
+
+  const evalBooleanFalseTest = () => {
+    assert.equal(1, 1);
+  };
+
+  const evalBooleanOffTest = () => {
+    assert.equal(1, 1);
+  };
+
+  const evalBooleanErrorTest = () => {
+    assert.equal(1, 1);
+  };
+
+  const evalStringNullEmptyTest = () => {
+    assert.equal(1, 1);
+  };
+
+  const evalStringControlTest = () => {
+    assert.equal(1, 1);
+  };
+
+  const evalStringRegularTest = () => {
+    assert.equal(1, 1);
+  };
+
+  const evalNumberNullEmptyTest = () => {
+    assert.equal(1, 1);
+  };
+
+  const evalNumberControlTest = () => {
+    assert.equal(1, 1);
+  };
+
+  const evalNumberRegularTest = () => {
+    assert.equal(1, 1);
+  };
+
+  const evalNumberErrorTest = () => {
+    assert.equal(1, 1);
+  };
+
+  const evalStructureNullEmptyTest = () => {
+    assert.equal(1, 1);
+  };
+
+  const evalStructureControlTest = () => {
+    assert.equal(1, 1);
+  };
+
+  const evalStructureRegularTest = () => {
+    assert.equal(1, 1);
+  };
+
+  const evalStructureComplexTest = () => {
+    assert.equal(1, 1);
+  };
+
+  const evalStructureErrorTest = () => {
+    assert.equal(1, 1);
+  };
+
+  shouldFailWithBadApiKeyTest();
+
+  evalBooleanNullEmptyTest();
+  evalBooleanControlTest();
+  evalBooleanTrueTest();
+  evalBooleanOnTest();
+  evalBooleanFalseTest();
+  evalBooleanOffTest();
+  evalBooleanErrorTest();
+
+  evalStringNullEmptyTest();
+  evalStringControlTest();
+  evalStringRegularTest();
+
+  evalNumberNullEmptyTest();
+  evalNumberControlTest();
+  evalNumberRegularTest();
+  evalNumberErrorTest();
+
+  evalStructureNullEmptyTest();
+  evalStructureControlTest();
+  evalStructureRegularTest();
+  evalStructureComplexTest();
+  evalStructureErrorTest();
+
+  assert.end();
+}

package/src/__tests__/testUtils/browser.js

@@ -0,0 +1,7 @@
+// Util method to trigger 'unload' DOM event
+export function triggerUnloadEvent() {
+  const event = document.createEvent('HTMLEvents');
+  event.initEvent('unload', true, true);
+  event.eventName = 'unload';
+  window.dispatchEvent(event);
+}

package/src/__tests__/testUtils/eventSourceMock.js

@@ -0,0 +1,85 @@
+/**
+ * EventEmitter mock based on https://github.com/gcedo/eventsourcemock/blob/master/src/EventSource.js
+ *
+ * To setup the mock assign it to the window object.
+ * ```
+ *  import EventSource from 'eventsourcemock';
+ *  Object.defineProperty(window, 'EventSource', {
+ *    value: EventSource,
+ *  });
+ * ```
+ *
+ */
+
+import EventEmitter from 'events';
+
+const defaultOptions = {
+  withCredentials: false
+};
+
+export const sources = {};
+let __listener;
+export function setMockListener(listener) {
+  __listener = listener;
+}
+
+export default class EventSource {
+
+  constructor(
+    url,
+    eventSourceInitDict = defaultOptions
+  ) {
+    this.url = url;
+    this.withCredentials = eventSourceInitDict.withCredentials;
+    this.readyState = 0;
+    // eslint-disable-next-line no-undef
+    this.__emitter = new EventEmitter();
+    this.__eventSourceInitDict = arguments[1];
+    sources[url] = this;
+    if (__listener) setTimeout(__listener, 0, this);
+  }
+
+  addEventListener(eventName, listener) {
+    this.__emitter.addListener(eventName, listener);
+  }
+
+  removeEventListener(eventName, listener) {
+    this.__emitter.removeListener(eventName, listener);
+  }
+
+  close() {
+    this.readyState = 2;
+  }
+
+  // The following methods can be used to mock EventSource behavior and events
+  emit(eventName, messageEvent) {
+    this.__emitter.emit(eventName, messageEvent);
+
+    let listener;
+    switch (eventName) {
+      case 'error': listener = this.onerror; break;
+      case 'open': listener = this.onopen; break;
+      case 'message': listener = this.onmessage; break;
+    }
+    if (typeof listener === 'function') {
+      listener(messageEvent);
+    }
+  }
+
+  emitError(error) {
+    this.emit('error', error);
+  }
+
+  emitOpen() {
+    this.readyState = 1;
+    this.emit('open');
+  }
+
+  emitMessage(message) {
+    this.emit('message', message);
+  }
+}
+
+EventSource.CONNECTING = 0;
+EventSource.OPEN = 1;
+EventSource.CLOSED = 2;

package/src/__tests__/testUtils/fetchMock/browser.js

@@ -0,0 +1,6 @@
+import fetchMock from 'fetch-mock';
+
+// config the fetch mock to chain routes (appends the new route to the list of routes)
+fetchMock.config.overwriteRoutes = false;
+
+export default fetchMock;

package/src/__tests__/testUtils/fetchMock/node.js

@@ -0,0 +1,11 @@
+import fetchMock from 'fetch-mock';
+import { __setFetch } from '../../../platform/getFetch/node';
+
+const sandboxFetchMock = fetchMock.sandbox();
+
+// config the fetch mock to chain routes (appends the new route to the list of routes)
+sandboxFetchMock.config.overwriteRoutes = false;
+
+__setFetch(sandboxFetchMock);
+
+export default sandboxFetchMock;

package/src/__tests__/testUtils/fetchMock/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "./node.js",
+  "browser": "./browser.js"
+}

package/src/__tests__/testUtils/index.js

@@ -0,0 +1,69 @@
+const DEFAULT_ERROR_MARGIN = 50; // 0.05 secs
+
+/**
+ * Assert if an `actual` and `expected` numeric values are nearlyEqual.
+ *
+ * @param {number} actual actual time lapse in millis
+ * @param {number} expected expected time lapse in millis
+ * @param {number} epsilon error margin in millis
+ * @returns {boolean} whether the absolute difference is minor to epsilon value or not
+ */
+export function nearlyEqual(actual, expected, epsilon = DEFAULT_ERROR_MARGIN) {
+  const diff = Math.abs(actual - expected);
+  return diff <= epsilon;
+}
+
+/**
+ * mock the basic behaviour for `/segmentChanges` endpoint:
+ *  - when `?since=-1`, it returns the given segment `keys` in `added` list.
+ *  - otherwise, it returns empty `added` and `removed` lists, and the same since and till values.
+ *
+ * @param {Object} fetchMock see http://www.wheresrhys.co.uk/fetch-mock
+ * @param {string|RegExp|...} matcher see http://www.wheresrhys.co.uk/fetch-mock/#api-mockingmock_matcher
+ * @param {string[]} keys array of segment keys to fetch
+ * @param {number} changeNumber optional changeNumber
+ */
+export function mockSegmentChanges(fetchMock, matcher, keys, changeNumber = 1457552620999) {
+  fetchMock.get(matcher, function (url) {
+    const since = parseInt(url.split('=').pop());
+    const name = url.split('?')[0].split('/').pop();
+    return {
+      status: 200, body: {
+        'name': name,
+        'added': since === -1 ? keys : [],
+        'removed': [],
+        'since': since,
+        'till': since === -1 ? changeNumber : since,
+      }
+    };
+  });
+}
+
+export function hasNoCacheHeader(fetchMockOpts) {
+  return fetchMockOpts.headers['Cache-Control'] === 'no-cache';
+}
+
+const eventsEndpointMatcher = /^\/(testImpressions|metrics|events)/;
+const authEndpointMatcher = /^\/v2\/auth/;
+const streamingEndpointMatcher = /^\/(sse|event-stream)/;
+
+/**
+ * Switch URLs servers based on target.
+ * Only used for testing purposes.
+ *
+ * @param {Object} settings settings object
+ * @param {String} target url path
+ * @return {String}  completed url
+ */
+export function url(settings, target) {
+  if (eventsEndpointMatcher.test(target)) {
+    return `${settings.urls.events}${target}`;
+  }
+  if (authEndpointMatcher.test(target)) {
+    return `${settings.urls.auth}${target}`;
+  }
+  if (streamingEndpointMatcher.test(target)) {
+    return `${settings.urls.streaming}${target}`;
+  }
+  return `${settings.urls.sdk}${target}`;
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from './lib/js-split-provider';

package/src/lib/js-split-provider.ts

@@ -0,0 +1,156 @@
+import { EvaluationContext, Provider, ResolutionDetails, ParseError, FlagNotFoundError, JsonValue, OpenFeatureError, StandardResolutionReasons } from '@openfeature/js-sdk';
+import SplitIO from '@splitsoftware/splitio/types/splitio';
+
+export interface SplitProviderOptions {
+  splitClient: SplitIO.IClient;
+}
+
+type Consumer = {
+  key: string | undefined;
+  attributes: SplitIO.Attributes;
+};
+
+export class OpenFeatureSplitProvider implements Provider {
+  metadata = {
+    name: 'split',
+  };
+  private initialized: Promise<void>;
+  private client: SplitIO.IClient;
+
+  constructor(options: SplitProviderOptions) {
+    this.client = options.splitClient;
+    this.initialized = new Promise((resolve) => {
+      this.client.on(this.client.Event.SDK_READY, () => {
+        console.log(`${this.metadata.name} provider initialized`);
+        resolve();
+      });
+    });
+  }
+
+  async resolveBooleanEvaluation(
+    flagKey: string,
+    defaultValue: boolean,
+    context: EvaluationContext
+  ): Promise<ResolutionDetails<boolean>> {
+    const details = await this.evaluateTreatment(flagKey, this.transformContext(context));
+
+    let value: boolean;
+    switch (details.value as unknown) {
+      case 'on':
+        value = true;
+        break;
+      case 'off':
+        value = false;
+        break;
+      case 'true':
+        value = true;
+        break;
+      case 'false':
+        value = false;
+        break;
+      case true:
+        value = true;
+        break;
+      case false:
+        value = false;
+        break;
+      case 'control':
+        value = defaultValue;
+        details.reason = 'FLAG_NOT_FOUND';
+        break;
+      default:
+        throw new ParseError(`Invalid boolean value for ${details.value}`);
+    }
+    return { ...details, value };
+  }
+
+  async resolveStringEvaluation(
+    flagKey: string,
+    _: string,
+    context: EvaluationContext
+  ): Promise<ResolutionDetails<string>> {
+    const details = await this.evaluateTreatment(flagKey, this.transformContext(context));
+    if (details.value == 'control') {
+      throw new FlagNotFoundError(`Got error for split ${flagKey}`);
+    }
+    return details;
+  }
+
+  async resolveNumberEvaluation(
+    flagKey: string,
+    _: number,
+    context: EvaluationContext
+  ): Promise<ResolutionDetails<number>> {
+    const details = await this.evaluateTreatment(flagKey, this.transformContext(context));
+    return { ...details, value: this.parseValidNumber(details.value) };
+  }
+
+  async resolveObjectEvaluation<U extends JsonValue>(
+    flagKey: string,
+    _: U,
+    context: EvaluationContext
+  ): Promise<ResolutionDetails<U>> {
+    const details = await this.evaluateTreatment(flagKey, this.transformContext(context));
+    return { ...details, value: this.parseValidJsonObject(details.value) };
+  }
+
+  private async evaluateTreatment(flagKey: string, consumer: Consumer): Promise<ResolutionDetails<string>> {
+    if (!consumer.key) {
+      const details: ResolutionDetails<string> = {
+        value: 'control',
+        variant: 'control',
+        reason: StandardResolutionReasons.ERROR,
+        errorCode: 'TARGETING_KEY_MISSING'
+      }
+      return details;
+    } else {
+      await this.initialized;
+      const value = this.client.getTreatment(consumer.key, flagKey, consumer.attributes);
+      const details: ResolutionDetails<string> = {
+        value: value,
+        variant: value,
+        reason: StandardResolutionReasons.TARGETING_MATCH
+      };
+      return details;
+    }
+  }
+
+  //Transform the context into an object useful for the Split API, an key string with arbitrary Split "Attributes".
+  private transformContext(context: EvaluationContext): Consumer {
+    const { targetingKey, ...attributes } = context;
+    return {
+      key: targetingKey,
+      // Stringify context objects include date.
+      attributes: JSON.parse(JSON.stringify(attributes)),
+    };
+  }
+
+  private parseValidNumber(stringValue: string | undefined) {
+    if (stringValue === undefined) {
+      throw new ParseError(`Invalid 'undefined' value.`);
+    }
+    const result = Number.parseFloat(stringValue);
+    if (Number.isNaN(result)) {
+      throw new ParseError(`Invalid numeric value ${stringValue}`);
+    }
+    return result;
+  }
+
+  private parseValidJsonObject<T extends JsonValue>(stringValue: string | undefined): T {
+    if (stringValue === undefined) {
+      throw new ParseError(`Invalid 'undefined' JSON value.`);
+    }
+    // we may want to allow the parsing to be customized.
+    try {
+      const value = JSON.parse(stringValue);
+      if (typeof value !== 'object') {
+        throw new ParseError(
+          `Flag value ${stringValue} had unexpected type ${typeof value}, expected "object"`
+        );
+      }
+      return value;
+    } catch (err) {
+      throw new ParseError(`Error parsing ${stringValue} as JSON, ${err}`);
+    }
+  }
+}