@travetto/model-memory 8.0.0-alpha.24 → 8.0.0-alpha.26

package/README.md

@@ -14,7 +14,7 @@ yarn add @travetto/model-memory
 ```
 
 This module provides a memory-based implementation for the [Data Modeling Support](https://github.com/travetto/travetto/tree/main/module/model#readme "Datastore abstraction for core operations."). Supported features:
-   *  [CRUD](https://github.com/travetto/travetto/tree/main/module/model/src/types/crud.ts#L11)
-   *  [Expiry](https://github.com/travetto/travetto/tree/main/module/model/src/types/expiry.ts#L10)
    *  [Blob](https://github.com/travetto/travetto/tree/main/module/model/src/types/blob.ts#L8)
-   *  [Indexed](https://github.com/travetto/travetto/tree/main/module/model-indexed/src/types/service.ts#L16)
+   *  [CRUD](https://github.com/travetto/travetto/tree/main/module/model/src/types/crud.ts#L10)
+   *  [Expiry](https://github.com/travetto/travetto/tree/main/module/model/src/types/expiry.ts#L10)
+   *  [Indexed](https://github.com/travetto/travetto/tree/main/module/model-indexed/src/types/service.ts#L21)

package/__index__.ts

@@ -1 +1 @@
-export * from './src/service.ts';
+export * from './src/service.ts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model-memory",
-  "version": "8.0.0-alpha.24",
+  "version": "8.0.0-alpha.26",
   "type": "module",
   "description": "Memory backing for the travetto model module.",
   "keywords": [
@@ -26,15 +26,15 @@
     "directory": "module/model-memory"
   },
   "dependencies": {
-    "@travetto/config": "^8.0.0-alpha.21",
-    "@travetto/di": "^8.0.0-alpha.19",
-    "@travetto/model": "^8.0.0-alpha.22",
-    "@travetto/model-indexed": "^8.0.0-alpha.24",
-    "@travetto/schema": "^8.0.0-alpha.21"
+    "@travetto/config": "^8.0.0-alpha.23",
+    "@travetto/di": "^8.0.0-alpha.21",
+    "@travetto/model": "^8.0.0-alpha.24",
+    "@travetto/model-indexed": "^8.0.0-alpha.26",
+    "@travetto/schema": "^8.0.0-alpha.23"
   },
   "peerDependencies": {
-    "@travetto/cli": "^8.0.0-alpha.27",
-    "@travetto/test": "^8.0.0-alpha.20"
+    "@travetto/cli": "^8.0.0-alpha.29",
+    "@travetto/test": "^8.0.0-alpha.22"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/service.ts

@@ -1,21 +1,52 @@
-import {
-  type Class, type TimeSpan, castTo, type BinaryMetadata,
-  type ByteRange, type BinaryType, BinaryUtil, type BinaryArray, JSONUtil, BinaryMetadataUtil,
-} from '@travetto/runtime';
-import { Injectable, PostConstruct } from '@travetto/di';
 import { Config } from '@travetto/config';
+import { Injectable, PostConstruct } from '@travetto/di';
 import {
-  type ModelType, type ModelCrudSupport, type ModelExpirySupport, type ModelStorageSupport, ModelRegistryIndex,
-  NotFoundError, ExistsError, type OptionalId, type ModelBlobSupport, ModelCrudUtil, ModelExpiryUtil, ModelStorageUtil,
+  ExistsError,
   IndexNotSupported,
+  type ModelBlobSupport,
+  type ModelCrudSupport,
+  ModelCrudUtil,
+  type ModelExpirySupport,
+  ModelExpiryUtil,
   type ModelListOptions,
+  ModelRegistryIndex,
+  type ModelStorageSupport,
+  ModelStorageUtil,
+  type ModelType,
+  NotFoundError,
+  type OptionalId,
+  UniqueError
 } from '@travetto/model';
 import {
-  type ModelIndexedSupport, type KeyedIndexSelection, type KeyedIndexBody, type ModelPageOptions, ModelIndexedUtil,
-  type SingleItemIndex, type SortedIndexSelection, type ModelPageResult, type SortedIndex,
-  type AllIndexes, isModelIndexedIndex, type FullKeyedIndexBody, type FullKeyedIndexWithPartialBody, ModelIndexedComputedIndex,
-  type ModelIndexedSearchOptions, type SortedIndexSelectionType,
+  type AllIndexes,
+  type FullKeyedIndexBody,
+  type FullKeyedIndexWithPartialBody,
+  isModelIndexedIndex,
+  type KeyedIndexBody,
+  type KeyedIndexSelection,
+  ModelIndexedComputedIndex,
+  type ModelIndexedSearchOptions,
+  type ModelIndexedSupport,
+  ModelIndexedUtil,
+  type ModelPageOptions,
+  type ModelPageResult,
+  type SingleItemIndex,
+  type SortedIndex,
+  type SortedIndexSelection,
+  type SortedIndexSelectionType
 } from '@travetto/model-indexed';
+import {
+  type BinaryArray,
+  type BinaryMetadata,
+  BinaryMetadataUtil,
+  type BinaryType,
+  BinaryUtil,
+  type ByteRange,
+  type Class,
+  castTo,
+  JSONUtil,
+  type TimeSpan
+} from '@travetto/runtime';
 
 const ModelBlobNamespace = '__blobs';
 const ModelBlobMetaNamespace = `${ModelBlobNamespace}_meta`;
@@ -23,8 +54,7 @@ const ModelBlobMetaNamespace = `${ModelBlobNamespace}_meta`;
 type StoreType = Map<string, BinaryArray>;
 
 const sortValue = (a: string | number, b: string | number): number =>
-  (typeof a === 'number' && typeof b === 'number') ?
-    a - b : (typeof a === 'string' && typeof b === 'string') ? a.localeCompare(b) : 0;
+  typeof a === 'number' && typeof b === 'number' ? a - b : typeof a === 'string' && typeof b === 'string' ? a.localeCompare(b) : 0;
 
 @Config('model.memory')
 export class MemoryModelConfig {
@@ -51,23 +81,25 @@ function getFirstId(data: Map<string, unknown> | Set<string>, value?: string | n
  * Standard in-memory support
  */
 @Injectable()
-export class MemoryModelService implements
-  ModelCrudSupport, ModelBlobSupport,
-  ModelExpirySupport, ModelStorageSupport,
-  ModelIndexedSupport {
-
+export class MemoryModelService
+  implements ModelCrudSupport, ModelBlobSupport, ModelExpirySupport, ModelStorageSupport, ModelIndexedSupport
+{
   #store = new Map<string, StoreType>();
   #indices = {
     'indexed:sorted': new Map<string, Map<string, Map<string, number | string>>>(),
-    'indexed:keyed': new Map<string, Map<string, Set<string>>>(),
+    'indexed:keyed': new Map<string, Map<string, Set<string>>>()
   } as const;
 
   idSource = ModelCrudUtil.uuidSource();
   config: MemoryModelConfig;
 
-  constructor(config: MemoryModelConfig) { this.config = config; }
+  constructor(config: MemoryModelConfig) {
+    this.config = config;
+  }
 
-  get client(): Map<string, StoreType> { return this.#store; }
+  get client(): Map<string, StoreType> {
+    return this.#store;
+  }
 
   #getStore<T extends ModelType>(cls: Class<T> | string): StoreType {
     const key = typeof cls === 'string' ? cls : ModelRegistryIndex.getStoreName(cls);
@@ -95,7 +127,9 @@ export class MemoryModelService implements
         const computed = ModelIndexedComputedIndex.get(idx, item).validate({ sort: true });
         switch (idx.type) {
           case 'indexed:sorted':
-          case 'indexed:keyed': this.#indices[idx.type].get(idxName)?.get(computed.getKey())?.delete(id); break;
+          case 'indexed:keyed':
+            this.#indices[idx.type].get(idxName)?.get(computed.getKey())?.delete(id);
+            break;
         }
       }
     } catch (error) {
@@ -118,7 +152,7 @@ export class MemoryModelService implements
           if (idx.unique) {
             const existing = this.#indices[idx.type].get(idxName)?.get(key);
             if (existing && existing.size > 0 && !existing.has(item.id)) {
-              throw new ExistsError(cls, key);
+              throw new UniqueError(cls, key);
             }
           }
           this.#indices[idx.type].getOrInsert(idxName, new Map()).getOrInsert(key, new Set()).add(item.id);
@@ -146,11 +180,11 @@ export class MemoryModelService implements
     }
   }
 
-  async #getIdByIndex<
-    T extends ModelType,
-    K extends KeyedIndexSelection<T>,
-    S extends SortedIndexSelection<T>
-  >(cls: Class<T>, idx: SingleItemIndex<T, K, S>, body: FullKeyedIndexBody<T, K, S>): Promise<string> {
+  async #getIdByIndex<T extends ModelType, K extends KeyedIndexSelection<T>, S extends SortedIndexSelection<T>>(
+    cls: Class<T>,
+    idx: SingleItemIndex<T, K, S>,
+    body: FullKeyedIndexBody<T, K, S>
+  ): Promise<string> {
     const computed = ModelIndexedComputedIndex.get(idx, body).validate({ sort: true });
 
     const index = this.#indices[idx.type].get(indexName(cls, idx))?.get(computed.getKey());
@@ -176,11 +210,8 @@ export class MemoryModelService implements
     throw new NotFoundError(cls, computed.getKey({ sort: true }));
   }
 
-  async * #iterateIds(
-    ids: string[],
-    options?: ModelListOptions & ModelPageOptions<number>,
-  ): AsyncIterable<string[]> {
-    let offset = options && 'offset' in options ? options.offset ?? 0 : 0;
+  async *#iterateIds(ids: string[], options?: ModelListOptions & ModelPageOptions<number>): AsyncIterable<string[]> {
+    let offset = options && 'offset' in options ? (options.offset ?? 0) : 0;
     const batchSize = options?.batchSizeHint ?? 100;
     let produced = 0;
     const maxCount = options?.limit ?? Number.MAX_SAFE_INTEGER;
@@ -198,9 +229,7 @@ export class MemoryModelService implements
     }
   }
 
-  async * #getIndexIds<
-    T extends ModelType,
-  >(
+  async *#getIndexIds<T extends ModelType>(
     cls: Class<T>,
     idx: AllIndexes<T>,
     body: KeyedIndexBody<T>,
@@ -219,9 +248,9 @@ export class MemoryModelService implements
       ids = [];
     } else if (index instanceof Map) {
       ids = [...index.entries()]
-        .filter(([, sort]) => filterIndex ? filterIndex(sort) : true)
+        .filter(([, sort]) => (filterIndex ? filterIndex(sort) : true))
         .sort((a, b) => sortValue(a[1], b[1]))
-        .map(([id,]) => id);
+        .map(([id]) => id);
     } else {
       ids = [...index];
     }
@@ -299,7 +328,7 @@ export class MemoryModelService implements
     await this.#persist(cls, where, 'remove');
   }
 
-  async * list<T extends ModelType>(cls: Class<T>, options?: ModelListOptions): AsyncIterable<T[]> {
+  async *list<T extends ModelType>(cls: Class<T>, options?: ModelListOptions): AsyncIterable<T[]> {
     for await (const batch of this.#iterateIds([...this.#getStore(cls).keys()], options)) {
       yield ModelCrudUtil.filterOutNotFound(batch.map(id => this.get(cls, id)));
     }
@@ -307,7 +336,13 @@ export class MemoryModelService implements
 
   // Blob Support
   async upsertBlob(location: string, input: BinaryType, metadata?: BinaryMetadata, overwrite = true): Promise<void> {
-    if (!overwrite && await this.getBlobMetadata(location).then(() => true, () => false)) {
+    if (
+      !overwrite &&
+      (await this.getBlobMetadata(location).then(
+        () => true,
+        () => false
+      ))
+    ) {
       return;
     }
     const resolved = await BinaryMetadataUtil.compute(input, metadata);
@@ -318,7 +353,6 @@ export class MemoryModelService implements
   }
 
   async getBlob(location: string, range?: ByteRange): Promise<Blob> {
-
     const blobs = this.#find(ModelBlobNamespace, location, 'notfound');
 
     let data = blobs.get(location)!;
@@ -364,14 +398,13 @@ export class MemoryModelService implements
           store.delete(key);
           deleted += 1;
         }
-      } catch { } // Do not let a single error stop the process
+      } catch {} // Do not let a single error stop the process
     }
     return deleted;
   }
 
   // Storage Support
-  async createStorage(): Promise<void> {
-  }
+  async createStorage(): Promise<void> {}
 
   async deleteStorage(): Promise<void> {
     this.#store.clear();
@@ -398,53 +431,48 @@ export class MemoryModelService implements
   }
 
   // Indexed
-  async getByIndex<
-    T extends ModelType,
-    K extends KeyedIndexSelection<T>,
-    S extends SortedIndexSelection<T>
-  >(cls: Class<T>, idx: SingleItemIndex<T, K, S>, body: FullKeyedIndexBody<T, K, S>): Promise<T> {
+  async getByIndex<T extends ModelType, K extends KeyedIndexSelection<T>, S extends SortedIndexSelection<T>>(
+    cls: Class<T>,
+    idx: SingleItemIndex<T, K, S>,
+    body: FullKeyedIndexBody<T, K, S>
+  ): Promise<T> {
     return this.get(cls, await this.#getIdByIndex(cls, idx, body));
-
   }
 
-  async deleteByIndex<
-    T extends ModelType,
-    K extends KeyedIndexSelection<T>,
-    S extends SortedIndexSelection<T>
-  >(cls: Class<T>, idx: SingleItemIndex<T, K, S>, body: FullKeyedIndexBody<T, K, S>): Promise<void> {
+  async deleteByIndex<T extends ModelType, K extends KeyedIndexSelection<T>, S extends SortedIndexSelection<T>>(
+    cls: Class<T>,
+    idx: SingleItemIndex<T, K, S>,
+    body: FullKeyedIndexBody<T, K, S>
+  ): Promise<void> {
     await this.delete(cls, await this.#getIdByIndex(cls, idx, body));
   }
 
-  upsertByIndex<
-    T extends ModelType,
-    K extends KeyedIndexSelection<T>,
-    S extends SortedIndexSelection<T>
-  >(cls: Class<T>, idx: SingleItemIndex<T, K, S>, body: OptionalId<T>): Promise<T> {
+  upsertByIndex<T extends ModelType, K extends KeyedIndexSelection<T>, S extends SortedIndexSelection<T>>(
+    cls: Class<T>,
+    idx: SingleItemIndex<T, K, S>,
+    body: OptionalId<T>
+  ): Promise<T> {
     return ModelIndexedUtil.naiveUpsert(this, cls, idx, body);
   }
 
-  updateByIndex<
-    T extends ModelType,
-    K extends KeyedIndexSelection<T>,
-    S extends SortedIndexSelection<T>
-  >(cls: Class<T>, idx: SingleItemIndex<T, K, S>, body: T): Promise<T> {
+  updateByIndex<T extends ModelType, K extends KeyedIndexSelection<T>, S extends SortedIndexSelection<T>>(
+    cls: Class<T>,
+    idx: SingleItemIndex<T, K, S>,
+    body: T
+  ): Promise<T> {
     return ModelIndexedUtil.naiveUpdate(this, cls, idx, body);
   }
 
-  async updatePartialByIndex<
-    T extends ModelType,
-    K extends KeyedIndexSelection<T>,
-    S extends SortedIndexSelection<T>
-  >(cls: Class<T>, idx: SingleItemIndex<T, K, S>, body: FullKeyedIndexWithPartialBody<T, K, S>): Promise<T> {
+  async updatePartialByIndex<T extends ModelType, K extends KeyedIndexSelection<T>, S extends SortedIndexSelection<T>>(
+    cls: Class<T>,
+    idx: SingleItemIndex<T, K, S>,
+    body: FullKeyedIndexWithPartialBody<T, K, S>
+  ): Promise<T> {
     const item = await ModelCrudUtil.naivePartialUpdate(cls, () => this.getByIndex(cls, idx, castTo(body)), castTo(body));
     return this.update(cls, item);
   }
 
-  async pageByIndex<
-    T extends ModelType,
-    K extends KeyedIndexSelection<T>,
-    S extends SortedIndexSelection<T>
-  >(
+  async pageByIndex<T extends ModelType, K extends KeyedIndexSelection<T>, S extends SortedIndexSelection<T>>(
     cls: Class<T>,
     idx: SortedIndex<T, K, S>,
     body: KeyedIndexBody<T, K>,
@@ -456,16 +484,12 @@ export class MemoryModelService implements
     const items: T[] = [];
     for await (const batch of this.#getIndexIds(cls, idx, body, { limit: 100, ...options, offset })) {
       produced += batch.length;
-      items.push(...await ModelCrudUtil.filterOutNotFound(batch.map(id => this.get(cls, id))));
+      items.push(...(await ModelCrudUtil.filterOutNotFound(batch.map(id => this.get(cls, id)))));
     }
     return { items, nextOffset: items.length ? JSONUtil.toBase64(offset + produced) : undefined };
   }
 
-  async  * listByIndex<
-    T extends ModelType,
-    K extends KeyedIndexSelection<T>,
-    S extends SortedIndexSelection<T>
-  >(
+  async *listByIndex<T extends ModelType, K extends KeyedIndexSelection<T>, S extends SortedIndexSelection<T>>(
     cls: Class<T>,
     idx: SortedIndex<T, K, S>,
     body: KeyedIndexBody<T, K>,
@@ -483,12 +507,9 @@ export class MemoryModelService implements
     B extends SortedIndexSelectionType<T, S> & string
   >(cls: Class<T>, idx: SortedIndex<T, K, S>, body: KeyedIndexBody<T, K>, prefix: B, options?: ModelIndexedSearchOptions): Promise<T[]> {
     const items: T[] = [];
-    for await (const batch of this.#getIndexIds(
-      cls, idx, body, options,
-      id => (typeof id === 'string' && id.startsWith(prefix))
-    )) {
-      items.push(...await ModelCrudUtil.filterOutNotFound(batch.map(id => this.get(cls, id))));
+    for await (const batch of this.#getIndexIds(cls, idx, body, options, id => typeof id === 'string' && id.startsWith(prefix))) {
+      items.push(...(await ModelCrudUtil.filterOutNotFound(batch.map(id => this.get(cls, id)))));
     }
     return items;
   }
-}
+}