Initial commit

Author: Mahrukhizhar

.gitignore

@@ -0,0 +1,28 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# dependencies
+/node_modules
+/.pnp	
+.pnp.js
+
+# testing
+/coverage
+
+# production
+/build
+
+package-lock.json
+
+# misc
+.DS_Store
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+jmeter.log
+jmeter/results.xml
+.eslintcache

package-lock.json

@@ -0,0 +1,16 @@
+{
+  "name": "node_sdk",
+  "version": "1.0.0",
+  "description": "",
+  "main": "src/index.js",
+  "scripts": {
+    "start": "node src/index.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "type": "module",
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "object-assign": "^4.1.1"
+  }
+}

package.json

@@ -0,0 +1,19 @@
+
+export function ulClient(config) {
+    return {
+        config: config,
+        variation : (flagKey,identity,attributes={}) =>{
+            if(flagKey == undefined || flagKey.length < 0){
+                console.error('Please provide valid flagKey');
+                return "control";
+            }
+            if(identity == undefined || identity.length<0){
+                console.error('Please provide valid identity')
+                return "control";
+            }
+            console.log('evaluating variation')
+            return "variation-1";   
+        }
+    }
+
+}

src/client/ulClient.js

@@ -0,0 +1,33 @@
+/**
+ * Factory method for UnLaunch Client
+ */
+
+import { ConfigsFactory } from '../utils/settings/index.js'
+import { validateApiKey } from '../utils/validations/apiKey.js';
+import Store from '../utils/store/index.js';
+import {CONFIGURATIONS,READY} from '../utils/store/constants.js';
+import {ulClient} from '../client/ulClient.js'
+
+
+export function UnlaunchFactory(configurations) {
+    const store = new Store();
+    const configs = ConfigsFactory(configurations);
+    store.set(CONFIGURATIONS, configs);
+    store.set(READY, true);
+
+    console.log(store.getAll())
+    if (!configs.core.sdkKey) {
+        throw ('Factory intantiation requires a valid sdk key');
+    } else {
+        if (!validateApiKey(configs.core.sdkKey)) {
+            throw ('Client intantiation requires a valid sdk key');
+        }
+    }
+    return {
+        client() {
+            console.info('New client instance created.');
+            return ulClient(configs);
+        },
+        logger: 'Logger' // add it later
+    }
+} 

src/client/ulFactory.js

@@ -0,0 +1,11 @@
+//constants
+export const CONSTANTS = {
+  SDK_READY: 'Getting ready - Unlaunch SDK',
+  SDK_VARIATION: 'SDK - Get Variation',
+  SDK_VARIATION_WITH_CONFIG: 'SDK - Get Variation with config',
+  FLAGS_READY: 'Getting ready - Feature Flags',
+  METRICS_PUSH: 'Pushing - Metrics',
+  IMPRESSIONS_PUSH: 'Pushing - Impressions',
+  EVENTS_PUSH: 'Pushing - Events',
+  FLAGS_FETCH: 'Fetching - Feature Flags'
+};

src/constants/constants.js

@@ -0,0 +1,21 @@
+import {UnlaunchFactory} from '../src/client/ulFactory.js';
+
+var factory = UnlaunchFactory({
+    core:{
+        sdkKey:'111'
+        },
+    intervals: {
+        // fetch feature updates each 30 sec
+        pollingInterval: 440,
+        // publish metrics each 120 sec
+        metricsFlushInterval: 120,
+        // flush events every 60 seconds after the first flush
+        eventsFlushInterval: 60,
+        // http connection timeout 
+        httpConnectionTimeout: 10
+      }
+  });
+  
+const client = factory.client();
+const variation = client.variation();
+console.log("Evaluation Result: "+ variation);

src/index.js

@@ -0,0 +1,36 @@
+
+/**
+ * Checks if a given value is a string.
+ */
+export function isString(val) {
+  return typeof val === 'string' || val instanceof String;
+}
+
+/**
+ * Validates if a value is an object.
+ */
+
+export function isObject(obj) {
+  return obj && typeof obj === 'object' && obj.constructor === Object;
+}
+
+/**
+ * Overwriting default with custom configuration
+ * Validation: Parameters should always be correct (at least have a target and a source, of type object).
+ */
+
+export function merge(source, custom) {
+  let res = {};
+ 
+  isObject(source) && Object.keys(source).forEach(key => {
+    let val = source[key];
+    if(custom[key] && isObject(custom[key])){
+      Object.keys(custom[key]).forEach(customkey =>{
+        source[key][customkey] = custom[key][customkey];
+      })
+    }
+  
+  });
+
+  return source;
+}

src/utils/lang/index.js

