@aws-amplify/core 5.8.2-unstable.c3ec8a5.0 → 6.0.1-console-preview.7919075.0

package/lib/Cache/InMemoryCache.d.ts

@@ -0,0 +1,129 @@
+import { StorageCache } from './StorageCache';
+import { ICache, CacheConfig, CacheItemOptions } from './types';
+/**
+ * Customized in-memory cache with LRU implemented
+ * @member cacheObj - object which store items
+ * @member cacheList - list of keys in the cache with LRU
+ * @member curSizeInBytes - current size of the cache
+ * @member maxPriority - max of the priority
+ */
+export declare class InMemoryCacheClass extends StorageCache implements ICache {
+    private cacheList;
+    private curSizeInBytes;
+    private maxPriority;
+    /**
+     * initialize the cache
+     *
+     * @param config - the configuration of the cache
+     */
+    constructor(config?: CacheConfig);
+    /**
+     * decrease current size of the cache
+     *
+     * @param amount - the amount of the cache size which needs to be decreased
+     */
+    private _decreaseCurSizeInBytes;
+    /**
+     * increase current size of the cache
+     *
+     * @param amount - the amount of the cache szie which need to be increased
+     */
+    private _increaseCurSizeInBytes;
+    /**
+     * check whether item is expired
+     *
+     * @param key - the key of the item
+     *
+     * @return true if the item is expired.
+     */
+    private _isExpired;
+    /**
+     * delete item from cache
+     *
+     * @param prefixedKey - the key of the item
+     * @param listIdx - indicates which cache list the key belongs to
+     */
+    private _removeItem;
+    /**
+     * put item into cache
+     *
+     * @param prefixedKey - the key of the item
+     * @param itemData - the value of the item
+     * @param itemSizeInBytes - the byte size of the item
+     * @param listIdx - indicates which cache list the key belongs to
+     */
+    private _setItem;
+    /**
+     * see whether cache is full
+     *
+     * @param itemSize
+     *
+     * @return true if cache is full
+     */
+    private _isCacheFull;
+    /**
+     * check whether the cache contains the key
+     *
+     * @param key
+     */
+    private containsKey;
+    /**
+     * * Set item into cache. You can put number, string, boolean or object.
+     * The cache will first check whether has the same key.
+     * If it has, it will delete the old item and then put the new item in
+     * The cache will pop out items if it is full
+     * You can specify the cache item options. The cache will abort and output a warning:
+     * If the key is invalid
+     * If the size of the item exceeds itemMaxSize.
+     * If the value is undefined
+     * If incorrect cache item configuration
+     * If error happened with browser storage
+     *
+     * @param key - the key of the item
+     * @param value - the value of the item
+     * @param options - optional, the specified meta-data
+     *
+     * @throws if the item is too big which exceeds the limit of single item size
+     * @throws if the key is invalid
+     */
+    setItem(key: string, value: object | string | number | boolean, options?: CacheItemOptions): void;
+    /**
+     * Get item from cache. It will return null if item doesn’t exist or it has been expired.
+     * If you specified callback function in the options,
+     * then the function will be executed if no such item in the cache
+     * and finally put the return value into cache.
+     * Please make sure the callback function will return the value you want to put into the cache.
+     * The cache will abort output a warning:
+     * If the key is invalid
+     *
+     * @param key - the key of the item
+     * @param options - the options of callback function
+     */
+    getItem(key: string, options?: CacheItemOptions): any;
+    /**
+     * remove item from the cache
+     *
+     * @param key - the key of the item
+     */
+    removeItem(key: string): void;
+    /**
+     * clear the entire cache
+     */
+    clear(): void;
+    /**
+     * Return all the keys in the cache.
+     */
+    getAllKeys(): string[];
+    /**
+     * return the current size of the cache
+     *
+     * @return the current size of the cache
+     */
+    getCacheCurSize(): number;
+    /**
+     * Return a new instance of cache with customized configuration.
+     * @param config - the customized configuration
+     */
+    createInstance(config: CacheConfig): ICache;
+}
+export declare const InMemoryCache: ICache;

package/lib/Cache/InMemoryCache.js

