@fjell/cache 4.4.3 → 4.5.0

package/src/{AItemAggregator.ts → Aggregator.ts}

@@ -1,5 +1,4 @@
-/* eslint-disable no-undefined, max-params */
-
+/* eslint-disable no-undefined */
 import {
   ComKey,
   Item,
@@ -8,11 +7,26 @@ import {
   PriKey,
   TypesProperties
 } from "@fjell/core";
-import { AItemCache } from "./AItemCache";
 import { Cache } from "./Cache";
 import { CacheMap } from "./CacheMap";
 import LibLogger from "./logger";
 
+const logger = LibLogger.get('ItemAggregator');
+
+export interface Aggregator<
+  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
+> extends Cache<V, S, L1, L2, L3, L4, L5> {
+  populate: (item: V) => Promise<V>;
+  populateAggregate: (key: string, item: V) => Promise<void>;
+  populateEvent: (key: string, item: V) => Promise<void>;
+}
+
 export interface CacheConfig { cache: any, optional: boolean }
 
 export interface AggregateConfig { [key: string]: (CacheConfig) }
@@ -35,7 +49,7 @@ export const toCacheConfig = <
   return cacheConfig;
 }
 
-export class AItemAggregator<
+export const createAggregator = <
   V extends Item<S, L1, L2, L3, L4, L5>,
   S extends string,
   L1 extends string = never,
@@ -43,51 +57,38 @@ export class AItemAggregator<
   L3 extends string = never,
   L4 extends string = never,
   L5 extends string = never
