@fjell/cache 4.5.1 → 4.6.0

package/dist/Cache.cjs.js

@@ -0,0 +1,279 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@fjell/core');
+const CacheMap = require('./CacheMap.cjs.js');
+const logger$1 = require('./logger.cjs.js');
+const httpApi = require('@fjell/http-api');
+
+const logger = logger$1.default.get('Cache');
+const createCache = (api, pkType, parentCache)=>{
+    let pkTypes = [
+        pkType
+    ];
+    if (parentCache) {
+        pkTypes = pkTypes.concat(parentCache.pkTypes);
+    }
+    let cacheMap = new CacheMap.CacheMap(pkTypes);
+    const all = async (query = {}, locations = [])=>{
+        logger.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.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.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.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.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.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.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.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.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.default('retrieve', {
+            key
+        });
+        if (!core.isValidItemKey(key)) {
+            logger.error('Key for Retrieve is not a valid ItemKey: %j', key);
+            throw new Error('Key for Retrieve is not a valid ItemKey');
+        }
+        const containsItemKey = cacheMap.includesKey(key);
+        let retrieved;
+        if (containsItemKey) {
+            logger.default('Looking for Object in Cache', key);
+            retrieved = cacheMap.get(key);
+        } else {
+            logger.default('Object Not Found in Cache, Retrieving from Server API', {
+                key
+            });
+            [, retrieved] = await get(key);
+        }
+        const retValue = [
+            containsItemKey ? null : cacheMap,
+            retrieved ? core.validatePK(retrieved, pkType) : null
+        ];
+        // logger.debug('Returning from retrieve', { retValue });
+        return retValue;
+    };
+    const remove = async (key)=>{
+        logger.default('remove', {
+            key
+        });
+        // TODO: This is validating the key, but it doesn't have knowledge of the pkType
+        // This should be looking at the parentCaches and calculating an array of pkTypes
+        if (!core.isValidItemKey(key)) {
+            logger.error('Key for Remove is not a valid ItemKey: %j', key);
+            throw new Error('Key for Remove is not a valid ItemKey');
+        }
+        try {
+            await api.remove(key, {});
+            cacheMap.delete(key);
+        } catch (e) {
+            logger.error("Error deleting item", {
+                error: e
+            });
+            throw e;
+        }
+        return cacheMap;
+    };
+    const update = async (key, v)=>{
+        logger.default('update', {
+            key,
+            v
+        });
+        // TODO: This is validating the key, but it doesn't have knowledge of the pkType
+        // This should be looking at the parentCaches and calculating an array of pkTypes
+        if (!core.isValidItemKey(key)) {
+            logger.error('Key for Update is not a valid ItemKey: %j', key);
+            throw new Error('Key for Update is not a valid ItemKey');
+        }
+        try {
+            const updated = await api.update(key, v, {});
+            cacheMap.set(updated.key, updated);
+            return [
+                cacheMap,
+                core.validatePK(updated, pkType)
+            ];
+        } catch (e) {
+            logger.error("Error updating chat", {
+                error: e
+            });
+            throw e;
+        }
+    };
+    const find = async (finder, finderParams, locations = [])=>{
+        logger.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.CacheMap(pkTypes);
+        return [
+            cacheMap
+        ];
+    };
+    const set = async (key, v)=>{
+        logger.default('set', {
+            key,
+            v
+        });
+        // TODO: This is validating the key, but it doesn't have knowledge of the pkType
+        // This should be looking at the parentCaches and calculating an array of pkTypes
+        if (!core.isValidItemKey(key)) {
+            logger.error('Key for Update is not a valid ItemKey: %j', key);
+            throw new Error('Key for Update is not a valid ItemKey');
+        }
+        // TODO: This could be merged with the isValidItemKey check, later.
+        core.validatePK(v, pkType);
+        if (!core.isItemKeyEqual(key, v.key)) {
+            logger.error('Key does not match item key: %j != %j', key, v.key);
+            throw new Error('Key does not match item key');
+        }
+        cacheMap.set(key, v);
+        return [
+            cacheMap,
+            core.validatePK(v, pkType)
+        ];
+    };
+    return {
+        all,
+        one,
+        action,
+        allAction,
+        create,
+        get,
+        retrieve,
+        remove,
+        update,
+        find,
+        reset,
+        set,
+        pkTypes,
+        cacheMap
+    };
+};
+
+exports.createCache = createCache;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FjaGUuY2pzLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

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

