@fjell/cache 4.5.2 → 4.6.1

package/dist/CacheMap.cjs.js

@@ -0,0 +1,108 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@fjell/core');
+const logger$1 = require('./logger.cjs.js');
+
+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 = logger$1.default.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.debug('Returning all items, LocKeys is empty');
+            return this.values();
+        } else {
+            const locKeys = locations;
+            logger.debug('allIn', {
+                locKeys,
+                keys: this.keys().length
+            });
+            return this.keys().filter((key)=>key && core.isComKey(key)).filter((key)=>{
+                const ComKey = key;
+                logger.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.debug('contains', {
+            query,
+            locations
+        });
+        const items = this.allIn(locations);
+        return items.some((item)=>core.isQueryMatch(item, query));
+    }
+    queryIn(query, locations = []) {
+        logger.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(this, "types", void 0);
+        this.types = types;
+    }
+}
+
+exports.CacheMap = CacheMap;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FjaGVNYXAuY2pzLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

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

@@ -1,4 +1,4 @@
-import { AllItemTypeArrays, ComKey, Dictionary, Item, ItemQuery, LocKeyArray, PriKey } from "@fjell/core";
+import { AllItemTypeArrays, ComKey, Dictionary, Item, ItemQuery, LocKeyArray, PriKey } from '@fjell/core';
 export declare class CacheMap<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 Dictionary<ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>, V> {
     private types;
     constructor(types: AllItemTypeArrays<S, L1, L2, L3, L4, L5>, map?: {

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

@@ -1,5 +1,19 @@
-import { Dictionary, isComKey, isQueryMatch } from "@fjell/core";
-import LibLogger from "./logger";
+import { Dictionary, isComKey, isQueryMatch } from '@fjell/core';
+import LibLogger from './logger.es.js';
+
+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("CacheMap");
 // const isObj = (x: any) => typeof x === "object" && x !== null;
 // const intersection = (a: object, b: object): object => {
@@ -35,12 +49,7 @@ const logger = LibLogger.get("CacheMap");
 //   });
 //   return result;
 // }
-export class CacheMap extends Dictionary {
-    types;
-    constructor(types, map) {
-        super(map);
-        this.types = types;
-    }
+class CacheMap extends Dictionary {
     get(key) {
         return super.get(key);
     }
@@ -48,38 +57,48 @@ export class CacheMap extends Dictionary {
         if (locations.length === 0) {
             logger.debug('Returning all items, LocKeys is empty');
             return this.values();
-        }
-        else {
+        } else {
             const locKeys = locations;
-            logger.debug('allIn', { locKeys, keys: this.keys().length });
-            return this.keys()
-                .filter((key) => key && isComKey(key))
-                .filter((key) => {
+            logger.debug('allIn', {
+                locKeys,
+                keys: this.keys().length
+            });
+            return this.keys().filter((key)=>key && isComKey(key)).filter((key)=>{
                 const ComKey = key;
                 logger.debug('Comparing Location Keys', {
                     locKeys,
-                    ComKey,
+                    ComKey
                 });
                 return JSON.stringify(locKeys) === JSON.stringify(ComKey.loc);
-            })
-                .map((key) => this.get(key));
+            }).map((key)=>this.get(key));
         }
     }
     // TODO: Can we do case insensitive matching?
     contains(query, locations) {
-        logger.debug('contains', { query, locations });
+        logger.debug('contains', {
+            query,
+            locations
+        });
         const items = this.allIn(locations);
-        return items.some((item) => isQueryMatch(item, query));
+        return items.some((item)=>isQueryMatch(item, query));
     }
     queryIn(query, locations = []) {
-        logger.debug('queryIn', { query, locations });
+        logger.debug('queryIn', {
+            query,
+            locations
+        });
         const items = this.allIn(locations);
-        return items.filter((item) => isQueryMatch(item, query));
+        return items.filter((item)=>isQueryMatch(item, query));
     }
     clone() {
         const clone = new CacheMap(this.types, this.map);
         return clone;
     }
+    constructor(types, map){
+        super(map), _define_property(this, "types", void 0);
+        this.types = types;
+    }
 }
-;
-//# sourceMappingURL=CacheMap.js.map
+
+export { CacheMap };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FjaGVNYXAuZXMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/CacheRegistry.cjs.js

@@ -0,0 +1,66 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const logger$1 = require('./logger.cjs.js');
+
+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 = logger$1.default.get('CacheRegistry');
+class CacheRegistry {
+    constructor(){
+        // 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", async (cache)=>{
+            try {
+                logger.debug('Attempting to register cache with pkTypes:', cache.pkTypes);
+                const key = JSON.stringify(cache.pkTypes);
+                if (this.cacheMap[key]) {
+                    logger.debug(`Cache with pkTypes ${key} already exists, will be overwritten`);
+                }
+                this.cacheMap[key] = cache;
+                logger.debug('Cache registered successfully with key:', key);
+            } catch (error) {
+                logger.error('Failed to register cache:', error);
+                throw error;
+            }
+        });
+        _define_property(this, "getCache", (kts)=>{
+            logger.debug('Attempting to get cache for key types:', kts);
+            const key = JSON.stringify(kts);
+            logger.debug('Looking up cache with key:', key);
+            const cache = this.cacheMap[key];
+            if (!cache) {
+                logger.warning(`No cache found for key types: ${key}`);
+            }
+            return cache;
+        });
+        _define_property(this, "printRegisteredCaches", ()=>{
+            logger.debug('Printing all registered caches:');
+            const cacheCount = Object.keys(this.cacheMap).length;
+            logger.debug(`Total number of registered caches: ${cacheCount}`);
+            if (cacheCount === 0) {
+                logger.debug('No caches are currently registered');
+            }
+            Object.entries(this.cacheMap).forEach(([keyTypes])=>{
+                logger.debug(`Cache with key types: ${keyTypes}`);
+            });
+        });
+        logger.debug('CacheRegistry instance created');
+    }
+}
+_define_property(CacheRegistry, "instance", void 0);
+
+exports.CacheRegistry = CacheRegistry;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FjaGVSZWdpc3RyeS5janMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

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

@@ -1,13 +1,10 @@
-import { Item } from "@fjell/core";
-import { Cache } from "./Cache";
+import { Item } from '@fjell/core';
+import { Cache } from './Cache';
 export declare class CacheRegistry {
     private static instance;
-    private configured;
     constructor();
-    static getInstance(): CacheRegistry;
     private cacheMap;
-    registerCache: <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<Item<S, L1, L2, L3, L4, L5>, S, L1, L2, L3, L4, L5>) => void;
-    isConfigured: () => boolean;
-    markConfigured: () => void;
+    registerCache: <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<Item<S, L1, L2, L3, L4, L5>, S, L1, L2, L3, L4, L5>) => Promise<void>;
     getCache: (kts: string[]) => any;
+    printRegisteredCaches: () => void;
 }

package/dist/CacheRegistry.es.js

@@ -0,0 +1,62 @@
+import LibLogger from './logger.es.js';
+
+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 {
+    constructor(){
+        // 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", async (cache)=>{
+            try {
+                logger.debug('Attempting to register cache with pkTypes:', cache.pkTypes);
+                const key = JSON.stringify(cache.pkTypes);
+                if (this.cacheMap[key]) {
+                    logger.debug(`Cache with pkTypes ${key} already exists, will be overwritten`);
+                }
+                this.cacheMap[key] = cache;
+                logger.debug('Cache registered successfully with key:', key);
+            } catch (error) {
+                logger.error('Failed to register cache:', error);
+                throw error;
+            }
+        });
+        _define_property(this, "getCache", (kts)=>{
+            logger.debug('Attempting to get cache for key types:', kts);
+            const key = JSON.stringify(kts);
+            logger.debug('Looking up cache with key:', key);
+            const cache = this.cacheMap[key];
+            if (!cache) {
+                logger.warning(`No cache found for key types: ${key}`);
+            }
+            return cache;
+        });
+        _define_property(this, "printRegisteredCaches", ()=>{
+            logger.debug('Printing all registered caches:');
+            const cacheCount = Object.keys(this.cacheMap).length;
+            logger.debug(`Total number of registered caches: ${cacheCount}`);
+            if (cacheCount === 0) {
+                logger.debug('No caches are currently registered');
+            }
+            Object.entries(this.cacheMap).forEach(([keyTypes])=>{
+                logger.debug(`Cache with key types: ${keyTypes}`);
+            });
+        });
+        logger.debug('CacheRegistry instance created');
+    }
+}
+_define_property(CacheRegistry, "instance", void 0);
+
+export { CacheRegistry };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FjaGVSZWdpc3RyeS5lcy5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9