@fjell/cache 4.6.7 → 4.6.11

package/dist/index.cjs

@@ -5,10 +5,11 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const Logging = require('@fjell/logging');
 const core = require('@fjell/core');
 const httpApi = require('@fjell/http-api');
+const registry = require('@fjell/registry');
 
-const LibLogger = Logging.getLogger('@fjell/cache');
+const logger$1.default = Logging.getLogger('@fjell/cache');
 
-const logger$3 = LibLogger.get('ItemAggregator');
+const logger$j = logger$1.default.get('ItemAggregator');
 const toCacheConfig = (config)=>{
     let cacheConfig;
     if (config.optional === undefined) {
@@ -23,7 +24,7 @@ const toCacheConfig = (config)=>{
 };
 const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
     const populate = async (item)=>{
-        logger$3.default('populate', {
+        logger$j.default('populate', {
             item
         });
         for(const key in aggregates){
@@ -32,19 +33,19 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
         for(const key in events){
             await populateEvent(key, item);
         }
-        logger$3.default('populate done', {
+        logger$j.default('populate done', {
             item
         });
         return item;
     };
     const populateAggregate = async (key, item)=>{
-        logger$3.default('populate aggregate key', {
+        logger$j.default('populate aggregate key', {
             key
         });
         const cacheConfig = toCacheConfig(aggregates[key]);
         if (item.refs === undefined) {
             if (cacheConfig.optional === false) {
-                logger$3.error('Item does not have refs an is not optional ' + JSON.stringify(item));
+                logger$j.error('Item does not have refs an is not optional ' + JSON.stringify(item));
                 throw new Error('Item does not have refs an is not optional ' + JSON.stringify(item));
             } else {
                 if (item.events && Object.prototype.hasOwnProperty.call(item.events, key)) {
@@ -53,7 +54,7 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
             }
         } else if (item.refs[key] === undefined) {
             if (cacheConfig.optional === false) {
-                logger$3.error('Item does not have mandatory ref with key, not optional ' + key + ' ' + JSON.stringify(item));
+                logger$j.error('Item does not have mandatory ref with key, not optional ' + key + ' ' + JSON.stringify(item));
                 throw new Error('Item does not have mandatory ref with key, not optional ' + key + ' ' + JSON.stringify(item));
             } else {
                 if (item.events && Object.prototype.hasOwnProperty.call(item.events, key)) {
@@ -62,10 +63,10 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
             }
         } else {
             const ref = item.refs[key];
-            logger$3.default('AGG Retrieving Item in Populate', {
+            logger$j.default('AGG Retrieving Item in Populate', {
                 key: ref
             });
-            const [, newItem] = await cacheConfig.cache.retrieve(ref);
+            const [, newItem] = await cacheConfig.cache.operations.retrieve(ref);
             if (newItem) {
                 if (item.aggs === undefined) {
                     item.aggs = {};
@@ -79,7 +80,7 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
     };
     // TODO: I'm not a big fan that this just "automatically" assumes that the "by" key in event is a ref.
     const populateEvent = async (key, item)=>{
-        logger$3.default('populate event key', {
+        logger$j.default('populate event key', {
             key
         });
         const cacheConfig = toCacheConfig(events[key]);
@@ -87,13 +88,13 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
             throw new Error('Item does not have events ' + JSON.stringify(item));
         } else if (item.events[key] === undefined) {
             if (cacheConfig.optional === false) {
-                logger$3.error('Item does not have mandatory event with key ' + key + ' ' + JSON.stringify(item));
+                logger$j.error('Item does not have mandatory event with key ' + key + ' ' + JSON.stringify(item));
                 throw new Error('Item does not have mandatory event with key ' + key + ' ' + JSON.stringify(item));
             }
         } else {
             const event = item.events[key];
             if (event.by === undefined) {
-                logger$3.error('populateEvent with an Event that does not have by', {
+                logger$j.error('populateEvent with an Event that does not have by', {
                     event,
                     ik: item.key,
                     eventKey: key
@@ -103,21 +104,21 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
                     event
                 }));
             }
-            logger$3.default('EVENT Retrieving Item in Populate', {
+            logger$j.default('EVENT Retrieving Item in Populate', {
                 key: event.by
             });
-            const [, newItem] = await cacheConfig.cache.retrieve(event.by);
+            const [, newItem] = await cacheConfig.cache.operations.retrieve(event.by);
             if (newItem) {
                 event.agg = newItem;
             }
         }
     };
     const all = async (query = {}, locations = [])=>{
-        logger$3.default('all', {
+        logger$j.default('all', {
             query,
             locations
         });
-        const [cacheMap, items] = await cache.all(query, locations);
+        const [cacheMap, items] = await cache.operations.all(query, locations);
         const populatedItems = await Promise.all(items.map(async (item)=>populate(item)));
         return [
             cacheMap,
@@ -125,11 +126,11 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
         ];
     };
     const one = async (query = {}, locations = [])=>{
-        logger$3.default('one', {
+        logger$j.default('one', {
             query,
             locations
         });
-        const [cacheMap, item] = await cache.one(query, locations);
+        const [cacheMap, item] = await cache.operations.one(query, locations);
         let populatedItem = null;
         if (item) {
             populatedItem = await populate(item);
@@ -140,12 +141,12 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
         ];
     };
     const action = async (key, action, body = {})=>{
-        logger$3.default('action', {
+        logger$j.default('action', {
             key,
             action,
             body
         });
-        const [cacheMap, item] = await cache.action(key, action, body);
+        const [cacheMap, item] = await cache.operations.action(key, action, body);
         const populatedItem = await populate(item);
         return [
             cacheMap,
@@ -153,12 +154,12 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
         ];
     };
     const allAction = async (action, body = {}, locations = [])=>{
-        logger$3.default('action', {
+        logger$j.default('action', {
             action,
             body,
             locations
         });
-        const [cacheMap, items] = await cache.allAction(action, body, locations);
+        const [cacheMap, items] = await cache.operations.allAction(action, body, locations);
         const populatedItems = await Promise.all(items.map(async (item)=>populate(item)));
         return [
             cacheMap,
@@ -166,23 +167,23 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
         ];
     };
     const allFacet = async (facet, params = {}, locations = [])=>{
-        logger$3.default('allFacet', {
+        logger$j.default('allFacet', {
             facet,
             params,
             locations
         });
-        const [cacheMap, response] = await cache.allFacet(facet, params, locations);
+        const [cacheMap, response] = await cache.operations.allFacet(facet, params, locations);
         return [
             cacheMap,
             response
         ];
     };
     const create = async (v, locations = [])=>{
-        logger$3.default('create', {
+        logger$j.default('create', {
             v,
             locations
         });
-        const [cacheMap, item] = await cache.create(v, locations);
+        const [cacheMap, item] = await cache.operations.create(v, locations);
         const populatedItem = await populate(item);
         return [
             cacheMap,
@@ -190,10 +191,10 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
         ];
     };
     const get = async (key)=>{
-        logger$3.default('get', {
+        logger$j.default('get', {
             key
         });
-        const [cacheMap, item] = await cache.get(key);
+        const [cacheMap, item] = await cache.operations.get(key);
         let populatedItem = null;
         if (item) {
             populatedItem = await populate(item);
@@ -204,10 +205,10 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
         ];
     };
     const retrieve = async (key)=>{
-        logger$3.default('retrieve', {
+        logger$j.default('retrieve', {
             key
         });
-        const [cacheMap, item] = await cache.retrieve(key);
+        const [cacheMap, item] = await cache.operations.retrieve(key);
         let populatedItem = null;
         if (item) {
             populatedItem = await populate(item);
@@ -218,18 +219,18 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
         ];
     };
     const remove = async (key)=>{
-        logger$3.default('remove', {
+        logger$j.default('remove', {
             key
         });
-        const cacheMap = await cache.remove(key);
+        const cacheMap = await cache.operations.remove(key);
         return cacheMap;
     };
     const update = async (key, v)=>{
-        logger$3.default('update', {
+        logger$j.default('update', {
             key,
             v
         });
-        const [cacheMap, item] = await cache.update(key, v);
+        const [cacheMap, item] = await cache.operations.update(key, v);
         const populatedItem = await populate(item);
         return [
             cacheMap,
@@ -238,23 +239,23 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
     };
     // Facets are a pass-thru for aggregators
     const facet = async (key, facet)=>{
-        logger$3.default('facet', {
+        logger$j.default('facet', {
             key,
             facet
         });
-        const [cacheMap, response] = await cache.facet(key, facet);
+        const [cacheMap, response] = await cache.operations.facet(key, facet);
         return [
             cacheMap,
             response
         ];
     };
     const find = async (finder, finderParams = {}, locations = [])=>{
-        logger$3.default('find', {
+        logger$j.default('find', {
             finder,
             finderParams,
             locations
         });
-        const [cacheMap, items] = await cache.find(finder, finderParams, locations);
+        const [cacheMap, items] = await cache.operations.find(finder, finderParams, locations);
         const populatedItems = await Promise.all(items.map(async (item)=>populate(item)));
         return [
             cacheMap,
@@ -262,12 +263,12 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
         ];
     };
     const findOne = async (finder, finderParams = {}, locations = [])=>{
-        logger$3.default('find', {
+        logger$j.default('find', {
             finder,
             finderParams,
             locations
         });
-        const [cacheMap, item] = await cache.findOne(finder, finderParams, locations);
+        const [cacheMap, item] = await cache.operations.findOne(finder, finderParams, locations);
         const populatedItem = await populate(item);
         return [
             cacheMap,
@@ -275,12 +276,12 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
         ];
     };
     const set = async (key, v)=>{
-        logger$3.default('set', {
+        logger$j.default('set', {
             key,
             v
         });
         // TODO: There should be some input validation here to ensure a valid item.
-        const [cacheMap, item] = await cache.set(key, v);
+        const [cacheMap, item] = await cache.operations.set(key, v);
         const populatedItem = await populate(item);
         return [
             cacheMap,
@@ -288,10 +289,17 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
         ];
     };
     const reset = async ()=>{
-        const cacheMap = await cache.reset();
+        const cacheMap = await cache.operations.reset();
         return cacheMap;
     };
     return {
+        // Cache properties
+        coordinate: cache.coordinate,
+        registry: cache.registry,
+        api: cache.api,
+        cacheMap: cache.cacheMap,
+        operations: cache.operations,
+        // Cache operations exposed directly
         all,
         one,
         action,
@@ -307,15 +315,14 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
         findOne,
         reset,
         set,
-        pkTypes: cache.pkTypes,
-        cacheMap: cache.cacheMap,
+        // Aggregator-specific operations
         populate,
         populateAggregate,
         populateEvent
     };
 };
 
-function _define_property$1(obj, key, value) {
+function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -328,7 +335,7 @@ function _define_property$1(obj, key, value) {
     }
     return obj;
 }
-const logger$2 = LibLogger.get("CacheMap");
+const logger$i = logger$1.default.get("CacheMap");
 // Normalize a key value to string for consistent comparison and hashing
 const normalizeKeyValue$1 = (value)=>{
     return String(value);
@@ -431,17 +438,17 @@ class CacheMap extends core.Dictionary {
     }
     allIn(locations) {
         if (locations.length === 0) {
-            logger$2.debug('Returning all items, LocKeys is empty');
+            logger$i.debug('Returning all items, LocKeys is empty');
             return this.values();
         } else {
             const locKeys = locations;
-            logger$2.debug('allIn', {
+            logger$i.debug('allIn', {
                 locKeys,
                 keys: this.keys().length
             });
             return this.keys().filter((key)=>key && core.isComKey(key)).filter((key)=>{
                 const ComKey = key;
-                logger$2.debug('Comparing Location Keys', {
+                logger$i.debug('Comparing Location Keys', {
                     locKeys,
                     ComKey
                 });
@@ -451,7 +458,7 @@ class CacheMap extends core.Dictionary {
     }
     // TODO: Can we do case insensitive matching?
     contains(query, locations) {
-        logger$2.debug('contains', {
+        logger$i.debug('contains', {
             query,
             locations
         });
@@ -459,7 +466,7 @@ class CacheMap extends core.Dictionary {
         return items.some((item)=>core.isQueryMatch(item, query));
     }
     queryIn(query, locations = []) {
-        logger$2.debug('queryIn', {
+        logger$i.debug('queryIn', {
             query,
             locations
         });
@@ -471,12 +478,277 @@ class CacheMap extends core.Dictionary {
         return clone;
     }
     constructor(types, map){
-        super(map, createNormalizedHashFunction()), _define_property$1(this, "types", void 0);
+        super(map, createNormalizedHashFunction()), _define_property(this, "types", void 0);
         this.types = types;
     }
 }
 
-const logger$1 = LibLogger.get('Cache');
+const logger$h = logger$1.default.get('all');
+const all = async (api, cacheMap, pkType, query = {}, locations = [])=>{
+    logger$h.default('all', {
+        query,
+        locations
+    });
+    let ret = [];
+    try {
+        ret = await api.all(query, locations);
+        ret.forEach((v)=>{
+            cacheMap.set(v.key, v);
+        });
+    } catch (e) {
+        if (e instanceof httpApi.NotFoundError) ; else {
+            throw e;
+        }
+    }
+    return [
+        cacheMap,
+        core.validatePK(ret, pkType)
+    ];
+};
+
+const logger$g = logger$1.default.get('one');
+const one = async (api, cacheMap, pkType, query = {}, locations = [])=>{
+    logger$g.default('one', {
+        query,
+        locations
+    });
+    let retItem = null;
+    try {
+        retItem = await api.one(query, locations);
+        if (retItem) {
+            cacheMap.set(retItem.key, retItem);
+        }
+    } catch (e) {
+        if (e instanceof httpApi.NotFoundError) ; else {
+            throw e;
+        }
+    }
+    return [
+        cacheMap,
+        retItem ? core.validatePK(retItem, pkType) : null
+    ];
+};
+
+const logger$f = logger$1.default.get('create');
+const create = async (api, cacheMap, pkType, v, locations = [])=>{
+    logger$f.default('create', {
+        v,
+        locations
+    });
+    const created = await api.create(v, locations);
+    cacheMap.set(created.key, created);
+    return [
+        cacheMap,
+        core.validatePK(created, pkType)
+    ];
+};
+
+const logger$e = logger$1.default.get('get');
+const get.get = async (api, cacheMap, pkType, key)=>{
+    logger$e.default('get', {
+        key
+    });
+    if (!core.isValidItemKey(key)) {
+        logger$e.error('Key for Get is not a valid ItemKey: %j', key);
+        throw new Error('Key for Get is not a valid ItemKey');
+    }
+    let ret;
+    try {
+        ret = await api.get(key);
+        if (ret) {
+            cacheMap.set(ret.key, ret);
+        }
+    } catch (e) {
+        logger$e.error("Error getting item for key", {
+            key,
+            message: e.message,
+            stack: e.stack
+        });
+        throw e;
+    }
+    return [
+        cacheMap,
+        ret ? core.validatePK(ret, pkType) : null
+    ];
+};
+
+const logger$d = logger$1.default.get('retrieve');
+const retrieve = async (api, cacheMap, pkType, key)=>{
+    logger$d.default('retrieve', {
+        key
+    });
+    if (!core.isValidItemKey(key)) {
+        logger$d.error('Key for Retrieve is not a valid ItemKey: %j', key);
+        throw new Error('Key for Retrieve is not a valid ItemKey');
+    }
+    const containsItemKey = cacheMap.includesKey(key);
+    let retrieved;
+    if (containsItemKey) {
+        logger$d.default('Looking for Object in Cache', key);
+        retrieved = cacheMap.get(key);
+    } else {
+        logger$d.default('Object Not Found in Cache, Retrieving from Server API', {
+            key
+        });
+        [, retrieved] = await get.get(api, cacheMap, pkType, key);
+    }
+    const retValue = [
+        containsItemKey ? null : cacheMap,
+        retrieved ? core.validatePK(retrieved, pkType) : null
+    ];
+    return retValue;
+};
+
+const logger$c = logger$1.default.get('remove');
+const remove = async (api, cacheMap, key)=>{
+    logger$c.default('remove', {
+        key
+    });
+    if (!core.isValidItemKey(key)) {
+        logger$c.error('Key for Remove is not a valid ItemKey: %j', key);
+        throw new Error('Key for Remove is not a valid ItemKey');
+    }
+    try {
+        await api.remove(key);
+        cacheMap.delete(key);
+    } catch (e) {
+        logger$c.error("Error deleting item", {
+            error: e
+        });
+        throw e;
+    }
+    return cacheMap;
+};
+
+const logger$b = logger$1.default.get('update');
+const update = async (api, cacheMap, pkType, key, v)=>{
+    logger$b.default('update', {
+        key,
+        v
+    });
+    if (!core.isValidItemKey(key)) {
+        logger$b.error('Key for Update is not a valid ItemKey: %j', key);
+        throw new Error('Key for Update is not a valid ItemKey');
+    }
+    try {
+        const updated = await api.update(key, v);
+        cacheMap.set(updated.key, updated);
+        return [
+            cacheMap,
+            core.validatePK(updated, pkType)
+        ];
+    } catch (e) {
+        logger$b.error("Error updating item", {
+            error: e
+        });
+        throw e;
+    }
+};
+
+const logger$a = logger$1.default.get('action');
+const action = async (api, cacheMap, pkType, key, action, body = {})=>{
+    logger$a.default('action', {
+        key,
+        action,
+        body
+    });
+    if (!core.isValidItemKey(key)) {
+        logger$a.error('Key for Action is not a valid ItemKey: %j', key);
+        throw new Error('Key for Action is not a valid ItemKey');
+    }
+    const updated = await api.action(key, action, body);
+    cacheMap.set(updated.key, updated);
+    return [
+        cacheMap,
+        core.validatePK(updated, pkType)
+    ];
+};
+
+const logger$9 = logger$1.default.get('allAction');
+const allAction = async (api, cacheMap, pkType, action, body = {}, locations = [])=>{
+    logger$9.default('allAction', {
+        action,
+        body,
+        locations
+    });
+    let ret = [];
+    try {
+        ret = await api.allAction(action, body, locations);
+        ret.forEach((v)=>{
+            cacheMap.set(v.key, v);
+        });
+    } catch (e) {
+        // istanbul ignore next
+        if (e instanceof httpApi.NotFoundError) ; else {
+            throw e;
+        }
+    }
+    return [
+        cacheMap,
+        core.validatePK(ret, pkType)
+    ];
+};
+
+const logger$8 = logger$1.default.get('facet');
+const facet = async (api, cacheMap, key, facet, params = {})=>{
+    logger$8.default('facet', {
+        key,
+        facet
+    });
+    const ret = await api.facet(key, facet, params);
+    return [
+        cacheMap,
+        ret
+    ];
+};
+
+const logger$7 = logger$1.default.get('allFacet');
+const allFacet = async (api, cacheMap, facet, params = {}, locations = [])=>{
+    logger$7.default('allFacet', {
+        facet,
+        params,
+        locations
+    });
+    const ret = await api.allFacet(facet, params, locations);
+    return [
+        cacheMap,
+        ret
+    ];
+};
+
+const logger$6 = logger$1.default.get('find');
+const find = async (api, cacheMap, pkType, finder, params = {}, locations = [])=>{
+    logger$6.default('find', {
+        finder,
+        params,
+        locations
+    });
+    const ret = await api.find(finder, params, locations);
+    ret.forEach((v)=>{
+        cacheMap.set(v.key, v);
+    });
+    return [
+        cacheMap,
+        core.validatePK(ret, pkType)
+    ];
+};
+
+const logger$5 = logger$1.default.get('findOne');
+const findOne = async (api, cacheMap, pkType, finder, finderParams = {}, locations = [])=>{
+    logger$5.default('findOne', {
+        finder,
+        finderParams,
+        locations
+    });
+    const ret = await api.findOne(finder, finderParams, locations);
+    cacheMap.set(ret.key, ret);
+    return [
+        cacheMap,
+        core.validatePK(ret, pkType)
+    ];
+};
+
+const logger$4 = logger$1.default.get('set');
 // Normalize a key value to string for consistent comparison
 const normalizeKeyValue = (value)=>{
     return String(value);
@@ -516,374 +788,153 @@ const normalizeKey = (key)=>{
     }
     return key;
 };
-const createCache = async (api, pkType, parentCache)=>{
-    let pkTypes = [
-        pkType
-    ];
-    if (parentCache) {
-        pkTypes = pkTypes.concat(parentCache.pkTypes);
+const set = async (cacheMap, pkType, key, v)=>{
+    logger$4.default('set', {
+        key,
+        v
+    });
+    if (!core.isValidItemKey(key)) {
+        logger$4.error('Key for Set is not a valid ItemKey: %j', key);
+        throw new Error('Key for Set is not a valid ItemKey');
     }
-    let cacheMap = new CacheMap(pkTypes);
-    const all = async (query = {}, locations = [])=>{
-        logger$1.default('all', {
-            query,
-            locations
-        });
-        let ret = [];
-        try {
-            ret = await api.all(query, locations);
-            ret.forEach((v)=>{
-                cacheMap.set(v.key, v);
-            });
-        } catch (e) {
-            if (e instanceof httpApi.NotFoundError) ; else {
-                throw e;
-            }
-        }
-        return [
-            cacheMap,
-            core.validatePK(ret, pkType)
-        ];
-    };
-    const one = async (query = {}, locations = [])=>{
-        logger$1.default('one', {
-            query,
-            locations
-        });
-        let retItem = null;
-        try {
-            retItem = await api.one(query, locations);
-            if (retItem) {
-                cacheMap.set(retItem.key, retItem);
-            }
-        } catch (e) {
-            if (e instanceof httpApi.NotFoundError) ; else {
-                throw e;
-            }
-        }
-        return [
-            cacheMap,
-            retItem ? core.validatePK(retItem, pkType) : null
-        ];
-    };
-    const action = async (key, action, body = {})=>{
-        logger$1.default('action', {
-            key,
-            action,
-            body
-        });
-        // TODO: This is validating the key, but it doesn't have knowledge of the pkType
-        // This should be looking at the parentCaches and calculating an array of pkTypes
-        if (!core.isValidItemKey(key)) {
-            logger$1.error('Key for Action is not a valid ItemKey: %j', key);
-            throw new Error('Key for Action is not a valid ItemKey');
-        }
-        const updated = await api.action(key, action, body);
-        cacheMap.set(updated.key, updated);
-        return [
-            cacheMap,
-            core.validatePK(updated, pkType)
-        ];
-    };
-    const allAction = async (action, body = {}, locations = [])=>{
-        logger$1.default('allAction', {
-            action,
-            body,
-            locations
-        });
-        let ret = [];
-        try {
-            ret = await api.allAction(action, body, locations);
-            ret.forEach((v)=>{
-                cacheMap.set(v.key, v);
-            });
-        } catch (e) {
-            // istanbul ignore next
-            if (e instanceof httpApi.NotFoundError) ; else {
-                throw e;
-            }
-        }
-        return [
-            cacheMap,
-            core.validatePK(ret, pkType)
-        ];
-    };
-    const allFacet = async (facet, params = {}, locations = [])=>{
-        logger$1.default('allFacet', {
-            facet,
-            params,
-            locations
-        });
-        const ret = await api.allFacet(facet, params, locations);
-        return [
-            cacheMap,
-            ret
-        ];
+    // Validate the item's primary key
+    core.validatePK(v, pkType);
+    if (!isItemKeyEqualNormalized(key, v.key)) {
+        logger$4.error('Key does not match item key: %j != %j', key, v.key);
+        throw new Error('Key does not match item key');
+    }
+    cacheMap.set(key, v);
+    return [
+        cacheMap,
+        core.validatePK(v, pkType)
+    ];
+};
+
+const reset = async (coordinate)=>{
+    const cacheMap = new CacheMap(coordinate.kta);
+    return [
+        cacheMap
+    ];
+};
+
+// Import all operation functions
+const createOperations = (api, coordinate, cacheMap, pkType)=>{
+    return {
+        all: (query, locations)=>all(api, cacheMap, pkType, query, locations),
+        one: (query, locations)=>one(api, cacheMap, pkType, query, locations),
+        create: (item, locations)=>create(api, cacheMap, pkType, item, locations),
+        get: (key)=>get.get(api, cacheMap, pkType, key),
+        retrieve: (key)=>retrieve(api, cacheMap, pkType, key),
+        remove: (key)=>remove(api, cacheMap, key),
+        update: (key, item)=>update(api, cacheMap, pkType, key, item),
+        action: (key, actionName, body)=>action(api, cacheMap, pkType, key, actionName, body),
+        allAction: (actionName, body, locations)=>allAction(api, cacheMap, pkType, actionName, body, locations),
+        facet: (key, facetName, params)=>facet(api, cacheMap, key, facetName, params),
+        allFacet: (facetName, params, locations)=>allFacet(api, cacheMap, facetName, params, locations),
+        find: (finder, params, locations)=>find(api, cacheMap, pkType, finder, params, locations),
+        findOne: (finder, params, locations)=>findOne(api, cacheMap, pkType, finder, params, locations),
+        set: (key, item)=>set(cacheMap, pkType, key, item),
+        reset: ()=>reset(coordinate)
     };
-    const create = async (v, locations = [])=>{
-        logger$1.default('create', {
-            v,
-            locations
-        });
-        const created = await api.create(v, locations);
-        cacheMap.set(created.key, created);
-        return [
-            cacheMap,
-            core.validatePK(created, pkType)
-        ];
+};
+
+const logger$3 = logger$1.default.get('Cache');
+const createCache = async (api, coordinate, registry)=>{
+    logger$3.debug('createCache', {
+        coordinate,
+        registry
+    });
+    // Create the cache map using the coordinate's key type array
+    const cacheMap = new CacheMap(coordinate.kta);
+    // Get the primary key type from the coordinate
+    const pkType = coordinate.kta[0];
+    // Create operations
+    const operations = createOperations(api, coordinate, cacheMap, pkType);
+    return {
+        coordinate,
+        registry,
+        api,
+        cacheMap,
+        operations
     };
-    const get = async (key)=>{
-        logger$1.default('get', {
-            key
-        });
-        // TODO: This is validating the key, but it doesn't have knowledge of the pkType
-        // This should be looking at the parentCaches and calculating an array of pkTypes
-        if (!core.isValidItemKey(key)) {
-            logger$1.error('Key for Get is not a valid ItemKey: %j', key);
-            throw new Error('Key for Get is not a valid ItemKey');
-        }
-        let ret;
-        try {
-            ret = await api.get(key);
-            if (ret) {
-                cacheMap.set(ret.key, ret);
-            }
-        } catch (e) {
-            logger$1.error("Error getting item for key", {
-                key,
-                message: e.message,
-                stack: e.stack
-            });
-            throw e;
-        }
-        return [
+};
+const isCache = (cache)=>{
+    return cache !== null && typeof cache === 'object' && 'coordinate' in cache && 'registry' in cache && 'api' in cache && 'cacheMap' in cache && 'operations' in cache;
+};
+
+const logger$2 = logger$1.default.get("Instance");
+const createInstance = async (registry, coordinate, api)=>{
+    logger$2.debug("createInstance", {
+        coordinate,
+        api,
+        registry
+    });
+    return await createCache(api, coordinate, registry);
+};
+const isInstance = (instance)=>{
+    return instance !== null && typeof instance === 'object' && 'coordinate' in instance && 'registry' in instance && 'api' in instance && 'cacheMap' in instance && 'operations' in instance;
+};
+
+const logger$1 = logger$1.default.get("InstanceFactory");
+/**
+ * Factory function for creating cache instances
+ */ const createInstanceFactory = (api)=>{
+    return (coordinate, context)=>{
+        logger$1.debug("Creating cache instance", {
+            coordinate,
+            registry: context.registry,
+            api
+        });
+        // Since InstanceFactory must be synchronous but our createInstance is async,
+        // we need to create a special cache instance synchronously and defer the async initialization
+        const cacheMap = new CacheMap(coordinate.kta);
+        const pkType = coordinate.kta[0];
+        const operations = createOperations(api, coordinate, cacheMap, pkType);
+        return {
+            coordinate,
+            registry: context.registry,
+            api,
             cacheMap,
-            ret ? core.validatePK(ret, pkType) : null
-        ];
-    };
-    const retrieve = async (key)=>{
-        logger$1.default('retrieve', {
-            key
-        });
-        if (!core.isValidItemKey(key)) {
-            logger$1.error('Key for Retrieve is not a valid ItemKey: %j', key);
-            throw new Error('Key for Retrieve is not a valid ItemKey');
-        }
-        const containsItemKey = cacheMap.includesKey(key);
-        let retrieved;
-        if (containsItemKey) {
-            logger$1.default('Looking for Object in Cache', key);
-            retrieved = cacheMap.get(key);
-        } else {
-            logger$1.default('Object Not Found in Cache, Retrieving from Server API', {
-                key
-            });
-            [, retrieved] = await get(key);
-        }
-        const retValue = [
-            containsItemKey ? null : cacheMap,
-            retrieved ? core.validatePK(retrieved, pkType) : null
-        ];
-        // logger.debug('Returning from retrieve', { retValue });
-        return retValue;
-    };
-    const remove = async (key)=>{
-        logger$1.default('remove', {
-            key
-        });
-        // TODO: This is validating the key, but it doesn't have knowledge of the pkType
-        // This should be looking at the parentCaches and calculating an array of pkTypes
-        if (!core.isValidItemKey(key)) {
-            logger$1.error('Key for Remove is not a valid ItemKey: %j', key);
-            throw new Error('Key for Remove is not a valid ItemKey');
-        }
-        try {
-            await api.remove(key);
-            cacheMap.delete(key);
-        } catch (e) {
-            logger$1.error("Error deleting item", {
-                error: e
-            });
-            throw e;
-        }
-        return cacheMap;
+            operations
+        };
     };
-    const update = async (key, v)=>{
-        logger$1.default('update', {
-            key,
-            v
-        });
-        // TODO: This is validating the key, but it doesn't have knowledge of the pkType
-        // This should be looking at the parentCaches and calculating an array of pkTypes
-        if (!core.isValidItemKey(key)) {
-            logger$1.error('Key for Update is not a valid ItemKey: %j', key);
-            throw new Error('Key for Update is not a valid ItemKey');
-        }
-        try {
-            const updated = await api.update(key, v);
-            cacheMap.set(updated.key, updated);
-            return [
-                cacheMap,
-                core.validatePK(updated, pkType)
-            ];
-        } catch (e) {
-            logger$1.error("Error updating chat", {
-                error: e
-            });
-            throw e;
+};
+
+const logger = logger$1.default.get("Registry");
+/**
+ * Factory function for creating cache registries
+ */ const createRegistryFactory = ()=>{
+    return (type, registryHub)=>{
+        if (type !== 'cache') {
+            throw new Error(`Cache registry factory can only create 'cache' type registries, got: ${type}`);
         }
-    };
-    // Facets are a pass-thru for caches
-    const facet = async (key, facet, params = {})=>{
-        logger$1.default('facet', {
-            key,
-            facet
+        logger.debug("Creating cache registry", {
+            type,
+            registryHub
         });
-        const ret = await api.facet(key, facet, params);
-        return [
-            cacheMap,
-            ret
-        ];
-    };
-    const find = async (finder, params = {}, locations = [])=>{
-        logger$1.default('find', {
-            finder,
-            params,
-            locations
-        });
-        const ret = await api.find(finder, params, locations);
-        ret.forEach((v)=>{
-            cacheMap.set(v.key, v);
-        });
-        return [
-            cacheMap,
-            core.validatePK(ret, pkType)
-        ];
-    };
-    const findOne = async (finder, finderParams = {}, locations = [])=>{
-        logger$1.default('findOne', {
-            finder,
-            finderParams,
-            locations
-        });
-        const ret = await api.findOne(finder, finderParams, locations);
-        cacheMap.set(ret.key, ret);
-        return [
-            cacheMap,
-            core.validatePK(ret, pkType)
-        ];
-    };
-    const reset = async ()=>{
-        cacheMap = new CacheMap(pkTypes);
-        return [
-            cacheMap
-        ];
-    };
-    const set = async (key, v)=>{
-        logger$1.default('set', {
-            key,
-            v
-        });
-        // TODO: This is validating the key, but it doesn't have knowledge of the pkType
-        // This should be looking at the parentCaches and calculating an array of pkTypes
-        if (!core.isValidItemKey(key)) {
-            logger$1.error('Key for Update is not a valid ItemKey: %j', key);
-            throw new Error('Key for Update is not a valid ItemKey');
-        }
-        // TODO: This could be merged with the isValidItemKey check, later.
-        core.validatePK(v, pkType);
-        if (!isItemKeyEqualNormalized(key, v.key)) {
-            logger$1.error('Key does not match item key: %j != %j', key, v.key);
-            throw new Error('Key does not match item key');
-        }
-        cacheMap.set(key, v);
-        return [
-            cacheMap,
-            core.validatePK(v, pkType)
-        ];
+        const baseRegistry = registry.createRegistry(type, registryHub);
+        // Cast to Registry for type safety
+        return baseRegistry;
     };
+};
+/**
+ * Creates a new cache registry instance
+ */ const createRegistry = (registryHub)=>{
+    const baseRegistry = registry.createRegistry('cache', registryHub);
     return {
-        all,
-        one,
-        action,
-        allAction,
-        allFacet,
-        create,
-        get,
-        retrieve,
-        remove,
-        update,
-        facet,
-        find,
-        findOne,
-        reset,
-        set,
-        pkTypes,
-        cacheMap
+        ...baseRegistry
     };
 };
 
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-const logger = LibLogger.get('CacheRegistry');
-class CacheRegistry {
-    constructor(){
-        // TODO: My use of Generics has Boxed me into a corner where I can't reference AbstractCache without the types
-        _define_property(this, "cacheMap", {});
-        _define_property(this, "registerCache", async (cache)=>{
-            try {
-                logger.debug('Attempting to register cache with pkTypes:', cache.pkTypes);
-                const key = JSON.stringify(cache.pkTypes);
-                if (this.cacheMap[key]) {
-                    logger.debug(`Cache with pkTypes ${key} already exists, will be overwritten`);
-                }
-                this.cacheMap[key] = cache;
-                logger.debug('Cache registered successfully with key:', key);
-            } catch (error) {
-                logger.error('Failed to register cache:', error);
-                throw error;
-            }
-        });
-        _define_property(this, "getCache", (kts)=>{
-            logger.debug('Attempting to get cache for key types:', kts);
-            const key = JSON.stringify(kts);
-            logger.debug('Looking up cache with key:', key);
-            const cache = this.cacheMap[key];
-            if (!cache) {
-                logger.warning(`No cache found for key types: ${key}`);
-            }
-            return cache;
-        });
-        _define_property(this, "printRegisteredCaches", ()=>{
-            logger.debug('Printing all registered caches:');
-            const cacheCount = Object.keys(this.cacheMap).length;
-            logger.debug(`Total number of registered caches: ${cacheCount}`);
-            if (cacheCount === 0) {
-                logger.debug('No caches are currently registered');
-            }
-            Object.entries(this.cacheMap).forEach(([keyTypes])=>{
-                logger.debug(`Cache with key types: ${keyTypes}`);
-            });
-        });
-        logger.debug('CacheRegistry instance created');
-    }
-}
-_define_property(CacheRegistry, "instance", void 0);
-
 exports.CacheMap = CacheMap;
-exports.CacheRegistry = CacheRegistry;
 exports.createAggregator = createAggregator;
 exports.createCache = createCache;
+exports.createInstance = createInstance;
+exports.createInstanceFactory = createInstanceFactory;
+exports.createOperations = createOperations;
+exports.createRegistry = createRegistry;
+exports.createRegistryFactory = createRegistryFactory;
+exports.isCache = isCache;
+exports.isInstance = isInstance;
 exports.toCacheConfig = toCacheConfig;
 //# sourceMappingURL=index.cjs.map