@fjell/core 4.4.13 → 4.4.16

package/dist/index.cjs

@@ -1,1131 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-const Logging = require('@fjell/logging');
-const deepmerge = require('deepmerge');
-const luxon = require('luxon');
-
-function _interopNamespaceDefault(e) {
-  const n = Object.create(null, { [Symbol.toStringTag]: { value: 'Module' } });
-  if (e) {
-    for (const k in e) {
-      if (k !== 'default') {
-        const d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: () => e[k]
-        });
-      }
-    }
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-const luxon__namespace = /*#__PURE__*/_interopNamespaceDefault(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');
-// Normalize a key value to string for consistent comparison and hashing
-const normalizeKeyValue = (value)=>{
-    return String(value);
-};
-// Normalized hash function for Dictionary that converts pk/lk values to strings
-const createNormalizedHashFunction = ()=>{
-    return (key)=>{
-        if (typeof key === 'object' && key !== null) {
-            // Create a normalized version of the key with string values
-            const normalizedKey = JSON.parse(JSON.stringify(key));
-            // Normalize pk values
-            if ('pk' in normalizedKey && normalizedKey.pk !== undefined && normalizedKey.pk !== null) {
-                normalizedKey.pk = normalizeKeyValue(normalizedKey.pk);
-            }
-            // Normalize lk values
-            if ('lk' in normalizedKey && normalizedKey.lk !== undefined && 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 !== undefined && locItem.lk !== null) {
-                        return {
-                            ...locItem,
-                            lk: normalizeKeyValue(locItem.lk)
-                        };
-                    }
-                    return locItem;
-                });
-            }
-            return JSON.stringify(normalizedKey);
-        }
-        return JSON.stringify(key);
-    };
-};
-// Normalized comparison functions
-const isPriKeyEqualNormalized = (a, b)=>{
-    logger$2.trace('isPriKeyEqualNormalized', {
-        a,
-        b
-    });
-    return a && b && normalizeKeyValue(a.pk) === normalizeKeyValue(b.pk) && a.kt === b.kt;
-};
-const isLocKeyEqualNormalized = (a, b)=>{
-    logger$2.trace('isLocKeyEqualNormalized', {
-        a,
-        b
-    });
-    return a && b && normalizeKeyValue(a.lk) === normalizeKeyValue(b.lk) && a.kt === b.kt;
-};
-const isComKeyEqualNormalized = (a, b)=>{
-    logger$2.trace('isComKeyEqualNormalized', {
-        a,
-        b
-    });
-    if (a && b && isPriKeyEqualNormalized({
-        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 (!isLocKeyEqualNormalized(a.loc[i], b.loc[i])) {
-                    return false;
-                }
-            }
-            return true;
-        } else {
-            return false;
-        }
-    } else {
-        return false;
-    }
-};
-const isItemKeyEqualNormalized = (a, b)=>{
-    logger$2.trace('isItemKeyEqualNormalized', {
-        a,
-        b
-    });
-    if (isComKey(a) && isComKey(b)) {
-        return isComKeyEqualNormalized(a, b);
-    } else if (isPriKey(a) && isPriKey(b)) {
-        if (isComKey(a) || isComKey(b)) {
-            return false;
-        } else {
-            return isPriKeyEqualNormalized(a, b);
-        }
-    } else {
-        return false;
-    }
-};
-// Original comparison functions (kept for backward compatibility)
-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' || typeof pk === 'number') {
-        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__namespace.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 validatePKForItem = (item, pkType)=>{
-    if (!item) {
-        logger.error('Validating PK, Item is undefined', {
-            item
-        });
-        throw new Error('Validating PK, Item is undefined');
-    }
-    if (!item.key) {
-        logger.error('Validating PK, Item does not have a key', {
-            item
-        });
-        throw new Error('Validating PK, Item does not have a key');
-    }
-    const keyTypeArray = toKeyTypeArray(item.key);
-    if (keyTypeArray[0] !== pkType) {
-        logger.error('Key Type Array Mismatch', {
-            keyTypeArray,
-            pkType
-        });
-        throw new Error(`Item does not have the correct primary key type. Expected ${pkType}, got ${keyTypeArray[0]}`);
-    }
-    return item;
-};
-const validatePK = (input, pkType)=>{
-    logger.trace('Checking Return Type', {
-        input
-    });
-    if (Array.isArray(input)) {
-        return input.map((item)=>validatePKForItem(item, pkType));
-    }
-    return validatePKForItem(input, pkType);
-};
-const validateKeys = (item, keyTypes)=>{
-    logger.trace('Checking Return Type', {
-        item
-    });
-    if (!item) {
-        throw new Error('validating keys, item is undefined');
-    }
-    if (!item.key) {
-        throw new Error('validating keys, item does not have a key: ' + JSON.stringify(item));
-    }
-    const keyTypeArray = toKeyTypeArray(item.key);
-    if (keyTypeArray.length !== keyTypes.length) {
-        throw new Error(`Item does not have the correct number of keys. Expected ${keyTypes.length}, but got ${keyTypeArray.length}`);
-    }
-    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. Expected [${keyTypes.join(', ')}], but got [${keyTypeArray.join(', ')}]`);
-    }
-    return item;
-};
-const isPriItem = (item)=>{
-    return !!(item && item.key && isPriKey(item.key));
-};
-const isComItem = (item)=>{
-    return !!(item && item.key && isComKey(item.key));
-};
-
-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.createNormalizedHashFunction = createNormalizedHashFunction;
-exports.generateKeyArray = generateKeyArray;
-exports.ikToLKA = ikToLKA;
-exports.isComItem = isComItem;
-exports.isComKey = isComKey;
-exports.isComKeyEqual = isComKeyEqual;
-exports.isComKeyEqualNormalized = isComKeyEqualNormalized;
-exports.isCondition = isCondition;
-exports.isItemKey = isItemKey;
-exports.isItemKeyEqual = isItemKeyEqual;
-exports.isItemKeyEqualNormalized = isItemKeyEqualNormalized;
-exports.isLocKey = isLocKey;
-exports.isLocKeyEqual = isLocKeyEqual;
-exports.isLocKeyEqualNormalized = isLocKeyEqualNormalized;
-exports.isPriItem = isPriItem;
-exports.isPriKey = isPriKey;
-exports.isPriKeyEqual = isPriKeyEqual;
-exports.isPriKeyEqualNormalized = isPriKeyEqualNormalized;
-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