@aws-amplify/core 6.0.1-preview-testing.034e780.0 → 6.0.1-server-generate-client.1e317a1.0

package/lib-esm/Cache/{AsyncStorageCache.d.ts → StorageCacheCommon.d.ts}

@@ -1,89 +1,38 @@
-import AsyncStorage from '@react-native-async-storage/async-storage';
-import { StorageCache } from './StorageCache';
-import { CacheConfig, CacheItem, CacheItemOptions, ICache } from './types';
-export declare class AsyncStorageCache extends StorageCache implements ICache {
-    /**
-     * initialize the cache
+import { KeyValueStorageInterface } from '../types';
+import { CacheConfig, CacheItem, CacheItemOptions } from './types';
+/**
+ * Initialization of the cache
+ *
+ */
+export declare abstract class StorageCacheCommon {
+    protected config: CacheConfig;
+    protected keyValueStorage: KeyValueStorageInterface;
+    /**
+     * Initialize the cache
      *
-     * @param {Object} config - the configuration of the cache
-     */
-    constructor(config?: CacheConfig);
-    /**
-     * decrease current size of the cache
-     * @private
-     * @param amount - the amount of the cache size which needs to be decreased
-     */
-    _decreaseCurSizeInBytes(amount: number): Promise<void>;
-    /**
-     * increase current size of the cache
-     * @private
-     * @param amount - the amount of the cache szie which need to be increased
-     */
-    _increaseCurSizeInBytes(amount: number): Promise<void>;
-    /**
-     * update the visited time if item has been visited
-     * @private
-     * @param item - the item which need to be refreshed
-     * @param prefixedKey - the key of the item
+     * @param config - Custom configuration for this instance.
+     */
+    constructor({ config, keyValueStorage, }: {
+        config?: CacheConfig;
+        keyValueStorage: KeyValueStorageInterface;
+    });
+    protected abstract getAllCacheKeys(options?: {
+        omitSizeKey?: boolean;
+    }): Promise<string[]>;
+    getModuleName(): string;
+    /**
+     * Set custom configuration for the cache instance.
      *
-     * @return the refreshed item
-     */
-    _refreshItem(item: CacheItem, prefixedKey: string): Promise<CacheItem>;
-    /**
-     * check wether item is expired
-     * @private
-     * @param key - the key of the item
+     * @param config - customized configuration (without keyPrefix, which can't be changed)
      *
-     * @return true if the item is expired.
-     */
-    _isExpired(key: string): Promise<boolean>;
-    /**
-     * delete item from cache
-     * @private
-     * @param prefixedKey - the key of the item
-     * @param size - optional, the byte size of the item
-     */
-    _removeItem(prefixedKey: string, size?: number): Promise<void>;
-    /**
-     * put item into cache
-     * @private
-     * @param prefixedKey - the key of the item
-     * @param itemData - the value of the item
-     * @param itemSizeInBytes - the byte size of the item
+     * @return - the current configuration
      */
-    _setItem(prefixedKey: string, item: any): Promise<void>;
+    configure(config?: Omit<CacheConfig, 'keyPrefix'>): CacheConfig;
     /**
-     * total space needed when poping out items
-     * @private
-     * @param itemSize
-     *
-     * @return total space needed
-     */
-    _sizeToPop(itemSize: number): Promise<number>;
-    /**
-     * see whether cache is full
-     * @private
-     * @param itemSize
-     *
-     * @return true if cache is full
-     */
-    _isCacheFull(itemSize: number): Promise<boolean>;
-    /**
-     * scan the storage and find out all the keys owned by this cache
-     * also clean the expired keys while scanning
-     * @private
-     * @return array of keys
-     */
-    _findValidKeys(): Promise<string[]>;
-    /**
-     * get all the items we have, sort them by their priority,
-     * if priority is same, sort them by their last visited time
-     * pop out items from the low priority (5 is the lowest)
-     * @private
-     * @param keys - all the keys in this cache
-     * @param sizeToPop - the total size of the items which needed to be poped out
+     * return the current size of the cache
+     * @return {Promise}
      */
-    _popOutItems(keys: string[], sizeToPop: number): Promise<void>;
+    getCurrentCacheSize(): Promise<number>;
     /**
      * Set item into cache. You can put number, string, boolean or object.
      * The cache will first check whether has the same key.
@@ -99,9 +48,10 @@ export declare class AsyncStorageCache extends StorageCache implements ICache {
      * @param {String} key - the key of the item
      * @param {Object} value - the value of the item
      * @param {Object} [options] - optional, the specified meta-data
+     *
      * @return {Promise}
      */
-    setItem(key: string, value: any, options: Record<string, any>): Promise<void>;
+    setItem(key: string, value: any, options?: Record<string, any>): Promise<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,
@@ -114,9 +64,10 @@ export declare class AsyncStorageCache extends StorageCache implements ICache {
      *
      * @param {String} key - the key of the item
      * @param {Object} [options] - the options of callback function
+     *
      * @return {Promise} - return a promise resolves to be the value of the item
      */
-    getItem(key: string, options: CacheItemOptions): Promise<any>;
+    getItem(key: string, options?: CacheItemOptions): Promise<CacheItem['data']>;
     /**
      * remove item from the cache
      * The cache will abort output a warning:
@@ -126,29 +77,103 @@ export declare class AsyncStorageCache extends StorageCache implements ICache {
      */
     removeItem(key: string): Promise<void>;
     /**
-     * clear the entire cache
-     * The cache will abort output a warning:
-     * If error happened with AsyncStorage
+     * Return all the keys owned by this cache.
+     * Will return an empty array if error occurred.
+     *
      * @return {Promise}
      */
-    clear(): Promise<void>;
+    getAllKeys(): Promise<string[]>;
+    protected getStorage(): KeyValueStorageInterface;
     /**
-     * return the current size of the cache
-     * @return {Promise}
+     * check whether item is expired
+     *
+     * @param key - the key of the item
+     *
+     * @return true if the item is expired.
      */
-    getCacheCurSize(): Promise<number>;
+    protected isExpired(key: string): Promise<boolean>;
     /**
-     * Return all the keys in the cache.
-     * Will return an empty array if error happend.
-     * @return {Promise}
+     * delete item from cache
+     *
+     * @param prefixedKey - the key of the item
+     * @param size - optional, the byte size of the item
      */
-    getAllKeys(): Promise<string[]>;
+    protected removeCacheItem(prefixedKey: string, size?: number): Promise<void>;
+    /**
+     * 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;
+    private sanitizeConfig;
+    /**
+     * increase current size of the cache
+     *
+     * @param amount - the amount of the cache szie which need to be increased
+     */
+    private increaseCurrentSizeInBytes;
+    /**
+     * decrease current size of the cache
+     *
+     * @param amount - the amount of the cache size which needs to be decreased
+     */
+    private decreaseCurrentSizeInBytes;
+    /**
+     * update the visited time if item has been visited
+     *
+     * @param item - the item which need to be updated
+     * @param prefixedKey - the key of the item
+     *
+     * @return the updated item
+     */
+    private updateVisitedTime;
+    /**
+     * 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
+     */
+    private setCacheItem;
     /**
-     * Return a new instance of cache with customized configuration.
-     * @param {Object} config - the customized configuration
-     * @return {Object} - the new instance of Cache
+     * total space needed when poping out items
+     *
+     * @param itemSize
+     *
+     * @return total space needed
+     */
+    private sizeToPop;
+    /**
+     * see whether cache is full
+     *
+     * @param itemSize
+     *
+     * @return true if cache is full
      */
-    createInstance(config: CacheConfig): ICache;
+    private isCacheFull;
+    /**
+     * get all the items we have, sort them by their priority,
+     * if priority is same, sort them by their last visited time
+     * pop out items from the low priority (5 is the lowest)
+     * @private
+     * @param keys - all the keys in this cache
+     * @param sizeToPop - the total size of the items which needed to be poped out
+     */
+    private popOutItems;
+    /**
+     * Scan the storage and combine the following operations for efficiency
+     *   1. Clear out all expired keys owned by this cache, not including the size key.
+     *   2. Return the remaining keys.
+     *
+     * @return The remaining valid keys
+     */
+    private clearInvalidAndGetRemainingKeys;
+    /**
+     * clear the entire cache
+     * The cache will abort and output a warning if error occurs
+     * @return {Promise}
+     */
+    clear(): Promise<void>;
 }
-declare const instance: ICache;
-export { AsyncStorage, instance as Cache };