@@ -0,0 +1,349 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryCache = exports.InMemoryCacheClass = void 0;
+var Utils_1 = require("./Utils");
+var StorageCache_1 = require("./StorageCache");
+var Logger_1 = require("../Logger");
+var AssertError_1 = require("../Util/errors/AssertError");
+var constants_1 = require("../constants");
+var CacheUtils_1 = require("./Utils/CacheUtils");
+var logger = new Logger_1.ConsoleLogger('InMemoryCache');
+/**
+ * Customized in-memory cache with LRU implemented
+ * @member cacheObj - object which store items
+ * @member cacheList - list of keys in the cache with LRU
+ * @member curSizeInBytes - current size of the cache
+ * @member maxPriority - max of the priority
+ */
+var InMemoryCacheClass = /** @class */ (function (_super) {
+    __extends(InMemoryCacheClass, _super);
+    /**
+     * initialize the cache
+     *
+     * @param config - the configuration of the cache
+     */
+    function InMemoryCacheClass(config) {
+        var _this = _super.call(this, config) || this;
+        _this.cacheList = [];
+        _this.curSizeInBytes = 0;
+        _this.maxPriority = 5;
+        _this.getItem = _this.getItem.bind(_this);
+        _this.setItem = _this.setItem.bind(_this);
+        _this.removeItem = _this.removeItem.bind(_this);
+        // initialize list for every priority
+        for (var i = 0; i < _this.maxPriority; i += 1) {
+            _this.cacheList[i] = new Utils_1.CacheList();
+        }
+        return _this;
+    }
+    /**
+     * decrease current size of the cache
+     *
+     * @param amount - the amount of the cache size which needs to be decreased
+     */
+    InMemoryCacheClass.prototype._decreaseCurSizeInBytes = function (amount) {
+        this.curSizeInBytes -= amount;
+    };
+    /**
+     * increase current size of the cache
+     *
+     * @param amount - the amount of the cache szie which need to be increased
+     */
+    InMemoryCacheClass.prototype._increaseCurSizeInBytes = function (amount) {
+        this.curSizeInBytes += amount;
+    };
+    /**
+     * check whether item is expired
+     *
+     * @param key - the key of the item
+     *
+     * @return true if the item is expired.
+     */
+    InMemoryCacheClass.prototype._isExpired = function (key) {
+        var text = Utils_1.CacheObject.getItem(key);
+        (0, AssertError_1.asserts)(text !== null, {
+            name: constants_1.STORAGE_CACHE_EXCEPTION,
+            message: 'item from storage is null',
+        });
+        var item = JSON.parse(text);
+        if ((0, Utils_1.getCurrTime)() >= item.expires) {
+            return true;
+        }
+        return false;
+    };
+    /**
+     * delete item from cache
+     *
+     * @param prefixedKey - the key of the item
+     * @param listIdx - indicates which cache list the key belongs to
+     */
+    InMemoryCacheClass.prototype._removeItem = function (prefixedKey, listIdx) {
+        // delete the key from the list
+        this.cacheList[listIdx].removeItem(prefixedKey);
+        // decrease the current size of the cache
+        var item = Utils_1.CacheObject.getItem(prefixedKey);
+        (0, AssertError_1.asserts)(item !== null, {
+            name: constants_1.STORAGE_CACHE_EXCEPTION,
+            message: 'item from storage is null',
+        });
+        this._decreaseCurSizeInBytes(JSON.parse(item).byteSize);
+        // finally remove the item from memory
+        Utils_1.CacheObject.removeItem(prefixedKey);
+    };
+    /**
+     * put item into cache
+     *
+     * @param prefixedKey - the key of the item
+     * @param itemData - the value of the item
+     * @param itemSizeInBytes - the byte size of the item
+     * @param listIdx - indicates which cache list the key belongs to
+     */
+    InMemoryCacheClass.prototype._setItem = function (prefixedKey, item, listIdx) {
+        // insert the key into the list
+        this.cacheList[listIdx].insertItem(prefixedKey);
+        // increase the current size of the cache
+        this._increaseCurSizeInBytes(item.byteSize);
+        // finally add the item into memory
+        Utils_1.CacheObject.setItem(prefixedKey, JSON.stringify(item));
+    };
+    /**
+     * see whether cache is full
+     *
+     * @param itemSize
+     *
+     * @return true if cache is full
+     */
+    InMemoryCacheClass.prototype._isCacheFull = function (itemSize) {
+        return this.curSizeInBytes + itemSize > this.cacheConfig.capacityInBytes;
+    };
+    /**
+     * check whether the cache contains the key
+     *
+     * @param key
+     */
+    InMemoryCacheClass.prototype.containsKey = function (key) {
+        var prefixedKey = this.cacheConfig.keyPrefix + key;
+        for (var i = 0; i < this.maxPriority; i += 1) {
+            if (this.cacheList[i].containsKey(prefixedKey)) {
+                return i + 1;
+            }
+        }
+        return -1;
+    };
+    /**
+     * * Set item into cache. You can put number, string, boolean or object.
+     * The cache will first check whether has the same key.
+     * If it has, it will delete the old item and then put the new item in
+     * The cache will pop out items if it is full
+     * You can specify the cache item options. The cache will abort and output a warning:
+     * If the key is invalid
+     * If the size of the item exceeds itemMaxSize.
+     * If the value is undefined
+     * If incorrect cache item configuration
+     * If error happened with browser storage
+     *
+     * @param key - the key of the item
+     * @param value - the value of the item
+     * @param options - optional, the specified meta-data
+     *
+     * @throws if the item is too big which exceeds the limit of single item size
+     * @throws if the key is invalid
+     */
+    InMemoryCacheClass.prototype.setItem = function (key, value, options) {
+        var prefixedKey = this.cacheConfig.keyPrefix + key;
+        // invalid keys
+        if (prefixedKey === this.cacheConfig.keyPrefix ||
+            prefixedKey === (0, CacheUtils_1.getCurrSizeKey)(this.cacheConfig.keyPrefix)) {
+            logger.warn("Invalid key: should not be empty or 'CurSize'");
+            return;
+        }
+        if (typeof value === 'undefined') {
+            logger.warn("The value of item should not be undefined!");
+            return;
+        }
+        var cacheItemOptions = {
+            priority: options && options.priority !== undefined
+                ? options.priority
+                : this.cacheConfig.defaultPriority,
+            expires: options && options.expires !== undefined
+                ? options.expires
+                : this.cacheConfig.defaultTTL + (0, Utils_1.getCurrTime)(),
+        };
+        if (cacheItemOptions.priority < 1 || cacheItemOptions.priority > 5) {
+            logger.warn("Invalid parameter: priority due to out or range. It should be within 1 and 5.");
+            return;
+        }
+        var item = this.fillCacheItem(prefixedKey, value, cacheItemOptions);
+        // check wether this item is too big;
+        if (item.byteSize > this.cacheConfig.itemMaxSize) {
+            logger.warn("Item with key: ".concat(key, " you are trying to put into is too big!"));
+            return;
+        }
+        // if key already in the cache, then delete it.
+        var presentKeyPrio = this.containsKey(key);
+        if (presentKeyPrio !== -1) {
+            this._removeItem(prefixedKey, presentKeyPrio - 1);
+        }
+        // pop out items in the cache when cache is full based on LRU
+        // first start from lowest priority cache list
+        var cacheListIdx = this.maxPriority - 1;
+        while (this._isCacheFull(item.byteSize) && cacheListIdx >= 0) {
+            if (!this.cacheList[cacheListIdx].isEmpty()) {
+                var popedItemKey = this.cacheList[cacheListIdx].getLastItem();
+                this._removeItem(popedItemKey, cacheListIdx);
+            }
+            else {
+                cacheListIdx -= 1;
+            }
+        }
+        this._setItem(prefixedKey, item, Number(item.priority) - 1);
+    };
+    /**
+     * Get item from cache. It will return null if item doesn’t exist or it has been expired.
+     * If you specified callback function in the options,
+     * then the function will be executed if no such item in the cache
+     * and finally put the return value into cache.
+     * Please make sure the callback function will return the value you want to put into the cache.
+     * The cache will abort output a warning:
+     * If the key is invalid
+     *
+     * @param key - the key of the item
+     * @param options - the options of callback function
+     */
+    InMemoryCacheClass.prototype.getItem = function (key, options) {
+        var _a;
+        var ret = null;
+        var prefixedKey = this.cacheConfig.keyPrefix + key;
+        if (prefixedKey === this.cacheConfig.keyPrefix ||
+            prefixedKey === (0, CacheUtils_1.getCurrSizeKey)(this.cacheConfig.keyPrefix)) {
+            logger.warn("Invalid key: should not be empty or 'CurSize'");
+            return null;
+        }
+        // check whether it's in the cachelist
+        var presentKeyPrio = this.containsKey(key);
+        if (presentKeyPrio !== -1) {
+            if (this._isExpired(prefixedKey)) {
+                // if expired, remove that item and return null
+                this._removeItem(prefixedKey, presentKeyPrio - 1);
+            }
+            else {
+                // if not expired, great, return the value and refresh it
+                ret = (_a = Utils_1.CacheObject.getItem(prefixedKey)) !== null && _a !== void 0 ? _a : '';
+                var item = JSON.parse(ret);
+                this.cacheList[item.priority - 1].refresh(prefixedKey);
+                return item.data;
+            }
+        }
+        if (options && options.callback !== undefined) {
+            var val = options.callback();
+            if (val !== null) {
+                this.setItem(key, val, options);
+            }
+            return val;
+        }
+        return null;
+    };
+    /**
+     * remove item from the cache
+     *
+     * @param key - the key of the item
+     */
+    InMemoryCacheClass.prototype.removeItem = function (key) {
+        var prefixedKey = this.cacheConfig.keyPrefix + key;
+        // check if the key is in the cache
+        var presentKeyPrio = this.containsKey(key);
+        if (presentKeyPrio !== -1) {
+            this._removeItem(prefixedKey, presentKeyPrio - 1);
+        }
+    };
+    /**
+     * clear the entire cache
+     */
+    InMemoryCacheClass.prototype.clear = function () {
+        var e_1, _a;
+        for (var i = 0; i < this.maxPriority; i += 1) {
+            try {
+                for (var _b = (e_1 = void 0, __values(this.cacheList[i].getKeys())), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var key = _c.value;
+                    this._removeItem(key, i);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        }
+    };
+    /**
+     * Return all the keys in the cache.
+     */
+    InMemoryCacheClass.prototype.getAllKeys = function () {
+        var e_2, _a;
+        var keys = [];
+        for (var i = 0; i < this.maxPriority; i += 1) {
+            try {
+                for (var _b = (e_2 = void 0, __values(this.cacheList[i].getKeys())), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var key = _c.value;
+                    keys.push(key.substring(this.cacheConfig.keyPrefix.length));
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        }
+        return keys;
+    };
+    /**
+     * return the current size of the cache
+     *
+     * @return the current size of the cache
+     */
+    InMemoryCacheClass.prototype.getCacheCurSize = function () {
+        return this.curSizeInBytes;
+    };
+    /**
+     * Return a new instance of cache with customized configuration.
+     * @param config - the customized configuration
+     */
+    InMemoryCacheClass.prototype.createInstance = function (config) {
+        return new InMemoryCacheClass(config);
+    };
+    return InMemoryCacheClass;
+}(StorageCache_1.StorageCache));
+exports.InMemoryCacheClass = InMemoryCacheClass;
+exports.InMemoryCache = new InMemoryCacheClass();

package/lib/Cache/StorageCache.d.ts

@@ -0,0 +1,39 @@
+import { CacheConfig, CacheItem, CacheItemOptions } from './types';
+/**
+ * Initialization of the cache
+ *
+ */
+export declare class StorageCache {
+    private instanceConfig?;
+    /**
+     * Initialize the cache
+     *
+     * @param config - Custom configuration for this instance.
+     */
+    constructor(config?: CacheConfig);
+    getModuleName(): string;
+    private sanitizeConfig;
+    /**
+     * produce a JSON object with meta-data and data value
+     * @param value - the value of the item
+     * @param options - optional, the specified meta-data
+     *
+     * @return - the item which has the meta-data and the value
+     */
+    protected fillCacheItem(key: string, value: object | number | string | boolean, options: CacheItemOptions): CacheItem;
+    /**
+     * Set custom configuration for the cache instance.
+     *
+     * @param config - customized configuration (without keyPrefix, which can't be changed)
+     *
+     * @return - the current configuration
+     */
+    configure(config?: Omit<CacheConfig, 'keyPrefix'>): CacheConfig;
+    /**
+     * Returns an appropriate configuration for the Cache instance. Will apply any custom configuration for this
+     * instance on top of the global configuration. Default configuration will be applied in all cases.
+     *
+     * @internal
+     */
+    protected get cacheConfig(): CacheConfig;
+}

package/lib/Cache/StorageCache.js

@@ -0,0 +1,121 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageCache = void 0;
+var Utils_1 = require("./Utils");
+var singleton_1 = require("../singleton");
+var Logger_1 = require("../Logger");
+var logger = new Logger_1.ConsoleLogger('StorageCache');
+/**
+ * Initialization of the cache
+ *
+ */
+var StorageCache = /** @class */ (function () {
+    /**
+     * Initialize the cache
+     *
+     * @param config - Custom configuration for this instance.
+     */
+    function StorageCache(config) {
+        if (config) {
+            // A configuration was specified for this specific instance
+            this.instanceConfig = config;
+        }
+        this.sanitizeConfig();
+    }
+    StorageCache.prototype.getModuleName = function () {
+        return 'Cache';
+    };
+    StorageCache.prototype.sanitizeConfig = function () {
+        var tempInstanceConfig = this.instanceConfig || {};
+        if (this.cacheConfig.itemMaxSize > this.cacheConfig.capacityInBytes) {
+            logger.error('Invalid parameter: itemMaxSize. It should be smaller than capacityInBytes. Setting back to default.');
+            tempInstanceConfig.itemMaxSize = Utils_1.defaultConfig.itemMaxSize;
+        }
+        if (this.cacheConfig.defaultPriority > 5 ||
+            this.cacheConfig.defaultPriority < 1) {
+            logger.error('Invalid parameter: defaultPriority. It should be between 1 and 5. Setting back to default.');
+            tempInstanceConfig.defaultPriority = Utils_1.defaultConfig.defaultPriority;
+        }
+        if (Number(this.cacheConfig.warningThreshold) > 1 ||
+            Number(this.cacheConfig.warningThreshold) < 0) {
+            logger.error('Invalid parameter: warningThreshold. It should be between 0 and 1. Setting back to default.');
+            tempInstanceConfig.warningThreshold = Utils_1.defaultConfig.warningThreshold;
+        }
+        // Set 5MB limit
+        var cacheLimit = 5 * 1024 * 1024;
+        if (this.cacheConfig.capacityInBytes > cacheLimit) {
+            logger.error('Cache Capacity should be less than 5MB. Setting back to default. Setting back to default.');
+            tempInstanceConfig.capacityInBytes = Utils_1.defaultConfig.capacityInBytes;
+        }
+        // Apply sanitized values to the instance config
+        if (Object.keys(tempInstanceConfig).length > 0) {
+            this.instanceConfig = tempInstanceConfig;
+        }
+    };
+    /**
+     * produce a JSON object with meta-data and data value
+     * @param value - the value of the item
+     * @param options - optional, the specified meta-data
+     *
+     * @return - the item which has the meta-data and the value
+     */
+    StorageCache.prototype.fillCacheItem = function (key, value, options) {
+        var _a, _b;
+        var ret = {
+            key: key,
+            data: value,
+            timestamp: (0, Utils_1.getCurrTime)(),
+            visitedTime: (0, Utils_1.getCurrTime)(),
+            priority: (_a = options.priority) !== null && _a !== void 0 ? _a : 0,
+            expires: (_b = options.expires) !== null && _b !== void 0 ? _b : 0,
+            type: typeof value,
+            byteSize: 0,
+        };
+        ret.byteSize = (0, Utils_1.getByteLength)(JSON.stringify(ret));
+        // for accurate size
+        ret.byteSize = (0, Utils_1.getByteLength)(JSON.stringify(ret));
+        return ret;
+    };
+    /**
+     * Set custom configuration for the cache instance.
+     *
+     * @param config - customized configuration (without keyPrefix, which can't be changed)
+     *
+     * @return - the current configuration
+     */
+    StorageCache.prototype.configure = function (config) {
+        if (config) {
+            if (config.keyPrefix) {
+                logger.warn('keyPrefix can not be re-configured on an existing Cache instance.');
+            }
+            this.instanceConfig = this.instanceConfig
+                ? Object.assign({}, this.instanceConfig, config)
+                : config;
+        }
+        this.sanitizeConfig();
+        return this.cacheConfig;
+    };
+    Object.defineProperty(StorageCache.prototype, "cacheConfig", {
+        /**
+         * Returns an appropriate configuration for the Cache instance. Will apply any custom configuration for this
+         * instance on top of the global configuration. Default configuration will be applied in all cases.
+         *
+         * @internal
+         */
+        get: function () {
+            var globalCacheConfig = singleton_1.AmplifyV6.getConfig().Cache || {};
+            if (this.instanceConfig) {
+                return Object.assign({}, Utils_1.defaultConfig, globalCacheConfig, this.instanceConfig);
+            }
+            else {
+                return Object.assign({}, Utils_1.defaultConfig, globalCacheConfig);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return StorageCache;
+}());
+exports.StorageCache = StorageCache;