feat(api): add service capping logic

Author: Exilz

dist/index.js

@@ -52,7 +52,10 @@ var DEFAULT_API_OPTIONS = {
     prefixes: { default: '/' },
     printNetworkRequests: false,
     disableCache: false,
-    cacheExpiration: 5 * 60 * 1000
+    cacheExpiration: 5 * 60 * 1000,
+    cachePrefix: 'offlineApiCache',
+    capServices: false,
+    capLimit: 50
 };
 var DEFAULT_SERVICE_OPTIONS = {
     method: 'GET',
@@ -61,7 +64,6 @@ var DEFAULT_SERVICE_OPTIONS = {
     disableCache: false
 };
 var DEFAULT_CACHE_DRIVER = react_native_1.AsyncStorage;
-var CACHE_PREFIX = 'offlineApiCache:';
 var OfflineFirstAPI = (function () {
     function OfflineFirstAPI(options, services, driver) {
         this._APIServices = {};
@@ -133,7 +135,7 @@ var OfflineFirstAPI = (function () {
                     case 7:
                         // Cache if it hasn't been disabled and if the network request has been successful
                         if (res.data.ok && shouldUseCache) {
-                            this._cache(service, requestId, parsedResponseData, expiration);
+                            this._cache(serviceDefinition, service, requestId, parsedResponseData, expiration);
                         }
                         this._log('parsed network response', parsedResponseData);
                         return [2 /*return*/, parsedResponseData];
@@ -268,28 +270,49 @@ var OfflineFirstAPI = (function () {
      * @returns {(Promise<void|boolean>)}
      * @memberof OfflineFirstAPI
      */
-    OfflineFirstAPI.prototype._cache = function (service, requestId, response, expiration) {
+    OfflineFirstAPI.prototype._cache = function (serviceDefinition, service, requestId, response, expiration) {
         return __awaiter(this, void 0, void 0, function () {
-            var err_5;
+            var shouldCap, capLimit, serviceDictionaryKey, dictionary, cachedItemsCount, key, err_5;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        this._log("Caching " + requestId + " ...");
+                        shouldCap = typeof serviceDefinition.capService !== 'undefined' ?
+                            serviceDefinition.capService :
+                            this._APIOptions.capServices;
                         _a.label = 1;
                     case 1:
-                        _a.trys.push([1, 4, , 5]);
+                        _a.trys.push([1, 7, , 8]);
+                        this._log("Caching " + requestId + " ...");
                         return [4 /*yield*/, this._addKeyToServiceDictionary(service, requestId, expiration)];
                     case 2:
                         _a.sent();
                         return [4 /*yield*/, this._APIDriver.setItem(this._getCacheObjectKey(requestId), JSON.stringify(response))];
                     case 3:
                         _a.sent();
                         this._log("Updated cache for request " + requestId);
-                        return [2 /*return*/, true];
+                        if (!shouldCap) return [3 /*break*/, 6];
+                        capLimit = serviceDefinition.capLimit || this._APIOptions.capLimit;
+                        serviceDictionaryKey = this._getServiceDictionaryKey(service);
+                        return [4 /*yield*/, this._APIDriver.getItem(serviceDictionaryKey)];
                     case 4:
+                        dictionary = _a.sent();
+                        if (!dictionary) return [3 /*break*/, 6];
+                        dictionary = JSON.parse(dictionary);
+                        cachedItemsCount = Object.keys(dictionary).length;
+                        if (!(cachedItemsCount > capLimit)) return [3 /*break*/, 6];
+                        this._log("service " + service + " cap reached (" + cachedItemsCount + " / " + capLimit + "), removing the oldest cached item...");
+                        key = this._getOldestCachedItem(dictionary).key;
+                        delete dictionary[key];
+                        return [4 /*yield*/, this._APIDriver.removeItem(key)];
+                    case 5:
+                        _a.sent();
+                        this._APIDriver.setItem(serviceDictionaryKey, JSON.stringify(dictionary));
+                        _a.label = 6;
+                    case 6: return [2 /*return*/, true];
+                    case 7:
                         err_5 = _a.sent();
                         throw new Error("Error while caching API response for " + requestId);
-                    case 5: return [2 /*return*/];
+                    case 8: return [2 /*return*/];
                 }
             });
         });
@@ -402,6 +425,28 @@ var OfflineFirstAPI = (function () {
             });
         });
     };
+    /**
+     * Returns the key and the expiration date of the oldest cached item of a cache dictionary
+     * @private
+     * @param {ICacheDictionary} dictionary
+     * @returns {*}
+     * @memberof OfflineFirstAPI
+     */
+    OfflineFirstAPI.prototype._getOldestCachedItem = function (dictionary) {
+        var oldest;
+        for (var key in dictionary) {
+            var keyExpiration = dictionary[key];
+            if (oldest) {
+                if (keyExpiration < oldest.expiration) {
+                    oldest = { key: key, expiration: keyExpiration };
+                }
+            }
+            else {
+                oldest = { key: key, expiration: keyExpiration };
+            }
+        }
+        return oldest;
+    };
     /**
      * Promise that resolves every cache key associated to a service : the service dictionary's name, and all requestId
      * stored. This is useful to clear the cache without affecting the user's stored data not related to this API.
@@ -412,6 +457,7 @@ var OfflineFirstAPI = (function () {
      */
     OfflineFirstAPI.prototype._getAllKeysForService = function (service) {
         return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
             var keys, serviceDictionaryKey, dictionary, dictionaryKeys, err_8;
             return __generator(this, function (_a) {
                 switch (_a.label) {
@@ -425,7 +471,7 @@ var OfflineFirstAPI = (function () {
                         dictionary = _a.sent();
                         if (dictionary) {
                             dictionary = JSON.parse(dictionary);
-                            dictionaryKeys = Object.keys(dictionary).map(function (key) { return CACHE_PREFIX + ":" + key; });
+                            dictionaryKeys = Object.keys(dictionary).map(function (key) { return _this._APIOptions.cachePrefix + ":" + key; });
                             keys = keys.concat(dictionaryKeys);
                         }
                         return [2 /*return*/, keys];
@@ -445,7 +491,7 @@ var OfflineFirstAPI = (function () {
      * @memberof OfflineFirstAP
      */
     OfflineFirstAPI.prototype._getServiceDictionaryKey = function (service) {
-        return CACHE_PREFIX + ":dictionary:" + service;
+        return this._APIOptions.cachePrefix + ":dictionary:" + service;
     };
     /**
      * Simple helper getting a request's cache key.
@@ -455,7 +501,7 @@ var OfflineFirstAPI = (function () {
      * @memberof OfflineFirstAP
      */
     OfflineFirstAPI.prototype._getCacheObjectKey = function (requestId) {
-        return CACHE_PREFIX + ":" + requestId;
+        return this._APIOptions.cachePrefix + ":" + requestId;
     };
     /**
      * Resolve each middleware provided and merge them into a single object that will be passed to

src/index.ts

@@ -9,6 +9,7 @@ import {
     IFetchOptions,
     IFetchResponse,
     ICachedData,
+    ICacheDictionary,
     IAPIDriver,
     APIMiddleware
 } from './interfaces';
@@ -20,6 +21,8 @@ const DEFAULT_API_OPTIONS = {
     disableCache: false,
     cacheExpiration: 5 * 60 * 1000,
     cachePrefix: 'offlineApiCache',
+    capServices: false,
+    capLimit: 50
 };
 
 const DEFAULT_SERVICE_OPTIONS = {
@@ -105,7 +108,7 @@ export default class OfflineFirstAPI {
 
             // Cache if it hasn't been disabled and if the network request has been successful
             if (res.data.ok && shouldUseCache) {
-                this._cache(service, requestId, parsedResponseData, expiration);
+                this._cache(serviceDefinition, service, requestId, parsedResponseData, expiration);
             }
 
             this._log('parsed network response', parsedResponseData);
@@ -199,12 +202,41 @@ export default class OfflineFirstAPI {
      * @returns {(Promise<void|boolean>)}
      * @memberof OfflineFirstAPI
      */
-    private async _cache (service: string, requestId: string, response: any, expiration: number): Promise<void|boolean> {
-        this._log(`Caching ${requestId} ...`);
+    private async _cache (
+        serviceDefinition: IAPIService,
+        service: string, requestId: string,
+        response: any, expiration: number
+    ): Promise<void|boolean> {
+        const shouldCap =
+            typeof serviceDefinition.capService !== 'undefined' ?
+            serviceDefinition.capService :
+            this._APIOptions.capServices;
+
         try {
+            this._log(`Caching ${requestId} ...`);
             await this._addKeyToServiceDictionary(service, requestId, expiration);
             await this._APIDriver.setItem(this._getCacheObjectKey(requestId), JSON.stringify(response));
             this._log(`Updated cache for request ${requestId}`);
+
+            // If capping is enabled for this request, get the service's dictionary cached items.
+            // If cap is reached, get the oldest cached item and remove it.
+            if (shouldCap) {
+                const capLimit = serviceDefinition.capLimit || this._APIOptions.capLimit;
+                const serviceDictionaryKey = this._getServiceDictionaryKey(service);
+                let dictionary = await this._APIDriver.getItem(serviceDictionaryKey);
+                if (dictionary) {
+                    dictionary = JSON.parse(dictionary);
+                    const cachedItemsCount = Object.keys(dictionary).length;
+                    if (cachedItemsCount > capLimit) {
+                        this._log(`service ${service} cap reached (${cachedItemsCount} / ${capLimit}), removing the oldest cached item...`);
+                        const { key } = this._getOldestCachedItem(dictionary);
+                        delete dictionary[key];
+                        await this._APIDriver.removeItem(key);
+                        this._APIDriver.setItem(serviceDictionaryKey, JSON.stringify(dictionary));
+                    }
+                }
+            }
+
             return true;
         } catch (err) {
             throw new Error(`Error while caching API response for ${requestId}`);
@@ -294,6 +326,29 @@ export default class OfflineFirstAPI {
         }
     }
 
+
+    /**
+     * Returns the key and the expiration date of the oldest cached item of a cache dictionary
+     * @private
+     * @param {ICacheDictionary} dictionary
+     * @returns {*}
+     * @memberof OfflineFirstAPI
+     */
+    private _getOldestCachedItem (dictionary: ICacheDictionary): any {
+        let oldest;
+        for (let key in dictionary) {
+            const keyExpiration: number = dictionary[key];
+            if (oldest) {
+                if (keyExpiration < oldest.expiration) {
+                    oldest = { key, expiration: keyExpiration };
+                }
+            } else {
+                oldest = { key, expiration: keyExpiration };
+            }
+        }
+        return oldest;
+    }
+
     /**
      * Promise that resolves every cache key associated to a service : the service dictionary's name, and all requestId
      * stored. This is useful to clear the cache without affecting the user's stored data not related to this API.

src/interfaces.ts

@@ -6,6 +6,9 @@ export interface IAPIOptions {
     printNetworkRequests?: boolean;
     disableCache?: boolean;
     cacheExpiration?: number;
+    cachePrefix?: string;
+    capServices?: boolean;
+    capLimit?: number;
     offlineDriver: IAPIDriver;
 };
 
@@ -17,6 +20,8 @@ export interface IAPIService {
     prefix?: string;
     middlewares?: APIMiddleware[];
     disableCache?: boolean;
+    capService?: boolean;
+    capLimit?: number;
 };
 
 export interface IAPIServices {
@@ -43,6 +48,10 @@ export interface ICachedData {
     fresh?: boolean;
 }
 
+export interface ICacheDictionary {
+    [key: string]: number;
+}
+
 export interface IAPIDriver {
     getItem(key: string, callback?: (error?: Error, result?: string) => void);
     setItem(key: string, value: string, callback?: (error?: Error) => void);