@fjell/cache 4.6.10 → 4.6.13

package/dist/Cache.cjs.js

@@ -2,357 +2,34 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const core = require('@fjell/core');
 const CacheMap = require('./CacheMap.cjs.js');
+const Operations = require('./Operations.cjs.js');
 const logger$1 = require('./logger.cjs.js');
-const httpApi = require('@fjell/http-api');
 
 const logger = logger$1.default.get('Cache');
-// 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 createCache = async (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 allFacet = async (facet, params = {}, locations = [])=>{
-        logger.default('allFacet', {
-            facet,
-            params,
-            locations
-        });
-        const ret = await api.allFacet(facet, params, locations);
-        return [
-            cacheMap,
-            ret
-        ];
-    };
-    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;
-        }
-    };
-    // Facets are a pass-thru for caches
-    const facet = async (key, facet, params = {})=>{
-        logger.default('facet', {
-            key,
-            facet
-        });
-        const ret = await api.facet(key, facet, params);
-        return [
-            cacheMap,
-            ret
-        ];
-    };
-    const find = async (finder, params = {}, locations = [])=>{
-        logger.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 findOne = async (finder, finderParams = {}, locations = [])=>{
-        logger.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 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 (!isItemKeyEqualNormalized(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)
-        ];
-    };
+const createCache = async (api, coordinate, registry)=>{
+    logger.debug('createCache', {
+        coordinate,
+        registry
+    });
+    // Create the cache map using the coordinate's key type array
+    const cacheMap = new CacheMap.CacheMap(coordinate.kta);
+    // Get the primary key type from the coordinate
+    const pkType = coordinate.kta[0];
+    // Create operations
+    const operations = Operations.createOperations(api, coordinate, cacheMap, pkType);
     return {
-        all,
-        one,
-        action,
-        allAction,
-        allFacet,
-        create,
-        get,
-        retrieve,
-        remove,
-        update,
-        facet,
-        find,
-        findOne,
-        reset,
-        set,
-        pkTypes,
-        cacheMap
+        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;
+};
 
 exports.createCache = createCache;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FjaGUuY2pzLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==
+exports.isCache = isCache;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FjaGUuY2pzLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/Cache.d.ts

@@ -1,23 +1,28 @@
-import { AllItemTypeArrays, ComKey, Item, ItemQuery, LocKeyArray, PriKey } from '@fjell/core';
-import { CacheMap } from './CacheMap';
+import { Item } from '@fjell/core';
+import { Instance as BaseInstance, Coordinate, Registry } from '@fjell/registry';
 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]>;
-    action: (key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>, action: string, body?: any) => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V]>;
-    allAction: (action: string, body?: any, locations?: LocKeyArray<L1, L2, L3, L4, L5> | []) => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V[]]>;
-    allFacet: (facet: string, params?: 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>, any]>;
-    create: (item: Partial<Item<S, L1, L2, L3, L4, L5>>, locations?: LocKeyArray<L1, L2, L3, L4, L5> | []) => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V]>;
-    get: (key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>) => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V | null]>;
-    retrieve: (key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>) => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5> | null, V | null]>;
-    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>, item: Partial<Item<S, L1, L2, L3, L4, L5>>) => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V]>;
-    facet: (key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>, facet: string, params?: Record<string, string | number | boolean | Date | Array<string | number | boolean | Date>>) => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, any]>;
-    find: (finder: string, params?: 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[]]>;
-    findOne: (finder: string, params?: 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>, item: 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>;
+import { CacheMap } from './CacheMap';
+import { Operations } from './Operations';
+/**
+ * The Cache interface extends the base Instance from @fjell/registry and adds cache operations
+ * for interacting with cached data.
+ *
+ * The interface extends the base Instance (which provides coordinate and registry) with:
+ * - api: Provides methods for interacting with server API
+ * - cacheMap: Local cache storage for items
+ * - operations: All cache operations (get, set, all, etc.) that work with both cache and API
+ *
+ * @template V - The type of the data model item, extending Item
+ * @template S - The string literal type representing the model's key type
+ * @template L1-L5 - Optional string literal types for location hierarchy levels
+ */
+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> extends BaseInstance<S, L1, L2, L3, L4, L5> {
+    /** The API client for interacting with server endpoints */
+    api: ClientApi<V, S, L1, L2, L3, L4, L5>;
+    /** The cache map that stores cached items */
     cacheMap: CacheMap<V, S, L1, L2, L3, L4, L5>;
+    /** All cache operations that work with both cache and API */
+    operations: Operations<V, S, L1, L2, L3, L4, L5>;
 }
-export declare const createCache: <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>(api: ClientApi<V, S, L1, L2, L3, L4, L5>, pkType: S, parentCache?: Cache<Item<L1, L2, L3, L4, L5>, L1, L2, L3, L4, L5>) => Promise<Cache<V, S, L1, L2, L3, L4, L5>>;
+export declare const createCache: <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>(api: ClientApi<V, S, L1, L2, L3, L4, L5>, coordinate: Coordinate<S, L1, L2, L3, L4, L5>, registry: Registry) => Promise<Cache<V, S, L1, L2, L3, L4, L5>>;
+export declare const isCache: (cache: any) => cache is Cache<any, any, any, any, any, any, any>;