-> implements Cache<V, S, L1, L2, L3, L4, L5> {
-
-  private cache: AItemCache<V, S, L1, L2, L3, L4, L5>;
-  private logger;
-  private aggregates: AggregateConfig = {};
-  private events: AggregateConfig = {};
-
-  public constructor(
-    cache: AItemCache<V, S, L1, L2, L3, L4, L5>,
+>(
+    cache: Cache<V, S, L1, L2, L3, L4, L5>,
     { aggregates = {}, events = {} }:
       {
         aggregates?: AggregateConfig,
         events?: AggregateConfig
-      },
-  ) {
-    this.cache = cache;
-    this.aggregates = aggregates;
-    this.events = events;
-    // istanbul ignore next
-    this.logger = LibLogger.get("AItemAggregator", ...aggregates ? Object.keys(aggregates) : []);
-  }
-
-  private async populate(item: V): Promise<V> {
-    this.logger.default('populate', { item });
-    for (const key in this.aggregates) {
-      await this.populateAggregate(key, item);
+      }
+  ): Aggregator<V, S, L1, L2, L3, L4, L5> => {
+
+  const populate = async (item: V): Promise<V> => {
+    logger.default('populate', { item });
+    for (const key in aggregates) {
+      await populateAggregate(key, item);
     }
-    for (const key in this.events) {
-      await this.populateEvent(key, item);
+    for (const key in events) {
+      await populateEvent(key, item);
     }
-    this.logger.default('populate done', { item });
+    logger.default('populate done', { item });
     return item;
   }
 
-  private async populateAggregate(key: string, item: V) {
-    this.logger.default('populate aggregate key', { key });
-    const cacheConfig = toCacheConfig(this.aggregates[key]);
+  const populateAggregate = async (key: string, item: V) => {
+    logger.default('populate aggregate key', { key });
+    const cacheConfig = toCacheConfig(aggregates[key]);
     if (item.refs === undefined) {
       if (cacheConfig.optional === false) {
-        this.logger.error('Item does not have refs an is not optional ' + JSON.stringify(item));
+        logger.error('Item does not have refs an is not optional ' + JSON.stringify(item));
         throw new Error('Item does not have refs an is not optional ' + JSON.stringify(item));
       }
     } else if (item.refs[key] === undefined) {
       if (cacheConfig.optional === false) {
-        this.logger.error('Item does not have mandatory ref with key, not optional ' +
+        logger.error('Item does not have mandatory ref with key, not optional ' +
             key + ' ' + JSON.stringify(item));
         throw new Error('Item does not have mandatory ref with key, not optional ' +
             key + ' ' + JSON.stringify(item));
@@ -96,7 +97,7 @@ export class AItemAggregator<
 
       const ref = item.refs[key];
 
-      this.logger.default('AGG Retrieving Item in Populate', { key: ref });
+      logger.default('AGG Retrieving Item in Populate', { key: ref });
       const [, newItem] = await cacheConfig.cache.retrieve(ref);
       if (newItem) {
         if (item.aggs === undefined) {
@@ -111,27 +112,27 @@ export class AItemAggregator<
   }
 
   // TODO: I'm not a big fan that this just "automatically" assumes that the "by" key in event is a ref.
-  private async populateEvent(key: string, item: V) {
-    this.logger.default('populate event key', { key });
-    const cacheConfig = toCacheConfig(this.events[key]);
+  const populateEvent = async (key: string, item: V) => {
+    logger.default('populate event key', { key });
+    const cacheConfig = toCacheConfig(events[key]);
 
     if (item.events === undefined) {
       throw new Error('Item does not have events ' + JSON.stringify(item));
     } else if (item.events[key] === undefined) {
       if (cacheConfig.optional === false) {
-        this.logger.error('Item does not have mandatory event with key ' + key + ' ' + JSON.stringify(item));
+        logger.error('Item does not have mandatory event with key ' + key + ' ' + JSON.stringify(item));
         throw new Error('Item does not have mandatory event with key ' + key + ' ' + JSON.stringify(item));
       }
     } else {
       const event = item.events[key];
 
       if (event.by === undefined) {
-        this.logger.error(
+        logger.error(
           'populateEvent with an Event that does not have by', { event, ik: item.key, eventKey: key });
         throw new Error('populateEvent with an Event that does not have by: ' + JSON.stringify({ key, event }));
       }
 
-      this.logger.default('EVENT Retrieving Item in Populate', { key: event.by });
+      logger.default('EVENT Retrieving Item in Populate', { key: event.by });
       const [, newItem] = await cacheConfig.cache.retrieve(event.by);
       if (newItem) {
         event.agg = newItem as Item;
@@ -139,113 +140,137 @@ export class AItemAggregator<
     }
   }
 
-  public async all(
+  const all = async (
     query: ItemQuery = {},
     locations: LocKeyArray<L1, L2, L3, L4, L5> | [] = []
   ):
-    Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V[]]> {
-    this.logger.default('all', { query, locations });
-    const [cacheMap, items] = await this.cache.all(query, locations);
-    const populatedItems = await Promise.all(items.map(async (item) => this.populate(item)));
+    Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V[]]> => {
+    logger.default('all', { query, locations });
+    const [cacheMap, items] = await cache.all(query, locations);
+    const populatedItems = await Promise.all(items.map(async (item) => populate(item)));
     return [cacheMap, populatedItems];
   }
 
-  public async one(
+  const one = async (
     query: ItemQuery = {},
     locations: LocKeyArray<L1, L2, L3, L4, L5> | [] = []
   ):
-    Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V | null]> {
-    this.logger.default('one', { query, locations });
-    const [cacheMap, item] = await this.cache.one(query, locations);
+    Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V | null]> => {
+    logger.default('one', { query, locations });
+    const [cacheMap, item] = await cache.one(query, locations);
     let populatedItem = null;
     if (item) {
-      populatedItem = await this.populate(item);
+      populatedItem = await populate(item);
     }
     return [cacheMap, populatedItem];
   }
 
-  public async action(
+  const action = async (
     key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>,
     action: string,
     body: any = {},
-  ): Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V]> {
-    this.logger.default('action', { key, action, body });
-    const [cacheMap, item] = await this.cache.action(key, action, body);
-    const populatedItem = await this.populate(item);
+  ): Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V]> => {
+    logger.default('action', { key, action, body });
+    const [cacheMap, item] = await cache.action(key, action, body);
+    const populatedItem = await populate(item);
     return [cacheMap, populatedItem];
   }
 
-  public async allAction(
+  const allAction = async (
     action: string,
     body: any = {},
     locations: LocKeyArray<L1, L2, L3, L4, L5> | [] = []
-  ): Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V[]]> {
-    this.logger.default('action', { action, body, locations });
-    const [cacheMap, items] = await this.cache.allAction(action, body, locations);
-    const populatedItems = await Promise.all(items.map(async (item) => this.populate(item)));
+  ): Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V[]]> => {
+    logger.default('action', { action, body, locations });
+    const [cacheMap, items] = await cache.allAction(action, body, locations);
+    const populatedItems = await Promise.all(items.map(async (item) => populate(item)));
     return [cacheMap, populatedItems];
   }
 
-  public async create(
+  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]> {
-    this.logger.default('create', { v, locations });
-    const [cacheMap, item] = await this.cache.create(v, locations);
-    const populatedItem = await this.populate(item);
+  ): Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V]> => {
+    logger.default('create', { v, locations });
+    const [cacheMap, item] = await cache.create(v, locations);
+    const populatedItem = await populate(item);
     return [cacheMap, populatedItem];
   }
 
-  public async get(
+  const get = async (
     key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>,
-  ): Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V | null]> {
-    this.logger.default('get', { key });
-    const [cacheMap, item] = await this.cache.get(key);
+  ): Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V | null]> => {
+    logger.default('get', { key });
+    const [cacheMap, item] = await cache.get(key);
     let populatedItem = null;
     if (item) {
-      populatedItem = await this.populate(item);
+      populatedItem = await populate(item);
     }
     return [cacheMap, populatedItem];
   }
 
-  public async retrieve(
+  const retrieve = async (
     key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>,
-  ): Promise<[CacheMap<V, S, L1, L2, L3, L4, L5> | null, V | null]> {
-    this.logger.default('retrieve', { key });
-    const [cacheMap, item] = await this.cache.retrieve(key);
+  ): Promise<[CacheMap<V, S, L1, L2, L3, L4, L5> | null, V | null]> => {
+    logger.default('retrieve', { key });
+    const [cacheMap, item] = await cache.retrieve(key);
     let populatedItem = null;
     if (item) {
-      populatedItem = await this.populate(item);
+      populatedItem = await populate(item);
     }
     return [cacheMap, populatedItem];
   }
 
-  public async remove(
+  const remove = async (
     key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>,
-  ): Promise<CacheMap<V, S, L1, L2, L3, L4, L5>> {
-    this.logger.default('remove', { key });
-    const cacheMap = await this.cache.remove(key);
+  ): Promise<CacheMap<V, S, L1, L2, L3, L4, L5>> => {
+    logger.default('remove', { key });
+    const cacheMap = await cache.remove(key);
     return cacheMap;
   }
 
-  public async update(
+  const update = async (
     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]> {
-    this.logger.default('update', { key, v });
-    const [cacheMap, item] = await this.cache.update(key, v);
-    const populatedItem = await this.populate(item);
+  ): Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V]> => {
+    logger.default('update', { key, v });
+    const [cacheMap, item] = await cache.update(key, v);
+    const populatedItem = await populate(item);
     return [cacheMap, populatedItem];
   }
 
-  public async find(
+  const find = 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[]]> {
-    this.logger.default('find', { finder, finderParams, locations });
-    const [cacheMap, items] = await this.cache.find(finder, finderParams, locations);
-    const populatedItems = await Promise.all(items.map(async (item) => this.populate(item)));
+  ): Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V[]]> => {
+    logger.default('find', { finder, finderParams, locations });
+    const [cacheMap, items] = await cache.find(finder, finderParams, locations);
+    const populatedItems = await Promise.all(items.map(async (item) => populate(item)));
     return [cacheMap, populatedItems];
   }
+
+  const reset = async (): Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>]> => {
+    const cacheMap = await cache.reset();
+    return cacheMap;
+  }
+
+  return {
+    all,
+    one,
+    action,
+    allAction,
+    create,
+    get,
+    retrieve,
+    remove,
+    update,
+    find,
+    reset,
+    pkTypes: cache.pkTypes,
+    cacheMap: cache.cacheMap,
+    populate,
+    populateAggregate,
+    populateEvent
+  }
 }

package/src/Cache.ts

@@ -1,13 +1,21 @@
-/* eslint-disable no-undefined */
 import {
+  AllItemTypeArrays,
   ComKey,
+  isValidItemKey,
   Item,
   ItemQuery,
   LocKeyArray,
   PriKey,
-  TypesProperties
+  TypesProperties,
+  validatePK
 } from "@fjell/core";
 import { CacheMap } from "./CacheMap";
+import LibLogger from "./logger";
+
+import { ClientApi } from "@fjell/client-api";
+import { NotFoundError } from "@fjell/http-api";
+
+const logger = LibLogger.get('Cache');
 
 export interface Cache<
   V extends Item<S, L1, L2, L3, L4, L5>,
@@ -70,4 +78,259 @@ export interface Cache<
     locations?: LocKeyArray<L1, L2, L3, L4, L5> | []
   ) => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V[]]>;
 
+  reset: () => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>]>;
+
+  pkTypes: AllItemTypeArrays<S, L1, L2, L3, L4, L5>;
+
+  cacheMap: CacheMap<V, S, L1, L2, L3, L4, L5>;
+}
+
+export const createCache = <
+  V extends Item<S, L1, L2, L3, L4, L5>,
+  S extends string,
+  L1 extends string = never,
+  L2 extends string = never,
+  L3 extends string = never,
+  L4 extends string = never,
+  L5 extends string = never
+>(
+    api: ClientApi<V, S, L1, L2, L3, L4, L5>,
+    pkType: S,
+    parentCache?: Cache<Item<L1, L2, L3, L4, L5>, L1, L2, L3, L4, L5>
+  ): Cache<V, S, L1, L2, L3, L4, L5> => {
+
+  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>;
+  }
+
+  let cacheMap: CacheMap<V, S, L1, L2, L3, L4, L5> =
+    new CacheMap<V, S, L1, L2, L3, L4, L5>(pkTypes as AllItemTypeArrays<S, L1, L2, L3, L4, L5>);
+
+  const all = async (
+    query: ItemQuery = {},
+    locations: LocKeyArray<L1, L2, L3, L4, L5> | [] = []
+  ):
+    Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V[]]> => {
+    logger.default('all', { query, locations });
+    let ret: V[] = [];
+    try {
+      ret = await api.all(query, {}, locations);
+      ret.forEach((v) => {
+        cacheMap.set(v.key, v);
+      });
+    } catch (e: unknown) {
+      if (e instanceof NotFoundError) {
+      } else {
+        throw e;
+      }
+
+    }
+    return [cacheMap, validatePK(ret, pkType) as V[]];
+  }
+
+  const one = async (
+    query: ItemQuery = {},
+    locations: LocKeyArray<L1, L2, L3, L4, L5> | [] = []
+  ):
+    Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V | null]> => {
+    logger.default('one', { query, locations });
+
+    let retItem: V | null = null;
+    try {
+      retItem = await api.one(query, {}, locations);
+      if (retItem) {
+        cacheMap.set(retItem.key, retItem);
+      }
+    } catch (e: unknown) {
+      if (e instanceof NotFoundError) {
+      } else {
+        throw e;
+      }
+
+    }
+    return [
+      cacheMap,
+      retItem ?
+        validatePK(retItem, pkType) as V :
+        null
+    ];
+  }
+
+  const action = async (
+    key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>,
+    action: string,
+    body: any = {},
+  ): Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V]> => {
+    logger.default('action', { key, action, body });
+
+    if (!isValidItemKey(key)) {
+      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, {});
+    cacheMap.set(updated.key, updated);
+    return [cacheMap, validatePK(updated, pkType) as V];
+  }
+
+  const allAction = async (
+    action: string,
+    body: any = {},
+    locations: LocKeyArray<L1, L2, L3, L4, L5> | [] = []
+  ): Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V[]]> => {
+    logger.default('allAction', { action, body, locations });
+    let ret: V[] = [];
+    try {
+      ret = await api.allAction(action, body, {}, locations);
+      ret.forEach((v) => {
+        cacheMap.set(v.key, v);
+      });
+    } catch (e: unknown) {
+      // istanbul ignore next
+      if (e instanceof NotFoundError) {
+      } else {
+        throw e;
+      }
+
+    }
+    return [cacheMap, validatePK(ret, pkType) as V[]];
+  }
+
+  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);
+    cacheMap.set(created.key, created);
+    return [cacheMap, validatePK(created, pkType) as V];
+  }
+
+  const get = async (
+    key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>,
+  ): Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V | null]> => {
+    logger.default('get', { key });
+    if (!isValidItemKey(key)) {
+      logger.error('Key for Get is not a valid ItemKey: %j', key);
+      throw new Error('Key for Get is not a valid ItemKey');
+    }
+    let ret: V | null;
+    try {
+      ret = await api.get(key, {});
+      if (ret) {
+        cacheMap.set(ret.key, ret);
+      }
+    } catch (e: any) {
+      logger.error("Error getting item for key", { key, message: e.message, stack: e.stack });
+      throw e;
+    }
+    return [
+      cacheMap,
+      ret ?
+        validatePK(ret, pkType) as V :
+        null
+    ];
+  }
+
+  const retrieve = async (
+    key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>,
+  ): Promise<[CacheMap<V, S, L1, L2, L3, L4, L5> | null, V | null]> => {
+    logger.default('retrieve', { key });
+    if (!isValidItemKey(key)) {
+      logger.error('Key for Retrieve is not a valid ItemKey: %j', key);
+      throw new Error('Key for Retrieve is not a valid ItemKey');
+    }
+    const containsItemKey = cacheMap.includesKey(key);
+
+    let retrieved: V | null;
+    if (containsItemKey) {
+      logger.default('Looking for Object in Cache', key);
+      retrieved = cacheMap.get(key);
+    } else {
+      logger.default('Object Not Found in Cache, Retrieving from Server API', { key });
+      [, retrieved] = await get(key);
+    }
+    const retValue: [CacheMap<V, S, L1, L2, L3, L4, L5> | null, V | null] = [
+      containsItemKey ? null : cacheMap,
+      retrieved ?
+        validatePK(retrieved, pkType) as V:
+        null
+    ];
+    // logger.debug('Returning from retrieve', { retValue });
+    return retValue;
+  }
+
+  const remove = async (
+    key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>,
+  ): Promise<CacheMap<V, S, L1, L2, L3, L4, L5>> => {
+    logger.default('remove', { key });
+    if (!isValidItemKey(key)) {
+      logger.error('Key for Remove is not a valid ItemKey: %j', key);
+      throw new Error('Key for Remove is not a valid ItemKey');
+    }
+    try {
+      await api.remove(key, {});
+      cacheMap.delete(key);
+    } catch (e) {
+      logger.error("Error deleting item", { error: e });
+      throw e;
+    }
+    return cacheMap;
+  }
+
+  const update = async (
+    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]> => {
+    logger.default('update', { key, v });
+
+    if (!isValidItemKey(key)) {
+      logger.error('Key for Update is not a valid ItemKey: %j', key);
+      throw new Error('Key for Update is not a valid ItemKey');
+    }
+
+    try {
+      const updated = await api.update(key, v, {});
+      cacheMap.set(updated.key, updated);
+      return [cacheMap, validatePK(updated, pkType) as V];
+    } catch (e) {
+      logger.error("Error updating chat", { error: e });
+      throw e;
+    }
+  }
+
+  const find = 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 ret: V[] = await api.find(finder, finderParams, {}, locations);
+    ret.forEach((v) => {
+      cacheMap.set(v.key, v);
+    });
+    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];
+  }
+
+  return {
+    all,
+    one,
+    action,
+    allAction,
+    create,
+    get,
+    retrieve,
+    remove,
+    update,
+    find,
+    reset,
+    pkTypes,
+    cacheMap
+  }
 }

