@fjell/cache 4.5.2 → 4.6.0

package/dist/index.cjs

@@ -0,0 +1,696 @@
+'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 LibLogger = Logging.getLogger('@fjellproject/cache');
+
+const logger$3 = LibLogger.get('ItemAggregator');
+const toCacheConfig = (config)=>{
+    let cacheConfig;
+    if (config.optional === undefined) {
+        cacheConfig = {
+            cache: config,
+            optional: false
+        };
+    } else {
+        cacheConfig = config;
+    }
+    return cacheConfig;
+};
+const createAggregator = (cache, { aggregates = {}, events = {} })=>{
+    const populate = async (item)=>{
+        logger$3.default('populate', {
+            item
+        });
+        for(const key in aggregates){
+            await populateAggregate(key, item);
+        }
+        for(const key in events){
+            await populateEvent(key, item);
+        }
+        logger$3.default('populate done', {
+            item
+        });
+        return item;
+    };
+    const populateAggregate = async (key, item)=>{
+        logger$3.default('populate aggregate key', {
+            key
+        });
+        const cacheConfig = toCacheConfig(aggregates[key]);
+        if (item.refs === undefined) {
+            if (cacheConfig.optional === false) {
+                logger$3.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$3.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$3.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
+                };
+            }
+        }
+    };
+    // 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$3.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$3.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$3.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$3.default('EVENT Retrieving Item in Populate', {
+                key: event.by
+            });
+            const [, newItem] = await cacheConfig.cache.retrieve(event.by);
+            if (newItem) {
+                event.agg = newItem;
+            }
+        }
+    };
+    const all = async (query = {}, locations = [])=>{
+        logger$3.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 = {}, locations = [])=>{
+        logger$3.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, action, body = {})=>{
+        logger$3.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, body = {}, locations = [])=>{
+        logger$3.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, locations = [])=>{
+        logger$3.default('create', {
+            v,
+            locations
+        });
+        const [cacheMap, item] = await cache.create(v, locations);
+        const populatedItem = await populate(item);
+        return [
+            cacheMap,
+            populatedItem
+        ];
+    };
+    const get = async (key)=>{
+        logger$3.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)=>{
+        logger$3.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)=>{
+        logger$3.default('remove', {
+            key
+        });
+        const cacheMap = await cache.remove(key);
+        return cacheMap;
+    };
+    const update = async (key, v)=>{
+        logger$3.default('update', {
+            key,
+            v
+        });
+        const [cacheMap, item] = await cache.update(key, v);
+        const populatedItem = await populate(item);
+        return [
+            cacheMap,
+            populatedItem
+        ];
+    };
+    const find = async (finder, finderParams, locations = [])=>{
+        logger$3.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, v)=>{
+        logger$3.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 ()=>{
+        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
+    };
+};
+
+function _define_property$1(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$2 = LibLogger.get("CacheMap");
+// 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$2.debug('Returning all items, LocKeys is empty');
+            return this.values();
+        } else {
+            const locKeys = locations;
+            logger$2.debug('allIn', {
+                locKeys,
+                keys: this.keys().length
+            });
+            return this.keys().filter((key)=>key && core.isComKey(key)).filter((key)=>{
+                const ComKey = key;
+                logger$2.debug('Comparing Location Keys', {
+                    locKeys,
+                    ComKey
+                });
+                return JSON.stringify(locKeys) === JSON.stringify(ComKey.loc);
+            }).map((key)=>this.get(key));
+        }
+    }
+    // TODO: Can we do case insensitive matching?
+    contains(query, locations) {
+        logger$2.debug('contains', {
+            query,
+            locations
+        });
+        const items = this.allIn(locations);
+        return items.some((item)=>core.isQueryMatch(item, query));
+    }
+    queryIn(query, locations = []) {
+        logger$2.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), _define_property$1(this, "types", void 0);
+        this.types = types;
+    }
+}
+
+const logger$1 = LibLogger.get('Cache');
+const createCache = (api, pkType, parentCache)=>{
+    let pkTypes = [
+        pkType
+    ];
+    if (parentCache) {
+        pkTypes = pkTypes.concat(parentCache.pkTypes);
+    }
+    let cacheMap = new CacheMap(pkTypes);
+    const all = async (query = {}, locations = [])=>{
+        logger$1.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 one = async (query = {}, locations = [])=>{
+        logger$1.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 action = async (key, action, body = {})=>{
+        logger$1.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 (!core.isValidItemKey(key)) {
+            logger$1.error('Key for Action is not a valid ItemKey: %j', key);
+            throw new Error('Key for Action is not a valid ItemKey');
+        }
+        const updated = await api.action(key, action, body, {});
+        cacheMap.set(updated.key, updated);
+        return [
+            cacheMap,
+            core.validatePK(updated, pkType)
+        ];
+    };
+    const allAction = async (action, body = {}, locations = [])=>{
+        logger$1.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 create = async (v, locations = [])=>{
+        logger$1.default('create', {
+            v,
+            locations
+        });
+        const created = await api.create(v, {}, locations);
+        cacheMap.set(created.key, created);
+        return [
+            cacheMap,
+            core.validatePK(created, pkType)
+        ];
+    };
+    const get = async (key)=>{
+        logger$1.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 (!core.isValidItemKey(key)) {
+            logger$1.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$1.error("Error getting item for key", {
+                key,
+                message: e.message,
+                stack: e.stack
+            });
+            throw e;
+        }
+        return [
+            cacheMap,
+            ret ? core.validatePK(ret, pkType) : null
+        ];
+    };
+    const retrieve = async (key)=>{
+        logger$1.default('retrieve', {
+            key
+        });
+        if (!core.isValidItemKey(key)) {
+            logger$1.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$1.default('Looking for Object in Cache', key);
+            retrieved = cacheMap.get(key);
+        } else {
+            logger$1.default('Object Not Found in Cache, Retrieving from Server API', {
+                key
+            });
+            [, retrieved] = await get(key);
+        }
+        const retValue = [
+            containsItemKey ? null : cacheMap,
+            retrieved ? core.validatePK(retrieved, pkType) : null
+        ];
+        // logger.debug('Returning from retrieve', { retValue });
+        return retValue;
+    };
+    const remove = async (key)=>{
+        logger$1.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 (!core.isValidItemKey(key)) {
+            logger$1.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$1.error("Error deleting item", {
+                error: e
+            });
+            throw e;
+        }
+        return cacheMap;
+    };
+    const update = async (key, v)=>{
+        logger$1.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 (!core.isValidItemKey(key)) {
+            logger$1.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$1.error("Error updating chat", {
+                error: e
+            });
+            throw e;
+        }
+    };
+    const find = async (finder, finderParams, locations = [])=>{
+        logger$1.default('find', {
+            finder,
+            finderParams,
+            locations
+        });
+        const ret = await api.find(finder, finderParams, {}, locations);
+        ret.forEach((v)=>{
+            cacheMap.set(v.key, v);
+        });
+        return [
+            cacheMap,
+            core.validatePK(ret, pkType)
+        ];
+    };
+    const reset = async ()=>{
+        cacheMap = new CacheMap(pkTypes);
+        return [
+            cacheMap
+        ];
+    };
+    const set = async (key, v)=>{
+        logger$1.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 (!core.isValidItemKey(key)) {
+            logger$1.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.
+        core.validatePK(v, pkType);
+        if (!core.isItemKeyEqual(key, v.key)) {
+            logger$1.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)
+        ];
+    };
+    return {
+        all,
+        one,
+        action,
+        allAction,
+        create,
+        get,
+        retrieve,
+        remove,
+        update,
+        find,
+        reset,
+        set,
+        pkTypes,
+        cacheMap
+    };
+};
+
+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 = LibLogger.get('CacheRegistry');
+class CacheRegistry {
+    static getInstance() {
+        if (!CacheRegistry.instance) {
+            CacheRegistry.instance = new CacheRegistry();
+        }
+        return CacheRegistry.instance;
+    }
+    constructor(){
+        _define_property(this, "configured", false);
+        // TODO: My use of Generics has Boxed me into a corner where I can't reference AbstractCache without the types
+        _define_property(this, "cacheMap", {});
+        _define_property(this, "registerCache", (cache)=>{
+            this.cacheMap[JSON.stringify(cache.pkTypes)] = cache;
+        });
+        _define_property(this, "isConfigured", ()=>{
+            return this.configured;
+        });
+        _define_property(this, "markConfigured", ()=>{
+            this.configured = true;
+        });
+        _define_property(this, "getCache", (kts)=>{
+            if (!this.configured) {
+                logger.error('CacheRegistry must be configured before use');
+                throw new Error("CacheRegistry must be configured before use");
+            }
+            return this.cacheMap[JSON.stringify(kts)];
+        });
+        logger.debug('CacheRegistry created');
+    }
+}
+_define_property(CacheRegistry, "instance", void 0);
+
+exports.CacheMap = CacheMap;
+exports.CacheRegistry = CacheRegistry;
+exports.createAggregator = createAggregator;
+exports.createCache = createCache;
+exports.toCacheConfig = toCacheConfig;
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.js

@@ -0,0 +1,17 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const Aggregator = require('./Aggregator.cjs.js');
+const Cache = require('./Cache.cjs.js');
+const CacheMap = require('./CacheMap.cjs.js');
+const CacheRegistry = require('./CacheRegistry.cjs.js');
+
+
+
+exports.createAggregator = Aggregator.createAggregator;
+exports.toCacheConfig = Aggregator.toCacheConfig;
+exports.createCache = Cache.createCache;
+exports.CacheMap = CacheMap.CacheMap;
+exports.CacheRegistry = CacheRegistry.CacheRegistry;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguY2pzLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}