add cache functionality

Author: Syndesi

package.json

@@ -41,7 +41,7 @@
   ],
   "dependencies": {
     "@ember-nexus/web-sdk": "^0.1.1",
-    "lru-cache": "^10.0.1",
+    "lru-cache": "^11.1.0",
     "luxon": "^3.4.4",
     "reflect-metadata": "^0.2",
     "tslib": "^2.8.1",

src/Cache/Cache.ts

@@ -0,0 +1,62 @@
+import { LRUCache } from 'lru-cache';
+
+import { CacheEntry } from './CacheEntry.js';
+import { LogicError } from '../Error/index.js';
+import { ParsedResponse } from '../Type/Definition/Response/index.js';
+
+class Cache<T> {
+  protected cache: LRUCache<string, CacheEntry<T>>;
+
+  public has(key: string): boolean {
+    return this.cache.has(key);
+  }
+
+  public get(key: string): CacheEntry<T> | undefined {
+    return this.cache.get(key);
+  }
+
+  public set(key: string, value: CacheEntry<T>): this {
+    this.cache.set(key, value);
+    return this;
+  }
+
+  /**
+   * Sets a cache entry with the given data and optional ETag.
+   * If no ETag is provided, reuses the previous one if available.
+   *
+   * Reusing a known ETag can improve API performance when the data
+   * is unchanged but the new source lacks ETag metadata.
+   */
+  public setFromDataEtag(key: string, data: T, etag?: string | undefined): this {
+    const previousCacheEntry = this.cache.get(key);
+    if (previousCacheEntry && etag === undefined) {
+      etag = previousCacheEntry.etag;
+    }
+    const cacheEntry = {
+      data: data,
+      etag: etag,
+    };
+    this.cache.set(key, cacheEntry);
+    return this;
+  }
+
+  public setFromParsedResponse(key: string, parsedResponse: ParsedResponse<T>): this {
+    const etag = parsedResponse.response.headers.get('ETag');
+    if (etag === null) {
+      throw new LogicError('Expected parsedResponse to contain ETag header.');
+    }
+    const cacheEntry = {
+      data: parsedResponse.data,
+      etag: etag,
+    };
+    this.cache.set(key, cacheEntry);
+    return this;
+  }
+
+  public refresh(_key: string): this {
+    // todo implement refresh
+    return this;
+  }
+}
+
+export { Cache };

src/Cache/CacheEntry.ts

@@ -0,0 +1,6 @@
+type CacheEntry<T> = {
+  data: T;
+  etag: string | undefined;
+};
+
+export { CacheEntry };

src/Cache/ElementCache.ts

@@ -0,0 +1,37 @@
+import { LRUCache } from 'lru-cache';
+
+import { Cache } from './Cache.js';
+import { CacheEntry } from './CacheEntry.js';
+import { Collection, Node, Relation, Uuid } from '../Type/Definition/index.js';
+import { ServiceIdentifier } from '../Type/Enum/index.js';
+
+class ElementCache extends Cache<Node | Relation> {
+  static identifier: ServiceIdentifier = ServiceIdentifier.cacheElement;
+
+  constructor() {
+    super();
+    this.cache = new LRUCache<string, CacheEntry<Node | Relation>>({
+      max: 500,
+    });
+  }
+
+  static constructFromServiceResolver(): ElementCache {
+    return new ElementCache();
+  }
+
+  static createCacheKey(elementId: Uuid): string {
+    return `${elementId}`;
+  }
+
+  setFromCollection(collection: Collection): this {
+    for (let i = 0; i < collection.nodes.length; i++) {
+      this.setFromDataEtag(ElementCache.createCacheKey(collection.nodes[i].id), collection.nodes[i]);
+    }
+    for (let i = 0; i < collection.relations.length; i++) {
+      this.setFromDataEtag(ElementCache.createCacheKey(collection.relations[i].id), collection.relations[i]);
+    }
+    return this;
+  }
+}
+
+export { ElementCache };

src/Cache/ElementChildrenCache.ts

@@ -0,0 +1,27 @@
+import { LRUCache } from 'lru-cache';
+
+import { Cache } from './Cache.js';
+import { CacheEntry } from './CacheEntry.js';
+import { Collection, Uuid } from '../Type/Definition/index.js';
+import { ServiceIdentifier } from '../Type/Enum/index.js';
+
+class ElementChildrenCache extends Cache<Collection> {
+  static identifier: ServiceIdentifier = ServiceIdentifier.cacheElementChildren;
+
+  constructor() {
+    super();
+    this.cache = new LRUCache<string, CacheEntry<Collection>>({
+      max: 50,
+    });
+  }
+
+  static constructFromServiceResolver(): ElementChildrenCache {
+    return new ElementChildrenCache();
+  }
+
+  static createCacheKey(parentId: Uuid, page: number, pageSize: number): string {
+    return `${parentId}-${page}-${pageSize}`;
+  }
+}
+
+export { ElementChildrenCache };

src/Cache/ElementParentsCache.ts

@@ -0,0 +1,27 @@
+import { LRUCache } from 'lru-cache';
+
+import { Cache } from './Cache.js';
+import { CacheEntry } from './CacheEntry.js';
+import { Collection, Uuid } from '../Type/Definition/index.js';
+import { ServiceIdentifier } from '../Type/Enum/index.js';
+
+class ElementParentsCache extends Cache<Collection> {
+  static identifier: ServiceIdentifier = ServiceIdentifier.cacheElementParents;
+
+  constructor() {
+    super();
+    this.cache = new LRUCache<string, CacheEntry<Collection>>({
+      max: 50,
+    });
+  }
+
+  static constructFromServiceResolver(): ElementParentsCache {
+    return new ElementParentsCache();
+  }
+
+  static createCacheKey(childId: Uuid, page: number, pageSize: number): string {
+    return `${childId}-${page}-${pageSize}`;
+  }
+}
+
+export { ElementParentsCache };

src/Cache/ElementRelatedCache.ts

@@ -0,0 +1,27 @@
+import { LRUCache } from 'lru-cache';
+
+import { Cache } from './Cache.js';
+import { CacheEntry } from './CacheEntry.js';
+import { Collection, Uuid } from '../Type/Definition/index.js';
+import { ServiceIdentifier } from '../Type/Enum/index.js';
+
+class ElementRelatedCache extends Cache<Collection> {
+  static identifier: ServiceIdentifier = ServiceIdentifier.cacheElementRelated;
+
+  constructor() {
+    super();
+    this.cache = new LRUCache<string, CacheEntry<Collection>>({
+      max: 50,
+    });
+  }
+
+  static constructFromServiceResolver(): ElementRelatedCache {
+    return new ElementRelatedCache();
+  }
+
+  static createCacheKey(centerId: Uuid, page: number, pageSize: number): string {
+    return `${centerId}-${page}-${pageSize}`;
+  }
+}
+
+export { ElementRelatedCache };

src/Cache/IndexCache.ts

@@ -0,0 +1,27 @@
+import { LRUCache } from 'lru-cache';
+
+import { Cache } from './Cache.js';
+import { CacheEntry } from './CacheEntry.js';
+import { Collection } from '../Type/Definition/index.js';
+import { ServiceIdentifier } from '../Type/Enum/index.js';
+
+class IndexCache extends Cache<Collection> {
+  static identifier: ServiceIdentifier = ServiceIdentifier.cacheIndex;
+
+  constructor() {
+    super();
+    this.cache = new LRUCache<string, CacheEntry<Collection>>({
+      max: 50,
+    });
+  }
+
+  static constructFromServiceResolver(): IndexCache {
+    return new IndexCache();
+  }
+
+  static createCacheKey(page: number, pageSize: number): string {
+    return `${page}-${pageSize}`;
+  }
+}
+
+export { IndexCache };

src/Cache/index.ts

@@ -0,0 +1,7 @@
+export * from './Cache.js';
+export * from './CacheEntry.js';
+export * from './ElementCache.js';
+export * from './ElementChildrenCache.js';
+export * from './ElementParentsCache.js';
+export * from './ElementRelatedCache.js';
+export * from './IndexCache.js';

src/Init.ts

@@ -2,6 +2,13 @@ import { EmberNexus } from '@ember-nexus/web-sdk/Service';
 import { Logger } from 'tslog';
 
 import { GetServiceResolverEvent } from './BrowserEvent/index.js';
+import {
+  ElementCache,
+  ElementChildrenCache,
+  ElementParentsCache,
+  ElementRelatedCache,
+  IndexCache,
+} from './Cache/index.js';
 import {
   DeleteElementEndpoint,
   GetElementChildrenEndpoint,
@@ -89,6 +96,13 @@ function init(rootNode: HTMLElement, emberNexus: EmberNexus | null = null): Serv
     PostChangePasswordEndpoint,
     PostRegisterEndpoint,
     PostTokenEndpoint,
+
+    // caches
+    ElementCache,
+    ElementChildrenCache,
+    ElementParentsCache,
+    ElementRelatedCache,
+    IndexCache,
   ];
   for (let i = 0; i < services.length; i++) {
     serviceResolver.setService(services[i].identifier, services[i].constructFromServiceResolver(serviceResolver));