@fjell/cache 4.6.1 → 4.6.3

package/dist/Aggregator.cjs.js

@@ -161,6 +161,18 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
             populatedItems
         ];
     };
+    const allFacet = async (facet, params = {}, locations = [])=>{
+        logger.default('allFacet', {
+            facet,
+            params,
+            locations
+        });
+        const [cacheMap, response] = await cache.allFacet(facet, params, locations);
+        return [
+            cacheMap,
+            response
+        ];
+    };
     const create = async (v, locations = [])=>{
         logger.default('create', {
             v,
@@ -220,7 +232,19 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
             populatedItem
         ];
     };
-    const find = async (finder, finderParams, locations = [])=>{
+    // 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,
             finderParams,
@@ -233,6 +257,19 @@ const createAggregator = async (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,
@@ -255,12 +292,15 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
         one,
         action,
         allAction,
+        allFacet,
         create,
         get,
         retrieve,
         remove,
         update,
+        facet,
         find,
+        findOne,
         reset,
         set,
         pkTypes: cache.pkTypes,
@@ -273,4 +313,4 @@ const createAggregator = async (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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQWdncmVnYXRvci5janMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/Aggregator.es.js

@@ -157,6 +157,18 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
             populatedItems
         ];
     };
+    const allFacet = async (facet, params = {}, locations = [])=>{
+        logger.default('allFacet', {
+            facet,
+            params,
+            locations
+        });
+        const [cacheMap, response] = await cache.allFacet(facet, params, locations);
+        return [
+            cacheMap,
+            response
+        ];
+    };
     const create = async (v, locations = [])=>{
         logger.default('create', {
             v,
@@ -216,7 +228,19 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
             populatedItem
         ];
     };
-    const find = async (finder, finderParams, locations = [])=>{
+    // 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,
             finderParams,
@@ -229,6 +253,19 @@ const createAggregator = async (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,
@@ -251,12 +288,15 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
         one,
         action,
         allAction,
+        allFacet,
         create,
         get,
         retrieve,
         remove,
         update,
+        facet,
         find,
+        findOne,
         reset,
         set,
         pkTypes: cache.pkTypes,
@@ -268,4 +308,4 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
 };
 
 export { createAggregator, toCacheConfig };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQWdncmVnYXRvci5lcy5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQWdncmVnYXRvci5lcy5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/Cache.cjs.js

@@ -23,7 +23,7 @@ const createCache = async (api, pkType, parentCache)=>{
         });
         let ret = [];
         try {
-            ret = await api.all(query, {}, locations);
+            ret = await api.all(query, locations);
             ret.forEach((v)=>{
                 cacheMap.set(v.key, v);
             });
@@ -44,7 +44,7 @@ const createCache = async (api, pkType, parentCache)=>{
         });
         let retItem = null;
         try {
-            retItem = await api.one(query, {}, locations);
+            retItem = await api.one(query, locations);
             if (retItem) {
                 cacheMap.set(retItem.key, retItem);
             }
@@ -70,7 +70,7 @@ const createCache = async (api, pkType, parentCache)=>{
             logger.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, {});
+        const updated = await api.action(key, action, body);
         cacheMap.set(updated.key, updated);
         return [
             cacheMap,
@@ -85,7 +85,7 @@ const createCache = async (api, pkType, parentCache)=>{
         });
         let ret = [];
         try {
-            ret = await api.allAction(action, body, {}, locations);
+            ret = await api.allAction(action, body, locations);
             ret.forEach((v)=>{
                 cacheMap.set(v.key, v);
             });
@@ -100,12 +100,24 @@ const createCache = async (api, pkType, parentCache)=>{
             core.validatePK(ret, pkType)
         ];
     };
+    const allFacet = async (facet, params = {}, locations = [])=>{
+        logger.default('allFacet', {
+            facet,
+            params,
+            locations
+        });
+        const ret = await api.allFacet(facet, params, locations);
+        return [
+            cacheMap,
+            ret
+        ];
+    };
     const create = async (v, locations = [])=>{
         logger.default('create', {
             v,
             locations
         });
-        const created = await api.create(v, {}, locations);
+        const created = await api.create(v, locations);
         cacheMap.set(created.key, created);
         return [
             cacheMap,
@@ -124,7 +136,7 @@ const createCache = async (api, pkType, parentCache)=>{
         }
         let ret;
         try {
-            ret = await api.get(key, {});
+            ret = await api.get(key);
             if (ret) {
                 cacheMap.set(ret.key, ret);
             }
@@ -178,7 +190,7 @@ const createCache = async (api, pkType, parentCache)=>{
             throw new Error('Key for Remove is not a valid ItemKey');
         }
         try {
-            await api.remove(key, {});
+            await api.remove(key);
             cacheMap.delete(key);
         } catch (e) {
             logger.error("Error deleting item", {
@@ -200,7 +212,7 @@ const createCache = async (api, pkType, parentCache)=>{
             throw new Error('Key for Update is not a valid ItemKey');
         }
         try {
-            const updated = await api.update(key, v, {});
+            const updated = await api.update(key, v);
             cacheMap.set(updated.key, updated);
             return [
                 cacheMap,
@@ -213,13 +225,25 @@ const createCache = async (api, pkType, parentCache)=>{
             throw e;
         }
     };
-    const find = async (finder, finderParams, locations = [])=>{
+    // Facets are a pass-thru for caches
+    const facet = async (key, facet, params = {})=>{
+        logger.default('facet', {
+            key,
+            facet
+        });
+        const ret = await api.facet(key, facet, params);
+        return [
+            cacheMap,
+            ret
+        ];
+    };
+    const find = async (finder, params = {}, locations = [])=>{
         logger.default('find', {
             finder,
-            finderParams,
+            params,
             locations
         });
-        const ret = await api.find(finder, finderParams, {}, locations);
+        const ret = await api.find(finder, params, locations);
         ret.forEach((v)=>{
             cacheMap.set(v.key, v);
         });
@@ -228,6 +252,19 @@ const createCache = async (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 [
@@ -262,12 +299,15 @@ const createCache = async (api, pkType, parentCache)=>{
         one,
         action,
         allAction,
+        allFacet,
         create,
         get,
         retrieve,
         remove,
         update,
+        facet,
         find,
+        findOne,
         reset,
         set,
         pkTypes,
@@ -276,4 +316,4 @@ const createCache = async (api, pkType, parentCache)=>{
 };
 
 exports.createCache = createCache;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FjaGUuY2pzLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FjaGUuY2pzLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/Cache.d.ts

@@ -6,13 +6,16 @@ export interface Cache<V extends Item<S, L1, L2, L3, L4, L5>, S extends string,
     one: (query?: ItemQuery, locations?: LocKeyArray<L1, L2, L3, L4, L5> | []) => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V | null]>;
     action: (key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>, action: string, body?: any) => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V]>;
     allAction: (action: string, body?: any, locations?: LocKeyArray<L1, L2, L3, L4, L5> | []) => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V[]]>;
-    create: (v: TypesProperties<V, S, L1, L2, L3, L4, L5>, locations?: LocKeyArray<L1, L2, L3, L4, L5> | []) => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V]>;
+    allFacet: (facet: string, params?: 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>, any]>;
+    create: (item: TypesProperties<V, S, L1, L2, L3, L4, L5>, locations?: LocKeyArray<L1, L2, L3, L4, L5> | []) => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V]>;
     get: (key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>) => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V | null]>;
     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]>;
-    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[]]>;
-    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]>;
+    update: (key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>, item: 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, params?: Record<string, string | number | boolean | Date | Array<string | number | boolean | Date>>) => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, any]>;
+    find: (finder: string, params?: 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, params?: 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>, item: 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>;

package/dist/Cache.es.js

@@ -19,7 +19,7 @@ const createCache = async (api, pkType, parentCache)=>{
         });
         let ret = [];
         try {
-            ret = await api.all(query, {}, locations);
+            ret = await api.all(query, locations);
             ret.forEach((v)=>{
                 cacheMap.set(v.key, v);
             });
@@ -40,7 +40,7 @@ const createCache = async (api, pkType, parentCache)=>{
         });
         let retItem = null;
         try {
-            retItem = await api.one(query, {}, locations);
+            retItem = await api.one(query, locations);
             if (retItem) {
                 cacheMap.set(retItem.key, retItem);
             }
@@ -66,7 +66,7 @@ const createCache = async (api, pkType, parentCache)=>{
             logger.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, {});
+        const updated = await api.action(key, action, body);
         cacheMap.set(updated.key, updated);
         return [
             cacheMap,
@@ -81,7 +81,7 @@ const createCache = async (api, pkType, parentCache)=>{
         });
         let ret = [];
         try {
-            ret = await api.allAction(action, body, {}, locations);
+            ret = await api.allAction(action, body, locations);
             ret.forEach((v)=>{
                 cacheMap.set(v.key, v);
             });
@@ -96,12 +96,24 @@ const createCache = async (api, pkType, parentCache)=>{
             validatePK(ret, pkType)
         ];
     };
+    const allFacet = async (facet, params = {}, locations = [])=>{
+        logger.default('allFacet', {
+            facet,
+            params,
+            locations
+        });
+        const ret = await api.allFacet(facet, params, locations);
+        return [
+            cacheMap,
+            ret
+        ];
+    };
     const create = async (v, locations = [])=>{
         logger.default('create', {
             v,
             locations
         });
-        const created = await api.create(v, {}, locations);
+        const created = await api.create(v, locations);
         cacheMap.set(created.key, created);
         return [
             cacheMap,
@@ -120,7 +132,7 @@ const createCache = async (api, pkType, parentCache)=>{
         }
         let ret;
         try {
-            ret = await api.get(key, {});
+            ret = await api.get(key);
             if (ret) {
                 cacheMap.set(ret.key, ret);
             }
@@ -174,7 +186,7 @@ const createCache = async (api, pkType, parentCache)=>{
             throw new Error('Key for Remove is not a valid ItemKey');
         }
         try {
-            await api.remove(key, {});
+            await api.remove(key);
             cacheMap.delete(key);
         } catch (e) {
             logger.error("Error deleting item", {
@@ -196,7 +208,7 @@ const createCache = async (api, pkType, parentCache)=>{
             throw new Error('Key for Update is not a valid ItemKey');
         }
         try {
-            const updated = await api.update(key, v, {});
+            const updated = await api.update(key, v);
             cacheMap.set(updated.key, updated);
             return [
                 cacheMap,
@@ -209,13 +221,25 @@ const createCache = async (api, pkType, parentCache)=>{
             throw e;
         }
     };
-    const find = async (finder, finderParams, locations = [])=>{
+    // Facets are a pass-thru for caches
+    const facet = async (key, facet, params = {})=>{
+        logger.default('facet', {
+            key,
+            facet
+        });
+        const ret = await api.facet(key, facet, params);
+        return [
+            cacheMap,
+            ret
+        ];
+    };
+    const find = async (finder, params = {}, locations = [])=>{
         logger.default('find', {
             finder,
-            finderParams,
+            params,
             locations
         });
-        const ret = await api.find(finder, finderParams, {}, locations);
+        const ret = await api.find(finder, params, locations);
         ret.forEach((v)=>{
             cacheMap.set(v.key, v);
         });
@@ -224,6 +248,19 @@ const createCache = async (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 [
@@ -258,12 +295,15 @@ const createCache = async (api, pkType, parentCache)=>{
         one,
         action,
         allAction,
+        allFacet,
         create,
         get,
         retrieve,
         remove,
         update,
+        facet,
         find,
+        findOne,
         reset,
         set,
         pkTypes,
@@ -272,4 +312,4 @@ const createCache = async (api, pkType, parentCache)=>{
 };
 
 export { createCache };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FjaGUuZXMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FjaGUuZXMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/index.cjs

@@ -165,6 +165,18 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
             populatedItems
         ];
     };
+    const allFacet = async (facet, params = {}, locations = [])=>{
+        logger$3.default('allFacet', {
+            facet,
+            params,
+            locations
+        });
+        const [cacheMap, response] = await cache.allFacet(facet, params, locations);
+        return [
+            cacheMap,
+            response
+        ];
+    };
     const create = async (v, locations = [])=>{
         logger$3.default('create', {
             v,
@@ -224,7 +236,19 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
             populatedItem
         ];
     };
-    const find = async (finder, finderParams, locations = [])=>{
+    // 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,
             finderParams,
@@ -237,6 +261,19 @@ const createAggregator = async (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,
@@ -259,12 +296,15 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
         one,
         action,
         allAction,
+        allFacet,
         create,
         get,
         retrieve,
         remove,
         update,
+        facet,
         find,
+        findOne,
         reset,
         set,
         pkTypes: cache.pkTypes,
@@ -390,7 +430,7 @@ const createCache = async (api, pkType, parentCache)=>{
         });
         let ret = [];
         try {
-            ret = await api.all(query, {}, locations);
+            ret = await api.all(query, locations);
             ret.forEach((v)=>{
                 cacheMap.set(v.key, v);
             });
@@ -411,7 +451,7 @@ const createCache = async (api, pkType, parentCache)=>{
         });
         let retItem = null;
         try {
-            retItem = await api.one(query, {}, locations);
+            retItem = await api.one(query, locations);
             if (retItem) {
                 cacheMap.set(retItem.key, retItem);
             }
@@ -437,7 +477,7 @@ const createCache = async (api, pkType, parentCache)=>{
             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, {});
+        const updated = await api.action(key, action, body);
         cacheMap.set(updated.key, updated);
         return [
             cacheMap,
@@ -452,7 +492,7 @@ const createCache = async (api, pkType, parentCache)=>{
         });
         let ret = [];
         try {
-            ret = await api.allAction(action, body, {}, locations);
+            ret = await api.allAction(action, body, locations);
             ret.forEach((v)=>{
                 cacheMap.set(v.key, v);
             });
@@ -467,12 +507,24 @@ const createCache = async (api, pkType, parentCache)=>{
             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
+        ];
+    };
     const create = async (v, locations = [])=>{
         logger$1.default('create', {
             v,
             locations
         });
-        const created = await api.create(v, {}, locations);
+        const created = await api.create(v, locations);
         cacheMap.set(created.key, created);
         return [
             cacheMap,
@@ -491,7 +543,7 @@ const createCache = async (api, pkType, parentCache)=>{
         }
         let ret;
         try {
-            ret = await api.get(key, {});
+            ret = await api.get(key);
             if (ret) {
                 cacheMap.set(ret.key, ret);
             }
@@ -545,7 +597,7 @@ const createCache = async (api, pkType, parentCache)=>{
             throw new Error('Key for Remove is not a valid ItemKey');
         }
         try {
-            await api.remove(key, {});
+            await api.remove(key);
             cacheMap.delete(key);
         } catch (e) {
             logger$1.error("Error deleting item", {
@@ -567,7 +619,7 @@ const createCache = async (api, pkType, parentCache)=>{
             throw new Error('Key for Update is not a valid ItemKey');
         }
         try {
-            const updated = await api.update(key, v, {});
+            const updated = await api.update(key, v);
             cacheMap.set(updated.key, updated);
             return [
                 cacheMap,
@@ -580,13 +632,25 @@ const createCache = async (api, pkType, parentCache)=>{
             throw e;
         }
     };
-    const find = async (finder, finderParams, locations = [])=>{
+    // Facets are a pass-thru for caches
+    const facet = async (key, facet, params = {})=>{
+        logger$1.default('facet', {
+            key,
+            facet
+        });
+        const ret = await api.facet(key, facet, params);
+        return [
+            cacheMap,
+            ret
+        ];
+    };
+    const find = async (finder, params = {}, locations = [])=>{
         logger$1.default('find', {
             finder,
-            finderParams,
+            params,
             locations
         });
-        const ret = await api.find(finder, finderParams, {}, locations);
+        const ret = await api.find(finder, params, locations);
         ret.forEach((v)=>{
             cacheMap.set(v.key, v);
         });
@@ -595,6 +659,19 @@ const createCache = async (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 [
@@ -629,12 +706,15 @@ const createCache = async (api, pkType, parentCache)=>{
         one,
         action,
         allAction,
+        allFacet,
         create,
         get,
         retrieve,
         remove,
         update,
+        facet,
         find,
+        findOne,
         reset,
         set,
         pkTypes,

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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fjell/cache",
   "description": "Cache for Fjell",
-  "version": "4.6.1",
+  "version": "4.6.3",
   "license": "Apache-2.0",
   "type": "module",
   "main": "./dist/index.cjs.js",
@@ -15,13 +15,13 @@
     }
   },
   "dependencies": {
-    "@fjell/client-api": "^4.4.0",
-    "@fjell/core": "^4.4.2",
-    "@fjell/http-api": "^4.4.0",
-    "@fjell/logging": "^4.4.2",
+    "@fjell/client-api": "^4.4.3",
+    "@fjell/core": "^4.4.3",
+    "@fjell/http-api": "^4.4.1",
+    "@fjell/logging": "^4.4.3",
     "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",

package/src/Aggregator.ts

@@ -195,6 +195,16 @@ export const createAggregator = async <
     return [cacheMap, populatedItems];
   }
 
+  const allFacet = async (
+    facet: string,
+    params: 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>, any]> => {
+    logger.default('allFacet', { facet, params, locations });
+    const [cacheMap, response] = await cache.allFacet(facet, params, locations);
+    return [cacheMap, response];
+  }
+
   const create = async (
     v: TypesProperties<V, S, L1, L2, L3, L4, L5>,
     locations: LocKeyArray<L1, L2, L3, L4, L5> | [] = []
@@ -247,9 +257,19 @@ export const createAggregator = async <
     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>>,
+    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 });
@@ -258,6 +278,17 @@ export const createAggregator = async <
     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>
@@ -280,12 +311,15 @@ export const createAggregator = async <
     one,
     action,
     allAction,
+    allFacet,
     create,
     get,
     retrieve,
     remove,
     update,
+    facet,
     find,
+    findOne,
     reset,
     set,
     pkTypes: cache.pkTypes,

package/src/Cache.ts

@@ -51,8 +51,14 @@ export interface Cache<
     locations?: LocKeyArray<L1, L2, L3, L4, L5> | []
   ) => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V[]]>
 
+  allFacet: (
+    facet: string,
+    params?: 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>, any]>;
+
   create: (
-    v: TypesProperties<V, S, L1, L2, L3, L4, L5>,
+    item: TypesProperties<V, S, L1, L2, L3, L4, L5>,
     locations?: LocKeyArray<L1, L2, L3, L4, L5> | []
   ) => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V]>;
 
@@ -70,18 +76,30 @@ export interface Cache<
 
   update: (
     key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>,
-    v: TypesProperties<V, S, L1, L2, L3, L4, L5>,
+    item: 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,
+    params?: Record<string, string | number | boolean | Date | Array<string | number | boolean | Date>>,
+  ) => 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>>,
+    params?: 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,
+    params?: 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>
+    item: 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>]>;
@@ -105,8 +123,8 @@ export const createCache = async <
   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>;
   }
 
@@ -121,7 +139,7 @@ export const createCache = async <
     logger.default('all', { query, locations });
     let ret: V[] = [];
     try {
-      ret = await api.all(query, {}, locations);
+      ret = await api.all(query, locations);
       ret.forEach((v) => {
         cacheMap.set(v.key, v);
       });
@@ -144,7 +162,7 @@ export const createCache = async <
 
     let retItem: V | null = null;
     try {
-      retItem = await api.one(query, {}, locations);
+      retItem = await api.one(query, locations);
       if (retItem) {
         cacheMap.set(retItem.key, retItem);
       }
@@ -177,7 +195,7 @@ export const createCache = async <
       throw new Error('Key for Action is not a valid ItemKey');
     }
 
-    const updated = await api.action(key, action, body, {});
+    const updated = await api.action(key, action, body);
     cacheMap.set(updated.key, updated);
     return [cacheMap, validatePK(updated, pkType) as V];
   }
@@ -190,7 +208,7 @@ export const createCache = async <
     logger.default('allAction', { action, body, locations });
     let ret: V[] = [];
     try {
-      ret = await api.allAction(action, body, {}, locations);
+      ret = await api.allAction(action, body, locations);
       ret.forEach((v) => {
         cacheMap.set(v.key, v);
       });
@@ -205,12 +223,22 @@ export const createCache = async <
     return [cacheMap, validatePK(ret, pkType) as V[]];
   }
 
+  const allFacet = async (
+    facet: string,
+    params: 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>, any]> => {
+    logger.default('allFacet', { facet, params, locations });
+    const ret = await api.allFacet(facet, params, locations);
+    return [cacheMap, ret];
+  }
+
   const create = async (
     v: TypesProperties<V, S, L1, L2, L3, L4, L5>,
     locations: LocKeyArray<L1, L2, L3, L4, L5> | [] = []
   ): Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V]> => {
     logger.default('create', { v, locations });
-    const created = await api.create(v, {}, locations);
+    const created = await api.create(v, locations);
     cacheMap.set(created.key, created);
     return [cacheMap, validatePK(created, pkType) as V];
   }
@@ -227,7 +255,7 @@ export const createCache = async <
     }
     let ret: V | null;
     try {
-      ret = await api.get(key, {});
+      ret = await api.get(key);
       if (ret) {
         cacheMap.set(ret.key, ret);
       }
@@ -264,7 +292,7 @@ export const createCache = async <
     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 });
@@ -282,7 +310,7 @@ export const createCache = async <
       throw new Error('Key for Remove is not a valid ItemKey');
     }
     try {
-      await api.remove(key, {});
+      await api.remove(key);
       cacheMap.delete(key);
     } catch (e) {
       logger.error("Error deleting item", { error: e });
@@ -305,7 +333,7 @@ export const createCache = async <
     }
 
     try {
-      const updated = await api.update(key, v, {});
+      const updated = await api.update(key, v);
       cacheMap.set(updated.key, updated);
       return [cacheMap, validatePK(updated, pkType) as V];
     } catch (e) {
@@ -314,19 +342,41 @@ export const createCache = async <
     }
   }
 
+  // Facets are a pass-thru for caches
+  const facet = async (
+    key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>,
+    facet: string,
+    params: Record<string, string | number | boolean | Date | Array<string | number | boolean | Date>> = {},
+  ): Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, any]> => {
+    logger.default('facet', { key, facet });
+    const ret = await api.facet(key, facet, params);
+    return [cacheMap, ret];
+  }
+
   const find = async (
     finder: string,
-    finderParams: Record<string, string | number | boolean | Date | Array<string | number | boolean | Date>>,
+    params: 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 ret: V[] = await api.find(finder, finderParams, {}, locations);
+    logger.default('find', { finder, params, locations });
+    const ret: V[] = await api.find(finder, params, locations);
     ret.forEach((v) => {
       cacheMap.set(v.key, v);
     });
     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 +387,7 @@ export const createCache = async <
     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)) {
@@ -362,12 +412,15 @@ export const createCache = async <
     one,
     action,
     allAction,
+    allFacet,
     create,
     get,
     retrieve,
     remove,
     update,
+    facet,
     find,
+    findOne,
     reset,
     set,
     pkTypes,

package/vitest.config.ts

@@ -1,5 +1,5 @@
 import { defineConfig } from 'vitest/config'
-import path from 'path'
+import * as path from 'path'
 
 export default defineConfig({
   test: {
@@ -13,7 +13,17 @@ export default defineConfig({
         '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: {