@fjell/core 4.4.1 → 4.4.3

package/dist/index.cjs

@@ -0,0 +1,1021 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const Logging = require('@fjell/logging');
+const deepmerge = require('deepmerge');
+const luxon = require('luxon');
+
+const LibLogger = Logging.getLogger('@fjell/core');
+
+function _define_property$3(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+const logger$3 = LibLogger.get("Dictionary");
+class Dictionary {
+    set(key, item) {
+        logger$3.trace('set', {
+            key,
+            item
+        });
+        const hashedKey = this.hashFunction(key);
+        this.map[hashedKey] = item;
+    }
+    get(key) {
+        logger$3.trace('get', {
+            key
+        });
+        const hashedKey = this.hashFunction(key);
+        return this.map[hashedKey] || null;
+    }
+    delete(key) {
+        logger$3.trace('delete', {
+            key
+        });
+        const hashedKey = this.hashFunction(key);
+        delete this.map[hashedKey];
+    }
+    keys() {
+        return Object.keys(this.map).map((key)=>JSON.parse(key));
+    }
+    values() {
+        return Object.values(this.map);
+    }
+    includesKey(key) {
+        return Object.keys(this.map).includes(this.hashFunction(key));
+    }
+    clone() {
+        const clonedMap = Object.assign({}, this.map);
+        const clone = new Dictionary(clonedMap, this.hashFunction);
+        return clone;
+    }
+    constructor(map, hashFunction){
+        _define_property$3(this, "map", {});
+        _define_property$3(this, "hashFunction", (key)=>JSON.stringify(key));
+        if (map) {
+            this.map = map;
+        }
+        if (hashFunction) {
+            this.hashFunction = hashFunction;
+        }
+    }
+}
+
+const logger$2 = LibLogger.get('KUtils');
+const isItemKeyEqual = (a, b)=>{
+    logger$2.trace('isKeyEqual', {
+        a,
+        b
+    });
+    if (isComKey(a) && isComKey(b)) {
+        return isComKeyEqual(a, b);
+    } else if (isPriKey(a) && isPriKey(b)) {
+        if (isComKey(a) || isComKey(b)) {
+            return false;
+        } else {
+            return isPriKeyEqual(a, b);
+        }
+    } else {
+        return false;
+    }
+};
+const isPriKeyEqual = (a, b)=>{
+    logger$2.trace('isPriKeyEqual', {
+        a,
+        b
+    });
+    return a && b && a.pk === b.pk && a.kt === b.kt;
+};
+const isLocKeyEqual = (a, b)=>{
+    logger$2.trace('isLocKeyEqual', {
+        a,
+        b
+    });
+    return a && b && a.lk === b.lk && a.kt === b.kt;
+};
+const isComKeyEqual = (a, b)=>{
+    logger$2.trace('isComKeyEqual', {
+        a,
+        b
+    });
+    if (a && b && isPriKeyEqual({
+        kt: a.kt,
+        pk: a.pk
+    }, {
+        kt: b.kt,
+        pk: b.pk
+    })) {
+        if (a.loc.length === b.loc.length) {
+            for(let i = 0; i < a.loc.length; i++){
+                if (!isLocKeyEqual(a.loc[i], b.loc[i])) {
+                    return false;
+                }
+            }
+            return true;
+        } else {
+            return false;
+        }
+    } else {
+        return false;
+    }
+};
+const isItemKey = (key)=>{
+    logger$2.trace('isItemKey', {
+        key
+    });
+    return key !== undefined && (isComKey(key) || isPriKey(key));
+};
+const isComKey = (key)=>{
+    logger$2.trace('isComKey', {
+        key
+    });
+    return key !== undefined && key.pk !== undefined && key.kt !== undefined && key.loc !== undefined && key.loc.length > 0;
+};
+const isPriKey = (key)=>{
+    logger$2.trace('isPriKey', {
+        key
+    });
+    return key !== undefined && key.pk !== undefined && key.kt !== undefined && (key.loc === undefined || key.loc.length === 0);
+};
+const isLocKey = (key)=>{
+    logger$2.trace('isLocKey', {
+        key
+    });
+    return key !== undefined && key.lk !== undefined && key.kt !== undefined;
+};
+const generateKeyArray = (key)=>{
+    logger$2.trace('generateKeyArray', {
+        key
+    });
+    const keys = [];
+    if (isComKey(key) || isPriKey(key)) {
+        // console.log('it is an item key');
+        if (isComKey(key)) {
+            //  console.log('it is a composite key');
+            const comKey = key;
+            keys.push({
+                pk: comKey.pk,
+                kt: comKey.kt
+            });
+            for(let i = 0; i < comKey.loc.length; i++){
+                keys.push(comKey.loc[i]);
+            }
+        } else {
+            keys.push(key);
+        }
+    } else {
+        // console.log('is is an array, length: ' + key.length);
+        const locKeys = key;
+        for(let i = 0; i < locKeys.length; i++){
+            // console.log('Pushing a key');
+            keys.push(locKeys[i]);
+        }
+    }
+    return keys;
+};
+// TODO: Exactly the same as in ContainedItemLib
+const constructPriKey = (pk, kt)=>{
+    logger$2.trace('constructPriKey', {
+        pk,
+        kt
+    });
+    let pri;
+    if (typeof pk === 'string') {
+        pri = {
+            kt: kt,
+            pk: pk
+        };
+    } else {
+        pri = pk;
+    }
+    return pri;
+};
+// TODO: Exactly the same as in ContainedItemLib
+const cPK = constructPriKey;
+const toKeyTypeArray = (ik)=>{
+    logger$2.trace('toKeyTypeArray', {
+        ik
+    });
+    if (isComKey(ik)) {
+        const ck = ik;
+        return [
+            ck.kt,
+            ...ck.loc.map((l)=>l.kt)
+        ];
+    } else {
+        return [
+            ik.kt
+        ];
+    }
+};
+const abbrevIK = (ik)=>{
+    logger$2.trace('abbrevIK', {
+        ik
+    });
+    if (ik) {
+        if (isComKey(ik)) {
+            const ck = ik;
+            return `${ck.kt}:${ck.pk}:${ck.loc.map((l)=>`${l.kt}:${l.lk}`).join(',')}`;
+        } else {
+            return `${ik.kt}:${ik.pk}`;
+        }
+    } else {
+        return 'null IK';
+    }
+};
+const abbrevLKA = (keyArray)=>{
+    logger$2.trace('abbrevLKA', {
+        keyArray
+    });
+    if (keyArray === undefined || keyArray === null) {
+        return 'null LKA';
+    } else {
+        return keyArray.map((key)=>{
+            if (key) {
+                return `${key.kt}:${key.lk}`;
+            } else {
+                return key;
+            }
+        }).join(',');
+    }
+};
+const primaryType = (ik)=>{
+    logger$2.trace('primaryType', {
+        ik
+    });
+    if (isComKey(ik)) {
+        return ik.kt;
+    } else {
+        return ik.kt;
+    }
+};
+/**
+ *
+ * @param ik ItemKey to be used as a basis for a location
+ * @returns
+ */ const itemKeyToLocKeyArray = (ik)=>{
+    logger$2.trace('itemKeyToLocKeyArray', {
+        ik: abbrevIK(ik)
+    });
+    let lka = [];
+    if (isComKey(ik)) {
+        const ck = ik;
+        lka = [
+            {
+                kt: ck.kt,
+                lk: ck.pk
+            },
+            ...ck.loc
+        ];
+    } else {
+        const pk = ik;
+        lka = [
+            {
+                kt: pk.kt,
+                lk: pk.pk
+            }
+        ];
+    }
+    logger$2.trace('itemKeyToLocKeyArray Results', {
+        ik: abbrevIK(ik),
+        lka: abbrevLKA(lka)
+    });
+    return lka;
+};
+const ikToLKA = itemKeyToLocKeyArray;
+/**
+ * Sometimes you need to take a location key array and convert it to the item key that points to the containing item.
+ * @param lka A location key array
+ * @returns An item key corresponding to the containing item this location refers to.
+ */ const locKeyArrayToItemKey = (lka)=>{
+    logger$2.trace('locKeyArrayToItemKey', {
+        lka: abbrevLKA(lka)
+    });
+    if (lka && lka.length === 1) {
+        const priKey = cPK(lka[0].lk, lka[0].kt);
+        return priKey;
+    } else if (lka && lka.length > 1 && lka[0] !== undefined) {
+        const locs = lka.slice(1);
+        const priKey = cPK(lka[0].lk, lka[0].kt);
+        const comKey = {
+            kt: priKey.kt,
+            pk: priKey.pk,
+            loc: locs
+        };
+        return comKey;
+    } else {
+        throw new Error('locKeyArrayToItemKey: lka is undefined or empty');
+    }
+};
+// TODO: This is annoying that we have to check for '' and 'null'
+const isValidPriKey = (key)=>{
+    const valid = key !== undefined && key !== null && key.pk !== undefined && key.pk !== null && key.pk !== '' && key.pk !== 'null' && key.kt !== undefined && key.kt !== null && key.kt !== '' && key.kt !== 'null';
+    return valid;
+};
+// TODO: This is annoying that we have to check for '' and 'null'
+const isValidLocKey = (key)=>{
+    const valid = key !== undefined && key !== null && key.lk !== undefined && key.lk !== null && key.lk !== '' && key.lk !== 'null' && key.kt !== undefined && key.kt !== null && key.kt !== '' && key.kt !== 'null';
+    return valid;
+};
+const isValidLocKeyArray = (keyArray)=>{
+    return keyArray !== undefined && keyArray !== null && keyArray.every(isValidLocKey);
+};
+const isValidComKey = (key)=>{
+    return key !== undefined && key !== null && isValidPriKey(key) && isValidLocKeyArray(key.loc);
+};
+const isValidItemKey = (key)=>{
+    return isComKey(key) && isValidComKey(key) || isPriKey(key) && isValidPriKey(key);
+};
+const lkaToIK = locKeyArrayToItemKey;
+
+function _define_property$2(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+class IFactory {
+    addRef(i, name) {
+        const ik = i.key;
+        const refName = name || primaryType(ik);
+        if (!this.item.refs) {
+            this.item.refs = {};
+        }
+        this.item.refs[refName] = ik;
+        return this;
+    }
+    static addRef(i, name) {
+        return new IFactory().addRef(i, name);
+    }
+    addDefaultEvents() {
+        if (!this.item.events) {
+            this.item.events = {};
+        }
+        const now = new Date();
+        if (!this.item.events.created) {
+            this.item.events.created = {
+                at: now
+            };
+        }
+        if (!this.item.events.updated) {
+            this.item.events.updated = {
+                at: now
+            };
+        }
+        if (!this.item.events.deleted) {
+            this.item.events.deleted = {
+                at: null
+            };
+        }
+        return this;
+    }
+    addEvent(name, at, by) {
+        if (!this.item.events) {
+            this.item.events = {};
+        }
+        this.item.events[name] = {
+            at,
+            by
+        };
+        return this;
+    }
+    static addEvent(name, at, by) {
+        return new IFactory().addEvent(name, at, by);
+    }
+    addProp(name, value) {
+        this.item[name] = value;
+        return this;
+    }
+    static addProp(name, value) {
+        return new IFactory().addProp(name, value);
+    }
+    addProps(props) {
+        this.item = deepmerge(this.item, props);
+        return this;
+    }
+    static addProps(props) {
+        return new IFactory().addProps(props);
+    }
+    toItem() {
+        return this.item;
+    }
+    constructor(props = {}){
+        _define_property$2(this, "item", {});
+        this.item = deepmerge(this.item, props);
+    }
+}
+
+function _define_property$1(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+class AItemService {
+    constructor(pkType, parentService){
+        _define_property$1(this, "pkType", void 0);
+        _define_property$1(this, "parentService", null);
+        _define_property$1(this, "getPkType", ()=>{
+            return this.pkType;
+        });
+        _define_property$1(this, "getKeyTypes", ()=>{
+            let keyTypes = [
+                this.getPkType()
+            ];
+            if (this.parentService) {
+                keyTypes = keyTypes.concat(this.parentService.getKeyTypes());
+            }
+            return keyTypes;
+        });
+        this.pkType = pkType;
+        if (parentService) {
+            this.parentService = parentService;
+        }
+    }
+}
+
+const isCondition = (condition)=>{
+    return (typeof condition.column === 'string' && Array.isArray(condition.value) && condition.value.every((item)=>typeof item === 'string') || Array.isArray(condition.value) && condition.value.every((item)=>typeof item === 'number') || typeof condition.value === 'string' || typeof condition.value === 'number' || typeof condition.value === 'boolean' || condition.value instanceof Date) && (condition.operator ? typeof condition.operator === 'string' : true);
+};
+
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+class IQFactory {
+    orderBy(field, direction = 'asc') {
+        if (!this.query.orderBy) {
+            this.query.orderBy = [];
+        }
+        this.query.orderBy.push({
+            field,
+            direction
+        });
+        return this;
+    }
+    agg(name, query) {
+        if (!this.query.aggs) {
+            this.query.aggs = {};
+        }
+        this.query.aggs[name] = query;
+        return this;
+    }
+    event(name, query) {
+        if (!this.query.events) {
+            this.query.events = {};
+        }
+        this.query.events[name] = query;
+        return this;
+    }
+    conditions(conditions, compoundType = 'AND') {
+        for (const condition of conditions){
+            if (!isCondition(condition)) {
+                throw new Error(`Invalid condition: ${JSON.stringify(condition)}`);
+            }
+        }
+        if (!this.query.compoundCondition) {
+            // If there is no top-level compound condition, create one
+            // with the given compound type.   This will mostly likely be the most common case.
+            this.query.compoundCondition = {
+                compoundType,
+                conditions: conditions
+            };
+        } else {
+            // If there is already a top-level compound condition, create a new compound condition
+            // and add it to the conditions array of the top-level compound condition.
+            const compoundCondition = {
+                compoundType,
+                conditions
+            };
+            this.query.compoundCondition.conditions.push(compoundCondition);
+        }
+        return this;
+    }
+    limit(limit) {
+        this.query.limit = limit;
+        return this;
+    }
+    offset(offset) {
+        this.query.offset = offset;
+        return this;
+    }
+    // TODO: right now, we're only supporting PK refs for queries.  Should add support for CKs
+    pk(kt, pk, name) {
+        if (!this.query.refs) {
+            this.query.refs = {};
+        }
+        const refName = name || kt;
+        this.query.refs[refName] = cPK(pk, kt);
+        return this;
+    }
+    condition(column, value, operator = '==') {
+        const condition = {
+            column,
+            value,
+            operator
+        };
+        if (isCondition(condition)) {
+            if (!this.query.compoundCondition) {
+                // If there is no top-level compound condition, create one
+                // with the default compound type of 'AND'.
+                this.query.compoundCondition = {
+                    compoundType: 'AND',
+                    conditions: []
+                };
+            }
+            this.query.compoundCondition.conditions.push(condition);
+            return this;
+        } else {
+            throw new Error(`Invalid condition: ${JSON.stringify(condition)}`);
+        }
+    }
+    static all() {
+        const iqFactory = new IQFactory();
+        return iqFactory;
+    }
+    static orderBy(field, direction = 'asc') {
+        const iqFactory = new IQFactory();
+        return iqFactory.orderBy(field, direction);
+    }
+    static agg(name, query) {
+        const iqFactory = new IQFactory();
+        return iqFactory.agg(name, query);
+    }
+    static event(name, query) {
+        const iqFactory = new IQFactory();
+        return iqFactory.event(name, query);
+    }
+    static limit(limit) {
+        const iqFactory = new IQFactory();
+        return iqFactory.limit(limit);
+    }
+    static offset(offset) {
+        const iqFactory = new IQFactory();
+        return iqFactory.offset(offset);
+    }
+    static pk(kt, pk, name) {
+        const iqFactory = new IQFactory();
+        return iqFactory.pk(kt, pk, name);
+    }
+    static condition(column, value, operator = '==') {
+        const iqFactory = new IQFactory();
+        return iqFactory.condition(column, value, operator);
+    }
+    static conditions(conditions, compoundType = 'AND') {
+        const iqFactory = new IQFactory();
+        return iqFactory.conditions(conditions, compoundType);
+    }
+    toQuery() {
+        return this.query;
+    }
+    constructor(query = {}){
+        _define_property(this, "query", {});
+        this.query = query;
+    }
+}
+
+const logger$1 = LibLogger.get('IQUtils');
+/**
+ * When we query or search, we're sending a GET request.  This converts everything in ItemQuery into a flat
+ * object that can be sent over a GET request.
+ *
+ * Note that there is some discussion about this.  Evidently Elastic supports search with POST, but that also
+ * feels like a bit of a hack. It's not a RESTful way to do things.  So we're sticking with GET for now.
+ *
+ * For reference, look at RFC 9110 "HTTP Semantics", June which clarified on top of and RFC 7231.  It's possible
+ * but there are so many caveats and conditions in the standard, it's not worth it.
+ *
+ * Anticipating the next question - "isn't there a limit to the length of a URL?"   The specification does not
+ * specify a limit, and there are limits in various browsers and servers - Apache is 4,000 chars, Chrome is 2M chars.
+ * Short answer is that if this query is being used to craft something that complex, it is probably a better idea
+ * to provide an action or a custom query endpoint on the server.
+ *
+ * @param query
+ * @returns QueryParams ready to be get over a GET request.
+ */ const queryToParams = (query)=>{
+    const params = {};
+    if (query.compoundCondition) {
+        params.compoundCondition = JSON.stringify(query.compoundCondition);
+    }
+    if (query.refs) {
+        params.refs = JSON.stringify(query.refs);
+    }
+    if (query.limit) {
+        params.limit = query.limit;
+    }
+    if (query.offset) {
+        params.offset = query.offset;
+    }
+    if (query.aggs) {
+        params.aggs = JSON.stringify(query.aggs);
+    }
+    if (query.events) {
+        params.events = JSON.stringify(query.events);
+    }
+    return params;
+};
+// This is a dateTimeReviver used for JSON parse - when we convert a param back to a query, we need this.
+const dateTimeReviver = function(key, value) {
+    if (typeof value === 'string') {
+        const parsedDate = luxon.DateTime.fromISO(value);
+        if (parsedDate.isValid) {
+            return parsedDate.toJSDate();
+        }
+    }
+    return value;
+};
+/**
+ * This method translates from a flat QueryParams object with stringify'd JSON back to a full ItemQuery.
+ *
+ * @param params Parameters sent over a GET request
+ * @returns A fully hydrated ItemQuery object.
+ */ const paramsToQuery = (params)=>{
+    const query = {};
+    if (params.compoundCondition) {
+        query.compoundCondition = JSON.parse(params.compoundCondition);
+    }
+    if (params.refs) {
+        query.refs = JSON.parse(params.refs);
+    }
+    if (params.limit) {
+        query.limit = Number(params.limit);
+    }
+    if (params.offset) {
+        query.offset = Number(params.offset);
+    }
+    if (params.aggs) {
+        query.aggs = JSON.parse(params.aggs);
+    }
+    if (params.events) {
+        query.events = JSON.parse(params.events, dateTimeReviver);
+    }
+    return query;
+};
+const isRefQueryMatch = (refKey, queryRef, references)=>{
+    logger$1.trace('doesRefMatch', {
+        queryRef,
+        references
+    });
+    logger$1.debug('Comparing Ref', {
+        refKey,
+        itemRef: references[refKey],
+        queryRef
+    });
+    return isItemKeyEqual(queryRef, references[refKey]);
+};
+const isCompoundConditionQueryMatch = (queryCondition, item)=>{
+    if (queryCondition.compoundType === 'AND') {
+        // If this is an AND compound condition, we need to check if all of the conditions match
+        return queryCondition.conditions.every((condition)=>isCondition(condition) ? isConditionQueryMatch(condition, item) : isCompoundConditionQueryMatch(condition, item));
+    } else {
+        // If this is an OR compound condition, we need to check if any of the conditions match
+        return queryCondition.conditions.some((condition)=>isCondition(condition) ? isConditionQueryMatch(condition, item) : isCompoundConditionQueryMatch(condition, item));
+    }
+};
+const isConditionQueryMatch = (queryCondition, item)=>{
+    const propKey = queryCondition.column;
+    logger$1.trace('doesConditionMatch', {
+        propKey,
+        queryCondition,
+        item
+    });
+    // eslint-disable-next-line no-undefined
+    if (item[propKey] === undefined) {
+        logger$1.debug('Item does not contain prop under key', {
+            propKey,
+            item
+        });
+        return false;
+    }
+    logger$1.debug('Comparing Condition', {
+        propKey,
+        itemProp: item[propKey],
+        queryCondition
+    });
+    let result = false;
+    switch(queryCondition.operator){
+        case '==':
+            result = item[propKey] === queryCondition.value;
+            break;
+        case '!=':
+            result = item[propKey] !== queryCondition.value;
+            break;
+        case '>':
+            result = item[propKey] > queryCondition.value;
+            break;
+        case '>=':
+            result = item[propKey] >= queryCondition.value;
+            break;
+        case '<':
+            result = item[propKey] < queryCondition.value;
+            break;
+        case '<=':
+            result = item[propKey] <= queryCondition.value;
+            break;
+        case 'in':
+            result = queryCondition.value.includes(item[propKey]);
+            break;
+        case 'not-in':
+            result = !queryCondition.value.includes(item[propKey]);
+            break;
+        case 'array-contains':
+            result = item[propKey].includes(queryCondition.value);
+            break;
+        case 'array-contains-any':
+            result = queryCondition.value.some((value)=>item[propKey].includes(value));
+            break;
+    }
+    return result;
+};
+const isAggQueryMatch = (aggKey, aggQuery, agg)=>{
+    const aggItem = agg.item;
+    logger$1.debug('Comparing Agg', {
+        aggKey,
+        aggItem,
+        aggQuery
+    });
+    // Fancy, right?  This is a recursive call to isQueryMatch
+    return isQueryMatch(aggItem, aggQuery);
+};
+const isEventQueryMatch = (eventKey, eventQuery, item)=>{
+    if (!item.events[eventKey]) {
+        logger$1.debug('Item does not contain event under key', {
+            eventKey,
+            events: item.events
+        });
+        return false;
+    } else {
+        const itemEvent = item.events[eventKey];
+        if (itemEvent.at !== null) {
+            if (eventQuery.start && !(eventQuery.start.getTime() <= itemEvent.at.getTime())) {
+                logger$1.debug('Item date before event start query', {
+                    eventQuery,
+                    itemEvent
+                });
+                return false;
+            }
+            if (eventQuery.end && !(eventQuery.end.getTime() > itemEvent.at.getTime())) {
+                logger$1.debug('Item date after event end query', {
+                    eventQuery,
+                    itemEvent
+                });
+                return false;
+            }
+        } else {
+            logger$1.debug('Item event does contains a null at', {
+                itemEvent
+            });
+            return false;
+        }
+        return true;
+    }
+};
+const isQueryMatch = (item, query)=>{
+    logger$1.trace('isMatch', {
+        item,
+        query
+    });
+    if (query.refs && item.refs) {
+        for(const key in query.refs){
+            const queryRef = query.refs[key];
+            if (!isRefQueryMatch(key, queryRef, item.refs)) return false;
+        }
+    } else if (query.refs && !item.refs) {
+        logger$1.debug('Query contains refs but item does not have refs', {
+            query,
+            item
+        });
+        return false;
+    }
+    if (query.compoundCondition && item) {
+        if (!isCompoundConditionQueryMatch(query.compoundCondition, item)) return false;
+    }
+    if (query.events && item.events) {
+        for(const key in query.events){
+            const queryEvent = query.events[key];
+            if (!isEventQueryMatch(key, queryEvent, item)) return false;
+        }
+        return true;
+    }
+    if (query.aggs && item.aggs) {
+        for(const key in query.aggs){
+            const aggQuery = query.aggs[key];
+            if (item.aggs[key] && !isAggQueryMatch(key, aggQuery, item.aggs[key])) return false;
+        }
+    }
+    if (query.aggs && !item.aggs) {
+        logger$1.debug('Query contains aggs but item does not have aggs', {
+            query,
+            item
+        });
+        return false;
+    }
+    // If it hasn't returned false by now, it must be a match
+    return true;
+};
+const abbrevQuery = (query)=>{
+    const abbrev = [
+        'IQ'
+    ];
+    if (query) {
+        if (query.refs) {
+            for(const key in query.refs){
+                const ref = abbrevRef(key, query.refs[key]);
+                abbrev.push(ref);
+            }
+        }
+        if (query.compoundCondition) {
+            const props = abbrevCompoundCondition(query.compoundCondition);
+            abbrev.push(props);
+        }
+        if (query.aggs) {
+            for(const key in query.aggs){
+                const agg = abbrevAgg(key, query.aggs[key]);
+                abbrev.push(agg);
+            }
+        }
+        if (query.events) {
+            const events = `(E${Object.keys(query.events).join(',')})`;
+            abbrev.push(events);
+        }
+        if (query.limit) {
+            abbrev.push(`L${query.limit}`);
+        }
+        if (query.offset) {
+            abbrev.push(`O${query.offset}`);
+        }
+    } else {
+        abbrev.push('(empty)');
+    }
+    return abbrev.join(' ');
+};
+const abbrevRef = (key, ref)=>{
+    if (isPriKey(ref)) {
+        const priKey = ref;
+        return `R(${key},${priKey.kt},${priKey.pk})`;
+    } else {
+        const comKey = ref;
+        return `R(${key},${JSON.stringify(comKey)})`;
+    }
+};
+const abbrevAgg = (key, agg)=>{
+    return `A(${key},${abbrevQuery(agg)})`;
+};
+const abbrevCompoundCondition = (compoundCondition)=>{
+    return `CC(${compoundCondition.compoundType},` + `${compoundCondition.conditions ? compoundCondition.conditions.map(abbrevCondition).join(',') : 'No Conditions'})`;
+};
+const abbrevCondition = (condition)=>{
+    if (isCondition(condition)) {
+        return `(${condition.column},${condition.value},${condition.operator})`;
+    } else {
+        return abbrevCompoundCondition(condition);
+    }
+};
+
+const logger = LibLogger.get('IUtils');
+const validatePK = (input, pkType)=>{
+    logger.trace('Checking Return Type', {
+        input
+    });
+    if (Array.isArray(input)) {
+        const itemArray = input;
+        return itemArray.map((item)=>validatePK(item, pkType));
+    } else {
+        const item = input;
+        if (item) {
+            if (item.key) {
+                const keyTypeArray = toKeyTypeArray(item.key);
+                const match = keyTypeArray[0] === pkType;
+                if (!match) {
+                    logger.error('Key Type Array Mismatch', {
+                        keyTypeArray,
+                        pkType
+                    });
+                    throw new Error('Item does not have the correct primary key type');
+                } else {
+                    return item;
+                }
+            } else {
+                logger.error('Validating PK, Item does not have a key', {
+                    item
+                });
+                throw new Error('Validating PK, Item does not have a key');
+            }
+        } else {
+            logger.error('Validating PK, Item is undefined', {
+                item
+            });
+            throw new Error('Validating PK, Item is undefined');
+        }
+    }
+};
+const validateKeys = (item, keyTypes)=>{
+    logger.trace('Checking Return Type', {
+        item
+    });
+    if (item) {
+        if (item.key) {
+            const keyTypeArray = toKeyTypeArray(item.key);
+            if (keyTypeArray.length !== keyTypes.length) {
+                throw new Error('Item does not have the correct number of keys');
+            } else {
+                const match = JSON.stringify(keyTypeArray) === JSON.stringify(keyTypes);
+                if (!match) {
+                    logger.error('Key Type Array Mismatch', {
+                        keyTypeArray,
+                        thisKeyTypes: keyTypes
+                    });
+                    throw new Error('Item does not have the correct key types');
+                } else {
+                    return item;
+                }
+            }
+        } else {
+            throw new Error('validating keys, item does not have a key: ' + JSON.stringify(item));
+        }
+    } else {
+        throw new Error('validating keys, item is undefined');
+    }
+};
+const isPriItem = (item)=>{
+    return item && item.key ? isPriKey(item.key) : false;
+};
+const isComItem = (item)=>{
+    return item && item.key ? isComKey(item.key) : false;
+};
+
+exports.AItemService = AItemService;
+exports.Dictionary = Dictionary;
+exports.IFactory = IFactory;
+exports.IQFactory = IQFactory;
+exports.abbrevAgg = abbrevAgg;
+exports.abbrevCompoundCondition = abbrevCompoundCondition;
+exports.abbrevCondition = abbrevCondition;
+exports.abbrevIK = abbrevIK;
+exports.abbrevLKA = abbrevLKA;
+exports.abbrevQuery = abbrevQuery;
+exports.abbrevRef = abbrevRef;
+exports.cPK = cPK;
+exports.constructPriKey = constructPriKey;
+exports.generateKeyArray = generateKeyArray;
+exports.ikToLKA = ikToLKA;
+exports.isComItem = isComItem;
+exports.isComKey = isComKey;
+exports.isComKeyEqual = isComKeyEqual;
+exports.isCondition = isCondition;
+exports.isItemKey = isItemKey;
+exports.isItemKeyEqual = isItemKeyEqual;
+exports.isLocKey = isLocKey;
+exports.isLocKeyEqual = isLocKeyEqual;
+exports.isPriItem = isPriItem;
+exports.isPriKey = isPriKey;
+exports.isPriKeyEqual = isPriKeyEqual;
+exports.isQueryMatch = isQueryMatch;
+exports.isValidComKey = isValidComKey;
+exports.isValidItemKey = isValidItemKey;
+exports.isValidLocKey = isValidLocKey;
+exports.isValidLocKeyArray = isValidLocKeyArray;
+exports.isValidPriKey = isValidPriKey;
+exports.itemKeyToLocKeyArray = itemKeyToLocKeyArray;
+exports.lkaToIK = lkaToIK;
+exports.locKeyArrayToItemKey = locKeyArrayToItemKey;
+exports.paramsToQuery = paramsToQuery;
+exports.primaryType = primaryType;
+exports.queryToParams = queryToParams;
+exports.toKeyTypeArray = toKeyTypeArray;
+exports.validateKeys = validateKeys;
+exports.validatePK = validatePK;
+//# sourceMappingURL=index.cjs.map