@fjell/cache 4.4.3 → 4.5.1

package/src/Aggregator.ts

@@ -0,0 +1,289 @@
+/* eslint-disable no-undefined */
+import {
+  ComKey,
+  Item,
+  ItemQuery,
+  LocKeyArray,
+  PriKey,
+  TypesProperties
+} from "@fjell/core";
+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) }
+
+export 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 => {
+  let cacheConfig: CacheConfig;
+  if ((config as CacheConfig).optional === undefined) {
+    cacheConfig = { cache: config as any, optional: false };
+  } else {
+    cacheConfig = config as CacheConfig;
+  }
+  return cacheConfig;
+}
+
+export const createAggregator = <
+  V extends Item<S, L1, L2, L3, L4, L5>,
+  S extends string,
+  L1 extends string = never,
+  L2 extends string = never,
+  L3 extends string = never,
+  L4 extends string = never,
+  L5 extends string = never
+>(
+    cache: Cache<V, S, L1, L2, L3, L4, L5>,
+    { aggregates = {}, events = {} }:
+      {
+        aggregates?: AggregateConfig,
+        events?: AggregateConfig
+      }
+  ): Aggregator<V, S, L1, L2, L3, L4, L5> => {
+
+  const populate = async (item: V): Promise<V> => {
+    logger.default('populate', { item });
+    for (const key in aggregates) {
+      await populateAggregate(key, item);
+    }
+    for (const key in events) {
+      await populateEvent(key, item);
+    }
+    logger.default('populate done', { item });
+    return item;
+  }
+
+  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) {
+        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) {
+        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));
+      }
+    } else {
+
+      const ref = item.refs[key];
+
+      logger.default('AGG Retrieving Item in Populate', { key: ref });
+      const [, newItem] = await cacheConfig.cache.retrieve(ref);
+      if (newItem) {
+        if (item.aggs === undefined) {
+          item.aggs = {};
+        }
+        item.aggs[key] = {
+          key: ref,
+          item: newItem as Item,
+        };
+      }
+    }
+  }
+
+  // TODO: I'm not a big fan that this just "automatically" assumes that the "by" key in event is a ref.
+  const populateEvent = async (key: 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) {
+        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) {
+        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 }));
+      }
+
+      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;
+      }
+    }
+  }
+
+  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 });
+    const [cacheMap, items] = await cache.all(query, locations);
+    const populatedItems = await Promise.all(items.map(async (item) => populate(item)));
+    return [cacheMap, populatedItems];
+  }
+
+  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 });
+    const [cacheMap, item] = await cache.one(query, locations);
+    let populatedItem = null;
+    if (item) {
+      populatedItem = await populate(item);
+    }
+    return [cacheMap, populatedItem];
+  }
+
+  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 });
+    const [cacheMap, item] = await cache.action(key, action, body);
+    const populatedItem = await populate(item);
+    return [cacheMap, populatedItem];
+  }
+
+  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('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];
+  }
+
+  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 [cacheMap, item] = await cache.create(v, locations);
+    const populatedItem = await populate(item);
+    return [cacheMap, populatedItem];
+  }
+
+  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 });
+    const [cacheMap, item] = await cache.get(key);
+    let populatedItem = null;
+    if (item) {
+      populatedItem = await populate(item);
+    }
+    return [cacheMap, populatedItem];
+  }
+
+  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 });
+    const [cacheMap, item] = await cache.retrieve(key);
+    let populatedItem = null;
+    if (item) {
+      populatedItem = await populate(item);
+    }
+    return [cacheMap, populatedItem];
+  }
+
+  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 });
+    const cacheMap = await cache.remove(key);
+    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 });
+    const [cacheMap, item] = await cache.update(key, v);
+    const populatedItem = await populate(item);
+    return [cacheMap, populatedItem];
+  }
+
+  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 [cacheMap, items] = await cache.find(finder, finderParams, locations);
+    const populatedItems = await Promise.all(items.map(async (item) => populate(item)));
+    return [cacheMap, populatedItems];
+  }
+
+  const set = async (
+    key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>,
+    v: V
+  ): Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V]> => {
+    logger.default('set', { key, v });
+
+    // TODO: There should be some input validation here to ensure a valid item.
+    const [cacheMap, item] = await cache.set(key, v);
+    const populatedItem = await populate(item);
+    return [cacheMap, populatedItem];
+  }
+
+  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,
+    set,
+    pkTypes: cache.pkTypes,
+    cacheMap: cache.cacheMap,
+    populate,
+    populateAggregate,
+    populateEvent
+  }
+}

package/src/Cache.ts

@@ -1,13 +1,22 @@
-/* eslint-disable no-undefined */
 import {
+  AllItemTypeArrays,
   ComKey,
+  isItemKeyEqual,
+  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 +79,298 @@ export interface Cache<
     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: V
+  ) => 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 });
+
+    // 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)) {
+      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 });
+    // 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)) {
+      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 });
+    // 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)) {
+      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 });
+
+    // 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)) {
+      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];
+  }
+
+  const set = async (
+    key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>,
+    v: V
+  ): 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)) {
+      logger.error('Key for Update is not a valid ItemKey: %j', key);
+      throw new Error('Key for Update is not a valid ItemKey');
+    }
+
+    // TODO: This could be merged with the isValidItemKey check, later.
+    validatePK(v, pkType);
+
+    if (!isItemKeyEqual(key, v.key)) {
+      logger.error('Key does not match item key: %j != %j', key, v.key);
+      throw new Error('Key does not match item key');
+    }
+
+    cacheMap.set(key, v);
+    return [cacheMap, validatePK(v, pkType) as V];
+  }
+
+  return {
+    all,
+    one,
+    action,
+    allAction,
+    create,
+    get,
+    retrieve,
+    remove,
+    update,
+    find,
+    reset,
+    set,
+    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[]]>;
-}