@fjell/cache 4.6.13 → 4.6.15

package/dist/index.cjs

@@ -1,940 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-const Logging = require('@fjell/logging');
-const core = require('@fjell/core');
-const httpApi = require('@fjell/http-api');
-const registry = require('@fjell/registry');
-
-const logger$1.default = Logging.getLogger('@fjell/cache');
-
-const logger$j = logger$1.default.get('ItemAggregator');
-const toCacheConfig = (config)=>{
-    let cacheConfig;
-    if (config.optional === undefined) {
-        cacheConfig = {
-            cache: config,
-            optional: false
-        };
-    } else {
-        cacheConfig = config;
-    }
-    return cacheConfig;
-};
-const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
-    const populate = async (item)=>{
-        logger$j.default('populate', {
-            item
-        });
-        for(const key in aggregates){
-            await populateAggregate(key, item);
-        }
-        for(const key in events){
-            await populateEvent(key, item);
-        }
-        logger$j.default('populate done', {
-            item
-        });
-        return item;
-    };
-    const populateAggregate = async (key, item)=>{
-        logger$j.default('populate aggregate key', {
-            key
-        });
-        const cacheConfig = toCacheConfig(aggregates[key]);
-        if (item.refs === undefined) {
-            if (cacheConfig.optional === false) {
-                logger$j.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] === undefined) {
-            if (cacheConfig.optional === false) {
-                logger$j.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$j.default('AGG Retrieving Item in Populate', {
-                key: ref
-            });
-            const [, newItem] = await cacheConfig.cache.operations.retrieve(ref);
-            if (newItem) {
-                if (item.aggs === undefined) {
-                    item.aggs = {};
-                }
-                item.aggs[key] = {
-                    key: ref,
-                    item: newItem
-                };
-            }
-        }
-    };
-    // 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, item)=>{
-        logger$j.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$j.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$j.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$j.default('EVENT Retrieving Item in Populate', {
-                key: event.by
-            });
-            const [, newItem] = await cacheConfig.cache.operations.retrieve(event.by);
-            if (newItem) {
-                event.agg = newItem;
-            }
-        }
-    };
-    const all = async (query = {}, locations = [])=>{
-        logger$j.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 one = async (query = {}, locations = [])=>{
-        logger$j.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 action = async (key, action, body = {})=>{
-        logger$j.default('action', {
-            key,
-            action,
-            body
-        });
-        const [cacheMap, item] = await cache.operations.action(key, action, body);
-        const populatedItem = await populate(item);
-        return [
-            cacheMap,
-            populatedItem
-        ];
-    };
-    const allAction = async (action, body = {}, locations = [])=>{
-        logger$j.default('action', {
-            action,
-            body,
-            locations
-        });
-        const [cacheMap, items] = await cache.operations.allAction(action, body, locations);
-        const populatedItems = await Promise.all(items.map(async (item)=>populate(item)));
-        return [
-            cacheMap,
-            populatedItems
-        ];
-    };
-    const allFacet = async (facet, params = {}, locations = [])=>{
-        logger$j.default('allFacet', {
-            facet,
-            params,
-            locations
-        });
-        const [cacheMap, response] = await cache.operations.allFacet(facet, params, locations);
-        return [
-            cacheMap,
-            response
-        ];
-    };
-    const create = async (v, locations = [])=>{
-        logger$j.default('create', {
-            v,
-            locations
-        });
-        const [cacheMap, item] = await cache.operations.create(v, locations);
-        const populatedItem = await populate(item);
-        return [
-            cacheMap,
-            populatedItem
-        ];
-    };
-    const get = async (key)=>{
-        logger$j.default('get', {
-            key
-        });
-        const [cacheMap, item] = await cache.operations.get(key);
-        let populatedItem = null;
-        if (item) {
-            populatedItem = await populate(item);
-        }
-        return [
-            cacheMap,
-            populatedItem
-        ];
-    };
-    const retrieve = async (key)=>{
-        logger$j.default('retrieve', {
-            key
-        });
-        const [cacheMap, item] = await cache.operations.retrieve(key);
-        let populatedItem = null;
-        if (item) {
-            populatedItem = await populate(item);
-        }
-        return [
-            cacheMap,
-            populatedItem
-        ];
-    };
-    const remove = async (key)=>{
-        logger$j.default('remove', {
-            key
-        });
-        const cacheMap = await cache.operations.remove(key);
-        return cacheMap;
-    };
-    const update = async (key, v)=>{
-        logger$j.default('update', {
-            key,
-            v
-        });
-        const [cacheMap, item] = await cache.operations.update(key, v);
-        const populatedItem = await populate(item);
-        return [
-            cacheMap,
-            populatedItem
-        ];
-    };
-    // Facets are a pass-thru for aggregators
-    const facet = async (key, facet)=>{
-        logger$j.default('facet', {
-            key,
-            facet
-        });
-        const [cacheMap, response] = await cache.operations.facet(key, facet);
-        return [
-            cacheMap,
-            response
-        ];
-    };
-    const find = async (finder, finderParams = {}, locations = [])=>{
-        logger$j.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 findOne = async (finder, finderParams = {}, locations = [])=>{
-        logger$j.default('find', {
-            finder,
-            finderParams,
-            locations
-        });
-        const [cacheMap, item] = await cache.operations.findOne(finder, finderParams, locations);
-        const populatedItem = await populate(item);
-        return [
-            cacheMap,
-            populatedItem
-        ];
-    };
-    const set = async (key, v)=>{
-        logger$j.default('set', {
-            key,
-            v
-        });
-        // TODO: There should be some input validation here to ensure a valid item.
-        const [cacheMap, item] = await cache.operations.set(key, v);
-        const populatedItem = await populate(item);
-        return [
-            cacheMap,
-            populatedItem
-        ];
-    };
-    const reset = 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,
-        one,
-        action,
-        allAction,
-        allFacet,
-        create,
-        get,
-        retrieve,
-        remove,
-        update,
-        facet,
-        find,
-        findOne,
-        reset,
-        set,
-        // Aggregator-specific operations
-        populate,
-        populateAggregate,
-        populateEvent
-    };
-};
-
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-const logger$i = logger$1.default.get("CacheMap");
-// Normalize a key value to string for consistent comparison and hashing
-const normalizeKeyValue$1 = (value)=>{
-    return String(value);
-};
-// Normalized hash function for Dictionary that converts pk/lk values to strings
-const createNormalizedHashFunction = ()=>{
-    return (key)=>{
-        if (typeof key === 'object' && key !== null) {
-            // Create a normalized version of the key with string values
-            const normalizedKey = JSON.parse(JSON.stringify(key));
-            // Normalize pk values
-            if ('pk' in normalizedKey && normalizedKey.pk !== null) {
-                normalizedKey.pk = normalizeKeyValue$1(normalizedKey.pk);
-            }
-            // Normalize lk values
-            if ('lk' in normalizedKey && normalizedKey.lk !== null) {
-                normalizedKey.lk = normalizeKeyValue$1(normalizedKey.lk);
-            }
-            // Normalize loc array lk values
-            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$1(locItem.lk)
-                        };
-                    }
-                    return locItem;
-                });
-            }
-            return JSON.stringify(normalizedKey);
-        }
-        return JSON.stringify(key);
-    };
-};
-// Helper function to normalize and compare location key arrays
-const 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;
-};
-// Helper function to normalize a location key item
-const normalizeLocKeyItem = (item)=>{
-    if (typeof item === 'object' && item !== null) {
-        const normalized = {
-            ...item
-        };
-        if ('lk' in normalized && normalized.lk !== null) {
-            normalized.lk = normalizeKeyValue$1(normalized.lk);
-        }
-        return normalized;
-    }
-    return item;
-};
-// const isObj = (x: any) => typeof x === "object" && x !== null;
-// const intersection = (a: object, b: object): object => {
-//   const result: { [key: string]: any } = {}
-//   if (([a, b]).every(isObj)) {
-//     Object.keys(a).forEach((key) => {
-//       // @ts-ignore
-//       const value = a[key]
-//       // @ts-ignore
-//       const other = b[key]
-//       if (isObj(value)) {
-//         result[key] = intersection(value, other)
-//       } else if (value === other) {
-//         result[key] = value
-//       }
-//     })
-//   }
-//   return result
-// }
-// const removeEmptyObjects = (obj: object): object => {
-//   const result: { [key: string]: any } = {}
-//   Object.keys(obj).forEach((key) => {
-//     // @ts-ignore
-//     const value = obj[key];
-//     if (isObj(value)) {
-//       const nested = removeEmptyObjects(value);
-//       if (Object.keys(nested).length > 0) {
-//         result[key] = nested
-//       }
-//     } else if (value !== null) {
-//       result[key] = value
-//     }
-//   });
-//   return result;
-// }
-class CacheMap extends core.Dictionary {
-    get(key) {
-        return super.get(key);
-    }
-    allIn(locations) {
-        if (locations.length === 0) {
-            logger$i.debug('Returning all items, LocKeys is empty');
-            return this.values();
-        } else {
-            const locKeys = locations;
-            logger$i.debug('allIn', {
-                locKeys,
-                keys: this.keys().length
-            });
-            return this.keys().filter((key)=>key && core.isComKey(key)).filter((key)=>{
-                const ComKey = key;
-                logger$i.debug('Comparing Location Keys', {
-                    locKeys,
-                    ComKey
-                });
-                return isLocKeyArrayEqual(locKeys, ComKey.loc);
-            }).map((key)=>this.get(key));
-        }
-    }
-    // TODO: Can we do case insensitive matching?
-    contains(query, locations) {
-        logger$i.debug('contains', {
-            query,
-            locations
-        });
-        const items = this.allIn(locations);
-        return items.some((item)=>core.isQueryMatch(item, query));
-    }
-    queryIn(query, locations = []) {
-        logger$i.debug('queryIn', {
-            query,
-            locations
-        });
-        const items = this.allIn(locations);
-        return items.filter((item)=>core.isQueryMatch(item, query));
-    }
-    clone() {
-        const clone = new CacheMap(this.types, this.map);
-        return clone;
-    }
-    constructor(types, map){
-        super(map, createNormalizedHashFunction()), _define_property(this, "types", void 0);
-        this.types = types;
-    }
-}
-
-const logger$h = logger$1.default.get('all');
-const all = async (api, cacheMap, pkType, query = {}, locations = [])=>{
-    logger$h.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 httpApi.NotFoundError) ; else {
-            throw e;
-        }
-    }
-    return [
-        cacheMap,
-        core.validatePK(ret, pkType)
-    ];
-};
-
-const logger$g = logger$1.default.get('one');
-const one = async (api, cacheMap, pkType, query = {}, locations = [])=>{
-    logger$g.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 httpApi.NotFoundError) ; else {
-            throw e;
-        }
-    }
-    return [
-        cacheMap,
-        retItem ? core.validatePK(retItem, pkType) : null
-    ];
-};
-
-const logger$f = logger$1.default.get('create');
-const create = async (api, cacheMap, pkType, v, locations = [])=>{
-    logger$f.default('create', {
-        v,
-        locations
-    });
-    const created = await api.create(v, locations);
-    cacheMap.set(created.key, created);
-    return [
-        cacheMap,
-        core.validatePK(created, pkType)
-    ];
-};
-
-const logger$e = logger$1.default.get('get');
-const get.get = async (api, cacheMap, pkType, key)=>{
-    logger$e.default('get', {
-        key
-    });
-    if (!core.isValidItemKey(key)) {
-        logger$e.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) {
-        logger$e.error("Error getting item for key", {
-            key,
-            message: e.message,
-            stack: e.stack
-        });
-        throw e;
-    }
-    return [
-        cacheMap,
-        ret ? core.validatePK(ret, pkType) : null
-    ];
-};
-
-const logger$d = logger$1.default.get('retrieve');
-const retrieve = async (api, cacheMap, pkType, key)=>{
-    logger$d.default('retrieve', {
-        key
-    });
-    if (!core.isValidItemKey(key)) {
-        logger$d.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) {
-        logger$d.default('Looking for Object in Cache', key);
-        retrieved = cacheMap.get(key);
-    } else {
-        logger$d.default('Object Not Found in Cache, Retrieving from Server API', {
-            key
-        });
-        [, retrieved] = await get.get(api, cacheMap, pkType, key);
-    }
-    const retValue = [
-        containsItemKey ? null : cacheMap,
-        retrieved ? core.validatePK(retrieved, pkType) : null
-    ];
-    return retValue;
-};
-
-const logger$c = logger$1.default.get('remove');
-const remove = async (api, cacheMap, key)=>{
-    logger$c.default('remove', {
-        key
-    });
-    if (!core.isValidItemKey(key)) {
-        logger$c.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$c.error("Error deleting item", {
-            error: e
-        });
-        throw e;
-    }
-    return cacheMap;
-};
-
-const logger$b = logger$1.default.get('update');
-const update = async (api, cacheMap, pkType, key, v)=>{
-    logger$b.default('update', {
-        key,
-        v
-    });
-    if (!core.isValidItemKey(key)) {
-        logger$b.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,
-            core.validatePK(updated, pkType)
-        ];
-    } catch (e) {
-        logger$b.error("Error updating item", {
-            error: e
-        });
-        throw e;
-    }
-};
-
-const logger$a = logger$1.default.get('action');
-const action = async (api, cacheMap, pkType, key, action, body = {})=>{
-    logger$a.default('action', {
-        key,
-        action,
-        body
-    });
-    if (!core.isValidItemKey(key)) {
-        logger$a.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,
-        core.validatePK(updated, pkType)
-    ];
-};
-
-const logger$9 = logger$1.default.get('allAction');
-const allAction = async (api, cacheMap, pkType, action, body = {}, locations = [])=>{
-    logger$9.default('allAction', {
-        action,
-        body,
-        locations
-    });
-    let ret = [];
-    try {
-        ret = await api.allAction(action, body, locations);
-        ret.forEach((v)=>{
-            cacheMap.set(v.key, v);
-        });
-    } catch (e) {
-        // istanbul ignore next
-        if (e instanceof httpApi.NotFoundError) ; else {
-            throw e;
-        }
-    }
-    return [
-        cacheMap,
-        core.validatePK(ret, pkType)
-    ];
-};
-
-const logger$8 = logger$1.default.get('facet');
-const facet = async (api, cacheMap, key, facet, params = {})=>{
-    logger$8.default('facet', {
-        key,
-        facet
-    });
-    const ret = await api.facet(key, facet, params);
-    return [
-        cacheMap,
-        ret
-    ];
-};
-
-const logger$7 = logger$1.default.get('allFacet');
-const allFacet = async (api, cacheMap, facet, params = {}, locations = [])=>{
-    logger$7.default('allFacet', {
-        facet,
-        params,
-        locations
-    });
-    const ret = await api.allFacet(facet, params, locations);
-    return [
-        cacheMap,
-        ret
-    ];
-};
-
-const logger$6 = logger$1.default.get('find');
-const find = async (api, cacheMap, pkType, finder, params = {}, locations = [])=>{
-    logger$6.default('find', {
-        finder,
-        params,
-        locations
-    });
-    const ret = await api.find(finder, params, locations);
-    ret.forEach((v)=>{
-        cacheMap.set(v.key, v);
-    });
-    return [
-        cacheMap,
-        core.validatePK(ret, pkType)
-    ];
-};
-
-const logger$5 = logger$1.default.get('findOne');
-const findOne = async (api, cacheMap, pkType, finder, finderParams = {}, locations = [])=>{
-    logger$5.default('findOne', {
-        finder,
-        finderParams,
-        locations
-    });
-    const ret = await api.findOne(finder, finderParams, locations);
-    cacheMap.set(ret.key, ret);
-    return [
-        cacheMap,
-        core.validatePK(ret, pkType)
-    ];
-};
-
-const logger$4 = logger$1.default.get('set');
-// Normalize a key value to string for consistent comparison
-const normalizeKeyValue = (value)=>{
-    return String(value);
-};
-// Normalized key comparison function that handles string/number differences
-const isItemKeyEqualNormalized = (a, b)=>{
-    // For now, just normalize the keys to strings and use the original comparison
-    const normalizedA = normalizeKey(a);
-    const normalizedB = normalizeKey(b);
-    return core.isItemKeyEqual(normalizedA, normalizedB);
-};
-// Helper function to normalize a key
-const normalizeKey = (key)=>{
-    if (typeof key === 'object' && key !== null) {
-        const normalizedKey = JSON.parse(JSON.stringify(key));
-        // Normalize pk values
-        if ('pk' in normalizedKey && normalizedKey.pk !== null) {
-            normalizedKey.pk = normalizeKeyValue(normalizedKey.pk);
-        }
-        // Normalize lk values
-        if ('lk' in normalizedKey && normalizedKey.lk !== null) {
-            normalizedKey.lk = normalizeKeyValue(normalizedKey.lk);
-        }
-        // Normalize loc array lk values
-        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 normalizedKey;
-    }
-    return key;
-};
-const set = async (cacheMap, pkType, key, v)=>{
-    logger$4.default('set', {
-        key,
-        v
-    });
-    if (!core.isValidItemKey(key)) {
-        logger$4.error('Key for Set is not a valid ItemKey: %j', key);
-        throw new Error('Key for Set is not a valid ItemKey');
-    }
-    // Validate the item's primary key
-    core.validatePK(v, pkType);
-    if (!isItemKeyEqualNormalized(key, v.key)) {
-        logger$4.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,
-        core.validatePK(v, pkType)
-    ];
-};
-
-const reset = async (coordinate)=>{
-    const cacheMap = new CacheMap(coordinate.kta);
-    return [
-        cacheMap
-    ];
-};
-
-// Import all operation functions
-const 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.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)
-    };
-};
-
-const logger$3 = logger$1.default.get('Cache');
-const createCache = async (api, coordinate, registry)=>{
-    logger$3.debug('createCache', {
-        coordinate,
-        registry
-    });
-    // Create the cache map using the coordinate's key type array
-    const cacheMap = new CacheMap(coordinate.kta);
-    // Get the primary key type from the coordinate
-    const pkType = coordinate.kta[0];
-    // Create operations
-    const operations = createOperations(api, coordinate, cacheMap, pkType);
-    return {
-        coordinate,
-        registry,
-        api,
-        cacheMap,
-        operations
-    };
-};
-const isCache = (cache)=>{
-    return cache !== null && typeof cache === 'object' && 'coordinate' in cache && 'registry' in cache && 'api' in cache && 'cacheMap' in cache && 'operations' in cache;
-};
-
-const logger$2 = logger$1.default.get("Instance");
-const createInstance = async (registry, coordinate, api)=>{
-    logger$2.debug("createInstance", {
-        coordinate,
-        api,
-        registry
-    });
-    return await createCache(api, coordinate, registry);
-};
-const isInstance = (instance)=>{
-    return instance !== null && typeof instance === 'object' && 'coordinate' in instance && 'registry' in instance && 'api' in instance && 'cacheMap' in instance && 'operations' in instance;
-};
-
-const logger$1 = logger$1.default.get("InstanceFactory");
-/**
- * Factory function for creating cache instances
- */ const createInstanceFactory = (api)=>{
-    return (coordinate, context)=>{
-        logger$1.debug("Creating cache instance", {
-            coordinate,
-            registry: context.registry,
-            api
-        });
-        // Since InstanceFactory must be synchronous but our createInstance is async,
-        // we need to create a special cache instance synchronously and defer the async initialization
-        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
-        };
-    };
-};
-
-const logger = logger$1.default.get("Registry");
-/**
- * Factory function for creating cache registries
- */ const createRegistryFactory = ()=>{
-    return (type, registryHub)=>{
-        if (type !== 'cache') {
-            throw new Error(`Cache registry factory can only create 'cache' type registries, got: ${type}`);
-        }
-        logger.debug("Creating cache registry", {
-            type,
-            registryHub
-        });
-        const baseRegistry = registry.createRegistry(type, registryHub);
-        // Cast to Registry for type safety
-        return baseRegistry;
-    };
-};
-/**
- * Creates a new cache registry instance
- */ const createRegistry = (registryHub)=>{
-    const baseRegistry = registry.createRegistry('cache', registryHub);
-    return {
-        ...baseRegistry
-    };
-};
-
-exports.CacheMap = CacheMap;
-exports.createAggregator = createAggregator;
-exports.createCache = createCache;
-exports.createInstance = createInstance;
-exports.createInstanceFactory = createInstanceFactory;
-exports.createOperations = createOperations;
-exports.createRegistry = createRegistry;
-exports.createRegistryFactory = createRegistryFactory;
-exports.isCache = isCache;
-exports.isInstance = isInstance;
-exports.toCacheConfig = toCacheConfig;
-//# sourceMappingURL=index.cjs.map