UI Caching Design

angular
    .module('referencedata-user')
    .service('openlmisSessionCacheService', openlmisSessionCacheService);

openlmisSessionCacheService.$inject = [/* Dependencies */];

function openlmisSessionCacheService(/* Dependencies */) {

    this.cache = cache;
    this.get = get;

    /**
     * Caches the response of the method throughout the session.
     * 
     * @param {string}   key      the key the resolved value will be available under
     * @param {Function} fn       the function to fetch the cached data, can return a Promise
     * @param {Object}   options  the options object, options:
     *                            - fetchOnLogin - defines when the data should be fetched (on login or on the first
     *                                             call to the get method with respective key), defaults to true
     */
    function cache(key, fn, options) {
        // method body
    }

    /**
     * Retrieves the cached value hidden under the given key
     *
     * @param  {string}  key  the key of the cached value
     * @return {Promise}      the promise resolved once the data is ready
     */
    function get(key) {
        // method body
    }
}

(function() {

    'use strict';

    angular
        .module('referencedata-user')
        .run(routes);

    routes.$inject = ['openlmisSessionCacheService', 'UserRepository', 'authorizationService'];

    function routes(openlmisSessionCacheService, UserRepository, authorizationService) {

        function getCurrentUser() {
            return new UserRepository().get(authorizationService.getUser().user_id);
        }

        openlmisSessionCacheService.cache('currentUser', getCurrentUser);

    }

})();

openlmisSessionCacheService.get('currentUser')
    .then(function(currentUser) {
        // do something with the current user
    })

angular
    .module('openlmis-cached-repository')
    .factory('OpenlmisCachedResource', OpenlmisCachedResource);

OpenlmisCachedResource.$inject = [/* Dependencies */];

function OpenlmisCachedResource(/* Dependencies */) {

    OpenlmisCachedResource.prototype.get = get;
    OpenlmisCachedResource.prototype.query = query;
    OpenlmisCachedResource.prototype.getAll = getAll;
    OpenlmisCachedResource.prototype.update = update;
    OpenlmisCachedResource.prototype.create = create;
    OpenlmisCachedResource.prototype.delete = deleteObject;

    return OpenlmisCachedResource;

    /**
     * @ngdoc method
     * @methodOf openlmis-cached-repository.OpenlmisCachedResource
     * @name OpenlmisCachedResource
     * @constructor
     *
     * @description
     * Creates an instance of the OpenlmisCachedResource class.
     *
     * Configuration options:
     * - paginated - flag defining whether response returned by the query request is paginated; defaults to true
     * - versioned - flag defining whether handled resource is versioned; defaults to false
     *
     * @param {String} uri    the URI pointing to the resource
     * @param {Object} config the optional configuration object, modifies the default behavior making this class
     *                        more flexible
     */
    function OpenlmisCachedResource(uri, config) {
        // implementation
    }

    /**
     * @ngdoc method
     * @methodOf openlmis-cached-repository.OpenlmisCachedResource
     * @name get
     *
     * @description
     * Retrieves an object with the given ID from cache or from the server.
     *
     * @param  {string}  id        the ID of the object
     * @param  {strong}  versionId (optional) the version of the object
     * @return {Promise}           the promise resolving to matching object, rejects if ID is not given or if the
     *                             request fails
     */
    function get(id, versionId) {
        // implementation
    }

    /**
     * @ngdoc method
     * @methodOf openlmis-cached-repository.OpenlmisCachedResource
     * @name query
     *
     * @description
     * Return the response of the GET request or cached value. Passes the given object as request parameters.
     *
     * @param  {Object}  params the map of request parameters
     * @return {Promise}        the promise resolving to the server response or cached value, rejected if request fails
     */
    function query(params) {
        // implementation
    }

    /**
     * @ngdoc method
     * @methodOf openlmis-cached-repository.OpenlmisCachedResource
     * @name getAll
     *
     * @description
     * Return the response of the GET request or cached value in a form of a list. Passes the given object as request
     * parameters.
     *
     * @param  {Object}  params the map of request parameters
     * @return {Promise}        the promise resolving to the server response or cached value, rejected if request fails
     */
    function getAll(params) {
        // implementation
    }

    /**
     * @ngdoc method
     * @methodOf openlmis-cached-repository.OpenlmisCachedResource
     * @name update
     * 
     * @description
     * Saves the given object on the OpenLMIS server. Uses PUT method. Caches the result.
     * 
     * @param  {Object}  object the object to be saved on the server
     * @return {Promise}        the promise resolving to the server response, rejected if request fails or object is
     *                          undefined or if the ID is undefined
     */
    function update(object) {
        // implementation
    }

    /**
     * @ngdoc method
     * @methodOf openlmis-cached-repository.OpenlmisCachedResource
     * @name create
     * 
     * @description
     * Creates the given object on the OpenLMIS server. Uses POST method. Caches the result.
     * 
     * @param  {Object}  object        the object to be created on the server
     * @param  {Object}  params        the parameters to be passed to the request
     * @return {Promise}               the promise resolving to the server response, rejected if request fails
     */
    function create(object, params) {
        // implementation
    }

    /**
     * @ngdoc method
     * @methodOf openlmis-cached-repository.OpenlmisCachedResource
     * @name delete
     * 
     * @description
     * Deletes the object on the OpenLMIS server. Removes the cached object.
     * 
     * @param  {Object}  object the object to be deleted from the server
     * @return {Promise}        the promise resolving to the server response, rejected if request fails or object is
     *                          undefined or if the ID is undefined
     */
    function deleteObject(object) {
        // implementation
    }

}