@fjell/cache 4.4.0

package/src/CacheMap.ts

@@ -0,0 +1,132 @@
+import {
+  AllItemTypeArrays,
+  ComKey,
+  Dictionary,
+  isComKey,
+  isQueryMatch,
+  Item,
+  ItemQuery,
+  LocKeyArray,
+  PriKey
+} from "@fjell/core";
+import LibLogger from "./logger";
+
+const logger = LibLogger.get("CacheMap");
+
+// const isObj = (x: any) => typeof x === "object" && x !== null;
+
+// const intersection = (a: object, b: object): object => {
+//   const result: { [key: string]: any } = {}
+
+//   if (([a, b]).every(isObj)) {
+//     Object.keys(a).forEach((key) => {
+//       // @ts-ignore
+//       const value = a[key]
+//       // @ts-ignore
+//       const other = b[key]
+
+//       if (isObj(value)) {
+//         result[key] = intersection(value, other)
+//       } else if (value === other) {
+//         result[key] = value
+//       }
+//     })
+//   }
+
+//   return result
+// }
+
+// const removeEmptyObjects = (obj: object): object => {
+//   const result: { [key: string]: any } = {}
+
+//   Object.keys(obj).forEach((key) => {
+//     // @ts-ignore
+//     const value = obj[key];
+
+//     if (isObj(value)) {
+//       const nested = removeEmptyObjects(value);
+
+//       if (Object.keys(nested).length > 0) {
+//         result[key] = nested
+//       }
+//     } else if (value !== null) {
+//       result[key] = value
+//     }
+//   });
+
+//   return result;
+// }
+
+export class CacheMap<
+  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
+> extends Dictionary<ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>, V> {
+
+  private types: AllItemTypeArrays<S, L1, L2, L3, L4, L5>;
+
+  public constructor(
+    types: AllItemTypeArrays<S, L1, L2, L3, L4, L5>,
+    map?: { [key: string]: V },
+  ) {
+    super(map);
+    this.types = types;
+  }
+
+  public get(
+    key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>,
+  ): V | null {
+    return super.get(key) as V | null;
+  }
+
+  public allIn(
+    locations: LocKeyArray<L1, L2, L3, L4, L5> | []
+  ): V[] {
+    if (locations.length === 0) {
+      logger.debug('Returning all items, LocKeys is empty');
+      return this.values();
+    } else {
+      const locKeys: LocKeyArray<L1, L2, L3, L4, L5> | [] = locations;
+      logger.debug('allIn', { locKeys, keys: this.keys().length });
+      return this.keys()
+        .filter((key) => key && isComKey(key))
+        .filter((key) => {
+          const ComKey = key as ComKey<S, L1, L2, L3, L4, L5>;
+          logger.debug('Comparing Location Keys', {
+            locKeys,
+            ComKey,
+          });
+          return JSON.stringify(locKeys) === JSON.stringify(ComKey.loc);
+        })
+        .map((key) => this.get(key) as V);
+    }
+  }
+
+  // TODO: Can we do case insensitive matching?
+  public contains(query: ItemQuery, locations: LocKeyArray<L1, L2, L3, L4, L5> | []): boolean {
+    logger.debug('contains', { query, locations });
+    const items = this.allIn(locations);
+
+    return items.some((item) => isQueryMatch(item, query));
+  }
+
+  public queryIn(
+    query: ItemQuery,
+    locations: LocKeyArray<L1, L2, L3, L4, L5> | [] = []
+  ): V[] {
+    logger.debug('queryIn', { query, locations });
+    const items = this.allIn(locations);
+
+    return items.filter((item) => isQueryMatch(item, query));
+  }
+
+  public clone(): CacheMap<V, S, L1, L2, L3, L4, L5> {
+    const clone = new CacheMap<V, S, L1, L2, L3, L4, L5>(this.types, this.map);
+    return clone;
+  }
+
+};

package/src/CacheRegistry.ts

@@ -0,0 +1,57 @@
+import { Item } from "@fjell/core";
+import { PItemCache } from "./PItemCache";
+import { CItemCache } from "./CItemCache";
+
+import LibLogger from './logger';
+
+const logger = LibLogger.get('CacheRegistry');
+
+export class CacheRegistry {
+
+  private static instance: CacheRegistry;
+  private configured: boolean = false;
+
+  public constructor() {
+    logger.debug('CacheRegistry created');
+  }
+
+  public static getInstance(
+  ): CacheRegistry {
+    if (!CacheRegistry.instance) {
+      CacheRegistry.instance = new CacheRegistry();
+    }
+    return CacheRegistry.instance;
+  }
+
+  // TODO: My use of Generics has Boxed me into a corner where I can't reference AbstractCache without the types
+  private cacheMap: { [kt: string]: any } = {};
+
+  public registerCache = <
+    S extends string,
+    L1 extends string = never,
+    L2 extends string = never,
+    L3 extends string = never,
+    L4 extends string = never,
+    L5 extends string = never
+  >(cache: PItemCache<Item<S>, S> |
+    CItemCache<Item<S, L1, L2, L3, L4, L5>, S, L1, L2, L3, L4, L5>): void => {
+    this.cacheMap[JSON.stringify(cache.getKeyTypes())] = cache;
+  };
+
+  public isConfigured = (): boolean => {
+    return this.configured;
+  }
+
+  public markConfigured = (): void => {
+    this.configured = true;
+  }
+
+  public getCache = (kts: string[]): any => {
+    if (!this.configured) {
+      logger.error('CacheRegistry must be configured before use');
+      throw new Error("CacheRegistry must be configured before use");
+    }
+    return this.cacheMap[JSON.stringify(kts)];
+  };
+
+}

