@fjell/cache 4.6.14 → 4.6.16

package/dist/index.cjs.js

@@ -1,26 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-const Aggregator = require('./Aggregator.cjs.js');
-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');
-
-
-
-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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguY2pzLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/index.cjs.map

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

package/dist/index.es.js

@@ -1,8 +0,0 @@
-export { createAggregator, toCacheConfig } from './Aggregator.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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZXMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7In0=

package/dist/logger.cjs.js

@@ -1,10 +0,0 @@
-'use strict';
-
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
-
-const Logging = require('@fjell/logging');
-
-const LibLogger = Logging.getLogger('@fjell/cache');
-
-exports.default = LibLogger;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nZ2VyLmNqcy5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7In0=

package/dist/logger.es.js

@@ -1,6 +0,0 @@
-import Logging from '@fjell/logging';
-
-const LibLogger = Logging.getLogger('@fjell/cache');
-
-export { LibLogger as default };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nZ2VyLmVzLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7OyJ9

package/dist/ops/action.cjs.js

@@ -1,28 +0,0 @@
-'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.es.js

@@ -1,24 +0,0 @@
-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

@@ -1,33 +0,0 @@
-'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.es.js

@@ -1,29 +0,0 @@
-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

@@ -1,35 +0,0 @@
-'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.es.js

@@ -1,31 +0,0 @@
-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

@@ -1,22 +0,0 @@
-'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.es.js

@@ -1,18 +0,0 @@
-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

@@ -1,23 +0,0 @@
-'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.es.js

@@ -1,19 +0,0 @@
-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

@@ -1,21 +0,0 @@
-'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.es.js

@@ -1,17 +0,0 @@
-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

@@ -1,26 +0,0 @@
-'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.es.js

@@ -1,22 +0,0 @@
-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

@@ -1,24 +0,0 @@
-'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.es.js

@@ -1,20 +0,0 @@
-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

@@ -1,38 +0,0 @@
-'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.es.js

@@ -1,34 +0,0 @@
-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

@@ -1,33 +0,0 @@
-'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.es.js

@@ -1,29 +0,0 @@
-import { validatePK } from '@fjell/core';
-import { NotFoundError } from '@fjell/http-api';
-import LibLogger from '../logger.es.js';
-
-const logger = LibLogger.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 NotFoundError) ; else {
-            throw e;
-        }
-    }
-    return [
-        cacheMap,
-        retItem ? validatePK(retItem, pkType) : null
-    ];
-};
-
-export { one };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib25lLmVzLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/ops/remove.cjs.js

@@ -1,30 +0,0 @@
-'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('remove');
-const remove = async (api, cacheMap, key)=>{
-    logger.default('remove', {
-        key
-    });
-    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;
-};
-
-exports.remove = remove;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVtb3ZlLmNqcy5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==