@fjell/cache 4.6.10 → 4.6.11

package/dist/index.cjs.js

@@ -7,6 +7,7 @@ const Cache = require('./Cache.cjs.js');
 const CacheMap = require('./CacheMap.cjs.js');
 const Instance = require('./Instance.cjs.js');
 const InstanceFactory = require('./InstanceFactory.cjs.js');
+const Operations = require('./Operations.cjs.js');
 const Registry = require('./Registry.cjs.js');
 
 
@@ -14,10 +15,12 @@ const Registry = require('./Registry.cjs.js');
 exports.createAggregator = Aggregator.createAggregator;
 exports.toCacheConfig = Aggregator.toCacheConfig;
 exports.createCache = Cache.createCache;
+exports.isCache = Cache.isCache;
 exports.CacheMap = CacheMap.CacheMap;
 exports.createInstance = Instance.createInstance;
 exports.isInstance = Instance.isInstance;
 exports.createInstanceFactory = InstanceFactory.createInstanceFactory;
+exports.createOperations = Operations.createOperations;
 exports.createRegistry = Registry.createRegistry;
 exports.createRegistryFactory = Registry.createRegistryFactory;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguY2pzLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguY2pzLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/index.d.ts

@@ -3,4 +3,5 @@ export * from './Cache';
 export * from './CacheMap';
 export * from './Instance';
 export * from './InstanceFactory';
+export * from './Operations';
 export * from './Registry';

package/dist/index.es.js

@@ -1,7 +1,8 @@
 export { createAggregator, toCacheConfig } from './Aggregator.es.js';
-export { createCache } from './Cache.es.js';
+export { createCache, isCache } from './Cache.es.js';
 export { CacheMap } from './CacheMap.es.js';
 export { createInstance, isInstance } from './Instance.es.js';
 export { createInstanceFactory } from './InstanceFactory.es.js';
+export { createOperations } from './Operations.es.js';
 export { createRegistry, createRegistryFactory } from './Registry.es.js';
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZXMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OzsifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZXMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7In0=

package/dist/ops/action.cjs.js

@@ -0,0 +1,28 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@fjell/core');
+const logger$1 = require('../logger.cjs.js');
+
+const logger = logger$1.default.get('action');
+const action = async (api, cacheMap, pkType, key, action, body = {})=>{
+    logger.default('action', {
+        key,
+        action,
+        body
+    });
+    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)
+    ];
+};
+
+exports.action = action;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWN0aW9uLmNqcy5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/ops/action.d.ts

@@ -0,0 +1,4 @@
+import { ComKey, Item, PriKey } from '@fjell/core';
+import { ClientApi } from '@fjell/client-api';
+import { CacheMap } from '../CacheMap';
+export declare const action: <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>, cacheMap: CacheMap<V, S, L1, L2, L3, L4, L5>, pkType: S, key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>, action: string, body?: any) => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V]>;

package/dist/ops/action.es.js

@@ -0,0 +1,24 @@
+import { isValidItemKey, validatePK } from '@fjell/core';
+import LibLogger from '../logger.es.js';
+
+const logger = LibLogger.get('action');
+const action = async (api, cacheMap, pkType, key, action, body = {})=>{
+    logger.default('action', {
+        key,
+        action,
+        body
+    });
+    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)
+    ];
+};
+
+export { action };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWN0aW9uLmVzLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/ops/all.cjs.js

@@ -0,0 +1,33 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@fjell/core');
+const httpApi = require('@fjell/http-api');
+const logger$1 = require('../logger.cjs.js');
+
+const logger = logger$1.default.get('all');
+const all = async (api, cacheMap, pkType, 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)
+    ];
+};
+
+exports.all = all;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxsLmNqcy5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/ops/all.d.ts

@@ -0,0 +1,4 @@
+import { Item, ItemQuery, LocKeyArray } from '@fjell/core';
+import { ClientApi } from '@fjell/client-api';
+import { CacheMap } from '../CacheMap';
+export declare const all: <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>, cacheMap: CacheMap<V, S, L1, L2, L3, L4, L5>, pkType: S, query?: ItemQuery, locations?: LocKeyArray<L1, L2, L3, L4, L5> | []) => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V[]]>;

package/dist/ops/all.es.js

@@ -0,0 +1,29 @@
+import { validatePK } from '@fjell/core';
+import { NotFoundError } from '@fjell/http-api';
+import LibLogger from '../logger.es.js';
+
+const logger = LibLogger.get('all');
+const all = async (api, cacheMap, pkType, 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)
+    ];
+};
+
+export { all };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxsLmVzLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/ops/allAction.cjs.js

