@fjell/core 4.4.0 → 4.4.1

package/dist/AItemService.d.ts

@@ -0,0 +1,8 @@
+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;
+    constructor(pkType: S, parentService?: AItemService<L1, L2, L3, L4, L5, never>);
+    getPkType: () => S;
+    getKeyTypes: () => AllItemTypeArrays<S, L1, L2, L3, L4, L5>;
+}

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/dictionary.d.ts

@@ -0,0 +1,16 @@
+export declare class Dictionary<T, V> {
+    protected map: {
+        [key: string]: V;
+    };
+    protected hashFunction: (key: T) => string;
+    constructor(map?: {
+        [key: string]: V;
+    }, hashFunction?: (key: T) => string);
+    set(key: T, item: V): void;
+    get(key: T): V | null;
+    delete(key: T): void;
+    keys(): T[];
+    values(): V[];
+    includesKey(key: T): boolean;
+    clone(): Dictionary<T, V>;
+}

package/dist/dictionary.js

@@ -0,0 +1,67 @@
+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
+        });
+        const hashedKey = this.hashFunction(key);
+        this.map[hashedKey] = item;
+    }
+    get(key) {
+        logger.trace('get', {
+            key
+        });
+        const hashedKey = this.hashFunction(key);
+        return this.map[hashedKey] || null;
+    }
+    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));
+    }
+    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(this, "map", {});
+        _define_property(this, "hashFunction", (key)=>JSON.stringify(key));
+        if (map) {
+            this.map = map;
+        }
+        if (hashFunction) {
+            this.hashFunction = hashFunction;
+        }
+    }
+}
+
+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/index.d.ts

@@ -0,0 +1,11 @@
+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';
+export * from './item/IQUtils';
+export * from './item/IUtils';
+export * from './item/ItemQuery';

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/item/IFactory.d.ts

@@ -0,0 +1,16 @@
+import { Item } from '../items';
+import { ComKey, PriKey } from '../keys';
+export declare class IFactory<V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never> {
+    private item;
+    constructor(props?: Record<string, any>);
+    addRef(i: Item<any, any | never, any | never, any | never, any | never, any | never>, name?: string): this;
+    static addRef<V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(i: V, name?: string): IFactory<V, S, L1, L2, L3, L4, L5>;
+    addDefaultEvents(): this;
+    addEvent(name: string, at: Date | null, by?: ComKey<any, any | never, any | never, any | never, any | never, any | never> | PriKey<any>): this;
+    static addEvent<V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(name: string, at: Date | null, by?: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>): IFactory<V, S, L1, L2, L3, L4, L5>;
+    addProp(name: string, value: string | number | boolean | Date): this;
+    static addProp<V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(name: string, value: string | number | boolean | Date): IFactory<V, S, L1, L2, L3, L4, L5>;
+    addProps(props: Record<string, any>): this;
+    static addProps<V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(props: Record<string, any>): IFactory<V, S, L1, L2, L3, L4, L5>;
+    toItem(): V;
+}

package/dist/item/IFactory.js

@@ -0,0 +1,89 @@
+import deepmerge from 'deepmerge';
+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);
+        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(this, "item", {});
+        this.item = deepmerge(this.item, props);
+    }
+}
+
+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/item/IQFactory.d.ts

@@ -0,0 +1,23 @@
+import { CompoundType, Condition, ConditionOperator, EventQuery, ItemQuery, OrderDirection } from './ItemQuery';
+export declare class IQFactory {
+    private query;
+    constructor(query?: ItemQuery);
+    orderBy(field: string, direction?: OrderDirection): this;
+    agg(name: string, query: ItemQuery): this;
+    event(name: string, query: EventQuery): this;
+    conditions(conditions: Condition[], compoundType?: CompoundType): this;
+    limit(limit: number): this;
+    offset(offset: number): this;
+    pk(kt: string, pk: string, name?: string): this;
+    condition(column: string, value: string[] | string | number[] | number | boolean | Date, operator?: ConditionOperator): this;
+    static all(): IQFactory;
+    static orderBy(field: string, direction?: OrderDirection): IQFactory;
+    static agg(name: string, query: ItemQuery): IQFactory;
+    static event(name: string, query: EventQuery): IQFactory;
+    static limit(limit: number): IQFactory;
+    static offset(offset: number): IQFactory;
+    static pk(kt: string, pk: string, name?: string): IQFactory;
+    static condition(column: string, value: string[] | string | number[] | number | boolean | Date, operator?: ConditionOperator): IQFactory;
+    static conditions(conditions: Condition[], compoundType?: CompoundType): IQFactory;
+    toQuery(): ItemQuery;
+}

package/dist/item/IQFactory.js

@@ -0,0 +1,150 @@
+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
+        });
+        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;
+    }
+}
+
+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/item/IQUtils.d.ts

@@ -0,0 +1,35 @@
+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.
+ *
+ * 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.
+ */
+export declare const queryToParams: (query: ItemQuery) => QueryParams;
+/**
+ * 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.
+ */
+export declare const paramsToQuery: (params: QueryParams) => ItemQuery;
+export declare const isQueryMatch: <S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(item: Item<S, L1, L2, L3, L4, L5>, query: ItemQuery) => boolean;
+export declare const abbrevQuery: (query: ItemQuery | null | undefined) => string;
+export declare const abbrevRef: <S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never>(key: string, ref: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>) => string;
+export declare const abbrevAgg: (key: string, agg: ItemQuery) => string;
+export declare const abbrevCompoundCondition: (compoundCondition: CompoundCondition) => string;
+export declare const abbrevCondition: (condition: Condition | CompoundCondition) => string;