@travetto/model-memory 7.1.4 → 8.0.0-alpha.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model-memory",
-  "version": "7.1.4",
+  "version": "8.0.0-alpha.1",
   "type": "module",
   "description": "Memory backing for the travetto model module.",
   "keywords": [
@@ -26,14 +26,14 @@
     "directory": "module/model-memory"
   },
   "dependencies": {
-    "@travetto/config": "^7.1.4",
-    "@travetto/di": "^7.1.4",
-    "@travetto/model": "^7.1.4",
-    "@travetto/schema": "^7.1.4"
+    "@travetto/config": "^8.0.0-alpha.1",
+    "@travetto/di": "^8.0.0-alpha.1",
+    "@travetto/model": "^8.0.0-alpha.1",
+    "@travetto/schema": "^8.0.0-alpha.1"
   },
   "peerDependencies": {
-    "@travetto/cli": "^7.1.4",
-    "@travetto/test": "^7.1.4"
+    "@travetto/cli": "^8.0.0-alpha.1",
+    "@travetto/test": "^8.0.0-alpha.1"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/service.ts

@@ -1,22 +1,19 @@
-import { Readable } from 'node:stream';
-import { buffer as toBuffer } from 'node:stream/consumers';
-
 import {
-  type Class, type TimeSpan, type DeepPartial, castTo, type BlobMeta,
-  type ByteRange, type BinaryInput, BinaryUtil, JSONUtil
+  type Class, type TimeSpan, type DeepPartial, castTo, type BinaryMetadata,
+  type ByteRange, type BinaryType, BinaryUtil, type BinaryArray, JSONUtil, BinaryMetadataUtil
 } from '@travetto/runtime';
-import { Injectable } from '@travetto/di';
+import { Injectable, PostConstruct } from '@travetto/di';
 import { Config } from '@travetto/config';
 import {
   type ModelType, type IndexConfig, type ModelCrudSupport, type ModelExpirySupport, type ModelStorageSupport, type ModelIndexedSupport,
   ModelRegistryIndex, NotFoundError, ExistsError, type OptionalId, type ModelBlobSupport,
-  ModelCrudUtil, ModelExpiryUtil, ModelIndexedUtil, ModelStorageUtil, ModelBlobUtil
+  ModelCrudUtil, ModelExpiryUtil, ModelIndexedUtil, ModelStorageUtil
 } from '@travetto/model';
 
 const ModelBlobNamespace = '__blobs';
 const ModelBlobMetaNamespace = `${ModelBlobNamespace}_meta`;
 
-type StoreType = Map<string, Buffer>;
+type StoreType = Map<string, BinaryArray>;
 
 @Config('model.memory')
 export class MemoryModelConfig {
@@ -60,10 +57,7 @@ export class MemoryModelService implements ModelCrudSupport, ModelBlobSupport, M
 
   #getStore<T extends ModelType>(cls: Class<T> | string): StoreType {
     const key = typeof cls === 'string' ? cls : ModelRegistryIndex.getStoreName(cls);
-    if (!this.#store.has(key)) {
-      this.#store.set(key, new Map());
-    }
-    return this.#store.get(key)!;
+    return this.#store.getOrInsert(key, new Map());
   }
 
   #find<T extends ModelType>(cls: Class<T> | string, id?: string, errorState?: 'exists' | 'notfound'): StoreType {
@@ -95,23 +89,11 @@ export class MemoryModelService implements ModelCrudSupport, ModelBlobSupport, M
     for (const idx of ModelRegistryIndex.getIndices(cls, ['sorted', 'unsorted'])) {
       const idxName = indexName(cls, idx);
       const { key, sort } = ModelIndexedUtil.computeIndexKey(cls, idx, castTo(item));
-      let index = this.#indices[idx.type].get(idxName)?.get(key);
-
-      if (!index) {
-        if (!this.#indices[idx.type].has(idxName)) {
-          this.#indices[idx.type].set(idxName, new Map());
-        }
-        if (idx.type === 'sorted') {
-          this.#indices[idx.type].get(idxName)!.set(key, index = new Map());
-        } else {
-          this.#indices[idx.type].get(idxName)!.set(key, index = new Set());
-        }
-      }
 
-      if (index instanceof Map) {
-        index?.set(item.id, +sort!);
+      if (idx.type === 'sorted') {
+        this.#indices[idx.type].getOrInsert(idxName, new Map()).getOrInsert(key, new Map()).set(item.id, +sort!);
       } else {
-        index?.add(item.id);
+        this.#indices[idx.type].getOrInsert(idxName, new Map()).getOrInsert(key, new Set()).add(item.id);
       }
     }
   }
@@ -122,7 +104,7 @@ export class MemoryModelService implements ModelCrudSupport, ModelBlobSupport, M
     const store = this.#getStore(cls);
     await this.#removeIndices(cls, item.id);
     if (action === 'write') {
-      store.set(item.id, Buffer.from(JSON.stringify(item)));
+      store.set(item.id, JSONUtil.toBinaryArray(item));
       await this.#writeIndices(cls, item);
       return item;
     } else {
@@ -148,7 +130,8 @@ export class MemoryModelService implements ModelCrudSupport, ModelBlobSupport, M
     throw new NotFoundError(cls, key);
   }
 
-  async postConstruct(): Promise<void> {
+  @PostConstruct()
+  async initializeClient(): Promise<void> {
     await ModelStorageUtil.storageInitialization(this);
     ModelExpiryUtil.registerCull(this);
 
@@ -233,33 +216,35 @@ export class MemoryModelService implements ModelCrudSupport, ModelBlobSupport, M
   }
 
   // Blob Support
-  async upsertBlob(location: string, input: BinaryInput, meta?: BlobMeta, overwrite = true): Promise<void> {
-    if (!overwrite && await this.getBlobMeta(location).then(() => true, () => false)) {
+  async upsertBlob(location: string, input: BinaryType, metadata?: BinaryMetadata, overwrite = true): Promise<void> {
+    if (!overwrite && await this.getBlobMetadata(location).then(() => true, () => false)) {
       return;
     }
-
-    const [stream, blobMeta] = await ModelBlobUtil.getInput(input, meta);
+    const resolved = await BinaryMetadataUtil.compute(input, metadata);
     const blobs = this.#getStore(ModelBlobNamespace);
     const metaContent = this.#getStore(ModelBlobMetaNamespace);
-    metaContent.set(location, Buffer.from(JSON.stringify(blobMeta)));
-    blobs.set(location, await toBuffer(stream));
+    metaContent.set(location, JSONUtil.toBinaryArray(resolved));
+    blobs.set(location, await BinaryUtil.toBinaryArray(input));
   }
 
   async getBlob(location: string, range?: ByteRange): Promise<Blob> {
+
     const blobs = this.#find(ModelBlobNamespace, location, 'notfound');
-    let buffer = blobs.get(location)!;
-    const final = range ? ModelBlobUtil.enforceRange(range, buffer.length) : undefined;
+
+    let data = blobs.get(location)!;
+    const final = range ? BinaryMetadataUtil.enforceRange(range, { size: data.byteLength }) : undefined;
+
     if (final) {
-      buffer = Buffer.from(buffer.subarray(final.start, final.end + 1));
+      data = BinaryUtil.sliceByteArray(data, final.start, final.end + 1);
     }
-    const meta = await this.getBlobMeta(location);
-    return BinaryUtil.readableBlob(() => Readable.from(buffer), { ...meta, range: final });
+
+    const metadata = await this.getBlobMetadata(location);
+    return BinaryMetadataUtil.makeBlob(data, { ...metadata, range: final });
   }
 
-  async getBlobMeta(location: string): Promise<BlobMeta> {
+  async getBlobMetadata(location: string): Promise<BinaryMetadata> {
     const metaContent = this.#find(ModelBlobMetaNamespace, location, 'notfound');
-    const meta: BlobMeta = JSONUtil.parseSafe(metaContent.get(location)!);
-    return meta;
+    return JSONUtil.fromBinaryArray(metaContent.get(location)!);
   }
 
   async deleteBlob(location: string): Promise<void> {
@@ -273,9 +258,9 @@ export class MemoryModelService implements ModelCrudSupport, ModelBlobSupport, M
     }
   }
 
-  async updateBlobMeta(location: string, meta: BlobMeta): Promise<void> {
+  async updateBlobMetadata(location: string, metadata: BinaryMetadata): Promise<void> {
     const metaContent = this.#getStore(ModelBlobMetaNamespace);
-    metaContent.set(location, Buffer.from(JSON.stringify(meta), 'utf8'));
+    metaContent.set(location, JSONUtil.toBinaryArray(metadata));
   }
 
   // Expiry