@@ -0,0 +1,35 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@fjell/core');
+const httpApi = require('@fjell/http-api');
+const logger$1 = require('../logger.cjs.js');
+
+const logger = logger$1.default.get('allAction');
+const allAction = async (api, cacheMap, pkType, 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)
+    ];
+};
+
+exports.allAction = allAction;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxsQWN0aW9uLmNqcy5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/ops/allAction.d.ts

@@ -0,0 +1,4 @@
+import { Item, LocKeyArray } from '@fjell/core';
+import { ClientApi } from '@fjell/client-api';
+import { CacheMap } from '../CacheMap';
+export declare const allAction: <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>, cacheMap: CacheMap<V, S, L1, L2, L3, L4, L5>, pkType: S, action: string, body?: any, locations?: LocKeyArray<L1, L2, L3, L4, L5> | []) => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V[]]>;

package/dist/ops/allAction.es.js

@@ -0,0 +1,31 @@
+import { validatePK } from '@fjell/core';
+import { NotFoundError } from '@fjell/http-api';
+import LibLogger from '../logger.es.js';
+
+const logger = LibLogger.get('allAction');
+const allAction = async (api, cacheMap, pkType, 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)
+    ];
+};
+
+export { allAction };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxsQWN0aW9uLmVzLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/ops/allFacet.cjs.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const logger$1 = require('../logger.cjs.js');
+
+const logger = logger$1.default.get('allFacet');
+const allFacet = async (api, cacheMap, facet, params = {}, locations = [])=>{
+    logger.default('allFacet', {
+        facet,
+        params,
+        locations
+    });
+    const ret = await api.allFacet(facet, params, locations);
+    return [
+        cacheMap,
+        ret
+    ];
+};
+
+exports.allFacet = allFacet;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxsRmFjZXQuY2pzLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/ops/allFacet.d.ts

@@ -0,0 +1,4 @@
+import { Item, LocKeyArray } from '@fjell/core';
+import { ClientApi } from '@fjell/client-api';
+import { CacheMap } from '../CacheMap';
+export declare const allFacet: <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>, cacheMap: CacheMap<V, S, L1, L2, L3, L4, L5>, 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]>;

package/dist/ops/allFacet.es.js

@@ -0,0 +1,18 @@
+import LibLogger from '../logger.es.js';
+
+const logger = LibLogger.get('allFacet');
+const allFacet = async (api, cacheMap, facet, params = {}, locations = [])=>{
+    logger.default('allFacet', {
+        facet,
+        params,
+        locations
+    });
+    const ret = await api.allFacet(facet, params, locations);
+    return [
+        cacheMap,
+        ret
+    ];
+};
+
+export { allFacet };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxsRmFjZXQuZXMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/ops/create.cjs.js

@@ -0,0 +1,23 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@fjell/core');
+const logger$1 = require('../logger.cjs.js');
+
+const logger = logger$1.default.get('create');
+const create = async (api, cacheMap, pkType, 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)
+    ];
+};
+
+exports.create = create;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLmNqcy5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/ops/create.d.ts

@@ -0,0 +1,4 @@
+import { Item, LocKeyArray } from '@fjell/core';
+import { ClientApi } from '@fjell/client-api';
+import { CacheMap } from '../CacheMap';
+export declare const create: <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>, cacheMap: CacheMap<V, S, L1, L2, L3, L4, L5>, pkType: S, v: 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]>;

package/dist/ops/create.es.js

@@ -0,0 +1,19 @@
+import { validatePK } from '@fjell/core';
+import LibLogger from '../logger.es.js';
+
+const logger = LibLogger.get('create');
+const create = async (api, cacheMap, pkType, v, locations = [])=>{
+    logger.default('create', {
+        v,
+        locations
+    });
+    const created = await api.create(v, locations);
+    cacheMap.set(created.key, created);
+    return [
+        cacheMap,
+        validatePK(created, pkType)
+    ];
+};
+
+export { create };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLmVzLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/ops/facet.cjs.js

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const logger$1 = require('../logger.cjs.js');
+
+const logger = logger$1.default.get('facet');
+const facet = async (api, cacheMap, key, facet, params = {})=>{
+    logger.default('facet', {
+        key,
+        facet
+    });
+    const ret = await api.facet(key, facet, params);
+    return [
+        cacheMap,
+        ret
+    ];
+};
+
+exports.facet = facet;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmFjZXQuY2pzLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/ops/facet.d.ts

@@ -0,0 +1,4 @@
+import { ComKey, Item, PriKey } from '@fjell/core';
+import { ClientApi } from '@fjell/client-api';
+import { CacheMap } from '../CacheMap';
+export declare const facet: <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>, cacheMap: CacheMap<V, S, L1, L2, L3, L4, L5>, 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]>;

