code sanitized

Author: uttamukkoji

.gitignore

@@ -10,4 +10,5 @@ test/report.json/*
 tap-html.html
 *html-report
 coverage
-.env
+.env
+.dccache

.talismanrc

@@ -1,3 +1 @@
-fileignoreconfig:
-- filename: test/automation-script.js
-  checksum: dd31ccc9f78dbcfb48eafa5d7ab80d480776c70bc36d6a10eb86229fb79443af
+threshold: medium

src/core/cache-provider/index.js

@@ -0,0 +1,21 @@
+import localstorage from './localstorage';
+var CacheProvider = {};
+
+
+CacheProvider.providers = function(provider) {
+    if (provider) {
+        return localstorage;
+    } else {
+        console.error("Kindly provide valid provider.");
+    }
+};
+
+CacheProvider.policies = {
+    IGNORE_CACHE: -1,
+    ONLY_NETWORK: 0,
+    CACHE_ELSE_NETWORK: 1,
+    NETWORK_ELSE_CACHE: 2,
+    CACHE_THEN_NETWORK: 3
+};
+
+export default CacheProvider;

src/core/cache-provider/localstorage.js

@@ -0,0 +1,76 @@
+import * as cache from './../cache';
+
+let localStorage = {};
+
+localStorage.get = function (key, callback) {
+    try {
+        callback(null, cache.get(key));
+    } catch(e) {
+        callback(e);
+    }
+};
+
+localStorage.set = function (key, value, callback) {
+    try {
+        if(key && value) cache.set(key, value);
+        callback();
+    } catch(e) {
+        callback(e);
+    }
+};
+
+function clearValuesForKey(keyArray, append) {
+    if(!append && keyArray && keyArray.length) keyArray.push('');
+    let _key,
+        keys = cache.getKeys(),
+        storage = cache.getStorage();
+    if(!keyArray || !keyArray.length) {
+        for(let i = 0, _i = keys.length; i < _i; i++) {
+            delete storage[keys[i]];
+        }
+    } else {
+        _key = keyArray.join('.');
+        for(let i = 0, _i = keys.length; i < _i; i++) {
+            if(keys[i] && keys[i].indexOf(_key) === 0) delete storage[keys[i]];
+        }
+    }
+}
+
+localStorage.clearByContentType = function () {
+    try {
+        if(arguments.length === 2 || arguments.length === 3) {
+            let args = Array.prototype.slice.call(arguments);
+            let callback = args.splice(-1, 1).pop();
+            let valueArray = [];
+            valueArray.push.apply(valueArray, args);
+            clearValuesForKey(valueArray);
+            callback();
+        }
+    } catch(e) {
+        callback(e);
+    }
+}
+
+localStorage.clearByQuery = function (query, callback) {
+    try {
+        let keys = cache.getKeys(),
+            storage = cache.getStorage();
+        for(let i = 0, _i = keys.length; i < _i; i++) {
+            if(keys[i] && ~keys[i].indexOf(query)) delete storage[keys[i]];
+        }
+        callback();
+    } catch(e) {
+        callback(e);
+    }
+}
+
+localStorage.clearAll = function (callback) {
+    try {
+        clearValuesForKey();
+        callback();
+    } catch(e) {
+        callback(e);
+    }
+}
+
+export default localStorage;

src/core/cache.js

@@ -0,0 +1,30 @@
+import storage from 'runtime/localstorage.js';
+
+export function get(key) {
+    let data = storage.getItem(key);
+    try {
+        data = JSON.parse(data);
+    } catch (e) {
+        return data;
+    }
+    return data || null;
+}
+
+export function set(key, data) {
+    try {
+        if (typeof data === 'object') {
+            storage.setItem(key, JSON.stringify(data));         
+        } else {
+            storage.setItem(key, data);
+        }
+    } catch (error) {   
+    } 
+}
+
+export function getStorage() {
+    return storage || null;
+}
+
+export function getKeys() {
+    return (storage) ? Object.keys(storage) : [];
+}

src/core/contentstack.js

@@ -0,0 +1,39 @@
+import Stack from "./stack";
+import CacheProvider from './cache-provider/index';
+import ContentstackRegion from "./contentstackregion";
+
+ /**
+ * @class 
+  Contentstack 
+* @description Creates an instance of `Contentstack`.
+* @instance
+*/
+
+class Contentstack {
+
+	constructor(){
+		/**
+		 * @memberOf Contentstack
+		 * @description CachePolicy contains different cache policies constants.
+		 * @example
+		 * Contentstack.CachePolicy.IGNORE_CACHE
+		 * Contentstack.CachePolicy.ONLY_NETWORK
+		 * Contentstack.CachePolicy.CACHE_ELSE_NETWORK
+		 * Contentstack.CachePolicy.NETWORK_ELSE_CACHE
+		 * Contentstack.CachePolicy.CACHE_THEN_NETWORK
+		 */
+		this.CachePolicy = CacheProvider.policies;
+		this.Region = ContentstackRegion;
+		
+		this.Utils = require('@contentstack/utils');
+	}
+/**
+
+* @memberOf Contentstack
+*/
+	Stack(...stack_arguments){
+		return new Stack(...stack_arguments);
+	}
+}
+
+module.exports = new Contentstack();

