@fjell/cache 4.5.2 → 4.6.1

package/.kodrdriv/config.yaml

@@ -0,0 +1,10 @@
+verbose: false
+model: gpt-4.1
+contextDirectories:
+  - .kodrdriv/context
+commit:
+  cached: true
+  sendit: true
+release:
+  from: main
+  to: HEAD

package/.kodrdriv/context/content.md

@@ -0,0 +1 @@
+This is the Fjell Library for Client-side Caches

package/dist/Aggregator.cjs.js

@@ -0,0 +1,276 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const logger$1 = require('./logger.cjs.js');
+
+const logger = 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.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 === 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.events && Object.prototype.hasOwnProperty.call(item.events, key)) {
+                    delete item.events[key];
+                }
+            }
+        } 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 {
+                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.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.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;
+            }
+        }
+    };
+    const all = async (query = {}, locations = [])=>{
+        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 = {}, locations = [])=>{
+        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, action, body = {})=>{
+        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, body = {}, locations = [])=>{
+        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, locations = [])=>{
+        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)=>{
+        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)=>{
+        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)=>{
+        logger.default('remove', {
+            key
+        });
+        const cacheMap = await cache.remove(key);
+        return cacheMap;
+    };
+    const update = async (key, 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, finderParams, locations = [])=>{
+        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, 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 ()=>{
+        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
+    };
+};
+
+exports.createAggregator = createAggregator;
+exports.toCacheConfig = toCacheConfig;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQWdncmVnYXRvci5janMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/{src/Aggregator.d.ts → Aggregator.d.ts}

@@ -1,5 +1,5 @@
-import { Item } from "@fjell/core";
-import { Cache } from "./Cache";
+import { Item } from '@fjell/core';
+import { Cache } from './Cache';
 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>;
@@ -16,4 +16,4 @@ export declare const toCacheConfig: <V extends Item<S, L1, L2, L3, L4, L5>, S ex
 export declare 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>;
+}) => Promise<Aggregator<V, S, L1, L2, L3, L4, L5>>;

package/dist/Aggregator.es.js

@@ -0,0 +1,271 @@
+import LibLogger from './logger.es.js';
+
+const logger = LibLogger.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.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 === 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.events && Object.prototype.hasOwnProperty.call(item.events, key)) {
+                    delete item.events[key];
+                }
+            }
+        } 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 {
+                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.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.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;
+            }
+        }
+    };
+    const all = async (query = {}, locations = [])=>{
+        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 = {}, locations = [])=>{
+        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, action, body = {})=>{
+        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, body = {}, locations = [])=>{
+        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, locations = [])=>{
+        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)=>{
+        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)=>{
+        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)=>{
+        logger.default('remove', {
+            key
+        });
+        const cacheMap = await cache.remove(key);
+        return cacheMap;
+    };
+    const update = async (key, 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, finderParams, locations = [])=>{
+        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, 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 ()=>{
+        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
+    };
+};
+
+export { createAggregator, toCacheConfig };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQWdncmVnYXRvci5lcy5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=