@@ -0,0 +1,56 @@
+import objectAssign from 'object-assign';
+import { merge } from "../../../src/utils/lang/index.js";
+
+const base = {
+  core:{
+    sdkKey:'',
+    host:'http://app.unlaunch.io/'
+  },
+  intervals: {
+    // fetch feature updates each 30 sec
+    pollingInterval: 30,
+    // publish metrics each 120 sec
+    metricsFlushInterval: 120,
+    // flush events every 60 seconds after the first flush
+    eventsFlushInterval: 60,
+    // http connection timeout 
+    httpConnectionTimeout: 10
+  },
+  mode: {
+    offlineMode: false
+  },
+
+  urls: {
+    // CDN having all the information for your environment
+    sdk: '/api/v1/flags',
+    // Storage for your SDK events
+    events: '/api/v1/events'
+  },
+
+};
+
+function fromSecondsToMillis(n) {
+  return Math.round(n * 1000);
+}
+
+function defaults(custom) {
+  const withDefaults = merge(base, custom);
+
+  // // Scheduler periods
+  withDefaults.intervals.pollingInterval = fromSecondsToMillis(withDefaults.intervals.pollingInterval);
+  withDefaults.intervals.metricsFlushInterval = fromSecondsToMillis(withDefaults.intervals.metricsFlushInterval);
+  withDefaults.intervals.httpConnectionTimeout = fromSecondsToMillis(withDefaults.intervals.httpConnectionTimeout);
+  withDefaults.intervals.eventsFlushInterval = fromSecondsToMillis(withDefaults.intervals.eventsFlushInterval);
+
+  // // mode
+  //  withDefaults.mode.offlineMode = false;
+
+  // Startup periods
+  //  withDefaults.startup.requestTimeoutBeforeReady = fromSecondsToMillis(withDefaults.startup.requestTimeoutBeforeReady);
+  //  withDefaults.startup.readyTimeout = fromSecondsToMillis(withDefaults.startup.readyTimeout);
+  //  withDefaults.startup.eventsFirstPushWindow = fromSecondsToMillis(withDefaults.startup.eventsFirstPushWindow);
+
+  return withDefaults;
+}
+
+export const ConfigsFactory = (configurations) => objectAssign(Object.create({}), defaults(configurations));

src/utils/settings/index.js

@@ -0,0 +1,2 @@
+export const CONFIGURATIONS = "configs"
+export const READY="ready"

src/utils/store/constants.js

@@ -0,0 +1,29 @@
+import objectAssign from 'object-assign'
+
+class Store {
+  constructor() {
+    this._unlaunchMap = {};
+  }
+  // set key value in map
+  set(key, value) {
+    if (typeof key !== 'string' || (typeof key === 'string' && !key.length) || key === undefined) return false; // We can't store this.
+    this._unlaunchMap[key] = value;
+    return true;
+  }
+
+  //get a particular key from context
+  get(key){
+        if (typeof key !== 'string' || typeof key === 'string' && !key.length) return null;
+	const value = this._unlaunchMap[key];
+        if (value !== undefined) {
+      	  return value;
+    	} 		 
+	return null;
+  }
+
+  // get all items stored in context
+  getAll() { return objectAssign({}, this._unlaunchMap); }
+  
+}
+
+export default Store;

src/utils/store/index.js

@@ -0,0 +1,34 @@
+import { isString } from "../../../src/utils/lang/index.js";
+
+const usedKeysMap = {};
+
+export function validateApiKey(maybeApiKey) {
+  let apiKey = false;
+  if (maybeApiKey == undefined) { // eslint-disable-line eqeqeq
+    console.log('Factory instantiation: you passed a null or undefined api_key, api_key must be a non-empty string.');
+    //log.error  
+   } else if (isString(maybeApiKey)) {
+    if (maybeApiKey.length > 0)
+      apiKey = maybeApiKey;
+    else
+      console.error('Factory instantiation: you passed an empty api_key, api_key must be a non-empty string.');
+  } else {
+    console.error('Factory instantiation: you passed an invalid api_key, api_key must be a non-empty string.');
+  }
+
+  // // If the apiKey is correct, we'll save it as the instance creation should work.
+  // if (apiKey) {
+  //   if (!usedKeysMap[apiKey]) {
+  //     // If this key is not present, only warning scenarios is that we have factories for other keys.
+  //     usedKeysMap[apiKey] = 1;
+  //     if (Object.keys(usedKeysMap).length > 1) {
+  //       console.log('Factory instantiation: You already have an instance of the Split factory. Make sure you definitely want this additional instance. We recommend keeping only one instance of the factory at all times (Singleton pattern) and reusing it throughout your application.');
+  //     }
+  //   } else {
+  //     console.log(`Factory instantiation: You already have ${usedKeysMap[apiKey]} ${usedKeysMap[apiKey] === 1 ? 'factory' : 'factories'} with this API Key. We recommend keeping only one instance of the factory at all times (Singleton pattern) and reusing it throughout your application.`);
+  //     usedKeysMap[apiKey]++;
+  //   }
+  // }
+
+  return apiKey;
+}