Custom caching for $resource

Question

I have the following pattern in my AngularJS which calls for refactoring:

$scope.advertisers = Advertiser.query()
$scope.advertisersMap = {};
$scope.advertiser.$then(function (response) {
    arrayToMap(response.resource, $scope.advertisersMap)
}

arrayToMap is function that adds each item in an array to the object with it's ID as key.

Now, I would have liked that this will happen in Advertiser itself, e.g.

$scope.allAdvertisers = Advertiser.query()
// Somewhere else
var advertiser = Advertiser.get({id: 2})

Where Advertiser.get({id: 2}) will return from a cache populated earlier by the query method.

Advertiser is defined in factory:

.factory('Advertiser', ['djResource', 'Group', function ($djResource, Group) {

    var Advertiser = $djResource('/campaigns/advertisers/:advertiserId/', {advertiserId: '@id'});

    Advertiser.prototype.getGroups = function () {
        return Group.getByAdvertiser({advertiserId: this.id});
    };
    return Advertiser;
}])

Sadly, DjangoRestResource (and $resource which it wraps) caches by URLs, so query() will cache /advertisers/ while get(2) will cache /advertisers/2/, but I want query to cache in such way that get will be able to retrieve it as well.

I've tried replacing the query function by a wrapper function that does the caching, but I want it to return an promise which is also an Array like $resource does. It was something like:

    var oldQuery = Advertiser.query;
    var cache = $cacheFactory('advertisers');
    Advertiser.query = function () {
        var promise = oldQuery();
        return promise.then(function (response) {
            angular.forEach(response.resource, function (resource) {
                cache.put(resource.id, resource)
            })
        })
    };

But then the returned promise is no longer an Array-like object, and it doesn't not encapsulate the returned results in an Advertiser object as it used to, which breaks most of my code expects that Advertiser.query() will eventually be an Array.

What other approaches should I try? This snippet repeats itself in every controller for multiple factories and it hurts my eyes.

Answer 1

Here is solution to the problem:

function makeCachingMethod(object, method, cache, config) {
    var $q = angular.injector(['services']).get('$q');
    var oldMethod = object[method];
    object[method] = function () {
        var result;
        if (!config.isArray) {
            var id = config.idParam ? arguments[0][config.idParam] : arguments[0];
            result = cache.get(id);
            if (result !== undefined) {
                if (result.$promise === undefined) {
                    result.$promise = $q.when(result);
                    result.$resolved = true;
                }
                return result;
            }
        }
        result = oldMethod.apply(this, arguments);
        result.$promise.then(function (data) {
            if (config.isArray) {
                angular.forEach(data, function (item) {
                    cache.put(item.id, item);
                })
            } else {
                cache.put(data.id, data);
            }
            return data;
        });
        return result;
    }
}

And an example usage:

app.factory('Country', ['$resource', '$cacheFactory', function ($resource, $cacheFactory) {
    var Country = $resource('/campaigns/countries/:id', {id: "@id"}, {
        query: {method: 'GET', url: '/campaigns/countries/', isArray: true},
        get: {method: 'GET', url: '/campaigns/countries/:id/', isArray: false}
    });
    var cache = $cacheFactory('countries');
    makeCachingMethod(Country, 'query', cache, {isArray: true});
    makeCachingMethod(Country, 'get', cache, {idParam: 'id'});
    return Country;
}])

What is happening here?

I use makeCachingMethod to decorate the original method created by $resource. Following the pattern used by $resource itself, I use a configuration object to signal whether the decorated method returns an array or not, on how the id is passed in queries. I assume, though, that the key of the ID to save is 'id', which is correct for my models but might need to be changed.

Noticed that before returning an object from the cache, the decorator adds to it $promise and $resolved attributes, since my application expects objects originated from $resource which have these properties, and in order to keep using the promises API, e.g.:

$scope.advertiser = Advertiser.get({advertiserId: $scope.advertiserId});
$scope.advertiser.$promise.then(function () {
    $scope.doSomething();
});

Notice that since the function is defined outside the scope of any Angular module it is required to inject the $q service using angular.injector(). A nicer solution will be to return a service for invoking the decorator function. Such service could also handle the generation of the caches themselves.

This solution does not handle the expiration of cached models, which isn't much of problem in my scenario, as these rarely change.