@fjell/cache 4.6.2 → 4.6.4

package/.kodrdriv/config.yaml

@@ -3,8 +3,12 @@ model: gpt-4.1
 contextDirectories:
   - .kodrdriv/context
 commit:
+  add: true
   cached: true
   sendit: true
 release:
   from: main
   to: HEAD
+publish:
+  mergeMethod: squash
+  dependencyUpdatePatterns: ["@fjell/*"]

package/commit.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+set -e
+
+echo "Staging all changes..."
+git add .
+
+echo "Running kodrdriv commit..."
+pnpm dlx @eldrforge/kodrdriv commit 

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,
@@ -232,7 +244,7 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
             response
         ];
     };
-    const find = async (finder, finderParams, locations = [])=>{
+    const find = async (finder, finderParams = {}, locations = [])=>{
         logger.default('find', {
             finder,
             finderParams,
@@ -245,7 +257,7 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
             populatedItems
         ];
     };
-    const findOne = async (finder, finderParams, locations = [])=>{
+    const findOne = async (finder, finderParams = {}, locations = [])=>{
         logger.default('find', {
             finder,
             finderParams,
@@ -280,6 +292,7 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
         one,
         action,
         allAction,
+        allFacet,
         create,
         get,
         retrieve,
@@ -300,4 +313,4 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
 
 exports.createAggregator = createAggregator;
 exports.toCacheConfig = toCacheConfig;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQWdncmVnYXRvci5janMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=
+//# 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,
@@ -228,7 +240,7 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
             response
         ];
     };
-    const find = async (finder, finderParams, locations = [])=>{
+    const find = async (finder, finderParams = {}, locations = [])=>{
         logger.default('find', {
             finder,
             finderParams,
@@ -241,7 +253,7 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
             populatedItems
         ];
     };
-    const findOne = async (finder, finderParams, locations = [])=>{
+    const findOne = async (finder, finderParams = {}, locations = [])=>{
         logger.default('find', {
             finder,
             finderParams,
@@ -276,6 +288,7 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
         one,
         action,
         allAction,
+        allFacet,
         create,
         get,
         retrieve,
@@ -295,4 +308,4 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
 };
 
 export { createAggregator, toCacheConfig };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQWdncmVnYXRvci5lcy5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=
+//# 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,
@@ -214,24 +226,24 @@ const createCache = async (api, pkType, parentCache)=>{
         }
     };
     // Facets are a pass-thru for caches
-    const facet = async (key, facet)=>{
+    const facet = async (key, facet, params = {})=>{
         logger.default('facet', {
             key,
             facet
         });
-        const ret = await api.facet(key, facet, {});
+        const ret = await api.facet(key, facet, params);
         return [
             cacheMap,
             ret
         ];
     };
-    const find = async (finder, finderParams, locations = [])=>{
+    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);
         });
@@ -240,13 +252,13 @@ const createCache = async (api, pkType, parentCache)=>{
             core.validatePK(ret, pkType)
         ];
     };
-    const findOne = async (finder, finderParams, locations = [])=>{
+    const findOne = async (finder, finderParams = {}, locations = [])=>{
         logger.default('findOne', {
             finder,
             finderParams,
             locations
         });
-        const ret = await api.findOne(finder, finderParams, {}, locations);
+        const ret = await api.findOne(finder, finderParams, locations);
         cacheMap.set(ret.key, ret);
         return [
             cacheMap,
@@ -287,6 +299,7 @@ const createCache = async (api, pkType, parentCache)=>{
         one,
         action,
         allAction,
+        allFacet,
         create,
         get,
         retrieve,
@@ -303,4 +316,4 @@ const createCache = async (api, pkType, parentCache)=>{
 };
 
 exports.createCache = createCache;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FjaGUuY2pzLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FjaGUuY2pzLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/Cache.d.ts

@@ -1,4 +1,4 @@
-import { AllItemTypeArrays, ComKey, Item, ItemQuery, LocKeyArray, PriKey, TypesProperties } from '@fjell/core';
+import { AllItemTypeArrays, ComKey, Item, ItemQuery, LocKeyArray, PriKey } from '@fjell/core';
 import { CacheMap } from './CacheMap';
 import { ClientApi } from '@fjell/client-api';
 export interface Cache<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> {
@@ -6,15 +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: Partial<Item<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]>;
-    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]>;
+    update: (key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>, item: Partial<Item<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,
@@ -210,24 +222,24 @@ const createCache = async (api, pkType, parentCache)=>{
         }
     };
     // Facets are a pass-thru for caches
-    const facet = async (key, facet)=>{
+    const facet = async (key, facet, params = {})=>{
         logger.default('facet', {
             key,
             facet
         });
-        const ret = await api.facet(key, facet, {});
+        const ret = await api.facet(key, facet, params);
         return [
             cacheMap,
             ret
         ];
     };
-    const find = async (finder, finderParams, locations = [])=>{
+    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);
         });
@@ -236,13 +248,13 @@ const createCache = async (api, pkType, parentCache)=>{
             validatePK(ret, pkType)
         ];
     };
-    const findOne = async (finder, finderParams, locations = [])=>{
+    const findOne = async (finder, finderParams = {}, locations = [])=>{
         logger.default('findOne', {
             finder,
             finderParams,
             locations
         });
-        const ret = await api.findOne(finder, finderParams, {}, locations);
+        const ret = await api.findOne(finder, finderParams, locations);
         cacheMap.set(ret.key, ret);
         return [
             cacheMap,
@@ -283,6 +295,7 @@ const createCache = async (api, pkType, parentCache)=>{
         one,
         action,
         allAction,
+        allFacet,
         create,
         get,
         retrieve,
@@ -299,4 +312,4 @@ const createCache = async (api, pkType, parentCache)=>{
 };
 
 export { createCache };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FjaGUuZXMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==
+//# 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,
@@ -236,7 +248,7 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
             response
         ];
     };
-    const find = async (finder, finderParams, locations = [])=>{
+    const find = async (finder, finderParams = {}, locations = [])=>{
         logger$3.default('find', {
             finder,
             finderParams,
@@ -249,7 +261,7 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
             populatedItems
         ];
     };
-    const findOne = async (finder, finderParams, locations = [])=>{
+    const findOne = async (finder, finderParams = {}, locations = [])=>{
         logger$3.default('find', {
             finder,
             finderParams,
@@ -284,6 +296,7 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
         one,
         action,
         allAction,
+        allFacet,
         create,
         get,
         retrieve,
@@ -417,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);
             });
@@ -438,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);
             }
@@ -464,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,
@@ -479,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);
             });
@@ -494,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,
@@ -518,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);
             }
@@ -572,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", {
@@ -594,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,
@@ -608,24 +633,24 @@ const createCache = async (api, pkType, parentCache)=>{
         }
     };
     // Facets are a pass-thru for caches
-    const facet = async (key, facet)=>{
+    const facet = async (key, facet, params = {})=>{
         logger$1.default('facet', {
             key,
             facet
         });
-        const ret = await api.facet(key, facet, {});
+        const ret = await api.facet(key, facet, params);
         return [
             cacheMap,
             ret
         ];
     };
-    const find = async (finder, finderParams, locations = [])=>{
+    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);
         });
@@ -634,13 +659,13 @@ const createCache = async (api, pkType, parentCache)=>{
             core.validatePK(ret, pkType)
         ];
     };
-    const findOne = async (finder, finderParams, locations = [])=>{
+    const findOne = async (finder, finderParams = {}, locations = [])=>{
         logger$1.default('findOne', {
             finder,
             finderParams,
             locations
         });
-        const ret = await api.findOne(finder, finderParams, {}, locations);
+        const ret = await api.findOne(finder, finderParams, locations);
         cacheMap.set(ret.key, ret);
         return [
             cacheMap,
@@ -681,6 +706,7 @@ const createCache = async (api, pkType, parentCache)=>{
         one,
         action,
         allAction,
+        allFacet,
         create,
         get,
         retrieve,

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.2",
+  "version": "4.6.4",
   "license": "Apache-2.0",
   "type": "module",
   "main": "./dist/index.cjs.js",
@@ -15,40 +15,40 @@
     }
   },
   "dependencies": {
-    "@fjell/client-api": "^4.4.2",
-    "@fjell/core": "^4.4.2",
-    "@fjell/http-api": "^4.4.0",
-    "@fjell/logging": "^4.4.2",
+    "@fjell/client-api": "^4.4.4",
+    "@fjell/core": "^4.4.5",
+    "@fjell/http-api": "^4.4.3",
+    "@fjell/logging": "^4.4.5",
     "d3": "^7.9.0",
     "dayjs": "^1.11.13",
     "react": "19.1.0"
   },
   "devDependencies": {
-    "@babel/preset-env": "^7.26.9",
-    "@babel/preset-typescript": "^7.26.0",
+    "@babel/preset-env": "^7.27.2",
+    "@babel/preset-typescript": "^7.27.1",
     "@eslint/eslintrc": "^3.3.1",
-    "@eslint/js": "^9.27.0",
-    "@swc/core": "^1.11.24",
-    "@tsconfig/recommended": "^1.0.8",
+    "@eslint/js": "^9.30.0",
+    "@swc/core": "^1.12.7",
+    "@tsconfig/recommended": "^1.0.10",
     "@types/babel__preset-env": "^7.10.0",
     "@types/d3": "^7.4.3",
-    "@types/multer": "^1.4.12",
-    "@types/node": "^24.0.3",
-    "@typescript-eslint/eslint-plugin": "^8.24.1",
-    "@typescript-eslint/parser": "^8.24.1",
-    "@vitest/coverage-v8": "^3.1.4",
-    "@vitest/ui": "^3.1.4",
-    "concurrently": "^9.1.2",
-    "eslint": "^9.21.0",
-    "nodemon": "^3.1.9",
+    "@types/multer": "^1.4.13",
+    "@types/node": "^24.0.7",
+    "@typescript-eslint/eslint-plugin": "^8.35.0",
+    "@typescript-eslint/parser": "^8.35.0",
+    "@vitest/coverage-v8": "^3.2.4",
+    "@vitest/ui": "^3.2.4",
+    "concurrently": "^9.2.0",
+    "eslint": "^9.30.0",
+    "nodemon": "^3.1.10",
     "rimraf": "^6.0.1",
     "ts-node": "^10.9.2",
-    "tsc-alias": "^1.8.10",
-    "typescript": "^5.7.3",
-    "vite": "^6.3.5",
+    "tsc-alias": "^1.8.16",
+    "typescript": "^5.8.3",
+    "vite": "^7.0.0",
     "vite-plugin-dts": "^4.5.4",
     "vite-plugin-node": "^5.0.1",
-    "vitest": "^3.1.4"
+    "vitest": "^3.2.4"
   },
   "repository": {
     "type": "git",
@@ -57,6 +57,7 @@
   "scripts": {
     "dev": "concurrently \"tsc --noEmit --watch\" \"vite build --watch\"",
     "build": "pnpm run lint && tsc --noEmit && vite build",
+    "typecheck": "tsc --noEmit",
     "lint": "eslint . --ext .ts --fix",
     "clean": "rimraf dist",
     "test": "pnpm run lint && vitest run --coverage"

package/release.sh

@@ -0,0 +1,89 @@
+#!/bin/bash
+set -e
+
+
+echo "Preparing for release: switching from workspace to remote dependencies."
+if [ -f "pnpm-workspace.yaml" ]; then
+    echo "Renaming pnpm-workspace.yaml to prevent workspace-protocol resolution"
+    mv pnpm-workspace.yaml pnpm-workspace.yaml.bak
+else
+    echo "pnpm-workspace.yaml not found, skipping rename."
+fi
+
+echo "Updating dependencies to latest versions from registry"
+pnpm update --latest
+
+echo "Staging changes for release commit"
+git add package.json pnpm-lock.yaml
+
+echo "Running clean, lint, build, and test..."
+pnpm run clean && pnpm run lint && pnpm run build && pnpm run test
+
+if git diff --staged --quiet; then
+  echo "No changes to commit, skipping commit."
+else
+  ./commit.sh
+fi
+
+echo "Bumping version..."
+pnpm version patch
+
+echo "Generating release notes..."
+pnpm dlx @eldrforge/kodrdriv release > RELEASE_NOTES.md
+
+echo "Pushing to origin..."
+git push --follow-tags
+
+echo "Creating GitHub pull request..."
+PR_URL=$(gh pr create --fill)
+PR_NUM=$(echo "$PR_URL" | grep -o '[0-9]*$')
+echo "Pull request created: $PR_URL"
+
+echo "Waiting for PR #$PR_NUM checks to complete..."
+while true; do
+  STATUS=$(gh pr view "$PR_NUM" --json statusCheckRollup --jq '.statusCheckRollup.state' 2>/dev/null)
+  if [[ -z "$STATUS" ]]; then
+    STATUS="PENDING"
+  fi
+  echo "PR status: $STATUS"
+  if [[ "$STATUS" == "SUCCESS" ]]; then
+    echo "All checks passed!"
+    break
+  elif [[ "$STATUS" == "FAILURE" || "$STATUS" == "ERROR" ]]; then
+    echo "PR checks failed."
+    gh pr checks "$PR_NUM"
+    exit 1
+  elif [[ "$STATUS" == "PENDING" || "$STATUS" == "EXPECTED" ]]; then
+    echo "Checks are pending... waiting 10 seconds."
+    sleep 10
+  else
+    echo "Unknown PR status: $STATUS. Waiting 10 seconds."
+    sleep 10
+  fi
+done
+
+echo "Merging PR #$PR_NUM..."
+gh pr merge "$PR_NUM" --squash --delete-branch
+
+echo "Checking out main branch..."
+git checkout main
+git pull origin main
+
+echo "Creating GitHub release..."
+TAG_NAME="v$(jq -r .version package.json)"
+gh release create "$TAG_NAME" --notes-file RELEASE_NOTES.md
+
+echo "Creating next release branch..."
+CURRENT_VERSION=$(jq -r .version package.json)
+MAJOR=$(echo "$CURRENT_VERSION" | cut -d. -f1)
+MINOR=$(echo "$CURRENT_VERSION" | cut -d. -f2)
+PATCH=$(echo "$CURRENT_VERSION" | cut -d. -f3)
+NEXT_PATCH=$((PATCH + 1))
+NEXT_VERSION="$MAJOR.$MINOR.$NEXT_PATCH"
+
+echo "Next version is $NEXT_VERSION"
+git checkout -b "release/v$NEXT_VERSION"
+git commit -m "feat: Start release v$NEXT_VERSION"
+git push -u origin "release/v$NEXT_VERSION"
+
+echo "Release process completed."

package/src/Aggregator.ts

@@ -4,8 +4,7 @@ import {
   Item,
   ItemQuery,
   LocKeyArray,
-  PriKey,
-  TypesProperties
+  PriKey
 } from "@fjell/core";
 import { Cache } from "./Cache";
 import { CacheMap } from "./CacheMap";
@@ -60,10 +59,10 @@ export const createAggregator = async <
 >(
   cache: Cache<V, S, L1, L2, L3, L4, L5>,
   { aggregates = {}, events = {} }:
-      {
-        aggregates?: AggregateConfig,
-        events?: AggregateConfig
-      }
+    {
+      aggregates?: AggregateConfig,
+      events?: AggregateConfig
+    }
 ): Promise<Aggregator<V, S, L1, L2, L3, L4, L5>> => {
 
   const populate = async (item: V): Promise<V> => {
@@ -93,9 +92,9 @@ export const createAggregator = async <
     } else if (item.refs[key] === undefined) {
       if (cacheConfig.optional === false) {
         logger.error('Item does not have mandatory ref with key, not optional ' +
-            key + ' ' + JSON.stringify(item));
+          key + ' ' + JSON.stringify(item));
         throw new Error('Item does not have mandatory ref with key, not optional ' +
-            key + ' ' + JSON.stringify(item));
+          key + ' ' + JSON.stringify(item));
       } else {
         if (item.events && Object.prototype.hasOwnProperty.call(item.events, key)) {
           delete item.events[key];
@@ -195,8 +194,18 @@ 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>,
+    v: Partial<Item<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 });
@@ -239,7 +248,7 @@ export const createAggregator = async <
 
   const update = async (
     key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>,
-    v: TypesProperties<V, S, L1, L2, L3, L4, L5>,
+    v: Partial<Item<S, L1, L2, L3, L4, L5>>,
   ): Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V]> => {
     logger.default('update', { key, v });
     const [cacheMap, item] = await cache.update(key, v);
@@ -259,7 +268,7 @@ export const createAggregator = async <
 
   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 });
@@ -270,7 +279,7 @@ export const createAggregator = async <
 
   const findOne = 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 });
@@ -301,6 +310,7 @@ export const createAggregator = async <
     one,
     action,
     allAction,
+    allFacet,
     create,
     get,
     retrieve,

package/src/Cache.ts

@@ -7,7 +7,6 @@ import {
   ItemQuery,
   LocKeyArray,
   PriKey,
-  TypesProperties,
   validatePK
 } from "@fjell/core";
 import { CacheMap } from "./CacheMap";
@@ -51,8 +50,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: Partial<Item<S, L1, L2, L3, L4, L5>>,
     locations?: LocKeyArray<L1, L2, L3, L4, L5> | []
   ) => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V]>;
 
