@fjell/cache 4.6.10 → 4.6.13

package/dist/Cache.es.js

@@ -1,354 +1,30 @@
-import { isValidItemKey, validatePK, isItemKeyEqual } from '@fjell/core';
 import { CacheMap } from './CacheMap.es.js';
+import { createOperations } from './Operations.es.js';
 import LibLogger from './logger.es.js';
-import { NotFoundError } from '@fjell/http-api';
 
 const logger = LibLogger.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 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(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 NotFoundError) ; else {
-                throw e;
-            }
-        }
-        return [
-            cacheMap,
-            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 NotFoundError) ; else {
-                throw e;
-            }
-        }
-        return [
-            cacheMap,
-            retItem ? 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 (!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,
-            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 NotFoundError) ; else {
-                throw e;
-            }
-        }
-        return [
-            cacheMap,
-            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,
-            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 (!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 ? validatePK(ret, pkType) : null
-        ];
-    };
-    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');
-        }
-        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 ? 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 (!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 (!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,
-                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,
-            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,
-            validatePK(ret, pkType)
-        ];
-    };
-    const reset = async ()=>{
-        cacheMap = new 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 (!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.
-        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,
-            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(coordinate.kta);
+    // Get the primary key type from the coordinate
+    const pkType = coordinate.kta[0];
+    // Create operations
+    const 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;
+};
 
-export { createCache };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FjaGUuZXMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=
+export { createCache, isCache };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FjaGUuZXMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/Instance.cjs.js

@@ -3,25 +3,21 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 const logger$1 = require('./logger.cjs.js');
-const registry = require('@fjell/registry');
+const Cache = require('./Cache.cjs.js');
 
 const logger = logger$1.default.get("Instance");
-const createInstance = (registry$1, coordinate, cache)=>{
+const createInstance = async (registry, coordinate, api)=>{
     logger.debug("createInstance", {
         coordinate,
-        cache,
-        registry: registry$1
+        api,
+        registry
     });
-    const baseInstance = registry.createInstance(registry$1, coordinate);
-    return {
-        ...baseInstance,
-        cache
-    };
+    return await Cache.createCache(api, coordinate, registry);
 };
 const isInstance = (instance)=>{
-    return instance !== null && instance !== undefined && instance.coordinate !== undefined && instance.cache !== undefined && instance.registry !== undefined;
+    return instance !== null && typeof instance === 'object' && 'coordinate' in instance && 'registry' in instance && 'api' in instance && 'cacheMap' in instance && 'operations' in instance;
 };
 
 exports.createInstance = createInstance;
 exports.isInstance = isInstance;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5zdGFuY2UuY2pzLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5zdGFuY2UuY2pzLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/Instance.d.ts

@@ -1,20 +1,17 @@
 import { Item } from '@fjell/core';
-import { Instance as BaseInstance, Coordinate, Registry } from '@fjell/registry';
+import { Coordinate, Registry } from '@fjell/registry';
+import { ClientApi } from '@fjell/client-api';
 import { Cache } from './Cache';
 /**
  * The Cache Instance interface represents a cache model instance that 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:
- * - cache: Provides methods for interacting with cached data (get, set, all, etc.)
+ * This is an alias for the Cache interface since Cache now extends Instance directly.
  *
  * @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 Instance<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 cache object that provides methods for interacting with cached data */
-    cache: Cache<V, S, L1, L2, L3, L4, L5>;
-}
-export declare const createInstance: <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>(registry: Registry, coordinate: Coordinate<S, L1, L2, L3, L4, L5>, cache: Cache<V, S, L1, L2, L3, L4, L5>) => Instance<V, S, L1, L2, L3, L4, L5>;
+export type Instance<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<V, S, L1, L2, L3, L4, L5>;
+export declare const createInstance: <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>(registry: Registry, coordinate: Coordinate<S, L1, L2, L3, L4, L5>, api: ClientApi<V, S, L1, L2, L3, L4, L5>) => Promise<Instance<V, S, L1, L2, L3, L4, L5>>;
 export declare const isInstance: (instance: any) => instance is Instance<any, any, any, any, any, any, any>;

package/dist/Instance.es.js

@@ -1,22 +1,18 @@
 import LibLogger from './logger.es.js';
-import { createInstance as createInstance$1 } from '@fjell/registry';
+import { createCache } from './Cache.es.js';
 
 const logger = LibLogger.get("Instance");
-const createInstance = (registry, coordinate, cache)=>{
+const createInstance = async (registry, coordinate, api)=>{
     logger.debug("createInstance", {
         coordinate,
-        cache,
+        api,
         registry
     });
-    const baseInstance = createInstance$1(registry, coordinate);
-    return {
-        ...baseInstance,
-        cache
-    };
+    return await createCache(api, coordinate, registry);
 };
 const isInstance = (instance)=>{
-    return instance !== null && instance !== undefined && instance.coordinate !== undefined && instance.cache !== undefined && instance.registry !== undefined;
+    return instance !== null && typeof instance === 'object' && 'coordinate' in instance && 'registry' in instance && 'api' in instance && 'cacheMap' in instance && 'operations' in instance;
 };
 
 export { createInstance, isInstance };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5zdGFuY2UuZXMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5zdGFuY2UuZXMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/InstanceFactory.cjs.js

@@ -2,22 +2,34 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const Instance = require('./Instance.cjs.js');
+const CacheMap = require('./CacheMap.cjs.js');
+const Operations = require('./Operations.cjs.js');
 const logger$1 = require('./logger.cjs.js');
 
 const logger = logger$1.default.get("InstanceFactory");
 /**
  * Factory function for creating cache instances
- */ const createInstanceFactory = (cache)=>{
+ */ const createInstanceFactory = (api)=>{
     return (coordinate, context)=>{
         logger.debug("Creating cache instance", {
             coordinate,
             registry: context.registry,
-            cache
+            api
         });
-        return Instance.createInstance(context.registry, coordinate, cache);
+        // Since InstanceFactory must be synchronous but our createInstance is async,
+        // we need to create a special cache instance synchronously and defer the async initialization
+        const cacheMap = new CacheMap.CacheMap(coordinate.kta);
+        const pkType = coordinate.kta[0];
+        const operations = Operations.createOperations(api, coordinate, cacheMap, pkType);
+        return {
+            coordinate,
+            registry: context.registry,
+            api,
+            cacheMap,
+            operations
+        };
     };
 };
 
 exports.createInstanceFactory = createInstanceFactory;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5zdGFuY2VGYWN0b3J5LmNqcy5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5zdGFuY2VGYWN0b3J5LmNqcy5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/InstanceFactory.d.ts

@@ -1,8 +1,8 @@
 import { Item } from '@fjell/core';
-import { Cache } from './Cache';
+import { ClientApi } from '@fjell/client-api';
 import { InstanceFactory as BaseInstanceFactory } from '@fjell/registry';
-export type InstanceFactory<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>) => BaseInstanceFactory<S, L1, L2, L3, L4, L5>;
+export type InstanceFactory<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>) => BaseInstanceFactory<S, L1, L2, L3, L4, L5>;
 /**
  * Factory function for creating cache instances
  */
-export declare const createInstanceFactory: <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>) => BaseInstanceFactory<S, L1, L2, L3, L4, L5>;
+export declare const createInstanceFactory: <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>) => BaseInstanceFactory<S, L1, L2, L3, L4, L5>;