@@ -1,6 +1,6 @@
-import { AllItemTypeArrays, ComKey, Item, ItemQuery, LocKeyArray, PriKey, TypesProperties } from "@fjell/core";
-import { CacheMap } from "./CacheMap";
-import { ClientApi } from "@fjell/client-api";
+import { AllItemTypeArrays, ComKey, Item, ItemQuery, LocKeyArray, PriKey, TypesProperties } from '@fjell/core';
+import { CacheMap } from './CacheMap';
+import { ClientApi } from '@fjell/client-api';
 export interface Cache<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> {
     all: (query?: ItemQuery, locations?: LocKeyArray<L1, L2, L3, L4, L5> | []) => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V[]]>;
     one: (query?: ItemQuery, locations?: LocKeyArray<L1, L2, L3, L4, L5> | []) => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V | null]>;
@@ -12,7 +12,7 @@ export interface Cache<V extends Item<S, L1, L2, L3, L4, L5>, S extends string,
     remove: (key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>) => Promise<CacheMap<V, S, L1, L2, L3, L4, L5>>;
     update: (key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>, v: TypesProperties<V, S, L1, L2, L3, L4, L5>) => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V]>;
     find: (finder: string, finderParams: Record<string, string | number | boolean | Date | Array<string | number | boolean | Date>>, locations?: LocKeyArray<L1, L2, L3, L4, L5> | []) => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V[]]>;
-    set: (key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>, v: V) => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V]>;
+    set: (key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>, v: Item<S, L1, L2, L3, L4, L5>) => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V]>;
     reset: () => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>]>;
     pkTypes: AllItemTypeArrays<S, L1, L2, L3, L4, L5>;
     cacheMap: CacheMap<V, S, L1, L2, L3, L4, L5>;

package/dist/{src/Cache.js → Cache.es.js}

@@ -1,57 +1,65 @@
-import { isItemKeyEqual, isValidItemKey, validatePK } from "@fjell/core";
-import { CacheMap } from "./CacheMap";
-import LibLogger from "./logger";
-import { NotFoundError } from "@fjell/http-api";
+import { isValidItemKey, validatePK, isItemKeyEqual } from '@fjell/core';
+import { CacheMap } from './CacheMap.es.js';
+import LibLogger from './logger.es.js';
+import { NotFoundError } from '@fjell/http-api';
+
 const logger = LibLogger.get('Cache');
