@fjell/core 4.3.4 → 4.4.1

package/dist/{src/AItemService.d.ts → AItemService.d.ts}

@@ -1,4 +1,4 @@
-import { AllItemTypeArrays } from "./keys";
+import { AllItemTypeArrays } from './keys';
 export declare class AItemService<S extends string, L1 extends string, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never> {
     private pkType;
     private parentService;

package/dist/AItemService.js

@@ -0,0 +1,38 @@
+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 AItemService {
+    constructor(pkType, parentService){
+        _define_property(this, "pkType", void 0);
+        _define_property(this, "parentService", null);
+        _define_property(this, "getPkType", ()=>{
+            return this.pkType;
+        });
+        _define_property(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;
+        }
+    }
+}
+
+export { AItemService };
+//# sourceMappingURL=AItemService.js.map

package/dist/AItemService.js.map

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

package/dist/{src/dictionary.js → dictionary.js}

@@ -1,33 +1,44 @@
-import LibLogger from "./logger";
-const logger = LibLogger.get("Dictionary");
-export class Dictionary {
-    map = {};
-    hashFunction = (key) => JSON.stringify(key);
-    constructor(map, hashFunction) {
-        if (map) {
-            this.map = map;
-        }
-        if (hashFunction) {
-            this.hashFunction = hashFunction;
-        }
+import LibLogger from './logger.js';
+
+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;
+}
+const logger = LibLogger.get("Dictionary");
+class Dictionary {
     set(key, item) {
-        logger.trace('set', { key, item });
+        logger.trace('set', {
+            key,
+            item
+        });
         const hashedKey = this.hashFunction(key);
         this.map[hashedKey] = item;
     }
     get(key) {
-        logger.trace('get', { key });
+        logger.trace('get', {
+            key
+        });
         const hashedKey = this.hashFunction(key);
         return this.map[hashedKey] || null;
     }
     delete(key) {
-        logger.trace('delete', { key });
+        logger.trace('delete', {
+            key
+        });
         const hashedKey = this.hashFunction(key);
         delete this.map[hashedKey];
     }
     keys() {
-        return Object.keys(this.map).map(key => JSON.parse(key));
+        return Object.keys(this.map).map((key)=>JSON.parse(key));
     }
     values() {
         return Object.values(this.map);
@@ -40,5 +51,17 @@ export class Dictionary {
         const clone = new Dictionary(clonedMap, this.hashFunction);
         return clone;
     }
+    constructor(map, hashFunction){
+        _define_property(this, "map", {});
+        _define_property(this, "hashFunction", (key)=>JSON.stringify(key));
+        if (map) {
+            this.map = map;
+        }
+        if (hashFunction) {
+            this.hashFunction = hashFunction;
+        }
+    }
 }
-//# sourceMappingURL=dictionary.js.map
+
+export { Dictionary };
+//# sourceMappingURL=dictionary.js.map

package/dist/dictionary.js.map

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

package/dist/{src/index.d.ts → index.d.ts}

@@ -1,8 +1,8 @@
-export * from "./dictionary";
-export * from "./keys";
-export * from "./items";
-export { IFactory } from "./item/IFactory";
-export { AItemService } from "./AItemService";
+export * from './dictionary';
+export * from './keys';
+export * from './items';
+export { IFactory } from './item/IFactory';
+export { AItemService } from './AItemService';
 export * from './key/KUtils';
 export * from './item/IFactory';
 export * from './item/IQFactory';

package/dist/index.js

@@ -0,0 +1,9 @@
+export { Dictionary } from './dictionary.js';
+export { IFactory } from './item/IFactory.js';
+export { AItemService } from './AItemService.js';
+export { abbrevIK, abbrevLKA, cPK, constructPriKey, generateKeyArray, ikToLKA, isComKey, isComKeyEqual, isItemKey, isItemKeyEqual, isLocKey, isLocKeyEqual, isPriKey, isPriKeyEqual, isValidComKey, isValidItemKey, isValidLocKey, isValidLocKeyArray, isValidPriKey, itemKeyToLocKeyArray, lkaToIK, locKeyArrayToItemKey, primaryType, toKeyTypeArray } from './key/KUtils.js';
+export { IQFactory } from './item/IQFactory.js';
+export { abbrevAgg, abbrevCompoundCondition, abbrevCondition, abbrevQuery, abbrevRef, isQueryMatch, paramsToQuery, queryToParams } from './item/IQUtils.js';
+export { isComItem, isPriItem, validateKeys, validatePK } from './item/IUtils.js';
+export { isCondition } from './item/ItemQuery.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

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

package/dist/{src/item → item}/IFactory.js

@@ -1,10 +1,20 @@
 import deepmerge from 'deepmerge';
-import { primaryType } from '../key/KUtils';
-export class IFactory {
-    item = {};
-    constructor(props = {}) {
-        this.item = deepmerge(this.item, props);
+import { primaryType } from '../key/KUtils.js';
+
+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 IFactory {
     addRef(i, name) {
         const ik = i.key;
         const refName = name || primaryType(ik);
@@ -23,13 +33,19 @@ export class IFactory {
         }
         const now = new Date();
         if (!this.item.events.created) {
-            this.item.events.created = { at: now };
+            this.item.events.created = {
+                at: now
+            };
         }
         if (!this.item.events.updated) {
-            this.item.events.updated = { at: now };
+            this.item.events.updated = {
+                at: now
+            };
         }
         if (!this.item.events.deleted) {
-            this.item.events.deleted = { at: null };
+            this.item.events.deleted = {
+                at: null
+            };
         }
         return this;
     }
@@ -37,7 +53,10 @@ export class IFactory {
         if (!this.item.events) {
             this.item.events = {};
         }
-        this.item.events[name] = { at, by };
+        this.item.events[name] = {
+            at,
+            by
+        };
         return this;
     }
     static addEvent(name, at, by) {
@@ -60,5 +79,11 @@ export class IFactory {
     toItem() {
         return this.item;
     }
+    constructor(props = {}){
+        _define_property(this, "item", {});
+        this.item = deepmerge(this.item, props);
+    }
 }
-//# sourceMappingURL=IFactory.js.map
+
+export { IFactory };
+//# sourceMappingURL=IFactory.js.map

package/dist/item/IFactory.js.map

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

package/dist/{src/item → item}/IQFactory.d.ts

@@ -1,4 +1,4 @@
-import { CompoundType, Condition, ConditionOperator, EventQuery, ItemQuery, OrderDirection } from "./ItemQuery";
+import { CompoundType, Condition, ConditionOperator, EventQuery, ItemQuery, OrderDirection } from './ItemQuery';
 export declare class IQFactory {
     private query;
     constructor(query?: ItemQuery);

package/dist/{src/item → item}/IQFactory.js

@@ -1,15 +1,28 @@
-import { cPK } from '../key/KUtils';
-import { isCondition } from "./ItemQuery";
-export class IQFactory {
-    query = {};
-    constructor(query = {}) {
-        this.query = query;
-    }
+import { cPK } from '../key/KUtils.js';
+import { isCondition } from './ItemQuery.js';
+
+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 });
+        this.query.orderBy.push({
+            field,
+            direction
+        });
         return this;
     }
     agg(name, query) {
@@ -27,7 +40,7 @@ export class IQFactory {
         return this;
     }
     conditions(conditions, compoundType = 'AND') {
-        for (const condition of conditions) {
+        for (const condition of conditions){
             if (!isCondition(condition)) {
                 throw new Error(`Invalid condition: ${JSON.stringify(condition)}`);
             }
@@ -37,15 +50,14 @@ export class IQFactory {
             // with the given compound type.   This will mostly likely be the most common case.
             this.query.compoundCondition = {
                 compoundType,
-                conditions: conditions,
+                conditions: conditions
             };
-        }
-        else {
+        } 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,
+                conditions
             };
             this.query.compoundCondition.conditions.push(compoundCondition);
         }
@@ -69,20 +81,23 @@ export class IQFactory {
         return this;
     }
     condition(column, value, operator = '==') {
-        const 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: [],
+                    conditions: []
                 };
             }
             this.query.compoundCondition.conditions.push(condition);
             return this;
-        }
-        else {
+        } else {
             throw new Error(`Invalid condition: ${JSON.stringify(condition)}`);
         }
     }
@@ -125,5 +140,11 @@ export class IQFactory {
     toQuery() {
         return this.query;
     }
+    constructor(query = {}){
+        _define_property(this, "query", {});
+        this.query = query;
+    }
 }
-//# sourceMappingURL=IQFactory.js.map
+
+export { IQFactory };
+//# sourceMappingURL=IQFactory.js.map

package/dist/item/IQFactory.js.map

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

package/dist/{src/item → item}/IQUtils.d.ts

@@ -1,6 +1,6 @@
-import { Item } from "../items";
-import { ComKey, PriKey } from "../keys";
-import { CompoundCondition, Condition, ItemQuery, QueryParams } from "./ItemQuery";
+import { Item } from '../items';
+import { ComKey, PriKey } from '../keys';
+import { CompoundCondition, Condition, ItemQuery, QueryParams } from './ItemQuery';
 /**
  * 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.

package/dist/{src/item → item}/IQUtils.js

@@ -1,7 +1,8 @@
-import { isItemKeyEqual, isPriKey } from "../key/KUtils";
-import LibLogger from "../logger";
-import { DateTime } from "luxon";
-import { isCondition } from "./ItemQuery";
+import { isPriKey, isItemKeyEqual } from '../key/KUtils.js';
+import LibLogger from '../logger.js';
+import { DateTime } from 'luxon';
+import { isCondition } from './ItemQuery.js';
+
 const logger = LibLogger.get('IQUtils');
 /**
  * When we query or search, we're sending a GET request.  This converts everything in ItemQuery into a flat
@@ -20,8 +21,7 @@ const logger = LibLogger.get('IQUtils');
  *
  * @param query
  * @returns QueryParams ready to be get over a GET request.
- */
-export const queryToParams = (query) => {
+ */ const queryToParams = (query)=>{
     const params = {};
     if (query.compoundCondition) {
         params.compoundCondition = JSON.stringify(query.compoundCondition);
@@ -44,12 +44,11 @@ export const queryToParams = (query) => {
     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) {
+const dateTimeReviver = function(key, value) {
     if (typeof value === 'string') {
         const parsedDate = DateTime.fromISO(value);
         if (parsedDate.isValid) {
             return parsedDate.toJSDate();
-            ;
         }
     }
     return value;
@@ -59,8 +58,7 @@ const dateTimeReviver = function (key, value) {
  *
  * @param params Parameters sent over a GET request
  * @returns A fully hydrated ItemQuery object.
- */
-export const paramsToQuery = (params) => {
+ */ const paramsToQuery = (params)=>{
     const query = {};
     if (params.compoundCondition) {
         query.compoundCondition = JSON.parse(params.compoundCondition);
@@ -82,36 +80,49 @@ export const paramsToQuery = (params) => {
     }
     return query;
 };
-const isRefQueryMatch = (refKey, queryRef, references) => {
-    logger.trace('doesRefMatch', { queryRef, references });
-    logger.debug('Comparing Ref', { refKey, itemRef: references[refKey], queryRef });
+const isRefQueryMatch = (refKey, queryRef, references)=>{
+    logger.trace('doesRefMatch', {
+        queryRef,
+        references
+    });
+    logger.debug('Comparing Ref', {
+        refKey,
+        itemRef: references[refKey],
+        queryRef
+    });
     return isItemKeyEqual(queryRef, references[refKey]);
 };
-const isCompoundConditionQueryMatch = (queryCondition, item) => {
+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 {
+        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));
+        return queryCondition.conditions.some((condition)=>isCondition(condition) ? isConditionQueryMatch(condition, item) : isCompoundConditionQueryMatch(condition, item));
     }
 };
-const isConditionQueryMatch = (queryCondition, item) => {
+const isConditionQueryMatch = (queryCondition, item)=>{
     const propKey = queryCondition.column;
-    logger.trace('doesConditionMatch', { propKey, queryCondition, item });
+    logger.trace('doesConditionMatch', {
+        propKey,
+        queryCondition,
+        item
+    });
     // eslint-disable-next-line no-undefined
     if (item[propKey] === undefined) {
-        logger.debug('Item does not contain prop under key', { propKey, item });
+        logger.debug('Item does not contain prop under key', {
+            propKey,
+            item
+        });
         return false;
     }
-    logger.debug('Comparing Condition', { propKey, itemProp: item[propKey], queryCondition });
+    logger.debug('Comparing Condition', {
+        propKey,
+        itemProp: item[propKey],
+        queryCondition
+    });
     let result = false;
-    switch (queryCondition.operator) {
+    switch(queryCondition.operator){
         case '==':
             result = item[propKey] === queryCondition.value;
             break;
@@ -140,86 +151,104 @@ const isConditionQueryMatch = (queryCondition, item) => {
             result = item[propKey].includes(queryCondition.value);
             break;
         case 'array-contains-any':
-            result = queryCondition.value
-                .some(value => item[propKey].includes(value));
+            result = queryCondition.value.some((value)=>item[propKey].includes(value));
             break;
     }
     return result;
 };
-const isAggQueryMatch = (aggKey, aggQuery, agg) => {
+const isAggQueryMatch = (aggKey, aggQuery, agg)=>{
     const aggItem = agg.item;
-    logger.debug('Comparing Agg', { aggKey, aggItem, aggQuery });
+    logger.debug('Comparing Agg', {
+        aggKey,
+        aggItem,
+        aggQuery
+    });
     // Fancy, right?  This is a recursive call to isQueryMatch
     return isQueryMatch(aggItem, aggQuery);
 };
-const isEventQueryMatch = (eventKey, eventQuery, item) => {
+const isEventQueryMatch = (eventKey, eventQuery, item)=>{
     if (!item.events[eventKey]) {
-        logger.debug('Item does not contain event under key', { eventKey, events: item.events });
+        logger.debug('Item does not contain event under key', {
+            eventKey,
+            events: item.events
+        });
         return false;
-    }
-    else {
+    } else {
         const itemEvent = item.events[eventKey];
         if (itemEvent.at !== null) {
             if (eventQuery.start && !(eventQuery.start.getTime() <= itemEvent.at.getTime())) {
-                logger.debug('Item date before event start query', { eventQuery, itemEvent });
+                logger.debug('Item date before event start query', {
+                    eventQuery,
+                    itemEvent
+                });
                 return false;
             }
             if (eventQuery.end && !(eventQuery.end.getTime() > itemEvent.at.getTime())) {
-                logger.debug('Item date after event end query', { eventQuery, itemEvent });
+                logger.debug('Item date after event end query', {
+                    eventQuery,
+                    itemEvent
+                });
                 return false;
             }
-        }
-        else {
-            logger.debug('Item event does contains a null at', { itemEvent });
+        } else {
+            logger.debug('Item event does contains a null at', {
+                itemEvent
+            });
             return false;
         }
         return true;
     }
 };
-export const isQueryMatch = (item, query) => {
-    logger.trace('isMatch', { item, query });
+const isQueryMatch = (item, query)=>{
+    logger.trace('isMatch', {
+        item,
+        query
+    });
     if (query.refs && item.refs) {
-        for (const key in query.refs) {
+        for(const key in query.refs){
             const queryRef = query.refs[key];
-            if (!isRefQueryMatch(key, queryRef, item.refs))
-                return false;
+            if (!isRefQueryMatch(key, queryRef, item.refs)) return false;
         }
-    }
-    else if (query.refs && !item.refs) {
-        logger.debug('Query contains refs but item does not have refs', { query, item });
+    } else if (query.refs && !item.refs) {
+        logger.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 (!isCompoundConditionQueryMatch(query.compoundCondition, item)) return false;
     }
     if (query.events && item.events) {
-        for (const key in query.events) {
+        for(const key in query.events){
             const queryEvent = query.events[key];
-            if (!isEventQueryMatch(key, queryEvent, item))
-                return false;
+            if (!isEventQueryMatch(key, queryEvent, item)) return false;
         }
         return true;
     }
     if (query.aggs && item.aggs) {
-        for (const key in query.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 (item.aggs[key] && !isAggQueryMatch(key, aggQuery, item.aggs[key])) return false;
         }
     }
     if (query.aggs && !item.aggs) {
-        logger.debug('Query contains aggs but item does not have aggs', { query, item });
+        logger.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;
 };
-export const abbrevQuery = (query) => {
-    const abbrev = ['IQ'];
+const abbrevQuery = (query)=>{
+    const abbrev = [
+        'IQ'
+    ];
     if (query) {
         if (query.refs) {
-            for (const key in query.refs) {
+            for(const key in query.refs){
                 const ref = abbrevRef(key, query.refs[key]);
                 abbrev.push(ref);
             }
@@ -229,7 +258,7 @@ export const abbrevQuery = (query) => {
             abbrev.push(props);
         }
         if (query.aggs) {
-            for (const key in query.aggs) {
+            for(const key in query.aggs){
                 const agg = abbrevAgg(key, query.aggs[key]);
                 abbrev.push(agg);
             }
@@ -244,35 +273,33 @@ export const abbrevQuery = (query) => {
         if (query.offset) {
             abbrev.push(`O${query.offset}`);
         }
-    }
-    else {
+    } else {
         abbrev.push('(empty)');
     }
     return abbrev.join(' ');
 };
-export const abbrevRef = (key, ref) => {
+const abbrevRef = (key, ref)=>{
     if (isPriKey(ref)) {
         const priKey = ref;
         return `R(${key},${priKey.kt},${priKey.pk})`;
-    }
-    else {
+    } else {
         const comKey = ref;
         return `R(${key},${JSON.stringify(comKey)})`;
     }
 };
-export const abbrevAgg = (key, agg) => {
+const abbrevAgg = (key, agg)=>{
     return `A(${key},${abbrevQuery(agg)})`;
 };
-export const abbrevCompoundCondition = (compoundCondition) => {
-    return `CC(${compoundCondition.compoundType},` +
-        `${compoundCondition.conditions ? compoundCondition.conditions.map(abbrevCondition).join(',') : 'No Conditions'})`;
+const abbrevCompoundCondition = (compoundCondition)=>{
+    return `CC(${compoundCondition.compoundType},` + `${compoundCondition.conditions ? compoundCondition.conditions.map(abbrevCondition).join(',') : 'No Conditions'})`;
 };
-export const abbrevCondition = (condition) => {
+const abbrevCondition = (condition)=>{
     if (isCondition(condition)) {
         return `(${condition.column},${condition.value},${condition.operator})`;
-    }
-    else {
+    } else {
         return abbrevCompoundCondition(condition);
     }
 };
-//# sourceMappingURL=IQUtils.js.map
+
+export { abbrevAgg, abbrevCompoundCondition, abbrevCondition, abbrevQuery, abbrevRef, isQueryMatch, paramsToQuery, queryToParams };
+//# sourceMappingURL=IQUtils.js.map