package/dist/InstanceFactory.es.js

@@ -1,19 +1,31 @@
-import { createInstance } from './Instance.es.js';
+import { CacheMap } from './CacheMap.es.js';
+import { createOperations } from './Operations.es.js';
 import LibLogger from './logger.es.js';
 
 const logger = LibLogger.get("InstanceFactory");
 /**
  * Factory function for creating cache instances
- */ const createInstanceFactory = (cache)=>{
+ */ const createInstanceFactory = (api)=>{
     return (coordinate, context)=>{
         logger.debug("Creating cache instance", {
             coordinate,
             registry: context.registry,
-            cache
+            api
         });
-        return createInstance(context.registry, coordinate, cache);
+        // Since InstanceFactory must be synchronous but our createInstance is async,
+        // we need to create a special cache instance synchronously and defer the async initialization
+        const cacheMap = new CacheMap(coordinate.kta);
+        const pkType = coordinate.kta[0];
+        const operations = createOperations(api, coordinate, cacheMap, pkType);
+        return {
+            coordinate,
+            registry: context.registry,
+            api,
+            cacheMap,
+            operations
+        };
     };
 };
 
 export { createInstanceFactory };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5zdGFuY2VGYWN0b3J5LmVzLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5zdGFuY2VGYWN0b3J5LmVzLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/Operations.cjs.js

@@ -0,0 +1,43 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const all = require('./ops/all.cjs.js');
+const one = require('./ops/one.cjs.js');
+const create = require('./ops/create.cjs.js');
+const get = require('./ops/get.cjs.js');
+const retrieve = require('./ops/retrieve.cjs.js');
+const remove = require('./ops/remove.cjs.js');
+const update = require('./ops/update.cjs.js');
+const action = require('./ops/action.cjs.js');
+const allAction = require('./ops/allAction.cjs.js');
+const facet = require('./ops/facet.cjs.js');
+const allFacet = require('./ops/allFacet.cjs.js');
+const find = require('./ops/find.cjs.js');
+const findOne = require('./ops/findOne.cjs.js');
+const set = require('./ops/set.cjs.js');
+const reset = require('./ops/reset.cjs.js');
+
+// Import all operation functions
+const createOperations = (api, coordinate, cacheMap, pkType)=>{
+    return {
+        all: (query, locations)=>all.all(api, cacheMap, pkType, query, locations),
+        one: (query, locations)=>one.one(api, cacheMap, pkType, query, locations),
+        create: (item, locations)=>create.create(api, cacheMap, pkType, item, locations),
+        get: (key)=>get.get(api, cacheMap, pkType, key),
+        retrieve: (key)=>retrieve.retrieve(api, cacheMap, pkType, key),
+        remove: (key)=>remove.remove(api, cacheMap, key),
+        update: (key, item)=>update.update(api, cacheMap, pkType, key, item),
+        action: (key, actionName, body)=>action.action(api, cacheMap, pkType, key, actionName, body),
+        allAction: (actionName, body, locations)=>allAction.allAction(api, cacheMap, pkType, actionName, body, locations),
+        facet: (key, facetName, params)=>facet.facet(api, cacheMap, key, facetName, params),
+        allFacet: (facetName, params, locations)=>allFacet.allFacet(api, cacheMap, facetName, params, locations),
+        find: (finder, params, locations)=>find.find(api, cacheMap, pkType, finder, params, locations),
+        findOne: (finder, params, locations)=>findOne.findOne(api, cacheMap, pkType, finder, params, locations),
+        set: (key, item)=>set.set(cacheMap, pkType, key, item),
+        reset: ()=>reset.reset(coordinate)
+    };
+};
+
+exports.createOperations = createOperations;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiT3BlcmF0aW9ucy5janMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9