-export const createCache = (api, pkType, parentCache) => {
-    let pkTypes = [pkType];
+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.default('all', { query, locations });
+    const all = async (query = {}, locations = [])=>{
+        logger.default('all', {
+            query,
+            locations
+        });
         let ret = [];
         try {
             ret = await api.all(query, {}, locations);
-            ret.forEach((v) => {
+            ret.forEach((v)=>{
                 cacheMap.set(v.key, v);
             });
-        }
-        catch (e) {
-            if (e instanceof NotFoundError) {
-            }
-            else {
+        } catch (e) {
+            if (e instanceof NotFoundError) ; else {
                 throw e;
             }
         }
-        return [cacheMap, validatePK(ret, pkType)];
+        return [
+            cacheMap,
+            validatePK(ret, pkType)
+        ];
     };
-    const one = async (query = {}, locations = []) => {
-        logger.default('one', { query, locations });
+    const one = async (query = {}, locations = [])=>{
+        logger.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 NotFoundError) {
-            }
-            else {
+        } catch (e) {
+            if (e instanceof NotFoundError) ; else {
                 throw e;
             }
         }
         return [
             cacheMap,
-            retItem ?
-                validatePK(retItem, pkType) :
-                null
+            retItem ? validatePK(retItem, pkType) : null
         ];
     };
-    const action = async (key, action, body = {}) => {
-        logger.default('action', { key, action, body });
+    const action = async (key, action, body = {})=>{
+        logger.default('action', {
+            key,
+            action,
+            body
+        });
         // TODO: This is validating the key, but it doesn't have knowledge of the pkType
         // This should be looking at the parentCaches and calculating an array of pkTypes
         if (!isValidItemKey(key)) {
@@ -60,35 +68,50 @@ export const createCache = (api, pkType, parentCache) => {
         }
         const updated = await api.action(key, action, body, {});
         cacheMap.set(updated.key, updated);
-        return [cacheMap, validatePK(updated, pkType)];
+        return [
+            cacheMap,
+            validatePK(updated, pkType)
+        ];
     };
-    const allAction = async (action, body = {}, locations = []) => {
-        logger.default('allAction', { action, body, locations });
+    const allAction = async (action, body = {}, locations = [])=>{
+        logger.default('allAction', {
+            action,
+            body,
+            locations
+        });
         let ret = [];
         try {
             ret = await api.allAction(action, body, {}, locations);
-            ret.forEach((v) => {
+            ret.forEach((v)=>{
                 cacheMap.set(v.key, v);
             });
-        }
-        catch (e) {
+        } catch (e) {
             // istanbul ignore next
-            if (e instanceof NotFoundError) {
-            }
-            else {
+            if (e instanceof NotFoundError) ; else {
                 throw e;
             }
         }
-        return [cacheMap, validatePK(ret, pkType)];
+        return [
+            cacheMap,
+            validatePK(ret, pkType)
+        ];
     };
-    const create = async (v, locations = []) => {
-        logger.default('create', { v, locations });
+    const create = async (v, locations = [])=>{
+        logger.default('create', {
+            v,
+            locations
+        });
         const created = await api.create(v, {}, locations);
         cacheMap.set(created.key, created);
-        return [cacheMap, validatePK(created, pkType)];
+        return [
+            cacheMap,
+            validatePK(created, pkType)
+        ];
     };
-    const get = async (key) => {
-        logger.default('get', { key });
+    const get = async (key)=>{
+        logger.default('get', {
+            key
+        });
         // TODO: This is validating the key, but it doesn't have knowledge of the pkType
         // This should be looking at the parentCaches and calculating an array of pkTypes
         if (!isValidItemKey(key)) {
@@ -101,20 +124,23 @@ export const createCache = (api, pkType, parentCache) => {
             if (ret) {
                 cacheMap.set(ret.key, ret);
             }
-        }
-        catch (e) {
-            logger.error("Error getting item for key", { key, message: e.message, stack: e.stack });
+        } catch (e) {
+            logger.error("Error getting item for key", {
+                key,
+                message: e.message,
+                stack: e.stack
+            });
             throw e;
         }
         return [
             cacheMap,
-            ret ?
-                validatePK(ret, pkType) :
-                null
+            ret ? validatePK(ret, pkType) : null
         ];
     };
-    const retrieve = async (key) => {
-        logger.default('retrieve', { key });
+    const retrieve = async (key)=>{
+        logger.default('retrieve', {
+            key
+        });
         if (!isValidItemKey(key)) {
             logger.error('Key for Retrieve is not a valid ItemKey: %j', key);
             throw new Error('Key for Retrieve is not a valid ItemKey');
@@ -124,22 +150,23 @@ export const createCache = (api, pkType, parentCache) => {
         if (containsItemKey) {
             logger.default('Looking for Object in Cache', key);
             retrieved = cacheMap.get(key);
-        }
-        else {
-            logger.default('Object Not Found in Cache, Retrieving from Server API', { key });
+        } else {
+            logger.default('Object Not Found in Cache, Retrieving from Server API', {
+                key
+            });
             [, retrieved] = await get(key);
         }
         const retValue = [
             containsItemKey ? null : cacheMap,
-            retrieved ?
-                validatePK(retrieved, pkType) :
-                null
+            retrieved ? validatePK(retrieved, pkType) : null
         ];
         // logger.debug('Returning from retrieve', { retValue });
         return retValue;
     };
-    const remove = async (key) => {
-        logger.default('remove', { key });
+    const remove = async (key)=>{
+        logger.default('remove', {
+            key
+        });
         // TODO: This is validating the key, but it doesn't have knowledge of the pkType
         // This should be looking at the parentCaches and calculating an array of pkTypes
         if (!isValidItemKey(key)) {
@@ -149,15 +176,19 @@ export const createCache = (api, pkType, parentCache) => {
         try {
             await api.remove(key, {});
             cacheMap.delete(key);
-        }
-        catch (e) {
-            logger.error("Error deleting item", { error: e });
+        } catch (e) {
+            logger.error("Error deleting item", {
+                error: e
+            });
             throw e;
         }
         return cacheMap;
     };
-    const update = async (key, v) => {
-        logger.default('update', { key, v });
+    const update = async (key, v)=>{
+        logger.default('update', {
+            key,
+            v
+        });
         // TODO: This is validating the key, but it doesn't have knowledge of the pkType
         // This should be looking at the parentCaches and calculating an array of pkTypes
         if (!isValidItemKey(key)) {
@@ -167,27 +198,43 @@ export const createCache = (api, pkType, parentCache) => {
         try {
             const updated = await api.update(key, v, {});
             cacheMap.set(updated.key, updated);
-            return [cacheMap, validatePK(updated, pkType)];
-        }
-        catch (e) {
-            logger.error("Error updating chat", { error: e });
+            return [
+                cacheMap,
+                validatePK(updated, pkType)
+            ];
+        } catch (e) {
+            logger.error("Error updating chat", {
+                error: e
+            });
             throw e;
         }
     };
-    const find = async (finder, finderParams, locations = []) => {
-        logger.default('find', { finder, finderParams, locations });
+    const find = async (finder, finderParams, locations = [])=>{
+        logger.default('find', {
+            finder,
+            finderParams,
+            locations
+        });
         const ret = await api.find(finder, finderParams, {}, locations);
-        ret.forEach((v) => {
+        ret.forEach((v)=>{
             cacheMap.set(v.key, v);
         });
-        return [cacheMap, validatePK(ret, pkType)];
+        return [
+            cacheMap,
+            validatePK(ret, pkType)
+        ];
     };
-    const reset = async () => {
+    const reset = async ()=>{
         cacheMap = new CacheMap(pkTypes);
-        return [cacheMap];
+        return [
+            cacheMap
+        ];
     };
-    const set = async (key, v) => {
-        logger.default('set', { key, v });
+    const set = async (key, v)=>{
+        logger.default('set', {
+            key,
+            v
+        });
         // TODO: This is validating the key, but it doesn't have knowledge of the pkType
         // This should be looking at the parentCaches and calculating an array of pkTypes
         if (!isValidItemKey(key)) {
@@ -201,7 +248,10 @@ export const createCache = (api, pkType, parentCache) => {
             throw new Error('Key does not match item key');
         }
         cacheMap.set(key, v);
-        return [cacheMap, validatePK(v, pkType)];
+        return [
+            cacheMap,
+            validatePK(v, pkType)
+        ];
     };
     return {
         all,
@@ -220,4 +270,6 @@ export const createCache = (api, pkType, parentCache) => {
         cacheMap
     };
 };
-//# sourceMappingURL=Cache.js.map
+
+export { createCache };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FjaGUuZXMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==