@fjell/cache 4.6.14 → 4.6.16

package/dist/index.js

@@ -0,0 +1,715 @@
+// src/logger.ts
+import Logging from "@fjell/logging";
+var LibLogger = Logging.getLogger("@fjell/cache");
+var logger_default = LibLogger;
+
+// src/Aggregator.ts
+var logger = logger_default.get("ItemAggregator");
+var toCacheConfig = (config) => {
+  let cacheConfig;
+  if (config.optional === void 0) {
+    cacheConfig = { cache: config, optional: false };
+  } else {
+    cacheConfig = config;
+  }
+  return cacheConfig;
+};
+var createAggregator = async (cache, { aggregates = {}, events = {} }) => {
+  const populate = async (item) => {
+    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, item) => {
+    logger.default("populate aggregate key", { key });
+    const cacheConfig = toCacheConfig(aggregates[key]);
+    if (item.refs === void 0) {
+      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.events && Object.prototype.hasOwnProperty.call(item.events, key)) {
+          delete item.events[key];
+        }
+      }
+    } else if (item.refs[key] === void 0) {
+      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 {
+        if (item.events && Object.prototype.hasOwnProperty.call(item.events, key)) {
+          delete item.events[key];
+        }
+      }
+    } else {
+      const ref = item.refs[key];
+      logger.default("AGG Retrieving Item in Populate", { key: ref });
+      const [, newItem] = await cacheConfig.cache.operations.retrieve(ref);
+      if (newItem) {
+        if (item.aggs === void 0) {
+          item.aggs = {};
+        }
+        item.aggs[key] = {
+          key: ref,
+          item: newItem
+        };
+      }
+    }
+  };
+  const populateEvent = async (key, item) => {
+    logger.default("populate event key", { key });
+    const cacheConfig = toCacheConfig(events[key]);
+    if (item.events === void 0) {
+      throw new Error("Item does not have events " + JSON.stringify(item));
+    } else if (item.events[key] === void 0) {
+      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 === void 0) {
+        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.operations.retrieve(event.by);
+      if (newItem) {
+        event.agg = newItem;
+      }
+    }
+  };
+  const all2 = async (query = {}, locations = []) => {
+    logger.default("all", { query, locations });
+    const [cacheMap, items] = await cache.operations.all(query, locations);
+    const populatedItems = await Promise.all(items.map(async (item) => populate(item)));
+    return [cacheMap, populatedItems];
+  };
+  const one2 = async (query = {}, locations = []) => {
+    logger.default("one", { query, locations });
+    const [cacheMap, item] = await cache.operations.one(query, locations);
+    let populatedItem = null;
+    if (item) {
+      populatedItem = await populate(item);
+    }
+    return [cacheMap, populatedItem];
+  };
+  const action2 = async (key, action3, body = {}) => {
+    logger.default("action", { key, action: action3, body });
+    const [cacheMap, item] = await cache.operations.action(key, action3, body);
+    const populatedItem = await populate(item);
+    return [cacheMap, populatedItem];
+  };
+  const allAction2 = async (action3, body = {}, locations = []) => {
+    logger.default("action", { action: action3, body, locations });
+    const [cacheMap, items] = await cache.operations.allAction(action3, body, locations);
+    const populatedItems = await Promise.all(items.map(async (item) => populate(item)));
+    return [cacheMap, populatedItems];
+  };
+  const allFacet2 = async (facet3, params = {}, locations = []) => {
+    logger.default("allFacet", { facet: facet3, params, locations });
+    const [cacheMap, response] = await cache.operations.allFacet(facet3, params, locations);
+    return [cacheMap, response];
+  };
+  const create2 = async (v, locations = []) => {
+    logger.default("create", { v, locations });
+    const [cacheMap, item] = await cache.operations.create(v, locations);
+    const populatedItem = await populate(item);
+    return [cacheMap, populatedItem];
+  };
+  const get2 = async (key) => {
+    logger.default("get", { key });
+    const [cacheMap, item] = await cache.operations.get(key);
+    let populatedItem = null;
+    if (item) {
+      populatedItem = await populate(item);
+    }
+    return [cacheMap, populatedItem];
+  };
+  const retrieve2 = async (key) => {
+    logger.default("retrieve", { key });
+    const [cacheMap, item] = await cache.operations.retrieve(key);
+    let populatedItem = null;
+    if (item) {
+      populatedItem = await populate(item);
+    }
+    return [cacheMap, populatedItem];
+  };
+  const remove2 = async (key) => {
+    logger.default("remove", { key });
+    const cacheMap = await cache.operations.remove(key);
+    return cacheMap;
+  };
+  const update2 = async (key, v) => {
+    logger.default("update", { key, v });
+    const [cacheMap, item] = await cache.operations.update(key, v);
+    const populatedItem = await populate(item);
+    return [cacheMap, populatedItem];
+  };
+  const facet2 = async (key, facet3) => {
+    logger.default("facet", { key, facet: facet3 });
+    const [cacheMap, response] = await cache.operations.facet(key, facet3);
+    return [cacheMap, response];
+  };
+  const find2 = async (finder, finderParams = {}, locations = []) => {
+    logger.default("find", { finder, finderParams, locations });
+    const [cacheMap, items] = await cache.operations.find(finder, finderParams, locations);
+    const populatedItems = await Promise.all(items.map(async (item) => populate(item)));
+    return [cacheMap, populatedItems];
+  };
+  const findOne2 = async (finder, finderParams = {}, locations = []) => {
+    logger.default("find", { finder, finderParams, locations });
+    const [cacheMap, item] = await cache.operations.findOne(finder, finderParams, locations);
+    const populatedItem = await populate(item);
+    return [cacheMap, populatedItem];
+  };
+  const set2 = async (key, v) => {
+    logger.default("set", { key, v });
+    const [cacheMap, item] = await cache.operations.set(key, v);
+    const populatedItem = await populate(item);
+    return [cacheMap, populatedItem];
+  };
+  const reset2 = async () => {
+    const cacheMap = await cache.operations.reset();
+    return cacheMap;
+  };
+  return {
+    // Cache properties
+    coordinate: cache.coordinate,
+    registry: cache.registry,
+    api: cache.api,
+    cacheMap: cache.cacheMap,
+    operations: cache.operations,
+    // Cache operations exposed directly
+    all: all2,
+    one: one2,
+    action: action2,
+    allAction: allAction2,
+    allFacet: allFacet2,
+    create: create2,
+    get: get2,
+    retrieve: retrieve2,
+    remove: remove2,
+    update: update2,
+    facet: facet2,
+    find: find2,
+    findOne: findOne2,
+    reset: reset2,
+    set: set2,
+    // Aggregator-specific operations
+    populate,
+    populateAggregate,
+    populateEvent
+  };
+};
+
+// src/CacheMap.ts
+import {
+  Dictionary,
+  isComKey,
+  isQueryMatch
+} from "@fjell/core";
+var logger2 = logger_default.get("CacheMap");
+var normalizeKeyValue = (value) => {
+  return String(value);
+};
+var createNormalizedHashFunction = () => {
+  return (key) => {
+    if (typeof key === "object" && key !== null) {
+      const normalizedKey = JSON.parse(JSON.stringify(key));
+      if ("pk" in normalizedKey && normalizedKey.pk !== null) {
+        normalizedKey.pk = normalizeKeyValue(normalizedKey.pk);
+      }
+      if ("lk" in normalizedKey && normalizedKey.lk !== null) {
+        normalizedKey.lk = normalizeKeyValue(normalizedKey.lk);
+      }
+      if ("loc" in normalizedKey && Array.isArray(normalizedKey.loc)) {
+        normalizedKey.loc = normalizedKey.loc.map((locItem) => {
+          if (locItem && "lk" in locItem && locItem.lk !== null) {
+            return { ...locItem, lk: normalizeKeyValue(locItem.lk) };
+          }
+          return locItem;
+        });
+      }
+      return JSON.stringify(normalizedKey);
+    }
+    return JSON.stringify(key);
+  };
+};
+var isLocKeyArrayEqual = (a, b) => {
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let i = 0; i < a.length; i++) {
+    const normalizedA = normalizeLocKeyItem(a[i]);
+    const normalizedB = normalizeLocKeyItem(b[i]);
+    if (JSON.stringify(normalizedA) !== JSON.stringify(normalizedB)) {
+      return false;
+    }
+  }
+  return true;
+};
+var normalizeLocKeyItem = (item) => {
+  if (typeof item === "object" && item !== null) {
+    const normalized = { ...item };
+    if ("lk" in normalized && normalized.lk !== null) {
+      normalized.lk = normalizeKeyValue(normalized.lk);
+    }
+    return normalized;
+  }
+  return item;
+};
+var CacheMap = class _CacheMap extends Dictionary {
+  types;
+  constructor(types, map) {
+    super(map, createNormalizedHashFunction());
+    this.types = types;
+  }
+  get(key) {
+    return super.get(key);
+  }
+  allIn(locations) {
+    if (locations.length === 0) {
+      logger2.debug("Returning all items, LocKeys is empty");
+      return this.values();
+    } else {
+      const locKeys = locations;
+      logger2.debug("allIn", { locKeys, keys: this.keys().length });
+      return this.keys().filter((key) => key && isComKey(key)).filter((key) => {
+        const ComKey8 = key;
+        logger2.debug("Comparing Location Keys", {
+          locKeys,
+          ComKey: ComKey8
+        });
+        return isLocKeyArrayEqual(locKeys, ComKey8.loc);
+      }).map((key) => this.get(key));
+    }
+  }
+  // TODO: Can we do case insensitive matching?
+  contains(query, locations) {
+    logger2.debug("contains", { query, locations });
+    const items = this.allIn(locations);
+    return items.some((item) => isQueryMatch(item, query));
+  }
+  queryIn(query, locations = []) {
+    logger2.debug("queryIn", { query, locations });
+    const items = this.allIn(locations);
+    return items.filter((item) => isQueryMatch(item, query));
+  }
+  clone() {
+    const clone = new _CacheMap(this.types, this.map);
+    return clone;
+  }
+};
+
+// src/ops/all.ts
+import {
+  validatePK
+} from "@fjell/core";
+import { NotFoundError } from "@fjell/http-api";
+var logger3 = logger_default.get("all");
+var all = async (api, cacheMap, pkType, query = {}, locations = []) => {
+  logger3.default("all", { query, locations });
+  let ret = [];
+  try {
+    ret = await api.all(query, locations);
+    ret.forEach((v) => {
+      cacheMap.set(v.key, v);
+    });
+  } catch (e) {
+    if (e instanceof NotFoundError) {
+    } else {
+      throw e;
+    }
+  }
+  return [cacheMap, validatePK(ret, pkType)];
+};
+
+// src/ops/one.ts
+import {
+  validatePK as validatePK2
+} from "@fjell/core";
+import { NotFoundError as NotFoundError2 } from "@fjell/http-api";
+var logger4 = logger_default.get("one");
+var one = async (api, cacheMap, pkType, query = {}, locations = []) => {
+  logger4.default("one", { query, locations });
+  let retItem = null;
+  try {
+    retItem = await api.one(query, locations);
+    if (retItem) {
+      cacheMap.set(retItem.key, retItem);
+    }
+  } catch (e) {
+    if (e instanceof NotFoundError2) {
+    } else {
+      throw e;
+    }
+  }
+  return [
+    cacheMap,
+    retItem ? validatePK2(retItem, pkType) : null
+  ];
+};
+
+// src/ops/create.ts
+import {
+  validatePK as validatePK3
+} from "@fjell/core";
+var logger5 = logger_default.get("create");
+var create = async (api, cacheMap, pkType, v, locations = []) => {
+  logger5.default("create", { v, locations });
+  const created = await api.create(v, locations);
+  cacheMap.set(created.key, created);
+  return [cacheMap, validatePK3(created, pkType)];
+};
+
+// src/ops/get.ts
+import {
+  isValidItemKey,
+  validatePK as validatePK4
+} from "@fjell/core";
+var logger6 = logger_default.get("get");
+var get = async (api, cacheMap, pkType, key) => {
+  logger6.default("get", { key });
+  if (!isValidItemKey(key)) {
+    logger6.error("Key for Get is not a valid ItemKey: %j", key);
+    throw new Error("Key for Get is not a valid ItemKey");
+  }
+  let ret;
+  try {
+    ret = await api.get(key);
+    if (ret) {
+      cacheMap.set(ret.key, ret);
+    }
+  } catch (e) {
+    logger6.error("Error getting item for key", { key, message: e.message, stack: e.stack });
+    throw e;
+  }
+  return [
+    cacheMap,
+    ret ? validatePK4(ret, pkType) : null
+  ];
+};
+
+// src/ops/retrieve.ts
+import {
+  isValidItemKey as isValidItemKey2,
+  validatePK as validatePK5
+} from "@fjell/core";
+var logger7 = logger_default.get("retrieve");
+var retrieve = async (api, cacheMap, pkType, key) => {
+  logger7.default("retrieve", { key });
+  if (!isValidItemKey2(key)) {
+    logger7.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;
+  if (containsItemKey) {
+    logger7.default("Looking for Object in Cache", key);
+    retrieved = cacheMap.get(key);
+  } else {
+    logger7.default("Object Not Found in Cache, Retrieving from Server API", { key });
+    [, retrieved] = await get(api, cacheMap, pkType, key);
+  }
+  const retValue = [
+    containsItemKey ? null : cacheMap,
+    retrieved ? validatePK5(retrieved, pkType) : null
+  ];
+  return retValue;
+};
+
+// src/ops/remove.ts
+import {
+  isValidItemKey as isValidItemKey3
+} from "@fjell/core";
+var logger8 = logger_default.get("remove");
+var remove = async (api, cacheMap, key) => {
+  logger8.default("remove", { key });
+  if (!isValidItemKey3(key)) {
+    logger8.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) {
+    logger8.error("Error deleting item", { error: e });
+    throw e;
+  }
+  return cacheMap;
+};
+
+// src/ops/update.ts
+import {
+  isValidItemKey as isValidItemKey4,
+  validatePK as validatePK6
+} from "@fjell/core";
+var logger9 = logger_default.get("update");
+var update = async (api, cacheMap, pkType, key, v) => {
+  logger9.default("update", { key, v });
+  if (!isValidItemKey4(key)) {
+    logger9.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, validatePK6(updated, pkType)];
+  } catch (e) {
+    logger9.error("Error updating item", { error: e });
+    throw e;
+  }
+};
+
+// src/ops/action.ts
+import {
+  isValidItemKey as isValidItemKey5,
+  validatePK as validatePK7
+} from "@fjell/core";
+var logger10 = logger_default.get("action");
+var action = async (api, cacheMap, pkType, key, action2, body = {}) => {
+  logger10.default("action", { key, action: action2, body });
+  if (!isValidItemKey5(key)) {
+    logger10.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, action2, body);
+  cacheMap.set(updated.key, updated);
+  return [cacheMap, validatePK7(updated, pkType)];
+};
+
+// src/ops/allAction.ts
+import {
+  validatePK as validatePK8
+} from "@fjell/core";
+import { NotFoundError as NotFoundError3 } from "@fjell/http-api";
+var logger11 = logger_default.get("allAction");
+var allAction = async (api, cacheMap, pkType, action2, body = {}, locations = []) => {
+  logger11.default("allAction", { action: action2, body, locations });
+  let ret = [];
+  try {
+    ret = await api.allAction(action2, body, locations);
+    ret.forEach((v) => {
+      cacheMap.set(v.key, v);
+    });
+  } catch (e) {
+    if (e instanceof NotFoundError3) {
+    } else {
+      throw e;
+    }
+  }
+  return [cacheMap, validatePK8(ret, pkType)];
+};
+
+// src/ops/facet.ts
+var logger12 = logger_default.get("facet");
+var facet = async (api, cacheMap, key, facet2, params = {}) => {
+  logger12.default("facet", { key, facet: facet2 });
+  const ret = await api.facet(key, facet2, params);
+  return [cacheMap, ret];
+};
+
+// src/ops/allFacet.ts
+var logger13 = logger_default.get("allFacet");
+var allFacet = async (api, cacheMap, facet2, params = {}, locations = []) => {
+  logger13.default("allFacet", { facet: facet2, params, locations });
+  const ret = await api.allFacet(facet2, params, locations);
+  return [cacheMap, ret];
+};
+
+// src/ops/find.ts
+import {
+  validatePK as validatePK9
+} from "@fjell/core";
+var logger14 = logger_default.get("find");
+var find = async (api, cacheMap, pkType, finder, params = {}, locations = []) => {
+  logger14.default("find", { finder, params, locations });
+  const ret = await api.find(finder, params, locations);
+  ret.forEach((v) => {
+    cacheMap.set(v.key, v);
+  });
+  return [cacheMap, validatePK9(ret, pkType)];
+};
+
+// src/ops/findOne.ts
+import {
+  validatePK as validatePK10
+} from "@fjell/core";
+var logger15 = logger_default.get("findOne");
+var findOne = async (api, cacheMap, pkType, finder, finderParams = {}, locations = []) => {
+  logger15.default("findOne", { finder, finderParams, locations });
+  const ret = await api.findOne(finder, finderParams, locations);
+  cacheMap.set(ret.key, ret);
+  return [cacheMap, validatePK10(ret, pkType)];
+};
+
+// src/ops/set.ts
+import {
+  isItemKeyEqual,
+  isValidItemKey as isValidItemKey6,
+  validatePK as validatePK11
+} from "@fjell/core";
+var logger16 = logger_default.get("set");
+var normalizeKeyValue2 = (value) => {
+  return String(value);
+};
+var isItemKeyEqualNormalized = (a, b) => {
+  const normalizedA = normalizeKey(a);
+  const normalizedB = normalizeKey(b);
+  return isItemKeyEqual(normalizedA, normalizedB);
+};
+var normalizeKey = (key) => {
+  if (typeof key === "object" && key !== null) {
+    const normalizedKey = JSON.parse(JSON.stringify(key));
+    if ("pk" in normalizedKey && normalizedKey.pk !== null) {
+      normalizedKey.pk = normalizeKeyValue2(normalizedKey.pk);
+    }
+    if ("lk" in normalizedKey && normalizedKey.lk !== null) {
+      normalizedKey.lk = normalizeKeyValue2(normalizedKey.lk);
+    }
+    if ("loc" in normalizedKey && Array.isArray(normalizedKey.loc)) {
+      normalizedKey.loc = normalizedKey.loc.map((locItem) => {
+        if (locItem && "lk" in locItem && locItem.lk !== null) {
+          return { ...locItem, lk: normalizeKeyValue2(locItem.lk) };
+        }
+        return locItem;
+      });
+    }
+    return normalizedKey;
+  }
+  return key;
+};
+var set = async (cacheMap, pkType, key, v) => {
+  logger16.default("set", { key, v });
+  if (!isValidItemKey6(key)) {
+    logger16.error("Key for Set is not a valid ItemKey: %j", key);
+    throw new Error("Key for Set is not a valid ItemKey");
+  }
+  validatePK11(v, pkType);
+  if (!isItemKeyEqualNormalized(key, v.key)) {
+    logger16.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, validatePK11(v, pkType)];
+};
+
+// src/ops/reset.ts
+var reset = async (coordinate) => {
+  const cacheMap = new CacheMap(coordinate.kta);
+  return [cacheMap];
+};
+
+// src/Operations.ts
+var createOperations = (api, coordinate, cacheMap, pkType) => {
+  return {
+    all: (query, locations) => all(api, cacheMap, pkType, query, locations),
+    one: (query, locations) => one(api, cacheMap, pkType, query, locations),
+    create: (item, locations) => create(api, cacheMap, pkType, item, locations),
+    get: (key) => get(api, cacheMap, pkType, key),
+    retrieve: (key) => retrieve(api, cacheMap, pkType, key),
+    remove: (key) => remove(api, cacheMap, key),
+    update: (key, item) => update(api, cacheMap, pkType, key, item),
+    action: (key, actionName, body) => action(api, cacheMap, pkType, key, actionName, body),
+    allAction: (actionName, body, locations) => allAction(api, cacheMap, pkType, actionName, body, locations),
+    facet: (key, facetName, params) => facet(api, cacheMap, key, facetName, params),
+    allFacet: (facetName, params, locations) => allFacet(api, cacheMap, facetName, params, locations),
+    find: (finder, params, locations) => find(api, cacheMap, pkType, finder, params, locations),
+    findOne: (finder, params, locations) => findOne(api, cacheMap, pkType, finder, params, locations),
+    set: (key, item) => set(cacheMap, pkType, key, item),
+    reset: () => reset(coordinate)
+  };
+};
+
+// src/Cache.ts
+var logger17 = logger_default.get("Cache");
+var createCache = (api, coordinate, registry) => {
+  logger17.debug("createCache", { coordinate, registry });
+  const cacheMap = new CacheMap(coordinate.kta);
+  const pkType = coordinate.kta[0];
+  const operations = createOperations(api, coordinate, cacheMap, pkType);
+  return {
+    coordinate,
+    registry,
+    api,
+    cacheMap,
+    operations
+  };
+};
+var isCache = (cache) => {
+  return cache !== null && typeof cache === "object" && "coordinate" in cache && "registry" in cache && "api" in cache && "cacheMap" in cache && "operations" in cache;
+};
+
+// src/Instance.ts
+var logger18 = logger_default.get("Instance");
+var createInstance = (registry, coordinate, api) => {
+  logger18.debug("createInstance", { coordinate, api, registry });
+  return createCache(api, coordinate, registry);
+};
+var isInstance = (instance) => {
+  return instance !== null && typeof instance === "object" && "coordinate" in instance && "registry" in instance && "api" in instance && "cacheMap" in instance && "operations" in instance;
+};
+
+// src/InstanceFactory.ts
+var logger19 = logger_default.get("InstanceFactory");
+var createInstanceFactory = (api) => {
+  return (coordinate, context) => {
+    logger19.debug("Creating cache instance", { coordinate, registry: context.registry, api });
+    const cacheMap = new CacheMap(coordinate.kta);
+    const pkType = coordinate.kta[0];
+    const operations = createOperations(api, coordinate, cacheMap, pkType);
+    return {
+      coordinate,
+      registry: context.registry,
+      api,
+      cacheMap,
+      operations
+    };
+  };
+};
+
+// src/Registry.ts
+import {
+  createRegistry as createBaseRegistry
+} from "@fjell/registry";
+var logger20 = logger_default.get("Registry");
+var createRegistryFactory = () => {
+  return (type, registryHub) => {
+    if (type !== "cache") {
+      throw new Error(`Cache registry factory can only create 'cache' type registries, got: ${type}`);
+    }
+    logger20.debug("Creating cache registry", { type, registryHub });
+    const baseRegistry = createBaseRegistry(type, registryHub);
+    return baseRegistry;
+  };
+};
+var createRegistry = (registryHub) => {
+  const baseRegistry = createBaseRegistry("cache", registryHub);
+  return {
+    ...baseRegistry
+  };
+};
+export {
+  CacheMap,
+  createAggregator,
+  createCache,
+  createInstance,
+  createInstanceFactory,
+  createOperations,
+  createRegistry,
+  createRegistryFactory,
+  isCache,
+  isInstance,
+  toCacheConfig
+};
+//# sourceMappingURL=index.js.map