package/src/PItemCache.ts

@@ -0,0 +1,99 @@
+/* eslint-disable no-undefined, max-params */
+
+import { ClientApi } from "@fjell/client-api";
+import { Item, ItemQuery, PriKey, TypesProperties } from "@fjell/core";
+import { AItemCache } from "./AItemCache";
+import { CacheMap } from "./CacheMap";
+import LibLogger from './logger';
+
+const logger = LibLogger.get('PItemCache');
+export class PItemCache<
+  V extends Item<S>,
+  S extends string
+> extends AItemCache<V,S> {
+
+  public constructor(
+    cacheName: string,
+    api: ClientApi<V, S>,
+    pkType: S,
+  ) {
+    super(cacheName, api, pkType);
+  }
+
+  public async all(
+    query: ItemQuery = {},
+  ):
+    Promise<[CacheMap<V, S>, V[]]> {
+    logger.default('all', { query });
+    return await super.all(query) as [CacheMap<V, S>, V[]];
+  }
+
+  public async one(
+    query: ItemQuery = {},
+  ):
+    Promise<[CacheMap<V, S>, V | null]> {
+    logger.default('one', { query });
+    return await super.one(query) as [CacheMap<V, S>, V | null];
+  }
+
+  public async action(
+    key: PriKey<S>,
+    action: string,
+    body: any = {}
+  ): Promise<[CacheMap<V, S>, V]> {
+    logger.default('action', { key, action, body });
+    return await super.action(key, action, body) as [CacheMap<V, S>, V];
+  }
+
+  public async allAction(
+    action: string,
+    body: any = {}
+  ): Promise<[CacheMap<V, S>, V[]]> {
+    logger.default('action', { action, body });
+    return await super.allAction(action, body) as [CacheMap<V, S>, V[]];
+  }
+
+  public async create(
+    v: TypesProperties<V, S, never, never, never, never, never>,
+  ): Promise<[CacheMap<V, S>, V]> {
+    logger.default('create', { v });
+    return await super.create(v) as [CacheMap<V, S>, V];
+  }
+
+  public async get(key: PriKey<S>,
+  ): Promise<[CacheMap<V, S>, V | null]> {
+    logger.default('get', { key });
+    return await super.get(key) as [CacheMap<V, S>, V | null];
+  }
+
+  public async retrieve(
+    key: PriKey<S>,
+  ): Promise<[CacheMap<V, S> | null, V | null]> {
+    logger.default('retrieve', { key });
+    return await super.retrieve(key) as [CacheMap<V, S> | null, V | null];
+  }
+
+  public async remove(
+    key: PriKey<S>
+  ): Promise<CacheMap<V, S>> {
+    logger.default('remove', { key });
+    return await super.remove(key) as CacheMap<V, S>;
+  }
+
+  public async update(
+    key: PriKey<S>,
+    v: TypesProperties<V, S>
+  ): Promise<[CacheMap<V, S>, V]> {
+    logger.default('update', { key, v });
+    return await super.update(key, v) as [CacheMap<V, S>, V];
+  }
+
+  public async find(
+    finder: string,
+    finderParams: Record<string, string | number | boolean | Date | Array<string | number | boolean | Date>>,
+  ): Promise<[CacheMap<V, S>, V[]]> {
+    logger.default('find', { finder, finderParams });
+    return await super.find(finder, finderParams) as [CacheMap<V, S>, V[]];
+  }
+
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+
+export { Cache } from "./Cache";
+export { CacheMap } from "./CacheMap";
+export { CacheRegistry } from "./CacheRegistry";
+
+export { AggregateConfig, AItemAggregator } from "./AItemAggregator";
+
+export { AItemCache } from "./AItemCache";
+export { CItemCache } from "./CItemCache";
+export { PItemCache } from "./PItemCache";

package/src/logger.ts

@@ -0,0 +1,5 @@
+import Logging from '@fjell/logging';
+
+const LibLogger = Logging.getLogger('@fjellproject/cache');
+
+export default LibLogger;