package/src/CacheRegistry.ts

@@ -1,7 +1,5 @@
 import { Item } from "@fjell/core";
-import { PItemCache } from "./PItemCache";
-import { CItemCache } from "./CItemCache";
-
+import { Cache } from "./Cache";
 import LibLogger from './logger';
 
 const logger = LibLogger.get('CacheRegistry');
@@ -33,9 +31,8 @@ export class CacheRegistry {
     L3 extends string = never,
     L4 extends string = never,
     L5 extends string = never
-  >(cache: PItemCache<Item<S>, S> |
-    CItemCache<Item<S, L1, L2, L3, L4, L5>, S, L1, L2, L3, L4, L5>): void => {
-    this.cacheMap[JSON.stringify(cache.getKeyTypes())] = cache;
+  >(cache: Cache<Item<S, L1, L2, L3, L4, L5>, S, L1, L2, L3, L4, L5>): void => {
+    this.cacheMap[JSON.stringify(cache.pkTypes)] = cache;
   };
 
   public isConfigured = (): boolean => {

package/dist/src/AItemAggregator.d.ts

@@ -1,35 +0,0 @@
-import { ComKey, Item, ItemQuery, LocKeyArray, PriKey, TypesProperties } from "@fjell/core";
-import { AItemCache } from "./AItemCache";
-import { Cache } from "./Cache";
-import { CacheMap } from "./CacheMap";
-export interface CacheConfig {
-    cache: any;
-    optional: boolean;
-}
-export interface AggregateConfig {
-    [key: string]: (CacheConfig);
-}
-export declare const toCacheConfig: <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>(config: CacheConfig | Cache<V, S, L1, L2, L3, L4, L5>) => CacheConfig;
-export declare class AItemAggregator<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> implements Cache<V, S, L1, L2, L3, L4, L5> {
-    private cache;
-    private logger;
-    private aggregates;
-    private events;
-    constructor(cache: AItemCache<V, S, L1, L2, L3, L4, L5>, { aggregates, events }: {
-        aggregates?: AggregateConfig;
-        events?: AggregateConfig;
-    });
-    private populate;
-    private populateAggregate;
-    private populateEvent;
-    all(query?: ItemQuery, locations?: LocKeyArray<L1, L2, L3, L4, L5> | []): Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V[]]>;
-    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]>;
-    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[]]>;
-}