package/dist/ops/facet.es.js

@@ -0,0 +1,17 @@
+import LibLogger from '../logger.es.js';
+
+const logger = LibLogger.get('facet');
+const facet = async (api, cacheMap, key, facet, params = {})=>{
+    logger.default('facet', {
+        key,
+        facet
+    });
+    const ret = await api.facet(key, facet, params);
+    return [
+        cacheMap,
+        ret
+    ];
+};
+
+export { facet };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmFjZXQuZXMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/ops/find.cjs.js

@@ -0,0 +1,26 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@fjell/core');
+const logger$1 = require('../logger.cjs.js');
+
+const logger = logger$1.default.get('find');
+const find = async (api, cacheMap, pkType, 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)
+    ];
+};
+
+exports.find = find;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmluZC5janMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/ops/find.d.ts

@@ -0,0 +1,4 @@
+import { Item, LocKeyArray } from '@fjell/core';
+import { ClientApi } from '@fjell/client-api';
+import { CacheMap } from '../CacheMap';
+export declare const find: <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>, cacheMap: CacheMap<V, S, L1, L2, L3, L4, L5>, pkType: S, 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[]]>;

package/dist/ops/find.es.js

@@ -0,0 +1,22 @@
+import { validatePK } from '@fjell/core';
+import LibLogger from '../logger.es.js';
+
+const logger = LibLogger.get('find');
+const find = async (api, cacheMap, pkType, 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)
+    ];
+};
+
+export { find };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmluZC5lcy5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/ops/findOne.cjs.js

@@ -0,0 +1,24 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@fjell/core');
+const logger$1 = require('../logger.cjs.js');
+
+const logger = logger$1.default.get('findOne');
+const findOne = async (api, cacheMap, pkType, 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)
+    ];
+};
+
+exports.findOne = findOne;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmluZE9uZS5janMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/ops/findOne.d.ts

@@ -0,0 +1,4 @@
+import { Item, LocKeyArray } from '@fjell/core';
+import { ClientApi } from '@fjell/client-api';
+import { CacheMap } from '../CacheMap';
+export declare const findOne: <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>, cacheMap: CacheMap<V, S, L1, L2, L3, L4, L5>, pkType: S, 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]>;

package/dist/ops/findOne.es.js

@@ -0,0 +1,20 @@
+import { validatePK } from '@fjell/core';
+import LibLogger from '../logger.es.js';
+
+const logger = LibLogger.get('findOne');
+const findOne = async (api, cacheMap, pkType, 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)
+    ];
+};
+
+export { findOne };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmluZE9uZS5lcy5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/ops/get.cjs.js

@@ -0,0 +1,38 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@fjell/core');
+const logger$1 = require('../logger.cjs.js');
+
+const logger = logger$1.default.get('get');
+const get = async (api, cacheMap, pkType, key)=>{
+    logger.default('get', {
+        key
+    });
+    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
+    ];
+};
+
+exports.get = get;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LmNqcy5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/ops/get.d.ts

@@ -0,0 +1,4 @@
+import { ComKey, Item, PriKey } from '@fjell/core';
+import { ClientApi } from '@fjell/client-api';
+import { CacheMap } from '../CacheMap';
+export declare const get: <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>, cacheMap: CacheMap<V, S, L1, L2, L3, L4, L5>, pkType: S, key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>) => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V | null]>;

package/dist/ops/get.es.js

@@ -0,0 +1,34 @@
+import { isValidItemKey, validatePK } from '@fjell/core';
+import LibLogger from '../logger.es.js';
+
+const logger = LibLogger.get('get');
+const get = async (api, cacheMap, pkType, key)=>{
+    logger.default('get', {
+        key
+    });
+    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
+    ];
+};
+
+export { get };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LmVzLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/ops/one.cjs.js

@@ -0,0 +1,33 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@fjell/core');
+const httpApi = require('@fjell/http-api');
+const logger$1 = require('../logger.cjs.js');
+
+const logger = logger$1.default.get('one');
+const one = async (api, cacheMap, pkType, 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
+    ];
+};
+
+exports.one = one;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib25lLmNqcy5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/ops/one.d.ts

@@ -0,0 +1,4 @@
+import { Item, ItemQuery, LocKeyArray } from '@fjell/core';
+import { ClientApi } from '@fjell/client-api';
+import { CacheMap } from '../CacheMap';
+export declare const one: <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>, cacheMap: CacheMap<V, S, L1, L2, L3, L4, L5>, pkType: S, query?: ItemQuery, locations?: LocKeyArray<L1, L2, L3, L4, L5> | []) => Promise<[CacheMap<V, S, L1, L2, L3, L4, L5>, V | null]>;