I may not be a master of Angular, but what if we simply relocate the functions to establish a factory-like pattern? I haven't tested this out yet, but with just about two minutes of copying and pasting...

Edit: Eliminated the nested iterate functions.

(function () {

    'use strict';

    angular
        .module('blocks.object-cache')
        .service('ObjectCache', ObjectCache);

    ObjectCache.$inject = ['CacheFactory', '$auth'];

    function ObjectCache(CacheFactory, $auth) {

        var _options = {
            maxAge : (60 * 60 * 1000),
            deleteOnExpire : 'passive',
            storageMode : 'localStorage'
        };

        var factory = {
            getCache : getCache
        };

        return factory;
        ////////////////////////////

        function getCache(typeName, options) {

            options = options || {};
            options.maxAge = options.maxAge = _options.maxAge;
            options.deleteOnExpire = options.deleteOnExpire = _options.deleteOnExpire;
            options.storageMode = options.storageMode = _options.storageMode;

            typeName    = normalizeTypeName(typeName || 'objects');
            var userId  = getUserId() || 'public';
            var name    = userId + '_' + typeName;

            var service = {
                type    : typeName,
                user    : userId,
                name    : name,
                options : options,
                cache   : CacheFactory(name) || CacheFactory.createCache(name, options),
                clear   : function () {
                    this.cache.removeAll();
                },
                getAll  : function () {
                    var result = [];
                    var keys = this.cache.keys() || [];
                    for (var i = 0; i < keys.length; i += 1) {
                        result.push(this.cache(keys[i]));
                    }
                    return result;
                },
                getItems : function (ids) {
                    var result = [],
                        _ids   = [];
                    for (var i = 0; i < (ids || []).length; i += 1) {
                        var id = ids[i];
                        if (_ids.indexOf(id) < 0) {
                            _ids.push(id);
                            var item = this.cache.get(id);
                            if (item) { result.push(item); }
                        }
                    }
                    return result;
                },
                getItem  : function (id) {
                    var items = this.getItems([id]);
                    return (items.length > 0) ? items[0] : null;
                },
                putItem  : function (item, id, refresh) {
                    var existing = this.cache.get(id);
                    if (existing && !refresh) { return true; }
                    if (existing) { this.cache.remove(id); }
                    this.cache.put(item, id);
                    return (!!this.cache.get(id));
                },
                putItems : function (items, idField, refresh) {
                    var success = true;
                    for (var i = 0; i < (items || []).length; i += 1) {
                        var item = items[i];
                        var id   = item[idField];
                        if (typeof id != 'undefined') {
                            if (this.putItem(item, id, refresh)) { success = false; }
                        }
                    }
                    return success;
                },
                getItemsByKey : function (key, value, isCaseSensitive) {
                    var result = [];
                    (this.getAll() || []).forEach(function(item){
                        var itemValue = item[key];
                        if (typeof itemValue != 'undefined') {
                            if ((typeof value == 'string') && (typeof itemValue == 'string') && (!isCaseSensitive || value.toLowerCase() == itemValue.toLowerCase())) {
                                result.push(item);
                            } else if (((typeof value) == (typeof itemValue)) && (value == itemValue)) {
                                result.push(item);
                            } else {
                                // Other scenarios?
                            }
                        }
                    });
                    return result;
                },
                getItemByKeyFirst : function (key, value, isCaseSensitive) {
                    var items = this.getItemsByKey(key, value, isCaseSensitive) || [];
                    return (items.length > 0) ? items[0] : null;
                },
                getItemByKeySingle : function (key, value, isCaseSensitive) {
                    var items = this.getItemsByKey(key, value, isCaseSensitive) || [];
                    return (items.length === 0) ? items[0] : null;
                },
                removeItemsByKey : function (keyField, values, isCaseSensitive) {
                    var keysToRemove = [],
                        keys = this.cache.keys() || [];
                    for (var k = 0; k < keys.length; k += 1) {
                        var key     = keys[k];
                        var item    = this.cache.get(key);
                        var itemVal = item[keyField];
                        if (typeof itemVal != 'undefined') {
                            for (var v = 0; v < (values || []).length; v += 1) {
                                if ((typeof values[v] == 'string') && (typeof itemVal == 'string') && (!isCaseSensitive || values[v].toLowerCase() == itemVal.toLowerCase())) {
                                    keysToRemove.push(key);
                                    break;
                                } else if (((typeof values[v]) == (typeof itemVal)) && (values[v] == itemVal)) {
                                    keysToRemove.push(key);
                                    break;
                                } else {
                                    // Other scenarios?
                                }
                            }
                        }
                    }
                    var success = true;
                    for (var r = 0; r < keysToRemove.length; r += 1) {
                        this.cache.remove(keysToRemove[r]);
                        if (this.cache.get(keysToRemove[r])) { success = false; }
                    }
                    return success;
                },
                removeItemByKey : function (keyField, value, isCaseSensitive) {
                    return this.removeItemsByKey(keyField, [value], isCaseSensitive);
                },
                putItemsByKey : function(items, keyField, refresh, isCaseSensitive) {
                    if (!!refresh) {
                        var values  = _.map((items || []), keyField);
                        if (!this.removeItemsByKey(keyField, values, isCaseSensitive)) { return false; }
                    }
                    for (var i = 0; i < (items || []).length; i += 1) {
                        var id = items[i][keyField];
                        if (typeof id != 'undefined') {
                            this.cache.put(items[i], id);
                            if (!this.cache.get(id)) { return false; }
                        }
                    }
                    return true;
                },
                putItemByKey : function (item, keyField, refresh, isCaseSensitive) {
                    return this.putItemsByKey([item], keyField, refresh, isCaseSensitive);
                }
            };

            return service;
        }


        function getUserId () {
            return $auth.isAuthenticated() ? ($auth.getPayload().sub || 'unknown') : null;
        }
        function normalizeTypeName (typeName) {
            return typeName.split('.').join('-');
        }
    }

})();