src/core/contentstackregion.js

@@ -0,0 +1,7 @@
+const ContentstackRegion = {
+    EU: "eu",
+    US: "us"
+};
+
+export default ContentstackRegion;
+//module.exports = ContentstackRegion;

src/core/lib/request.js

@@ -0,0 +1,108 @@
+import * as Utils from "./utils.js";
+import fetch from "runtime/http.js";
+
+//JS SDK version
+let version = '{{VERSION}}';
+let environment,
+    api_key;
+export default function Request(options, fetchOptions) {
+    return new Promise(function(resolve, reject) {
+        let queryParams;
+        let serialize = function(obj, prefix) {
+
+            let str = [],
+                p;
+            if (typeof obj === "object" && obj.length !== undefined) {
+                for (var i = 0, _i = obj.length; i < _i; i++) {
+                    str.push(prefix + '[]=' + obj[i]);
+                }
+            } else {
+                for (p in obj) {
+                    let k = prefix ? prefix + "[" + p + "]" : p,
+                        v = obj[p];
+                    str.push((v !== null && typeof v === "object" && p !== 'query') ?
+                        serialize(v, k) :
+                        k + "=" + encodeURIComponent(p !== 'query' ? v : JSON.stringify(v)));
+                }
+            }
+            return str.join("&");
+        };
+
+        let url = options.url,
+            headers = options.headers;
+
+        // setting headers
+        headers['Content-Type'] = 'application/json; charset=UTF-8';
+        headers['X-User-Agent'] = 'contentstack-{{PLATFORM}}/' + version;
+
+        if (options.body && typeof options.body === 'object') {
+            delete options.body._method;
+            if (typeof options.body.query === "object" && Object.keys(options.body.query).length === 0) delete options.body.query;
+            queryParams = serialize(options.body);
+        }
+
+        return fetchRetry(url + '?' + queryParams, 
+                            headers, 
+                            fetchOptions, 
+                            resolve, 
+                            reject, 
+                            fetchOptions.retryDelay, 
+                            fetchOptions.retryLimit)
+        
+    });
+}
+
+function wait(retryDelay) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, retryDelay)
+    });
+}
+
+function fetchRetry(url, headers, fetchOptions, resolve, reject, retryDelay = 300, retryLimit = 5) {
+    var option = Utils.mergeDeep({ 
+        method: 'GET',
+        headers: headers,
+        timeout: 30000,                                
+    }, 
+    fetchOptions);
+
+    function onError (error) {
+        if (retryLimit === 0) {
+            reject(error);
+        }else {
+            var msDelay = retryDelay
+            retryLimit = retryLimit - 1
+            var retryCount = (fetchOptions.retryLimit - retryLimit)
+            if (fetchOptions.retryDelayOptions) {
+                if (fetchOptions.retryDelayOptions.base) {
+                    msDelay = fetchOptions.retryDelayOptions.base * retryCount
+                } else if (fetchOptions.retryDelayOptions.customBackoff) {
+                    msDelay = fetchOptions.retryDelayOptions.customBackoff(retryCount, error)
+                }
+            }
+            wait(msDelay)
+                .then(() => {
+                    return fetchRetry(url, headers, retryDelay, retryLimit, fetchOptions, resolve, reject)
+                })
+        }
+    }
+    fetch(url, option)
+        .then(function(response) {    
+            let data = response.json();      
+            if (response.ok && response.status === 200) {
+                resolve(data);
+            } else {
+                data.then((json) => {
+                    if (fetchOptions.retryCondition && fetchOptions.retryCondition(response)) {
+                        onError(json)     
+                    } else {
+                        reject(json)
+                    }   
+                }).catch(() => {
+                    reject({status: response.status, statusText: response.statusText})
+                });
+            }
+        }).catch((error) => {
+            reject(error)
+        });
+}