@fjell/cache 4.6.0 → 4.6.2

package/.kodrdriv/config.yaml

@@ -0,0 +1,10 @@
+verbose: false
+model: gpt-4.1
+contextDirectories:
+  - .kodrdriv/context
+commit:
+  cached: true
+  sendit: true
+release:
+  from: main
+  to: HEAD

package/.kodrdriv/context/content.md

@@ -0,0 +1 @@
+This is the Fjell Library for Client-side Caches

package/dist/Aggregator.cjs.js

@@ -17,7 +17,7 @@ const toCacheConfig = (config)=>{
     }
     return cacheConfig;
 };
-const createAggregator = (cache, { aggregates = {}, events = {} })=>{
+const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
     const populate = async (item)=>{
         logger.default('populate', {
             item
@@ -220,6 +220,18 @@ const createAggregator = (cache, { aggregates = {}, events = {} })=>{
             populatedItem
         ];
     };
+    // Facets are a pass-thru for aggregators
+    const facet = async (key, facet)=>{
+        logger.default('facet', {
+            key,
+            facet
+        });
+        const [cacheMap, response] = await cache.facet(key, facet);
+        return [
+            cacheMap,
+            response
+        ];
+    };
     const find = async (finder, finderParams, locations = [])=>{
         logger.default('find', {
             finder,
@@ -233,6 +245,19 @@ const createAggregator = (cache, { aggregates = {}, events = {} })=>{
             populatedItems
         ];
     };
+    const findOne = async (finder, finderParams, locations = [])=>{
+        logger.default('find', {
+            finder,
+            finderParams,
+            locations
+        });
+        const [cacheMap, item] = await cache.findOne(finder, finderParams, locations);
+        const populatedItem = await populate(item);
+        return [
+            cacheMap,
+            populatedItem
+        ];
+    };
     const set = async (key, v)=>{
         logger.default('set', {
             key,
@@ -260,7 +285,9 @@ const createAggregator = (cache, { aggregates = {}, events = {} })=>{
         retrieve,
         remove,
         update,
+        facet,
         find,
+        findOne,
         reset,
         set,
         pkTypes: cache.pkTypes,
@@ -273,4 +300,4 @@ const createAggregator = (cache, { aggregates = {}, events = {} })=>{
 
 exports.createAggregator = createAggregator;
 exports.toCacheConfig = toCacheConfig;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQWdncmVnYXRvci5janMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQWdncmVnYXRvci5janMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/Aggregator.d.ts

@@ -16,4 +16,4 @@ export declare const toCacheConfig: <V extends Item<S, L1, L2, L3, L4, L5>, S ex
 export declare const createAggregator: <V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(cache: Cache<V, S, L1, L2, L3, L4, L5>, { aggregates, events }: {
     aggregates?: AggregateConfig;
     events?: AggregateConfig;
-}) => Aggregator<V, S, L1, L2, L3, L4, L5>;
+}) => Promise<Aggregator<V, S, L1, L2, L3, L4, L5>>;

package/dist/Aggregator.es.js

@@ -13,7 +13,7 @@ const toCacheConfig = (config)=>{
     }
     return cacheConfig;
 };
-const createAggregator = (cache, { aggregates = {}, events = {} })=>{
+const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
     const populate = async (item)=>{
         logger.default('populate', {
             item
@@ -216,6 +216,18 @@ const createAggregator = (cache, { aggregates = {}, events = {} })=>{
             populatedItem
         ];
     };
+    // Facets are a pass-thru for aggregators
+    const facet = async (key, facet)=>{
+        logger.default('facet', {
+            key,
+            facet
+        });
+        const [cacheMap, response] = await cache.facet(key, facet);
+        return [
+            cacheMap,
+            response
+        ];
+    };
     const find = async (finder, finderParams, locations = [])=>{
         logger.default('find', {
             finder,
@@ -229,6 +241,19 @@ const createAggregator = (cache, { aggregates = {}, events = {} })=>{
             populatedItems
         ];
     };
+    const findOne = async (finder, finderParams, locations = [])=>{
+        logger.default('find', {
+            finder,
+            finderParams,
+            locations
+        });
+        const [cacheMap, item] = await cache.findOne(finder, finderParams, locations);
+        const populatedItem = await populate(item);
+        return [
+            cacheMap,
+            populatedItem
+        ];
+    };
     const set = async (key, v)=>{
         logger.default('set', {
             key,
@@ -256,7 +281,9 @@ const createAggregator = (cache, { aggregates = {}, events = {} })=>{
         retrieve,
         remove,
         update,
+        facet,
         find,
+        findOne,
         reset,
         set,
         pkTypes: cache.pkTypes,
@@ -268,4 +295,4 @@ const createAggregator = (cache, { aggregates = {}, events = {} })=>{
 };
 
 export { createAggregator, toCacheConfig };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQWdncmVnYXRvci5lcy5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQWdncmVnYXRvci5lcy5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/Cache.cjs.js

@@ -8,7 +8,7 @@ const logger$1 = require('./logger.cjs.js');
 const httpApi = require('@fjell/http-api');
 
 const logger = logger$1.default.get('Cache');
-const createCache = (api, pkType, parentCache)=>{
+const createCache = async (api, pkType, parentCache)=>{
     let pkTypes = [
         pkType
     ];
@@ -213,6 +213,18 @@ const createCache = (api, pkType, parentCache)=>{
             throw e;
         }
     };
+    // Facets are a pass-thru for caches
+    const facet = async (key, facet)=>{
+        logger.default('facet', {
+            key,
+            facet
+        });
+        const ret = await api.facet(key, facet, {});
+        return [
+            cacheMap,
+            ret
+        ];
+    };
     const find = async (finder, finderParams, locations = [])=>{
         logger.default('find', {
             finder,
@@ -228,6 +240,19 @@ const createCache = (api, pkType, parentCache)=>{
             core.validatePK(ret, pkType)
         ];
     };
+    const findOne = async (finder, finderParams, locations = [])=>{
+        logger.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.CacheMap(pkTypes);
         return [
@@ -267,7 +292,9 @@ const createCache = (api, pkType, parentCache)=>{
         retrieve,
         remove,
         update,
+        facet,
         find,
+        findOne,
         reset,
         set,
         pkTypes,
@@ -276,4 +303,4 @@ const createCache = (api, pkType, parentCache)=>{
 };
 
 exports.createCache = createCache;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FjaGUuY2pzLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FjaGUuY2pzLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/Cache.d.ts

@@ -11,10 +11,12 @@ export interface Cache<V extends Item<S, L1, L2, L3, L4, L5>, S extends string,
     retrieve: (key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>) => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5> | null, V | null]>;
     remove: (key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>) => Promise<CacheMap<V, S, L1, L2, L3, L4, L5>>;
     update: (key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>, v: TypesProperties<V, S, L1, L2, L3, L4, L5>) => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V]>;
+    facet: (key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>, facet: string) => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, any]>;
     find: (finder: string, finderParams: Record<string, string | number | boolean | Date | Array<string | number | boolean | Date>>, locations?: LocKeyArray<L1, L2, L3, L4, L5> | []) => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V[]]>;
+    findOne: (finder: string, finderParams: Record<string, string | number | boolean | Date | Array<string | number | boolean | Date>>, locations?: LocKeyArray<L1, L2, L3, L4, L5> | []) => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V]>;
     set: (key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>, v: Item<S, L1, L2, L3, L4, L5>) => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V]>;
     reset: () => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>]>;
     pkTypes: AllItemTypeArrays<S, L1, L2, L3, L4, L5>;
     cacheMap: CacheMap<V, S, L1, L2, L3, L4, L5>;
 }
-export declare const createCache: <V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(api: ClientApi<V, S, L1, L2, L3, L4, L5>, pkType: S, parentCache?: Cache<Item<L1, L2, L3, L4, L5>, L1, L2, L3, L4, L5>) => Cache<V, S, L1, L2, L3, L4, L5>;
+export declare const createCache: <V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(api: ClientApi<V, S, L1, L2, L3, L4, L5>, pkType: S, parentCache?: Cache<Item<L1, L2, L3, L4, L5>, L1, L2, L3, L4, L5>) => Promise<Cache<V, S, L1, L2, L3, L4, L5>>;

package/dist/Cache.es.js

@@ -4,7 +4,7 @@ import LibLogger from './logger.es.js';
 import { NotFoundError } from '@fjell/http-api';
 
 const logger = LibLogger.get('Cache');
-const createCache = (api, pkType, parentCache)=>{
+const createCache = async (api, pkType, parentCache)=>{
     let pkTypes = [
         pkType
     ];
@@ -209,6 +209,18 @@ const createCache = (api, pkType, parentCache)=>{
             throw e;
         }
     };
+    // Facets are a pass-thru for caches
+    const facet = async (key, facet)=>{
+        logger.default('facet', {
+            key,
+            facet
+        });
+        const ret = await api.facet(key, facet, {});
+        return [
+            cacheMap,
+            ret
+        ];
+    };
     const find = async (finder, finderParams, locations = [])=>{
         logger.default('find', {
             finder,
@@ -224,6 +236,19 @@ const createCache = (api, pkType, parentCache)=>{
             validatePK(ret, pkType)
         ];
     };
+    const findOne = async (finder, finderParams, locations = [])=>{
+        logger.default('findOne', {
+            finder,
+            finderParams,
+            locations
+        });
+        const ret = await api.findOne(finder, finderParams, {}, locations);
+        cacheMap.set(ret.key, ret);
+        return [
+            cacheMap,
+            validatePK(ret, pkType)
+        ];
+    };
     const reset = async ()=>{
         cacheMap = new CacheMap(pkTypes);
         return [
@@ -263,7 +288,9 @@ const createCache = (api, pkType, parentCache)=>{
         retrieve,
         remove,
         update,
+        facet,
         find,
+        findOne,
         reset,
         set,
         pkTypes,
@@ -272,4 +299,4 @@ const createCache = (api, pkType, parentCache)=>{
 };
 
 export { createCache };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FjaGUuZXMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FjaGUuZXMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/CacheRegistry.cjs.js

@@ -19,36 +19,48 @@ function _define_property(obj, key, value) {
 }
 const logger = logger$1.default.get('CacheRegistry');
 class CacheRegistry {
-    static getInstance() {
-        if (!CacheRegistry.instance) {
-            CacheRegistry.instance = new CacheRegistry();
-        }
-        return CacheRegistry.instance;
-    }
     constructor(){
-        _define_property(this, "configured", false);
         // 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", (cache)=>{
-            this.cacheMap[JSON.stringify(cache.pkTypes)] = cache;
-        });
-        _define_property(this, "isConfigured", ()=>{
-            return this.configured;
-        });
-        _define_property(this, "markConfigured", ()=>{
-            this.configured = true;
+        _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)=>{
-            if (!this.configured) {
-                logger.error('CacheRegistry must be configured before use');
-                throw new Error("CacheRegistry must be configured before use");
+            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');
             }
-            return this.cacheMap[JSON.stringify(kts)];
+            Object.entries(this.cacheMap).forEach(([keyTypes])=>{
+                logger.debug(`Cache with key types: ${keyTypes}`);
+            });
         });
-        logger.debug('CacheRegistry created');
+        logger.debug('CacheRegistry instance created');
     }
 }
 _define_property(CacheRegistry, "instance", void 0);
 
 exports.CacheRegistry = CacheRegistry;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FjaGVSZWdpc3RyeS5janMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FjaGVSZWdpc3RyeS5janMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/CacheRegistry.d.ts

@@ -2,12 +2,9 @@ import { Item } from '@fjell/core';
 import { Cache } from './Cache';
 export declare class CacheRegistry {
     private static instance;
-    private configured;
     constructor();
-    static getInstance(): CacheRegistry;
     private cacheMap;
-    registerCache: <S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(cache: Cache<Item<S, L1, L2, L3, L4, L5>, S, L1, L2, L3, L4, L5>) => void;
-    isConfigured: () => boolean;
-    markConfigured: () => void;
+    registerCache: <S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(cache: Cache<Item<S, L1, L2, L3, L4, L5>, S, L1, L2, L3, L4, L5>) => Promise<void>;
     getCache: (kts: string[]) => any;
+    printRegisteredCaches: () => void;
 }

package/dist/CacheRegistry.es.js

@@ -15,36 +15,48 @@ function _define_property(obj, key, value) {
 }
 const logger = LibLogger.get('CacheRegistry');
 class CacheRegistry {
-    static getInstance() {
-        if (!CacheRegistry.instance) {
-            CacheRegistry.instance = new CacheRegistry();
-        }
-        return CacheRegistry.instance;
-    }
     constructor(){
-        _define_property(this, "configured", false);
         // 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", (cache)=>{
-            this.cacheMap[JSON.stringify(cache.pkTypes)] = cache;
-        });
-        _define_property(this, "isConfigured", ()=>{
-            return this.configured;
-        });
-        _define_property(this, "markConfigured", ()=>{
-            this.configured = true;
+        _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)=>{
-            if (!this.configured) {
-                logger.error('CacheRegistry must be configured before use');
-                throw new Error("CacheRegistry must be configured before use");
+            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');
             }
-            return this.cacheMap[JSON.stringify(kts)];
+            Object.entries(this.cacheMap).forEach(([keyTypes])=>{
+                logger.debug(`Cache with key types: ${keyTypes}`);
+            });
         });
-        logger.debug('CacheRegistry created');
+        logger.debug('CacheRegistry instance created');
     }
 }
 _define_property(CacheRegistry, "instance", void 0);
 
 export { CacheRegistry };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FjaGVSZWdpc3RyeS5lcy5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FjaGVSZWdpc3RyeS5lcy5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/index.cjs

@@ -6,7 +6,7 @@ const Logging = require('@fjell/logging');
 const core = require('@fjell/core');
 const httpApi = require('@fjell/http-api');
 
-const LibLogger = Logging.getLogger('@fjellproject/cache');
+const LibLogger = Logging.getLogger('@fjell/cache');
 
 const logger$3 = LibLogger.get('ItemAggregator');
 const toCacheConfig = (config)=>{
@@ -21,7 +21,7 @@ const toCacheConfig = (config)=>{
     }
     return cacheConfig;
 };
-const createAggregator = (cache, { aggregates = {}, events = {} })=>{
+const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
     const populate = async (item)=>{
         logger$3.default('populate', {
             item
@@ -224,6 +224,18 @@ const createAggregator = (cache, { aggregates = {}, events = {} })=>{
             populatedItem
         ];
     };
+    // Facets are a pass-thru for aggregators
+    const facet = async (key, facet)=>{
+        logger$3.default('facet', {
+            key,
+            facet
+        });
+        const [cacheMap, response] = await cache.facet(key, facet);
+        return [
+            cacheMap,
+            response
+        ];
+    };
     const find = async (finder, finderParams, locations = [])=>{
         logger$3.default('find', {
             finder,
@@ -237,6 +249,19 @@ const createAggregator = (cache, { aggregates = {}, events = {} })=>{
             populatedItems
         ];
     };
+    const findOne = async (finder, finderParams, locations = [])=>{
+        logger$3.default('find', {
+            finder,
+            finderParams,
+            locations
+        });
+        const [cacheMap, item] = await cache.findOne(finder, finderParams, locations);
+        const populatedItem = await populate(item);
+        return [
+            cacheMap,
+            populatedItem
+        ];
+    };
     const set = async (key, v)=>{
         logger$3.default('set', {
             key,
@@ -264,7 +289,9 @@ const createAggregator = (cache, { aggregates = {}, events = {} })=>{
         retrieve,
         remove,
         update,
+        facet,
         find,
+        findOne,
         reset,
         set,
         pkTypes: cache.pkTypes,
@@ -375,7 +402,7 @@ class CacheMap extends core.Dictionary {
 }
 
 const logger$1 = LibLogger.get('Cache');
-const createCache = (api, pkType, parentCache)=>{
+const createCache = async (api, pkType, parentCache)=>{
     let pkTypes = [
         pkType
     ];
@@ -580,6 +607,18 @@ const createCache = (api, pkType, parentCache)=>{
             throw e;
         }
     };
+    // Facets are a pass-thru for caches
+    const facet = async (key, facet)=>{
+        logger$1.default('facet', {
+            key,
+            facet
+        });
+        const ret = await api.facet(key, facet, {});
+        return [
+            cacheMap,
+            ret
+        ];
+    };
     const find = async (finder, finderParams, locations = [])=>{
         logger$1.default('find', {
             finder,
@@ -595,6 +634,19 @@ const createCache = (api, pkType, parentCache)=>{
             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 [
@@ -634,7 +686,9 @@ const createCache = (api, pkType, parentCache)=>{
         retrieve,
         remove,
         update,
+        facet,
         find,
+        findOne,
         reset,
         set,
         pkTypes,
@@ -657,33 +711,45 @@ function _define_property(obj, key, value) {
 }
 const logger = LibLogger.get('CacheRegistry');
 class CacheRegistry {
-    static getInstance() {
-        if (!CacheRegistry.instance) {
-            CacheRegistry.instance = new CacheRegistry();
-        }
-        return CacheRegistry.instance;
-    }
     constructor(){
-        _define_property(this, "configured", false);
         // 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", (cache)=>{
-            this.cacheMap[JSON.stringify(cache.pkTypes)] = cache;
-        });
-        _define_property(this, "isConfigured", ()=>{
-            return this.configured;
-        });
-        _define_property(this, "markConfigured", ()=>{
-            this.configured = true;
+        _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)=>{
-            if (!this.configured) {
-                logger.error('CacheRegistry must be configured before use');
-                throw new Error("CacheRegistry must be configured before use");
+            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 this.cacheMap[JSON.stringify(kts)];
+            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 created');
+        logger.debug('CacheRegistry instance created');
     }
 }
 _define_property(CacheRegistry, "instance", void 0);

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/logger.cjs.js

@@ -4,7 +4,7 @@ Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toString
 
 const Logging = require('@fjell/logging');
 
-const LibLogger = Logging.getLogger('@fjellproject/cache');
+const LibLogger = Logging.getLogger('@fjell/cache');
 
 exports.default = LibLogger;
 //# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nZ2VyLmNqcy5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7In0=

package/dist/logger.es.js

@@ -1,6 +1,6 @@
 import Logging from '@fjell/logging';
 
-const LibLogger = Logging.getLogger('@fjellproject/cache');
+const LibLogger = Logging.getLogger('@fjell/cache');
 
 export { LibLogger as default };
 //# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nZ2VyLmVzLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7OyJ9

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fjell/cache",
   "description": "Cache for Fjell",
-  "version": "4.6.0",
+  "version": "4.6.2",
   "license": "Apache-2.0",
   "type": "module",
   "main": "./dist/index.cjs.js",
@@ -15,13 +15,13 @@
     }
   },
   "dependencies": {
-    "@fjell/client-api": "^4.4.0",
+    "@fjell/client-api": "^4.4.2",
     "@fjell/core": "^4.4.2",
     "@fjell/http-api": "^4.4.0",
     "@fjell/logging": "^4.4.2",
     "d3": "^7.9.0",
     "dayjs": "^1.11.13",
-    "react": "18.3.1"
+    "react": "19.1.0"
   },
   "devDependencies": {
     "@babel/preset-env": "^7.26.9",
@@ -33,7 +33,7 @@
     "@types/babel__preset-env": "^7.10.0",
     "@types/d3": "^7.4.3",
     "@types/multer": "^1.4.12",
-    "@types/node": "^22.13.5",
+    "@types/node": "^24.0.3",
     "@typescript-eslint/eslint-plugin": "^8.24.1",
     "@typescript-eslint/parser": "^8.24.1",
     "@vitest/coverage-v8": "^3.1.4",
@@ -55,7 +55,8 @@
     "url": "git+https://github.com/getfjell/cache.git"
   },
   "scripts": {
-    "build": "tsc --noEmit && vite build",
+    "dev": "concurrently \"tsc --noEmit --watch\" \"vite build --watch\"",
+    "build": "pnpm run lint && tsc --noEmit && vite build",
     "lint": "eslint . --ext .ts --fix",
     "clean": "rimraf dist",
     "test": "pnpm run lint && vitest run --coverage"

package/src/Aggregator.ts

@@ -49,7 +49,7 @@ export const toCacheConfig = <
   return cacheConfig;
 }
 
-export const createAggregator = <
+export const createAggregator = async <
   V extends Item<S, L1, L2, L3, L4, L5>,
   S extends string,
   L1 extends string = never,
@@ -58,13 +58,13 @@ export const createAggregator = <
   L4 extends string = never,
   L5 extends string = never
 >(
-    cache: Cache<V, S, L1, L2, L3, L4, L5>,
-    { aggregates = {}, events = {} }:
+  cache: Cache<V, S, L1, L2, L3, L4, L5>,
+  { aggregates = {}, events = {} }:
       {
         aggregates?: AggregateConfig,
         events?: AggregateConfig
       }
-  ): Aggregator<V, S, L1, L2, L3, L4, L5> => {
+): Promise<Aggregator<V, S, L1, L2, L3, L4, L5>> => {
 
   const populate = async (item: V): Promise<V> => {
     logger.default('populate', { item });
@@ -247,6 +247,16 @@ export const createAggregator = <
     return [cacheMap, populatedItem];
   }
 
+  // Facets are a pass-thru for aggregators
+  const facet = async (
+    key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>,
+    facet: string,
+  ): Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, any]> => {
+    logger.default('facet', { key, facet });
+    const [cacheMap, response] = await cache.facet(key, facet);
+    return [cacheMap, response];
+  }
+
   const find = async (
     finder: string,
     finderParams: Record<string, string | number | boolean | Date | Array<string | number | boolean | Date>>,
@@ -258,6 +268,17 @@ export const createAggregator = <
     return [cacheMap, populatedItems];
   }
 
+  const findOne = async (
+    finder: string,
+    finderParams: Record<string, string | number | boolean | Date | Array<string | number | boolean | Date>>,
+    locations: LocKeyArray<L1, L2, L3, L4, L5> | [] = []
+  ): Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V]> => {
+    logger.default('find', { finder, finderParams, locations });
+    const [cacheMap, item] = await cache.findOne(finder, finderParams, locations);
+    const populatedItem = await populate(item);
+    return [cacheMap, populatedItem];
+  }
+
   const set = async (
     key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>,
     v: Item<S, L1, L2, L3, L4, L5>
@@ -285,7 +306,9 @@ export const createAggregator = <
     retrieve,
     remove,
     update,
+    facet,
     find,
+    findOne,
     reset,
     set,
     pkTypes: cache.pkTypes,

package/src/Cache.ts

@@ -73,12 +73,23 @@ export interface Cache<
     v: TypesProperties<V, S, L1, L2, L3, L4, L5>,
   ) => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V]>;
 
+  facet: (
+    key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>,
+    facet: string,
+  ) => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, any]>;
+
   find: (
     finder: string,
     finderParams: Record<string, string | number | boolean | Date | Array<string | number | boolean | Date>>,
     locations?: LocKeyArray<L1, L2, L3, L4, L5> | []
   ) => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V[]]>;
 
+  findOne: (
+    finder: string,
+    finderParams: Record<string, string | number | boolean | Date | Array<string | number | boolean | Date>>,
+    locations?: LocKeyArray<L1, L2, L3, L4, L5> | []
+  ) => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V]>;
+
   set: (
     key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>,
     v: Item<S, L1, L2, L3, L4, L5>
@@ -91,7 +102,7 @@ export interface Cache<
   cacheMap: CacheMap<V, S, L1, L2, L3, L4, L5>;
 }
 
-export const createCache = <
+export const createCache = async <
   V extends Item<S, L1, L2, L3, L4, L5>,
   S extends string,
   L1 extends string = never,
@@ -100,13 +111,13 @@ export const createCache = <
   L4 extends string = never,
   L5 extends string = never
 >(
-    api: ClientApi<V, S, L1, L2, L3, L4, L5>,
-    pkType: S,
-    parentCache?: Cache<Item<L1, L2, L3, L4, L5>, L1, L2, L3, L4, L5>
-  ): Cache<V, S, L1, L2, L3, L4, L5> => {
+  api: ClientApi<V, S, L1, L2, L3, L4, L5>,
+  pkType: S,
+  parentCache?: Cache<Item<L1, L2, L3, L4, L5>, L1, L2, L3, L4, L5>
+): Promise<Cache<V, S, L1, L2, L3, L4, L5>> => {
 
-  let pkTypes: AllItemTypeArrays<S, L1, L2, L3, L4, L5> = [ pkType ];
-  if( parentCache ) {
+  let pkTypes: AllItemTypeArrays<S, L1, L2, L3, L4, L5> = [pkType];
+  if (parentCache) {
     pkTypes = pkTypes.concat(parentCache.pkTypes as any) as unknown as AllItemTypeArrays<S, L1, L2, L3, L4, L5>;
   }
 
@@ -264,7 +275,7 @@ export const createCache = <
     const retValue: [CacheMap<V, S, L1, L2, L3, L4, L5> | null, V | null] = [
       containsItemKey ? null : cacheMap,
       retrieved ?
-        validatePK(retrieved, pkType) as V:
+        validatePK(retrieved, pkType) as V :
         null
     ];
     // logger.debug('Returning from retrieve', { retValue });
@@ -314,6 +325,16 @@ export const createCache = <
     }
   }
 
+  // Facets are a pass-thru for caches
+  const facet = async (
+    key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>,
+    facet: string,
+  ): Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, any]> => {
+    logger.default('facet', { key, facet });
+    const ret = await api.facet(key, facet, {});
+    return [cacheMap, ret];
+  }
+
   const find = async (
     finder: string,
     finderParams: Record<string, string | number | boolean | Date | Array<string | number | boolean | Date>>,
@@ -327,6 +348,17 @@ export const createCache = <
     return [cacheMap, validatePK(ret, pkType) as V[]];
   }
 
+  const findOne = async (
+    finder: string,
+    finderParams: Record<string, string | number | boolean | Date | Array<string | number | boolean | Date>>,
+    locations: LocKeyArray<L1, L2, L3, L4, L5> | [] = []
+  ): Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V]> => {
+    logger.default('findOne', { finder, finderParams, locations });
+    const ret = await api.findOne(finder, finderParams, {}, locations);
+    cacheMap.set(ret.key, ret);
+    return [cacheMap, validatePK(ret, pkType) as V];
+  }
+
   const reset = async (): Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>]> => {
     cacheMap = new CacheMap<V, S, L1, L2, L3, L4, L5>(pkTypes);
     return [cacheMap];
@@ -337,7 +369,7 @@ export const createCache = <
     v: Item<S, L1, L2, L3, L4, L5>
   ): Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V]> => {
     logger.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 (!isValidItemKey(key)) {
@@ -367,7 +399,9 @@ export const createCache = <
     retrieve,
     remove,
     update,
+    facet,
     find,
+    findOne,
     reset,
     set,
     pkTypes,

package/src/CacheRegistry.ts

@@ -7,48 +7,60 @@ const logger = LibLogger.get('CacheRegistry');
 export class CacheRegistry {
 
   private static instance: CacheRegistry;
-  private configured: boolean = false;
 
   public constructor() {
-    logger.debug('CacheRegistry created');
-  }
-
-  public static getInstance(
-  ): CacheRegistry {
-    if (!CacheRegistry.instance) {
-      CacheRegistry.instance = new CacheRegistry();
-    }
-    return CacheRegistry.instance;
+    logger.debug('CacheRegistry instance created');
   }
 
   // TODO: My use of Generics has Boxed me into a corner where I can't reference AbstractCache without the types
   private cacheMap: { [kt: string]: any } = {};
 
-  public registerCache = <
+  public registerCache = async <
     S extends string,
     L1 extends string = never,
     L2 extends string = never,
     L3 extends string = never,
     L4 extends string = never,
     L5 extends string = never
-  >(cache: Cache<Item<S, L1, L2, L3, L4, L5>, S, L1, L2, L3, L4, L5>): void => {
-    this.cacheMap[JSON.stringify(cache.pkTypes)] = cache;
+  >(cache: Cache<Item<S, L1, L2, L3, L4, L5>, S, L1, L2, L3, L4, L5>): Promise<void> => {
+    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;
+    }
   };
 
-  public isConfigured = (): boolean => {
-    return this.configured;
-  }
-
-  public markConfigured = (): void => {
-    this.configured = true;
-  }
-
   public getCache = (kts: string[]): any => {
-    if (!this.configured) {
-      logger.error('CacheRegistry must be configured before use');
-      throw new Error("CacheRegistry must be configured before use");
+    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 this.cacheMap[JSON.stringify(kts)];
+    return cache;
   };
 
+  public printRegisteredCaches = (): void => {
+    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}`);
+    });
+  };
 }

package/src/logger.ts

@@ -1,5 +1,5 @@
 import Logging from '@fjell/logging';
 
-const LibLogger = Logging.getLogger('@fjellproject/cache');
+const LibLogger = Logging.getLogger('@fjell/cache');
 
 export default LibLogger;

package/vitest.config.ts

@@ -0,0 +1,44 @@
+import { defineConfig } from 'vitest/config'
+import * as path from 'path'
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['tests/**/*.test.ts'],
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+      exclude: [
+        'node_modules/',
+        'tests/',
+        'src/index.ts',
+        'eslint.config.mjs',
+        'vite.config.ts',
+        'vitest.config.ts',
+        'dist',
+      ],
+      thresholds: {
+        lines: 89,
+        functions: 85,
+        branches: 94,
+        statements: 89,
+      },
+    },
+    setupFiles: ['./tests/setup.ts'],
+    deps: {
+      inline: [/@fjell/],
+    },
+    testTimeout: 10000,
+    hookTimeout: 10000,
+    teardownTimeout: 10000,
+  },
+  resolve: {
+    alias: {
+      '@': path.resolve(__dirname, './src'),
+    },
+  },
+  build: {
+    sourcemap: true,
+  },
+})

package/eslint.config.mjs

@@ -1,70 +0,0 @@
-import typescriptEslint from "@typescript-eslint/eslint-plugin";
-import tsParser from "@typescript-eslint/parser";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import js from "@eslint/js";
-import { FlatCompat } from "@eslint/eslintrc";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const compat = new FlatCompat({
-  baseDirectory: __dirname,
-  recommendedConfig: js.configs.recommended,
-  allConfig: js.configs.all
-});
-
-export default [{
-  ignores: ["**/dist", "**/node_modules"],
-}, ...compat.extends("plugin:@typescript-eslint/recommended"), {
-  plugins: {
-    "@typescript-eslint": typescriptEslint,
-  },
-
-  languageOptions: {
-    parser: tsParser,
-  },
-
-  rules: {
-    "@typescript-eslint/no-unused-expressions": "off",
-    "no-console": 0,
-    "no-unused-vars": "off",
-
-    "max-len": ["error", {
-      code: 120,
-    }],
-
-    "max-depth": ["error", 4],
-    "max-params": ["error", 4],
-    "max-lines": ["error", 500],
-
-    "no-multiple-empty-lines": ["error", {
-      max: 1,
-      maxEOF: 1,
-    }],
-
-    "no-trailing-spaces": ["error", {
-      skipBlankLines: true,
-    }],
-
-    indent: ["error", 2, {
-      SwitchCase: 1,
-    }],
-
-    "sort-imports": ["error", {
-      ignoreCase: true,
-      ignoreDeclarationSort: true,
-      ignoreMemberSort: false,
-      memberSyntaxSortOrder: ["none", "all", "multiple", "single"],
-    }],
-
-    "no-var": "error",
-    "no-undefined": "error",
-    "@typescript-eslint/no-unused-vars": "error",
-    "@typescript-eslint/ban-ts-comment": "off",
-    "@typescript-eslint/no-explicit-any": "off",
-
-    "no-restricted-imports": ["error", {
-      patterns: ["..*", "src/*"],
-    }],
-  },
-}];

package/vite.config.ts

@@ -1,91 +0,0 @@
-// import { defineConfig } from 'vite';
-import { defineConfig as defineVitestConfig } from 'vitest/config';
-import { VitePluginNode } from 'vite-plugin-node';
-import dts from 'vite-plugin-dts';
-import path from 'path';
-
-export default defineVitestConfig({
-  server: {
-    port: 3000
-  },
-  plugins: [
-    ...VitePluginNode({
-      adapter: 'express',
-      appPath: './src/index.ts',
-      exportName: 'viteNodeApp',
-      tsCompiler: 'swc',
-    }),
-    // visualizer({
-    //     template: 'network',
-    //     filename: 'network.html',
-    //     projectRoot: process.cwd(),
-    // }),
-    dts({
-      entryRoot: 'src',
-      outDir: 'dist',
-      exclude: ['./tests/**/*.ts'],
-      include: ['./src/**/*.ts'],
-    }),
-  ],
-  resolve: {
-    alias: {
-      '@': path.resolve(__dirname, './src'),
-    },
-  },
-  build: {
-    target: 'esnext',
-    outDir: 'dist',
-    lib: {
-      entry: './src/index.ts',
-      formats: ['es', 'cjs'],
-    },
-    rollupOptions: {
-      input: 'src/index.ts',
-      output: [
-        {
-          format: 'esm',
-          entryFileNames: '[name].es.js',
-          preserveModules: true,
-          exports: 'named',
-          sourcemap: 'inline',
-        },
-        {
-          format: 'cjs',
-          entryFileNames: '[name].cjs.js',
-          preserveModules: true,
-          exports: 'named',
-          sourcemap: 'inline',
-        },
-      ],
-    },
-    // Make sure Vite generates ESM-compatible code
-    modulePreload: false,
-    minify: false,
-    sourcemap: true
-  },
-  test: {
-    include: [
-      'tests/**/*.test.ts',
-      'tests/**/*.spec.ts',
-    ],
-    coverage: {
-      provider: 'v8',
-      reporter: ['text', 'html', 'lcov'],
-      reportsDirectory: './coverage',
-      exclude: [
-        'node_modules/',
-        'tests/',
-        'src/index.ts',
-      ],
-      thresholds: {
-        global: {
-          branches: 75,
-          functions: 89,
-          lines: 89,
-          statements: 89,
-        },
-      },
-    },
-    environment: 'node',
-  },
-});