@@ -70,29 +75,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: Partial<Item<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,
-    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]>;
 
   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>]>;
@@ -132,7 +138,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);
       });
@@ -155,7 +161,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);
       }
@@ -188,7 +194,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];
   }
@@ -201,7 +207,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);
       });
@@ -216,12 +222,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>,
+    v: Partial<Item<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];
   }
@@ -238,7 +254,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);
       }
@@ -293,7 +309,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 });
@@ -304,7 +320,7 @@ export const createCache = async <
 
   const update = async (
     key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>,
-    v: TypesProperties<V, S, L1, L2, L3, L4, L5>,
+    v: Partial<Item<S, L1, L2, L3, L4, L5>>,
   ): Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V]> => {
     logger.default('update', { key, v });
 
@@ -316,7 +332,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) {
@@ -329,19 +345,20 @@ export const createCache = async <
   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, {});
+    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);
     });
@@ -350,11 +367,11 @@ export const createCache = async <
 
   const findOne = 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('findOne', { finder, finderParams, locations });
-    const ret = await api.findOne(finder, finderParams, {}, locations);
+    const ret = await api.findOne(finder, finderParams, locations);
     cacheMap.set(ret.key, ret);
     return [cacheMap, validatePK(ret, pkType) as V];
   }
@@ -394,6 +411,7 @@ export const createCache = async <
     one,
     action,
     allAction,
+    allFacet,
     create,
     get,
     retrieve,